关于工厂模式的探究

关于工厂模式的探究：
工厂模式分为三种:
1.简单工厂模式
2.工厂模式
3.抽象工厂模式

1.简单工厂模式的具体特征是 只有三个对象。 1. 工厂 2. 抽象的产品  3. 真实产品

public class Test {
    //抽象的产品
    public interface InterfaceProduct{
        void run();
    }
    //真实产品
    public static class   Product implements InterfaceProduct{
        public void run(){
            System.out.print("Product RUN");
        }
    }
    //工厂
    public static class Factor{
        InterfaceProduct getProduct(){
            return new Product();
        }
    }
    
    public static void main(String[] args) {
        Factor f = new Factor();
        InterfaceProduct ip = f.getProduct();
        ip.run();
    }
}

2.工厂模式
将上述的简单工厂进行拓展可以得到 如果将工厂也抽象画 产品由抽象的工厂产生呢

public class Test {
    //抽象的产品
    public  interface  InterfaceProduct{
         void run();
    }
    //真实产品
    public static class   Product implements InterfaceProduct{
        public void run(){
            System.out.print("Product RUN");
        }
    }
    
    //抽象工厂
    public static abstract class InterfaceFactor{
        abstract InterfaceProduct getProduct();
    }
    
    //工厂
    public  static class Factor extends InterfaceFactor{
        public InterfaceProduct getProduct(){
            return new Product();
        }
    }
    
    
    public static void main(String[] args) {
        InterfaceFactor f = new Factor();
        InterfaceProduct ip = f.getProduct();
        ip.run();
    }
}

总结：简单工厂模式和工厂模式的区别在于 简单工厂模式的产品由工厂直接产生，不经过一个子工厂的概念。
而如果工厂模式子工厂就一个的情况下，也可以直接使用简单工厂模式来完成。
工厂模式的核心为：抽象商品和商品的关系为实现，抽象工厂和工厂的关系为继承。

思考1： 在使用工厂模式的时候 为什么使用子工厂来代替工厂产生商品。 这样可以拓展出很多的工厂来生产不同的产品 提高抽象工厂这段代码的复用率。
思考2：在使用工厂模式的时候 为什么产品都被定为为抽象的。  这样当这个工厂生产Product2，Product3 的时候 我们就不需要修改实现中的代码了。
代码始终为InterfaceProduct ip = f.getProduct();  否则 当产品为产品2的时候 代码应该为 Product2 product2， = f.getProduct(); 仅仅需要在工厂类
修改代码 public InterfaceProduct getProduct(){return new Product2();}  可以极大的减少代码修改量。



3.抽象工厂

抽象工厂为工厂的一个特殊模式 。当一个工厂可以生产很多的产品的时候，如果用工厂模式拓展的话，可以出现很多工厂1，工厂2，工厂3去生产不同的产品。
还有一种解决方案为使用抽象工厂
public class TestAbstractFactor {
    static interface Product{
        void use();
    }
    //食物
    static class Food implements Product{
        public void use() {
            System.out.println("eat");
        }
    }
    //玩具
    static class Toy implements Product{
        public void use() {
            System.out.println("play");
        }
    }
    //武器
    static class Weapon implements Product{
        public void use() {
            System.out.println("kill people");
        }
    }
    static abstract class AbstractFactor{
        public abstract Food createFood();
        public abstract Toy createToy();
        public abstract Weapon createWeapon();
    }
    
    static class Factor extends AbstractFactor{
        @Override
        public Food createFood() {
            return new Food();
        }
        @Override
        public Toy createToy() {
            return new Toy();
        }
        @Override
        public Weapon createWeapon() {
            return new Weapon();
        }
        
    }

    public static void main(String[] args) {
        AbstractFactor af = new Factor();
        Product p1 = af.createFood();
        p1.use();
        Product p2 = af.createToy();
        p2.use();
        Product p3 = af.createWeapon();
        p3.use();
    }

}

输出结果为
eat
play
kill people

总结：抽象工厂模式适用于工厂可以产生很多的产品，并且不想产生太多的工厂类的情况下。理论上抽象工厂模式可以和工厂模式相互转化。