设计模式（一）

工厂方法模式

工厂方法模式是定义一个工厂接口，将对象的创建放到工厂的实现类中。

优点：

1. 只需知道名称就能获得产品
2. 新增产品只需添加具体工厂类和具体产品类，无需对原工厂进行修改，满足开闭式原则

缺点：

1. 每增加一个产品就要增加一个具体产品类和对应具体工厂类

模式结构

由抽象工厂，具体工厂，抽象产品，具体产品组成

public class FactoryTest {
    public static void main(String[] args) {
        Product productA = getProduct("productA");
        Product productB = getProduct("productB");
        productA.show();
        productB.show();
    }
	//获取产品的方法 通过名称判断
    public static Product getProduct(String ProductName){
        switch (ProductName){
            case "productA":
                return new ProductAFactory().newProduct();
            case "productB":
                return new ProductBFactory().newProduct();
            default:
                    return null;
        }
    }
}
//产品接口 也可为抽象类
interface Product{
   void show();
}
//产品A
class ProductA implements Product{
    @Override
    public void show() {
        System.out.println("产品A");
    }
}
//产品B
class ProductB implements Product{
    @Override
    public void show() {
        System.out.println("产品B");
    }
}
//抽象工厂
interface Factory{
   Product newProduct();
}
//产品A工厂
class ProductAFactory implements Factory{
    public Product newProduct(){
        return new ProductA();
    }
}
//产品B工厂
class ProductBFactory implements Factory{
    public Product newProduct(){
        return new ProductB();
    }
}

抽象工厂模式

工厂模式是用来产生同一个产品不同类型的，
抽象工厂是用来产生不同产品不同类型的，抽象工厂意味着需要抽象类

优点:

1. 只需修改工厂
2. 新增种类很方便

缺点:

1. 新增等级结构很麻烦，需要修改抽象层

模式结构

由抽象工厂，具体工厂，抽象类接口，抽象类，具体产品组成

public class AbstractFactory {
    public static void main(String[] args) {
        ShapeFactory f = new RedFactory();
        f.getCircle().draw();
        f.getRectange().draw();
    }
}

interface Shape{
    void draw();
}

abstract class Circle implements Shape{
    public abstract void  draw();
}
abstract class Retange implements Shape{
    public abstract void  draw();
}

class BlueCircle extends Circle{
    @Override
    public void draw() {
        System.out.println("蓝色圆");
    }
}

class RedCircle extends Circle{
    @Override
    public void draw() {
        System.out.println("红色圆");
    }
}

class RedRetange extends Retange{
    @Override
    public void draw() {
        System.out.println("红色方");
    }
}

class BlueRetange extends Retange{
    @Override
    public void draw() {
        System.out.println("蓝色方");
    }
}

interface ShapeFactory{
    Shape getCircle();
    Shape getRectange();
}

class RedFactory implements ShapeFactory{

    @Override
    public Shape getCircle() {
        return new  RedCircle();
    }

    @Override
    public Shape getRectange() {
        return new RedRetange();
    }
}

https://blog.csdn.net/zyhlwzy/article/details/80707488
https://blog.csdn.net/varyall/article/details/82355964