设计模式——生成器模式

1 问题的提出

在创建类时，有些类是容易创建的，直接调用构造方法即可new出对象的实例。如Student obj=new Student(“lyf”,18)，表明学生名字为lyf,年龄为18。Class obj1=new Class (“一年一班”,50),表明名为一年一班的班级中有50个学生。这种类的一大特点是类的属性类型是基本类型或字符串类。但是有些类却是不适用于用构造函数进行创建实例，成员变量是自定义的;例如下类：

public class Product{
 public Unit1 unit1;
 public Unit2 unit2;
 public Unit3 unit3;
}

public class Product{
 public Unit1 unit1;
 public Unit2 unit2;
 public Unit3 unit3;

  public void createUnit1(){
   //创建具体的单元1,忽略具体的实例创建过程
   unit1= .... 
  }
  public void createUnit2(){
   //创建具体的单元2,忽略具体的实例创建过程
   unit2= .... 
  }
 public void createUnit3(){
   //创建具体的单元2,忽略具体的实例创建过程
   unit3= .... 
  }
  
 public void createUnit3(){
   //创建具体的单元3,忽略具体的实例创建过程
   unit3= .... 
  }

  //以某种方式合成具体的对象,忽略具体的实现逻辑
  public void composite(){
    //unit+uni2+unit3
  }
}

由上述代码可知，创建Product的实例时 ,需要按步骤调用方法生成Product类中自定义属性类，并按照逻组合成分属性。

public class Main{
 Product p=new Product ();
 p.createUnit1();
 p.createUnit2();
 p.createUnit3();
 p.composite();
}

但随着Product类存在不同的种类时需要在Product中增加其他的方法；显然这是不符合开闭原则的。所以将引入生成器模式来解决这种复杂对象创建的问题

 //创建第二种Product的方法组
 public void _createUnit1(){
   //创建具体的单元1,忽略具体的实例创建过程
   unit1= .... 
  }
  public void _createUnit2(){
   //创建具体的单元2,忽略具体的实例创建过程
   unit2= .... 
  }
 public void _createUnit3(){
   //创建具体的单元2,忽略具体的实例创建过程
   unit3= .... 
  }
  
 public void _createUnit3(){
   //创建具体的单元3,忽略具体的实例创建过程
   unit3= .... 
  }

  //以某种方式合成具体的对象,忽略具体的实现逻辑
  public void _composite1(){
    //unit+uni2+unit3
  }

生成器模式是指一个复杂对象的构建与它的表示是分离的，可适用于下列场景：对象结构复杂，利用构造方法创建对象无法满足用户需求；对象的创建必须独立于创建该对象的类

2 实现步骤与编程实现

房子分为普通型和豪华型。不同体现在面积大小与卧室、卫生间、车库数量上。使用生成器模式编写功能类与测试类

步骤一：定义产品类
根据语义分析，可定义House类

public class House {

    //注：该对象的属性含有自定义属性类，结构较为复杂。不推荐使用构造函数 new出对象,因此忽略构造函数

    /**
     * 房子面积
     */
    public  double area;

    /**
     * 卧室
     */
    public BedRoom bedRoom ;

    /**
     * 卫生间
     */
    public WashRoom washRoom;


    /**
     * 车库
     */
    public Garage garage;



}

class  BedRoom{
    /**
     * 卧室数量
     */
    public int qty;
}


class  WashRoom{
    /**
     * 卫生间数量
     */
    public int qty;
}


class  Garage{
    /**
     * 车库数量
     */
    public int qty;
}

步骤二：定义抽象建造类

//抽象建造器
// 用来描述如一个房子的信息
public abstract class HouseBuilder {

    //设置房子面积
    abstract void setArea();
    //建制卧室
    abstract BedRoom createBedRoom();
    //建制洗手间
    abstract WashRoom createWashRoom();
    //建制车库
    abstract Garage createGarage();
    //装修
    abstract House composite();

}

步骤三：定义具体建造类

//普通房 三室二厕所带一个车库，总面积为158m^2
public class NormalHouseBuilder extends HouseBuilder {

    House house=new House();

    @Override
    void setArea() {
        house.area=150;
    }

    @Override
    BedRoom createBedRoom() {
       BedRoom bedRoom=new BedRoom();
       bedRoom.qty=3;
       return bedRoom;
    }

    @Override
    WashRoom createWashRoom() {
        WashRoom washRoom=new WashRoom();
        washRoom.qty=2;
        return washRoom;
    }

    @Override
    Garage createGarage() {
        Garage garage=new Garage();
        garage.qty=1;
        return garage;
    }


    @Override
    House composite() {
        setArea();
        BedRoom bedRoom = createBedRoom();
        WashRoom washRoom = createWashRoom();
        Garage garage = createGarage();

        //组装产品House的相关属性
        house.bedRoom=bedRoom;
        house.washRoom=washRoom;
        house.garage=garage;
        return house;
    }


}



//豪华型房子 五室三厕所带两个车库，总面积为278m^2
public class LuxuriousHouseBuilder extends HouseBuilder{
    House house=new House();

    @Override
    void setArea() {
        house.area=278;
    }

    @Override
    BedRoom createBedRoom() {
        BedRoom bedRoom=new BedRoom();
        bedRoom.qty=5;
        return bedRoom;
    }

    @Override
    WashRoom createWashRoom() {
        WashRoom washRoom=new WashRoom();
        washRoom.qty=3;
        return washRoom;
    }

    @Override
    Garage createGarage() {
        Garage garage=new Garage();
        garage.qty=2;
        return garage;
    }


    @Override
    House composite() {
        setArea();
        BedRoom bedRoom = createBedRoom();
        WashRoom washRoom = createWashRoom();
        Garage garage = createGarage();

        //组装产品House的相关属性
        house.bedRoom=bedRoom;
        house.washRoom=washRoom;
        house.garage=garage;
        return house;
    }
}

步骤四：定义具体指挥者

public class Director {

    private HouseBuilder builder;

    public Director(HouseBuilder builder){
        this.builder=builder;
    }


    public House build(){

        return builder.composite();
    }
}

步骤五：测试

public class Main {

    public static void main(String[] args) {


        NormalHouseBuilder builder=new NormalHouseBuilder();
        Director director=new Director(builder);


        //建制普通型的房子
        House house = director.build();
        System.out.println(house.area);
        System.out.println(house.bedRoom.qty);
        System.out.println(house.washRoom.qty);
        System.out.println(house.garage.qty);



        //建制豪华型的房子
        LuxuriousHouseBuilder builder1=new LuxuriousHouseBuilder();
        Director director1=new Director(builder1);
        House house1 = director1.build();
        System.out.println(house1.area);
        System.out.println(house1.bedRoom.qty);
        System.out.println(house1.washRoom.qty);
        System.out.println(house1.garage.qty);
    }
}

UML类图如下：

通过上述代码分析可知：生成器设计模式分为i欸四个关键角色：产品,抽象生成器，具体生成器，以及指挥者