设计模式02:简单工厂模式、工厂方法模式、抽象工厂、生成器模式

1.创建型模式(Creational Pattern)

创建型模式：对类的实例化过程进行了抽象，能够将软件模块中对象的创建和对象的使用分离。为了使软件的结构更加清晰，外界对于这些对象只需要知道它们共同的接口,而不清楚其具体的实现细节，使整个系统的设计更加符合单一职责原则。

1. 2 简单工厂模式/静态工厂方法模式

Factory：工厂角色

Product：抽象产品角色

ConcreteProduct：具体产品角色

缺点：只提供一个工厂类，当有新产品要加入到该系统，必须要修改工厂类，违背“开闭原则”

实现代码：

package SimpleFactory01;

/**
 * 01:简单工厂模式/静态工厂方法
 */
public class SimpleFactory {
    public static void main(String[] args) {
        System.out.println("简单工厂模式/静态工厂方法");
        //直接调用静态方法即可，不需要new
        Product product = Factory.createProduct("A");
        product.info();
        Product product1 = Factory.createProduct("B");
        product1.info();

    }
}

class Factory{
    public static Product createProduct(String type){
        Product product=null;
        switch (type){
            case "A":
                product=new ProductA();
                break;
            case "B":
                product=new ProductB();
                break;
            default:
                System.out.println("没有这个类型的产品信息");
                break;
        }
        return product;
    }
}

abstract class Product{
    public abstract void info();
}
class ProductA extends Product{
    @Override
    public void info(){
        System.out.println("产品信息: A");
    }
}
class ProductB extends Product{
    @Override
    public void info(){
        System.out.println("产品信息: B");
    }
}

1.2 工厂方法模式/多态工厂模式/虚拟构造器模式

在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。

Product：抽象产品

ConcreteProduct：具体产品

Factory：工厂

ConcreteFactory：具体工厂

核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给其子类去完成

可以允许系统在不修改工厂角色的情况下引进新产品

增加具体产品-->增加具体工厂，符合“开闭原则”

 具体代码实例：

 

package FactoryMethod02;

/**
 * 02:工厂方法
 * 1.意图:定义一个用于创建对象的接口，让子类决定实例化哪一个类。
 * Factory Method使一个类的实例化延迟到其子类。
 * 2.适用于：
 *      当一个类不知道她所必须创建的对象的类（在SimpleFactory中需要传入参数"A"或"B"来指定要创建的对象）
 *      当一个类希望由子类来指定她所创建的对象的时候
 */
public class FactoryMethod {

    public static void main(String[] args) {
        System.out.println("工厂方法");
        //创建对象接口，让其子类决定实例化哪一个类
        Factory factory=new FactoryA();
        Product productA = factory.createProduct();
        productA.info();

        //productB
        Factory factory1 = new FactoryB();
        Product productB = factory1.createProduct();
        productB.info();

    }

}


interface Factory{
    public Product createProduct();
}

class FactoryA implements Factory{

    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

class FactoryB implements Factory{

    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

interface Product {
    public void info();
}
class ProductA implements Product{

    @Override
    public void info() {
        System.out.println("产品信息: A");
    }
}
class ProductB implements Product{

    @Override
    public void info() {
        System.out.println("产品信息: B");
    }
}

1.3抽象工厂模式

 实例代码

package AbstractFactory03;

/**
 * 抽象工厂
 *
 */

public class AbstractFactory {
    public static void main(String[] args) {
        Factory factory1 = new Factory1();
        ProductA productA = factory1.createProductA();//A1
        ProductB productB = factory1.createProductB();//B1
        productA.info();
        productB.info();
        Factory factory2 = new Factory2();
        ProductA productA1 = factory2.createProductA();//A2
        ProductB productB1 = factory2.createProductB();//B2
        productA1.info();
        productB1.info();
    }
}

interface Factory{
    public ProductA createProductA();
    public ProductB createProductB();
}
class Factory1 implements Factory{
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}
class Factory2 implements Factory{
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ProductB2();
    }
}
interface ProductA{
    public void info();
}
class ProductA1 implements ProductA{
    @Override
    public void info() {
        System.out.println("A类产品信息: A1");
    }
}
class ProductA2 implements ProductA{
    @Override
    public void info() {
        System.out.println("A类产品信息: A2");
    }
}
interface ProductB{
    public void info();
}
class ProductB1 implements ProductB{
    @Override
    public void info() {
        System.out.println("B类产品信息: B1");
    }
}
class ProductB2 implements ProductB{
    @Override
    public void info() {
        System.out.println("B类产品信息: B2");
    }
}

1.4 生成器模式

 

代码示例：

 

package Builder04;

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

/**
 * 生成器模式:
 * 意图:将一个复杂对象的构建于它的表示分离，使得同样的构建过程可以创建不同的表示
 * 适用于：
 *  1.当创建复杂对象的算法应该独立于该对象组成部分以及他们的装配方式时
 *  2.当构造过程必须允许被构造的对象有不同的表示
 */
public class Main {
    public static void main(String[] args) {
        Director director=new Director();
        //生成器
        Builder builder1 = new Builder1();
        //生成产品
        director.Contruct(builder1);
        //获取产品
        Product product1 = builder1.getResult();
        product1.show();
    }
}

class Director{
    public void Contruct(Builder builder){
        builder.BuildPart();
    }
}


abstract class Builder{

    public abstract void BuildPart();
    public abstract Product getResult();

}
class Builder1 extends Builder{
    Product product = new Product();

    @Override
    public void BuildPart() {
         product.addPart("A");
         product.addPart("B");
         product.addPart("C");
    }

    @Override
    public Product getResult() {
        return product;
    }
}
class Builder2 extends Builder{
    Product product = new Product();

    @Override
    public void BuildPart() {
        product.addPart("D");
        product.addPart("E");
        product.addPart("F");
    }

    @Override
    public Product getResult() {
        return product;
    }
}


class Product {

    List<String> parts = new ArrayList<>();

    public void addPart(String part){
        parts.add(part);
    }

    public void show(){
        System.out.println("产品组成: ");
        for (String p:parts) {
            System.out.print(p+" ");
        }
        System.out.println();
    }

}