三类工厂模式分析

简单工厂模式

简单工厂模式是工厂模式里面最简单的模式，它定义了一个创建对象的类，由这个类来封装实例化对象的行为。再简单一点来说就是实现了生成产品类的代码和客户端代码分离，在工厂类中你可以添加所需的生成产品的代码。

产品的共同接口：

package factory;

public interface Product {
    //声明类所需继承的共同接口，也可以是抽象类
}

产品类A

package factory;

public class ProductA implements Product {
    public ProductA() {
        System.out.println("ProductA");
    }
}

产品类B

package factory;

public class ProductB implements Product {
    public ProductB() {
        System.out.println("ProductB");
    }
}

工厂类

package factory;

 */
public class Factory {
    //可以在工厂类中添加任何你所需要的产品
    public static Product create(String str)
    {
        //生成ProductA
        if(str.equalsIgnoreCase("ProductA"))
        {
            return new ProductA();
        }
        else
            //生成ProductB
            if(str.equalsIgnoreCase("ProductB"))
            {
                return new ProductB();
            }
        return null;
    }

}

客户端代码

package factory;

public class Client {
    public static void main(String[] args) {
        //调用Factory的静态方法生成所要的类
        Factory.create("productA");
        Factory.create("ProductB");
    }
}

简单工厂模式实现了生成产品类的代码和客户端代码分离，在工厂类中你可以添加所需要的产品代码，但是好的代码的原则是对扩展开发，对修改关闭。如果要增加产品c的话，你就要修改工厂类里面的生成产品的代码，在工厂代码里你需要添加if else判断就可以。

工厂模式

增加了产品c

package factoryMehtod;

public class ProductC implements Product {
    public ProductC() {
        System.out.println("productC");
    }
}

声明工厂接口

package factoryMehtod;

public interface Factory {
    //声明产生产品类的方法
    public Product createProduct();
}

产品A

package factoryMehtod;

public class FactoryA implements Factory {
    //实现工厂类的方法生成产品类A
    public Product createProduct()
    {
        return new ProductA();
    }

}

产品B

package factoryMehtod;

public class FactoryB implements Factory {
    //实现工厂类的方法生成产品类B
    public Product createProduct()
    {
        return new ProductB();
    }
}

产品C

package factoryMehtod;

public class FactoryC implements Factory {
    //实现工厂类的方法生成产品类C
    public Product createProduct()
    {
        return new ProductC();
    }
}

客户端

package factoryMehtod;

public class Client {
    public static void main(String[] args) {
        Factory factory;
        factory = new FactoryA();
        factory.createProduct();
        factory = new FactoryB();
        factory.createProduct();
        factory = new FactoryC();
        factory.createProduct();
    }
}

工厂方法模式中我们把生成的产品类的时间延迟（将对象的实例化推迟到了子类），通过相应的工厂类来生成对应的产品类。遵循了上面提到的扩展开放，修改封闭的原则。无论增加多少产品，我们都不用修改原来的代码，只需要增加产品工厂即可。但是这还是有缺点的，如果产品类过多，我们就要很多的工厂类。假如我们要试下的产品的接口不止一个，也就是有多个产品接口，不同产品接口有对应的产品族，我们就要采用抽象工厂模式。

增加gift接口

package abstractFactory;

public interface Gift {
    //声明产品赠品的接口，当然也可以是抽象类，同样为了简单就不声明方法了
}

giftA

package abstractFactory;

public class GiftA implements Gift {
    public GiftA()
    {
        System.out.println("GiftA");
    }
}

giftB

package abstractFactory;

public class GiftB implements Gift {
    public GiftB()
    {
        System.out.println("GiftB");
    }
}

工厂

package abstractFactory;
/*
 声明Product类工厂和Gift类工厂的工同工厂接口
 */
public interface Factory {
    public Product createProduct();
    public Gift createGift();

}

生成giftA和产品A

package abstractFactory;
/*
 *FactoryA可以生成ProductA和GiftA
 */
public class FactoryA implements Factory {
   @Override
    public Product createProduct()
    {
        return new ProductA();
    }
   @Override
    public Gift createGift()
    {
        return new GiftA();
    }
}

生成giftB和产品B

package abstractFactory;
/*
 *FactoryB可以生成ProductB和GiftB
 */
public class FactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
    @Override
    public Gift createGift() {
        return new GiftB();
    }

}

客户端

package abstractFactory;

public class Client {
    public static void main(String[] args) {
        Factory factory;
        factory = new FactoryA();
        factory.createProduct();
        factory.createGift();
        factory = new FactoryB();
        factory.createProduct();
        factory.createGift();
    }
}

抽象工厂模式我们可以定义实现不止一个接口，一个工厂可以生成不止一个产品。对象实例化对主程序依赖极大时，就要提取出来

总结：

1. 变量不持有实体类的引用
2. 不要让类继承自具体类，要继承抽象类或接口
3. 不要覆盖基类已经实现的方法