Java设计模式之工厂模式

一 初探

 java工厂模式分为：简单工厂模式(静态工厂)，工厂方法模式，抽象工厂模式。

直接上图UML：

二：解析，直接上代码：

1，简单工厂模式(静态工厂)

• SimpleProdcutFactory为一般类，含有static方法creat()，所以也叫静态工厂。
• creat()方法中用if或者switch做逻辑判断生产相应对象

优点：
最大的优点在于工厂类中包含了必要的逻辑，根据客户需要的逻辑动态实例化相关的类。
缺点：
不方便扩展业务，每当有新的产品产生时，均要维护工厂类

//产品
public abstract class IPaper {
    /**
     * 产品描述
     * @return
     */
    public abstract String desc();
}
public class A3Paper extends IPaper{
    @Override
    public String desc() {
        return "这是A3纸张，面子大";
    }
}
public class A4Paper extends IPaper {
    @Override
    public String desc() {
        return "这是A4纸张，你值得拥有！";
    }
}
/**
 * 简单工厂（也叫静态工厂：ceate方法为静态方法）
 */
public class SimpleFactroy {
    private static final int TYPE_A3 = 1;
    private static final int TYPE_A4 = 2;

    public static IPaper creat(int type){
        switch (type){
            case TYPE_A3:
                return new A3Paper();
            case TYPE_A4:
                default:
                return new A4Paper();

        }
    }
}
//测试
    public static void main(String[] args) {
        IPaper paper = SimpleFactroy.creat(SimpleFactroy.TYPE_A4);
        System.out.println(paper.desc());
    }

2，工厂方法模式

优点：

• 创建对象的接口，让子类决定具体实例化的对象，把简单的内部逻辑判断移到了客户端。
• 工厂方法模式克服了简单工厂所违背的开闭原则的缺点，又保持了封装对象创建过程的优点。扩展性高，想要增加一个产品，只要扩展一个工厂类就可以。

//产品
public interface ICar {
    public void desc();
}
public class BaomaCar implements ICar {
    @Override
    public void desc() {
        System.out.println("这是一辆宝马车");
    }
}
public class BaoshijieCar implements ICar {
    @Override
    public void desc() {
        System.out.println("这是一辆保时捷");
    }
}
//工厂方法模式
public interface IMethodFactory {
    public ICar creat();
}

public class BaomaCarMethodFactory implements IMethodFactory {
    @Override
    public ICar creat() {
        return new BaomaCar();
    }
}
public class BaoshijieCarMethodFactory implements IMethodFactory {
    @Override
    public ICar creat() {
        return new BaoshijieCar();
    }
}
//测试
    public static void main(String[] args) {
        IMethodFactory factory = new BaomaCarMethodFactory();
        ICar car = factory.creat();
        car.desc();
    }

3，抽象工厂模式

优点：

• 当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

//产品
public interface Door {
    public void open();
}
public interface Window {
    public int getSize();
}
public class CarADoor  implements Door{
    @Override
    public void open() {
        System.out.println("car-A门打开。好cool啊");
    }
}
public class CarAWindow implements Window{
    @Override
    public int getSize() {
        return 111;
    }
}
public class CarBDoor implements Door {
    @Override
    public void open() {
        System.out.println("car-B门打开。好拉风。。。");
    }
}
public class CarBWindow implements Window {
    @Override
    public int getSize() {
        return 222;
    }
}
//抽象工厂模式
public interface IAbstractFactcory {
    public Door creatDoor();
    public Window creatWindow();
}
public class FactoryA implements IAbstractFactcory {
    @Override
    public Door creatDoor() {
        return new CarADoor();
    }

    @Override
    public Window creatWindow() {
        return new CarAWindow();
    }
}
public class FactoryB implements IAbstractFactcory {
    @Override
    public Door creatDoor() {
        return new CarBDoor();
    }

    @Override
    public Window creatWindow() {
        return new CarBWindow();
    }
}
//测试
    public static void main(String[] args) {
        IAbstractFactcory factcory =  new FactoryA();
        Door door = factcory.creatDoor();
        door.open();
        Window window = factcory.creatWindow();
        System.out.println(window.getSize());
    }