设计模式一

工厂模式

优点
1.创建对象只需要知道其名称
2.增加产品只需要添加对应产品接口的子类，对其他产品没有影响
3.对调用者屏蔽了类的具体实现过程
缺点
每次增加一个产品时都需要添加新的产品子类并修改实例化工厂，既增加了系统复杂度又增加了类之间的耦合性。
实现

/**
 * 创建一个接口
 */
interface Car{
    void run();
}

/**
 * 创建具体的实现类
 */
class BaoMa implements Car{
    @Override
    public void run() {
        System.out.println("the BaoMa is run...");
    }
}

class BenChi implements Car{
    @Override
    public void run() {
        System.out.println("the BenChi is run...");
    }
}

class AoDi implements Car{
    @Override
    public void run() {
        System.out.println("the AoDi is run...");
    }
}

/**
 * 创建类的实例化工厂
 */
class CarFactory{
    public Car getCar(String name) {
        switch (name) {
            case "BaoMa" : return new BaoMa();
            case "BenChi" : return new BenChi();
            case "AoDi" : return new AoDi();
            default: return null;
        }
    }
}
public class FactoryPattern {
    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        Car baoMa = carFactory.getCar("BaoMa");
        baoMa.run();
        Car benChi = carFactory.getCar("BenChi");
        benChi.run();
        Car aoDi = carFactory.getCar("AoDi");
        aoDi.run();
    }
}

抽象工厂模式

当一个产品系类有多个产品族的时候，工厂模式不适合进行实例化，此时可以用抽象工厂模式进行产品的实例化。
优点
当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
缺点
产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。
实现

interface Car{
    void run();
}

/**
 * 创建具体的实现类
 */
class BaoMa implements Car {
    @Override
    public void run() {
        System.out.println("the BaoMa is run...");
    }
}

class BenChi implements Car {
    @Override
    public void run() {
        System.out.println("the BenChi is run...");
    }
}

class AoDi implements Car {
    @Override
    public void run() {
        System.out.println("the AoDi is run...");
    }
}

interface Color{
    void getColor();
}

class Red implements Color{
    @Override
    public void getColor() {
        System.out.println("the color is red");
    }
}

class Blue implements Color{
    @Override
    public void getColor() {
        System.out.println("the color is blue");
    }
}

interface AbstractFactory{
    Car getCar(String name);
    Color getColor(String name);
}

class CarFactory implements AbstractFactory{

    @Override
    public Car getCar(String name) {
        switch (name) {
            case "BaoMa" : return new BaoMa();
            case "BenChi" : return new BenChi();
            case "AoDi" : return new AoDi();
            default: return null;
        }
    }

    @Override
    public Color getColor(String name) {
        return null;
    }
}

class ColorFactory implements AbstractFactory{

    @Override
    public Car getCar(String name) {
        return null;
    }

    @Override
    public Color getColor(String name) {
        switch (name){
            case "red": return new Red();
            case "blue":return  new Blue();
            default: return null;
        }
    }
}

class FactoryProduce{
    public AbstractFactory getFactory(String name){
        switch (name){
            case "car" : return new CarFactory();
            case "color" : return new ColorFactory();
            default: return null;
        }
    }
}

public class AbstractFactoryPattern {
    public static void main(String[] args) {
        FactoryProduce factoryProduce = new FactoryProduce();
        AbstractFactory carFactory = factoryProduce.getFactory("car");
        AbstractFactory colorFactory = factoryProduce.getFactory("color");
        Car baoMa = carFactory.getCar("BaoMa");
        baoMa.run();
        Car benChi = carFactory.getCar("BenChi");
        benChi.run();
        Color red = colorFactory.getColor("red");
        red.getColor();
    }
}

单例模式

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
饿汉式实现

class Car{
    private static Car car = new Car();

    private Car(){}

    public static Car getInstance(){
        return car;
    }

    public void run(){
        System.out.println("the car is run....");
    }
}

懒汉式实现

class Car{
    private static Car car = null;

    private Car(){}

    public static Car getInstance(){
        if(car == null){
            synchronized(Car.class) {
                if(car == null){
                    car = new Car();
                }
            }
        }
        return car;
    }

    public void run(){
        System.out.println("the car is run....");
    }
}

建造者模式

建造者模式也是一种实例化类的模式，主要是用来实例化一些内部比较复杂的内，例如当我们吃快餐的时候，往往会有各种套餐选择，套餐中有不同的单品，如汉堡、饮料等，他们都有自己的名称，不同单品还需要不同的容器承装，饮料还需要指定大杯还是中杯等，此时工厂模式已经不能很好的对这些类进行实例化，这时候我们可以采用建造者模式，将套餐当成整体进行组装。
实现

/**
 * 单品类
 */
abstract class Item {
    /**
     * 单品名称
     */
    public String name;
    /**
     * 单品价格
     */
    public float price;
    /**
     * 承装容器
     */
    public Container container;

    abstract void print();

}

/**
 * 汉堡抽象类
 */
abstract class Hamburger extends Item{
    @Override
    public void print(){
        System.out.println("名称:"+name+",价格:"+price+",使用:"+container.name+"承装");
    }
}

/**
 * 鸡肉汉堡
 */
class ChickenHamburger extends Hamburger{
    public ChickenHamburger(){
        this.name = "鸡肉汉堡";
        this.price = 12.5f;
        this.container = new PackingBox();
    }
}

/**
 * 牛肉汉堡
 */
class BeefHamburger extends Hamburger{
    public BeefHamburger(){
        this.name = "牛肉汉堡";
        this.price = 17.5f;
        this.container = new PackingBox();
    }

}

/**
 * 饮品抽象类
 */
class Drink extends Item{
    public String size;
    @Override
    public void print(){
        System.out.println("名称:"+name+",价格:"+price+",型号:"+size+",使用:"+container.name+"承装");
    }
}

/**
 * 可乐
 */
class Cola extends Drink{
    public Cola(String size){
        this.name = "可乐";
        this.price = 5f;
        this.container = new Bottle();
        this.size = size;
    }
}

/**
 * 奶茶
 */
class Coffee extends Drink{
    public Coffee(String size){
        this.name = "咖啡";
        this.price = 7f;
        this.container = new Bottle();
        this.size = size;
    }
}

/**
 * 容器抽象类
 */
abstract class Container{
    public String name;
}

class PackingBox extends Container{
    public PackingBox(){
        this.name = "包装盒";
    }
}

class Bottle extends Container{
    public Bottle(){
        this.name = "瓶子";
    }
}

/**
 * 套餐
 */
class Meal{
    private String name;
    //套餐内的单品集合
    private List<Item> items = new ArrayList<Item>();

    public Meal(String name){
        this.name = name;
    }

    public void add(Item item){
        items.add(item);
    }

    public void showItem(){
        System.out.println(name+"内的单品有:");
        items.forEach(item -> item.print());
    }
}

/**
 * 生成套餐的工厂
 */
class MealFactory{
    public Meal getMeal1(){
        Meal meal = new Meal("套餐1");
        meal.add(new ChickenHamburger());
        meal.add(new Cola("大杯"));
        return meal;
    }

    public Meal getMeal2(){
        Meal meal = new Meal("套餐2");
        meal.add(new BeefHamburger());
        meal.add(new Coffee("中杯"));
        return meal;
    }
}
public class BuildPattern {
    public static void main(String[] args) {
        MealFactory mealFactory = new MealFactory();
        Meal meal1 = mealFactory.getMeal1();
        meal1.showItem();
        Meal meal2 = mealFactory.getMeal2();
        meal2.showItem();
    }
}

注:
建造者模式更加注重类的之间的组装关系而工厂模式注重类的实例化方式，两者之间可以混合使用