20190121——不羡神仙 Java建造者（Builder）模式

构建起（Builder）模式使用简单对象并使用逐步方法构建复杂对象，这种类型的设计模式属于创建模式，因为此模式提供了创建对象的最佳方法之一

构建器（Builder）模式构建器逐步构建最终对象，次构建器独立于其他对象。

实例
我们考虑一家快餐的商业案例，其中典型的餐点可能是汉堡或者冷饮，汉堡是一个素食汉堡或鸡肉汉堡，将被包装进行包装，冷饮可以是一个可乐或者百事将装在一个瓶子里

我们创建一个Item接口，表示食品项目，如汉堡类和饮料以及实现Item接口的具体类，还有一个包装接口，表示食品包装和实现包装接口的具体类，因为汉堡包装和冷饮包装成瓶子

然后创建一个具有ItemListList和MealBuilder的Meal类，通过组合Item来构建不同类型的Meal对象，BuilderPatternDemo，这是一个演示类将使用MealBuilder构建一个食品套餐

代码好多
第一步
创建两个接口分别代表食品和包装的项目
Item.java

package 建造者模式;

public interface Item {
    public String name();
    public Packing packing();
    public float price();
}

Packing.java

package 建造者模式;

public interface Packing {
    public String pack();
}

第二步
创建实现Packing的具体类
Wrapper.java

package 建造者模式;

public class Wrapper implements Packing {
    @Override
    public String pack() {
        return "Wrapper";
    }
}

Bottle.java

package 建造者模式;

public class Bottle implements Packing {
    @Override
    public String pack() {
        return "Bottle";
    }
}

第三步
创建抽象类实现Item接口提供的默认功能
Burger.java

package 建造者模式;

public abstract class Burger implements Item {
    @Override
    public Packing packing() {
        return new Wrapper();
    }

    @Override
    public abstract float price();
}

ColdDrink.java

package 建造者模式;

public abstract class ColdDrink implements Item{
    @Override
    public Packing packing() {
        return new Bottle();
    }

    @Override
    public abstract float price();
}

第四步
创建扩展汉堡（Burger）和冷饮（ColdDrink）类的具体类
VegBurgur.java

package 建造者模式;

public class VegBurgur extends Burger {
    @Override
    public float price() {
        return 25.0f;
    }

    @Override
    public String name() {
        return "Veg Burger";
    }
}

ChickenBurger.java

package 建造者模式;

public class ChickenBurger extends Burger {
    @Override
    public String name() {
        return "ChickenBurger";
    }

    @Override
    public float price() {
        return 50.5f;
    }
}

Coke.java

package 建造者模式;

public class Coke extends ColdDrink {
    @Override
    public float price() {
        return 30.0f;
    }

    @Override
    public String name() {
        return "Coke";
    }
}

Pespi.java

package 建造者模式;

public class Pepsi extends ColdDrink {
    @Override
    public String name() {
        return "Pepsi";
    }

    @Override
    public float price() {
        return 35.0f;
    }
}

第五步
创建一个具有上面定义的Item对象的Meal类

package 建造者模式;

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

public class Meal {
    private List<Item> items=new ArrayList<Item>();
    public void addItem(Item item){
        items.add(item);
    }
    public float getCost(){
        float cost =0.0f;
        for(Item item :items){
            cost+=item.price();
        }
        return cost;
    }
    public void showItems(){
        for(Item item:items){
            System.out.println("Item"+item.name());
            System.out.println("Packing"+item.packing().pack());
            System.out.println("Price"+item.price());
        }
    }
}

第六步
创建一个MealBuilder类，这是一个实际的构建类负责创建Meal对象

package 建造者模式;

public class MealBuilder {
    public Meal prepareVegMeal(){
        Meal meal =new Meal();
        meal.addItem(new VegBurgur());
        meal.addItem(new Coke());
        return meal;
    }
    public Meal preparNonVegMeal(){
        Meal meal =new Meal();
        meal.addItem(new ChickenBurger());
        meal.addItem(new Pepsi());
        return meal;
    }
}

第七步
BuilderPatternDemo类使用MealBuilder对象来演示构建器模式

package 建造者模式;

public class BuilderPatternDemo {
    public static void main(String[] args) {
        MealBuilder mealBuilder=new MealBuilder();
        Meal vegMeal =mealBuilder.prepareVegMeal();
        System.out.println("Veg Meal");
        vegMeal.showItems();
        System.out.println("Total cost:"+vegMeal.getCost());

        Meal nonVegMeal =mealBuilder.preparNonVegMeal();
        System.out.println("\n\nNon-Veg Meal");
        nonVegMeal.showItems();
        System.out.println("Total Cost:"+nonVegMeal.getCost());
    }
}

---

说点别的？ 建造者模式：是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示 工厂模式提供创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后Test结合起来得到的。

应用实例：
1.肯德基，汉堡，可乐，薯条，炸鸡翅是不变的，而组合是经常变化的，生成出所谓的“套餐”
2.Java中的StringBuilder

网上看到一个实例造人

public class Human {
	private String head;
	private String body;
	private String hand;
	private String foot;
	public String getHead() {
		return head;
	}
	public void setHead(String head) {
		this.head = head;
	}
	public String getBody() {
		return body;
	}
	public void setBody(String body) {
		this.body = body;
	}
	public String getHand() {
		return hand;
	}
	public void setHand(String hand) {
		this.hand = hand;
	}
	public String getFoot() {
		return foot;
	}
	public void setFoot(String foot) {
		this.foot = foot;
	}
}
--------------------- 
作者：易灬小侠 
来源：CSDN 
原文：https://blog.csdn.net/u010102390/article/details/80179754 
版权声明：本文为博主原创文章，转载请附上博文链接！

创建了一个人的类，human类，只要是人都是从这个类出来的
那我们想要造人，得有一个标准，来造人的话得有一个步骤，头，身体，手，脚，都得有