总章目录，设计模式（一）基本介绍

一、定义

工厂设计：定义一个创建对象的接口，让子类觉得实例化哪个类，对象的统一创建交由工厂完成，有良好的的封装性。

工程模式包含以下三种类型：

模式	优点	缺点
简单工厂	明确区分了各自的职责和权力，有利于整个软件体系结构的优化。	工厂类集中了所有实例的创建逻辑，违反高内聚的责任分配原则
工厂模式	增加了灵活性，产品类的实现如何变化，调用者都不需要关心，只需关心产品的接口，只要接口保持不变，系统中的上层模块就不会发生变化。	需要Creator和相应的子类作为factory method的载体。
抽象工厂	增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。	增加新的产品等级结构很复杂，需要修改抽象工厂和所有的具体工厂类，对“开闭原则”的支持呈现倾斜性。

二、简单工厂

2.1、案例分析

这是我们的饮料工厂，为了对应各种饮料，通常我们会创建一个基类，通过多态来创建不同的饮料，现在我们先使用简单工厂模式完成这部分功能。

2.2、基本介绍

简单工厂模式是属于创建型模式，又叫做静态工厂方法。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。
工厂方法模式的主要角色如下:
工厂（Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
具体产品（ConcreteProduct）:实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

2.3、案例实现——基本工厂

Product：饮品

public interface Drinks {

    void showDes();
}

ConcreteProduct

public class ColeDrink implements Drinks{
    @Override
    public void showDes() {
        System.out.println("可口可乐！");
    }
}

public class SpriteDrink implements Drinks{
    @Override
    public void showDes() {
        System.out.println("雪碧！");
    }
}

public class OriginDrink implements Drinks{
    @Override
    public void showDes() {
        System.out.println("橘子饮料！");
    }
}

Factory

public abstract class Factory {

    public Drinks orderDrink(String type) {
        System.out.println("点餐");
        //制作
        Drinks drinks = createDrink(type);
        drinks.showDes();
        System.out.println("打包");
        return drinks;
    }

    abstract Drinks createDrink(String  type);
}


/**
 * 可乐工厂生成可乐和雪碧
 */
public  class ColeFactory extends Factory{

    @Override
    Drinks createDrink(String type) {
        Drinks drinks = null;
        switch (type){
            case "cole":
                drinks=new ColeDrink();
            break;
            case "split":
                drinks=new SpriteDrink();
        }
        return drinks;
    }
}

public class OriginFactory extends Factory{

    @Override
    Drinks createDrink(String type) {
        Drinks drinks = null;
        switch (type){
            case "origin":
                drinks=new OriginDrink();
                break;
        }
        return drinks;
    }
}

开始购买

public class Main {
    public static void main(String[] args) {
        Factory coleFactory=new ColeFactory();
        coleFactory.orderDrink("cole");
        Factory originFactory=new OriginFactory();
        originFactory.orderDrink("origin");
    }
}

三、抽象工厂

3.1、基本介绍

抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

3.2、案例实现——抽象工厂

ProductA

public abstract class DrinksA {
   public abstract void getDrinks();
}

public class ColaA1 extends DrinksA {
    @Override
    public void getDrinks() {
        System.out.println("可乐A1");
    }
}

public class ColaA2 extends DrinksA {
    @Override
    public void getDrinks() {
        System.out.println("可乐A2");
    }
}

ProductB

public abstract class DrinksB {
   public abstract void getDrinks();
}

public class SpriteB1 extends DrinksB {
    @Override
    public void getDrinks() {
        System.out.println("雪碧B1");
    }
}

public class SpriteB2 extends DrinksB {
    @Override
    public void getDrinks() {
        System.out.println("雪碧B2");
    }
}