大话设计模式——工厂模式（Factory Method）

1. 常见的工厂模式主要有四种，这里用图形绘制来做个例子

(1) 普通工厂模式

首先定义一个接口

package designPatterns;

public interface Draw {
    
    public void draw();

}

然后定义一些具体的类，这些类都是继承了这个接口的，比如画一个三角形，或者画一个矩形。这里定义一个三角形的类，然后定义一个矩形的类

package designPatterns;

public class Rectangle implements Draw {

    @Override
    public void draw() {
        // TODO Auto-generated method stub
        System.out.println("draw a rectangle");
        
    }

}

package designPatterns;

public class Triangle implements Draw{

    @Override
    public void draw() {
        // TODO Auto-generated method stub
        System.out.println("draw a triangle");
        
    }

}

最后定义一个简单的工厂类，用来生产这些类

package designPatterns;

public class SimpleFactory {
    
    public Draw drawGraphics(String type){
        if("Rectangle".equals(type)){
            return new Rectangle();
        }else if("Triangle".equals(type)){
            return new Triangle();
        }else{
            System.out.println("Wrong type");
            return null;
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SimpleFactory sf = new SimpleFactory();
        Draw draw1 = sf.drawGraphics("Rectangle");
        Draw draw2 = sf.drawGraphics("Triangle");
        draw1.draw();
        draw2.draw();
    }

}

这就是一个普通的工厂类，普通的工厂类需要传递正确的参数，才能创建相应的实例。

(2) 工厂方法模式（多工厂模式）

工厂方法模式就是将每一个类的创建封装到一个函数中，然后工厂负责调用函数来生产相应的类，具体实现和测试代码如下

package designPatterns;

public class MultipleFactory {
    
    public Draw RectangleProduce(){
        return new Rectangle();
    }
    
    public Draw TriangleProduce(){
        return new Triangle();
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MultipleFactory mf = new MultipleFactory();
        Draw draw1 = mf.RectangleProduce();
        Draw draw2 = mf.TriangleProduce();
        draw1.draw();
        draw2.draw();    

    }

}

(3) 静态工厂方法模式

在工厂方法模式的基础上，在每一个produce函数前加上static，这样就可以不用先new一个工厂类，而是可以直接调用工厂类了。这个是static关键字的性质。

 

(4) 抽象工厂模式

上面的三种工厂模式都有一个缺点，就是类的创建必须依赖于工厂类。如果现在想要再扩展一个circle类用来画圆，则必须重新修改上述的三种工厂类。抽象工厂模式就是为了解决这个方法而存在的。抽象工厂的总体结构如图所示：

新建一个接口

package designPatterns;

public interface Provider {
    public Draw provider();
}

将两个画图分别分装在两个工厂中，两个工厂分别实现上述的接口

package designPatterns;

public class RectFactory implements Provider{

    @Override
    public Draw provider() {
        // TODO Auto-generated method stub
        return new Rectangle();
    }
    

}

package designPatterns;

public class TriangleFactory implements Provider {

    @Override
    public Draw provider() {
        // TODO Auto-generated method stub
        return new Triangle();
    }

}

在使用的时候，只需要用Provider接口来调用即可

package designPatterns;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Provider p1 = new RectFactory();
        Draw draw1 = p1.provider();
        Provider p2 = new TriangleFactory();
        Draw draw2 = p2.provider();
        draw1.draw();
        draw2.draw();

    }

}

抽象工厂的模式扩展起来比较简单，只需要重新定义一个其他的类，以及相应的工厂即可，分别继承与两个接口，就可以同过provider接口来调用了