设计模式之工厂模式（简单工厂+工厂模式+抽象工厂）

参考博文：https://www.cnblogs.com/toutou/p/4899388.html   侵权必删

什么是工厂模式：通过“对象创建”模式绕开new，来避免对象创建(new)过程中所导致的紧耦合（依赖具体类）。

适用性：使用new创建对象且导致紧耦合的场景。

思考：面向对象编程要以动态的思维去看待代码。换句话说，在看代码时需要时间概念，发现代码在未来的稳定之处和变化之处。一般接口和抽象类是稳定的，而具体实现是变化的，这也是面向接口/抽象编程的原因，可以使代码更加稳定。

先思考如下场景：目前只有一种ProductA，需要productA时，使用代码 ProductA pa = new ProductA()。如果未来需求变化，添加ProductB、ProductC等，会导致上述代码是不稳定。因为ProductA pa = new ProductA() 这俩部分都依赖了具体实现。

将ProductA、ProductB、ProductC抽象出Product，改写代码Product pa = new ProductA()，目前依然依赖nProductA，工厂问题就是为了解决这种new依赖的问题。

一、简单工厂模式

基本代码：

package simpleFactory;

public abstract class Produce {
    public abstract void readme();
}

package simpleFactory;

public class ProductA extends Produce{
    @Override
    public void readme() {
        System.out.println("AAAAAAA");
    }
}

package simpleFactory;

public class ProduvtB extends Produce {
    @Override
    public void readme() {
        System.out.println("BBBBBBBBBB");
    }
}

package simpleFactory;

public class SimpleFacory {
    public Produce getProduce(String type){
        if(type.equals("A")) {
            return new ProductA();
        }else if(type.equals("B")){
            return new ProduvtB();
        }else {
            System.out.println("typr error");
        }
        return null;
    }
}

    public static void main(String[] args) {
////---------------简单工厂模式---------------------
////        通过向工厂传递参数而获取期望的对象，单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。
////          明确区分了各自的职责和权力，有利于整个软件体系结构的优化。
////          但是工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高内聚的责任分配原则
//
//        SimpleFacory sf = new SimpleFacory();
//        Produce p = sf.getProduce("A");
//        p.readme();
//    }
}

二、工厂模式

package FactoryMethod;

import simpleFactory.Produce;

public abstract class Factory {
    public abstract Produce getProduce();

}

package FactoryMethod;

import simpleFactory.Produce;
import simpleFactory.ProductA;

public class FactoryA extends Factory{
    @Override
    public Produce getProduce() {
        return new ProductA();
    }
}

package FactoryMethod;

import simpleFactory.Produce;
import simpleFactory.ProduvtB;

public class FactoryB extends Factory {
    @Override
    public Produce getProduce() {
        return new ProduvtB();
    }
}

////------------------工厂模式------------------------
        Factory f = new FactoryA(); //这里使用new的方式代替，实际情况下应该根据需要传入具体的工厂
        Produce p = f.getProduce(); //均依赖抽象
        p.readme();

三、抽象工厂模式（可以认为抽象工厂模式是工厂模式的一般形式）

package AbstractFactory;

public abstract class ProduceNumber {
    public abstract void readme();
}

package AbstractFactory;

/**
 * 只能与产品A配套
 */
public class Produce1 extends ProduceNumber {
    public void readme(){
        System.out.println("111111111");
    }
}

package AbstractFactory;
/**
 * 只能与产品B配套
 */
public class Produce2 extends ProduceNumber {
    public void readme() {
        System.out.println("222222");
    }
}

package AbstractFactory;

import simpleFactory.Produce;

public abstract class AbstractFactory {
    public abstract Produce getProduce();
    public abstract ProduceNumber getProduceNumber();
}

package AbstractFactory;

import simpleFactory.Produce;
import simpleFactory.ProductA;

public class FactoryA1 extends AbstractFactory {
    @Override
    public Produce getProduce() {
        return new ProductA();
    }

    @Override
    public ProduceNumber getProduceNumber() {
        return new Produce1();
    }
}

package AbstractFactory;


import simpleFactory.Produce;
import simpleFactory.ProduvtB;

public class FactoryB2 extends AbstractFactory{
    @Override
    public Produce getProduce() {
        return new ProduvtB();
    }

    @Override
    public ProduceNumber getProduceNumber() {
        return new Produce2();
    }
}

//--------------------抽象工厂模式-----------------------
//        有产品A和产品1配套，产品B和产品2配套。如果只用工厂模式需要4个具体工厂，且有可能出现产品不匹配的问题。
//        抽象工厂模式为创建一组相关或相互依赖的对象提供一个接口，保证产品的配套问题，使得上述问题只要两个工厂。
//        适用场合：多个需要配套的产品


        AbstractFactory f = new FactoryA1();//这里使用new的方式代替，实际情况下应该根据需要传入具体的工厂
        Produce p = f.getProduce();
        ProduceNumber pn = f.getProduceNumber();
        p.readme();
        pn.readme();