设计模式第2篇：简单工厂、工厂方法、抽象工厂设计模式

1.简单工厂设计模式

　特点：一个抽象的产品类、多个具体的产品类、一个具体的工厂类。

　（1）抽象的产品类(例如产品为手机屏幕)

　　　 public interface Screen{

　　　　　　void screenSize（）；

　　　　}

　（2）具体的产品类（例如需要5英寸和6英寸的手机屏幕）

　　　 public class Screen5 implements Screen{

　　　　　　@Override

　　　　　　public void screenSize(){

　　　　　　　　System.out.println("生产5英寸的屏幕")

　　　　　　}

　　　　}

　　　　public class Screen6 implements Screen{

　　　　　　@Override

　　　　　　public void screenSize(){

　　　　　　　　System.out.println("生产6英寸的屏幕")

　　　　　　}

　　　　}

　　　　

　（3）一个具体工厂类(生产手机屏幕的工厂)

　　　  public class ScreenFactory {

　　　　　　public Screen produceScreen（int size）{

　　　　　　　　if （size == 5）{

　　　　　　　　　　return new Screen5();

　　　　　　　　}else if (size==6) {

　　　　　　　　　　return new Screen6();

　　　　　　　　}

　　　　　　}

　　　　}

　　使用场景：产品个数已知并且固定。

　　优缺点：实现简单，当产品个数固定时推荐使用，由于增加产品种类时需要修改工厂类，所以破坏了开闭设计原则（对扩展开放，对修改关闭）。

2.抽象工厂模式

　特点：一个抽象的产品类，多个具体的产品类，一个抽象的工厂类，多个具体的工厂类

　（1）抽象的产品类(例如产品为手机屏幕)

　　　 public interface Screen{

　　　　　　void screenSize（）；

　　　　}

　（2）具体的产品类（例如需要5英寸和6英寸的手机屏幕）

　　　 public class Screen5 implements Screen{

　　　　　　public Screen5(){

　　　　　　　　System.out.println("生产5英寸的屏幕")

　　　　　　}

　　　　}

　　　　public class Screen6 implements Screen{

　　　　　　public Screen6(){

　　　　　　　　System.out.println("生产6英寸的屏幕")

　　　　　　}

　　　　}

　　　　

　（3）一个抽象工厂类(生产手机屏幕的抽象工厂)

　　　  public interface ScreenAbstractFactory {

　　　　　　public Screen produceScreen（）；

　　　　}

　（4）生产具体屏幕尺寸的生产线

　　　　public class Screen5Factory implements ScreenAbstractFactory{

　　　　　　@Override

　　　　　　public Screen produceScreen(){

　　　　　　　　return new Screen5();

　　　　　　}

　　　　}

　　　　public class Screen6Factory implements ScreenAbstractFactory{

　　　　　　@Override

　　　　　　public Screen produceScreen(){

　　　　　　　　return new Screen6();

　　　　　　}

　　　　}

　（5）总工厂（拥有多条生产线的工厂）

　　　　public class ScreenFactory{

　　　　　　pubilc static createScreen（ScreenAbstractFactory factory）{

　　　　　　　　return factory.produceScreen();

　　　　　　}

　　　　}

　　优缺点：优点面向接口编程而不是面向实现，易于扩展。

3.用内部类实现抽象工厂方法模式

　　特点：一个抽象产品类，一个抽象工厂类，匿名内部类实现了抽象工厂的具体产品类

//一个抽象产品类
interface Screen{
    void screenSize();
}
//一个抽象工厂类
interface ScreenFactory{
    Screen produceScreen();
}
//匿名内部类实现了抽象工厂的具体产品类
class Screen5 implements Screen{
    public void screenSize(){
        System.out.println("生产5英寸屏幕");
    }
    private Screen5(){

    }
    public static ScreenFactory factory=new ScreenFactory() {
        @Override
        public Screen produceScreen() {
            return new Screen5();
        }
    };
}
//匿名内部类实现了抽象工厂的具体产品类
class Screen6 implements Screen{
    public void screenSize(){
        System.out.println("生产6英寸屏幕");
    }
    private Screen6(){

    }
    public static ScreenFactory factory=new ScreenFactory() {
        @Override
        public Screen produceScreen() {
            return new Screen6();
        }
    };
}
public class FactoryMethod {
    static Screen produceScreen(ScreenFactory factory){
        return factory.produceScreen();
    }
    public static void main(String[] agrs){
        FactoryMethod factoryMethod=new FactoryMethod();
        Screen screen5=factoryMethod.produceScreen(Screen5.factory);
        Screen screen6=factoryMethod.produceScreen(Screen6.factory);
        screen5.screenSize();
        screen6.screenSize();
    }
}