纯手写理解设计模式代码之工厂模式

工厂模式属于创建型模式:

抽象工厂模式

package com.demo.abstractFactory;

/**
 * 抽象工厂模式
 * 创建型设计模式
 * 就是将一类相同类型的产品抽象为产品族
 * 例如将苹果、苹果树、苹果汁抽象为苹果工厂
 * 这样生产这一产品系列的对象效率大大提升
 * 抽象工厂和方法工厂的对比：
 * 工厂方法适用产生单一产品
 * 抽象工厂适用生产大量同类产品，例如再抽象一类梨子水果产品，十分方便，但是有一缺点：
 * 例如在AbstractFactoryFruit下需要多加一个类型的工厂如：果干工厂
 * 那么将要修改顶层生产工厂的代码，并影响所有的实现类，不符合开闭原则
 */
interface AbstractFactoryFruit {
}

//水果工厂
interface Fruit extends AbstractFactoryFruit{

}
//水果树工厂
interface FruitTree extends AbstractFactoryFruit{

}
//果汁工厂
interface FruitJuice extends  AbstractFactoryFruit{

}

//顶层生产工厂
interface ProductFactory{
    Fruit getFruit();
    FruitTree getFruitTree();
    FruitJuice getFruitJuice();
}

package com.demo.abstractFactory;

/**
 * 抽象工厂模式
 * 创建型设计模式
 * 就是将一类相同类型的产品抽象为产品族
 * 例如将苹果、苹果树、苹果汁抽象为苹果工厂
 * 这样生产这一产品系列的对象效率大大提升
 * 抽象工厂和方法工厂的对比：
 * 工厂方法适用产生单一产品
 * 抽象工厂适用生产大量同类产品，例如再抽象一类梨子水果产品，十分方便，但是有一缺点：
 * 例如在AbstractFactoryFruit下需要多加一个类型的工厂如：果干工厂
 * 那么将要修改顶层生产工厂的代码，并影响所有的实现类，不符合开闭原则
 */
interface AbstractFactoryFruit {
}

//水果工厂
interface Fruit extends AbstractFactoryFruit{

}
//水果树工厂
interface FruitTree extends AbstractFactoryFruit{

}
//果汁工厂
interface FruitJuice extends  AbstractFactoryFruit{

}

//顶层生产工厂
interface ProductFactory{
    Fruit getFruit();
    FruitTree getFruitTree();
    FruitJuice getFruitJuice();
}

package com.demo.abstractFactory;

/**
 * 抽象工厂模式
 * 创建型设计模式
 * 就是将一类相同类型的产品抽象为产品族
 * 例如将苹果、苹果树、苹果汁抽象为苹果工厂
 * 这样生产这一产品系列的对象效率大大提升
 * 抽象工厂和方法工厂的对比：
 * 工厂方法适用产生单一产品
 * 抽象工厂适用生产大量同类产品，例如再抽象一类梨子水果产品，十分方便，但是有一缺点：
 * 例如在AbstractFactoryFruit下需要多加一个类型的工厂如：果干工厂
 * 那么将要修改顶层生产工厂的代码，并影响所有的实现类，不符合开闭原则
 */
interface AbstractFactoryFruit {
}

//水果工厂
interface Fruit extends AbstractFactoryFruit{

}
//水果树工厂
interface FruitTree extends AbstractFactoryFruit{

}
//果汁工厂
interface FruitJuice extends  AbstractFactoryFruit{

}

//顶层生产工厂
interface ProductFactory{
    Fruit getFruit();
    FruitTree getFruitTree();
    FruitJuice getFruitJuice();
}

package com.demo.abstractFactory;

/**
 * 抽象工厂模式
 * 创建型设计模式
 * 就是将一类相同类型的产品抽象为产品族
 * 例如将苹果、苹果树、苹果汁抽象为苹果工厂
 * 这样生产这一产品系列的对象效率大大提升
 * 抽象工厂和方法工厂的对比：
 * 工厂方法适用产生单一产品
 * 抽象工厂适用生产大量同类产品，例如再抽象一类梨子水果产品，十分方便，但是有一缺点：
 * 例如在AbstractFactoryFruit下需要多加一个类型的工厂如：果干工厂
 * 那么将要修改顶层生产工厂的代码，并影响所有的实现类，不符合开闭原则
 */
interface AbstractFactoryFruit {
}

//水果工厂
interface Fruit extends AbstractFactoryFruit{

}
//水果树工厂
interface FruitTree extends AbstractFactoryFruit{

}
//果汁工厂
interface FruitJuice extends  AbstractFactoryFruit{

}

//顶层生产工厂
interface ProductFactory{
    Fruit getFruit();
    FruitTree getFruitTree();
    FruitJuice getFruitJuice();
}

package com.demo.abstractFactory;

/**
 * 抽象工厂模式
 * 创建型设计模式
 * 就是将一类相同类型的产品抽象为产品族
 * 例如将苹果、苹果树、苹果汁抽象为苹果工厂
 * 这样生产这一产品系列的对象效率大大提升
 * 抽象工厂和方法工厂的对比：
 * 工厂方法适用产生单一产品
 * 抽象工厂适用生产大量同类产品，例如再抽象一类梨子水果产品，十分方便，但是有一缺点：
 * 例如在AbstractFactoryFruit下需要多加一个类型的工厂如：果干工厂
 * 那么将要修改顶层生产工厂的代码，并影响所有的实现类，不符合开闭原则
 */
interface AbstractFactoryFruit {
}

//水果工厂
interface Fruit extends AbstractFactoryFruit{

}
//水果树工厂
interface FruitTree extends AbstractFactoryFruit{

}
//果汁工厂
interface FruitJuice extends  AbstractFactoryFruit{

}

//顶层生产工厂
interface ProductFactory{
    Fruit getFruit();
    FruitTree getFruitTree();
    FruitJuice getFruitJuice();
}

工厂方法模式

package com.demo.factory;

import com.demo.singleton.SingletonTest;
import com.demo.test.A;
import com.demo.test.B;
import com.demo.test.Father;

/**
 * 工厂方法模式
 * 创建型设计模式
 * 根据依赖倒置原则的面向接口编程思想,将工厂类抽象成接口
 * 实现更灵活
 * 但是若需要创建的对象很多，则会造成实现类急剧增加，因为必须为每一种新对象创建一个实现类
 */
interface FactoryMethod {
   Father getFather();
}

class AFactory implements FactoryMethod{

    public Father getFather() {
        return new A();
    }
}

class BFactory implements FactoryMethod{

    public Father getFather() {
        return new B();
    }
}

实例工厂模式

package com.demo.factory;

/**
 * 实例工厂
 * 创建对象必须先创建工厂实例
 * 但是可以继承重写，灵活性更高
 */
public class InstanceFactory {
    public <A,B> A getInstance(B type){
        //通过判断传入的字段返回不同的对象
        if(type instanceof StaticFactory){
            //...
        }else{
            //...
        }
        return null;
    }
}

静态工厂模式

package com.demo.factory;

/**
 * 静态工厂--使用静态方法
 * 无需创建工厂实例，直接用类名点出来
 * 缺点是无法被重写，不能更好的实现多态
 */
public class StaticFactory {
    public static <A,B> A getInstance(B type){
        //通过判断传入的字段返回不同的对象
        if(type instanceof StaticFactory){
            //...
        }else{
            //...
        }
        return null;
    }

}