设计模式之工厂方法

Posted 2020-07-06 d_pay

工厂方法（Factory Method Pattern）

意图：

　　定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使得一个类的实例化延迟到其子类。

类图：（来自oodesign）

　　

 

工厂：工厂一般分为简单工厂，工厂方法和抽象工厂，用于创建对象，降低类间的耦合度，简单工厂可看做工厂方法的特例。

一般来说，工厂方法模式用于创建复杂对象。相比抽象工厂，工厂方法一般用于创建一个层次级别的对象，而抽象工厂更适合创建一系列不同层别的对象

如下一个创建文件的例子：

文件对象

public abstract class AbstractDocument {
    public abstract void open();
    public void save(String file){
        System.out.println(file+" is saved");
    }
    public abstract void close();
}

public class htmlDocument extends AbstractDocument{
    @Override
    public void open(){
        System.out.println("html file is open");
    }

    @Override
    public void close() {
        System.out.println("html file is closed");
    }
}

public class XMLDocument extends AbstractDocument{
    @Override
    public void open(){
        System.out.println("xml file is open");
    }

    @Override
    public void close() {
        System.out.println("xml file is closed");
    }
}

 

工厂类

　　

public abstract class Creator {
    AbstractDocument document = null;
    public abstract AbstractDocument CreateDocument(String type);
    public void newDocument(String type){
        document = CreateDocument(type);
        document.open();
    }
    public void close(){
        if(document!=null){
            document.close();
        }
    }
}

public class ConcreteCreator extends Creator{
    @Override
    public AbstractDocument CreateDocument(String type){
        if(type.equals("html"))
            return new HtmlDocument();
        else
            return new XMLDocument();
    }
}

 

 

客户端：

public class Client {
    public static void main(String[] args) {
        Creator creator = new ConcreteCreator();
        creator.newDocument("xml");
        creator.close();
        System.out.println("------------------");
        creator.newDocument("html");
        creator.close();
    }
}


/*

xml file is open
xml file is closed
------------------
html file is open
html file is closed

*/

 

工厂方法降低了类间的耦合度，对于创建较复杂的对象，可以很好的将其的创建封装在工厂方法中，保证对象间遵循迪米特法则。

如创建汽车：

public class Client {  
    public static void main(String[] args) {  
        Engine engine = new Engine();  
        Underpan underpan = new Underpan();  
        Wheel wheel = new Wheel();  
        ICar car = new Car(underpan, wheel, engine);  
        car.show();  
    }  
}  

 

陌生的类出现在了类的方法中，明显不符迪米特法则，这是便可以利用工厂方法模式：

interface IFactory {  
    public ICar createCar();  
}  
class Factory implements IFactory {  
    public ICar createCar() {  
        Engine engine = new Engine();  
        Underpan underpan = new Underpan();  
        Wheel wheel = new Wheel();  
        ICar car = new Car(underpan, wheel, engine);  
        return car;  
    }  
}  
public class Client {  
    public static void main(String[] args) {  
        IFactory factory = new Factory();  
        ICar car = factory.createCar();  
        car.show();  
    }  
}