建造者模式

建造者模式适用于对于逐渐的拼凑，极大提升灵活性
但是产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类。
比如现在我有一个需求生产洋娃娃
有两个公司分别生产组成产品不同的部分，洋娃娃是一个整体

//组件接口
public interface Moduel {
    String getInfo();
    Company getCompany();
    String getPrice();
}
//公司接口
public interface Company {
    String getCompany();
}
//公司实现
public class HeadCompany implements Company {
    @Override
    public String getCompany() {
        return "专业制造头的生产商";
    }
}
public class BodyCompany implements Company {
    @Override
    public String getCompany() {
        return "专业制造身体生产商";
    }
}

//抽象组件类
public abstract class Body  implements Moduel{
    @Override
    public Company getCompany() {
        return new BodyCompany();
    }
}
public abstract class Head implements Moduel {
    @Override
    public Company getCompany() {
        return new HeadCompany();
    }
}
//组件实现类

public class ManHead extends Head {
    @Override
    public String getInfo() {
        return "男性的头";
    }

    @Override
    public String getPrice() {
        return "1￥";
    }
}
public class ManBody extends Body{
    @Override
    public String getInfo() {
        return "男性的身体";
    }

    @Override
    public String getPrice() {
        return "10￥";
    }
}
public class WomanBody extends  Body{
        @Override
        public String getInfo() {
            return "女性的身体";
        }

        @Override
        public String getPrice() {
            return "8￥";
        }
}
public class WomanHead extends Head {
        @Override
        public String getInfo() {
            return "女性的头";
        }

        @Override
        public String getPrice() {
            return "1￥";
        }

}

//洋娃娃

import java.util.ArrayList;
import java.util.List;

public class Yangwawa {
    private List<Moduel> moduels=new ArrayList<>();
    public void addModuel(Moduel moduel){
        moduels.add(moduel);
    }
    public void getInfo(){
        for (Moduel moduel:moduels) {
            System.out.print("Company : " + moduel.getCompany().getCompany());
            System.out.print(" Model ："+moduel.getInfo());
            System.out.println(" price : "+moduel.getPrice());
        }
    }
    public void getCost(){
        int _cost=0;
        for (Moduel moduel:moduels) {
            String price = moduel.getPrice();
          _cost+=Integer.parseInt(price.substring(0,price.lastIndexOf("￥")));
        }
        System.out.println("总价 ："+_cost+"￥");
    }
}


//洋娃娃生产者
public class YangwawaBulider {
    public Yangwawa getManWaWa(){
        Yangwawa yangwawa=new Yangwawa();
        yangwawa.addModuel(new ManBody());
        yangwawa.addModuel(new ManHead());
        return yangwawa;
    }
    public Yangwawa getWomanWaWa(){
        Yangwawa yangwawa=new Yangwawa();
        yangwawa.addModuel(new WomanBody());
        yangwawa.addModuel(new WomanHead());
        return yangwawa;
    }
}
//测试类
public class BuliderDemo {
    public static void main(String[] args) {
        YangwawaBulider yangwawaBulider=new YangwawaBulider();
        Yangwawa manWaWa = yangwawaBulider.getManWaWa();
        System.out.println("创建一个男性娃娃");
        manWaWa.getInfo();
        manWaWa.getCost();
        System.out.println("创建一个女性娃娃");
        YangwawaBulider yangwawaBulider1=new YangwawaBulider();
        Yangwawa womanWaWa = yangwawaBulider1.getWomanWaWa();
        womanWaWa.getInfo();
        womanWaWa.getCost();
    }
}

----out------------------
创建一个男性娃娃
Company : 专业制造身体生产商 Model ：男性的身体 price : 10￥
Company : 专业制造头的生产商 Model ：男性的头 price : 1￥
总价 ：11￥
创建一个女性娃娃
Company : 专业制造身体生产商 Model ：女性的身体 price : 8￥
Company : 专业制造头的生产商 Model ：女性的头 price : 1￥
总价 ：9￥

跟抽象工厂相比，抽象工厂处理的是整个产品族的变化
而建造者模式是更精细与各个组件的拼接