Java/Android设计模式之 Builder设计模式,构建者模式

快来打我* 2022-05-22 11:50 148阅读 0赞

## 在众多的设计模式中构建者模式Builder显得非常的精妙，它能在用户不知道内部情况下创建一个对象，也就是省略部分细节，显得简洁大方。今天我们开始介绍这个构建者模式 ##

> 首先是对象，我们需要生成的对象，这里我们是一个抽象的产品类，其中操作系统需要具体的实现类去操作

//计算机,也就是产品类
    public abstract class Computer { 
        protected String mBoard;
        protected String mDisplay;
        protected String mOS;
    
        public  void setmBoard(String board){
            this.mBoard = board;
        }
    
        public  void setDisplay(String display){
            this.mDisplay = display;
        }
    
    
    
        public abstract void setmOS();
    
    
        @Override
        public String toString() {
            return "Computer{" +
                    "mBoard='" + mBoard + '\'' +
                    ", mDisplay='" + mDisplay + '\'' +
                    ", mOS='" + mOS + '\'' +
                    '}';
        }
    }

> 具体的产品类,实现了抽象的产品Computer

//具体的产品类
    public class Macbook extends Computer { 
        protected Macbook() {
        }
    
        @Override
        public void setmOS() {
            mOS = "Mac OS X 10.10";
        }
    }

> 抽象的构造者

//抽象的Builder
    public abstract  class Builder { 
        public abstract void buildBoard(String board);
        public abstract void buildDisplay(String display);
        public abstract void buildOS();
        public abstract Computer create();
    }

> 具体的构造者 这里首先new出来了一个对象，实现抽象的Builder，在builder方法；里面为computer设置相关的属性，最后create方法返回这个对象

//具体的Builder类 MacBookBuilder
    public class MacBookBuilder extends Builder{ 
        private Computer mComputer = new Macbook();
    
        @Override
        public void buildBoard(String board) {
            mComputer.setmBoard(board);
        }
    
        @Override
        public void buildDisplay(String display) {
            mComputer.setDisplay(display);
        }
    
        @Override
        public void buildOS() {
                mComputer.setmOS();
        }
    
        @Override
        public Computer create() {
            return mComputer;
        }
    }

> Director类，负责构造，首先用户在初始化这个类的时候需要传递一个Builder过来，一般是传递一个具体的Builder过来再调用construct这个方法就完成了产品的生成，在最后调用builder.create()就可以生成这个对象

//Director类，负责构造Computer
    public class Director { 
        Builder  mBuilder = null;
    
        public Director(Builder mBuilder) {
            this.mBuilder = mBuilder;
        }
        /** * 构建对象 */
        public void consttuct(String board, String display){
            mBuilder.buildBoard(board);
            mBuilder.buildDisplay(display);
            mBuilder.buildOS();
        }
    }

> 测试类

public class Main { 
    
        public static void main(String[] args) {
        //初始化一个具体的Mac电脑的构造Builder，在这里面已经设置了系统,这里保存了一个没有配置的电脑产品
            Builder  builder = new MacBookBuilder();
            //初始化一个构建类，这个构建类里面需要builder参数
            Director pcDirector = new Director(builder);
            //这个构建类就可以开始构造我们需要配置的产品
            pcDirector.consttuct("英特尔", "Retina显示器");
            //最后我们调用builder的create()方法就可以生成一个对象
            System.out.println("Computer info :"+ builder.create().toString());
        }
    }

## 在这里是比较简单的构造者模式的设计形式，在android的对话框中我们经常会使用到这种设计模式。 ##