设计模式之“工厂模式”

创建型模式之“工厂模式”

1. 工厂模式简述

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

2. 实例代码

2.1 产品相关代码

//产品接口
public interface IProduct {
    void productMethod();
}

//产品实现
public class Product implements IProduct {
    @Override
    public void productMethod() {
        System.out.println("This is Product Method...");
    }
}

2.2 工厂相关代码

//工厂接口
public interface IFactory {
    IProduct createProduct();
}


//工厂实现
public class Factory implements IFactory {
    @Override
    public IProduct createProduct() {
        return  new Product();
    }
}

3. 工厂模式的优点

• 可以使代码结果清晰，有效地封装变化。
• 降低耦合度。

3.1 工厂模式有四个要素：

1. 产品接口：定义产品的规范。
2. 产品实现：实现产品接口中具体类，决定产品在客户端的具体行为。
3. 工厂接口：工厂方法的核心。规范工厂“产出”的产品。
4. 工厂实现：决定如何实例化产品。

3.2 工厂模式的适用场景：

工厂模式是解耦模式，如果需要增加类之间的依赖关系时，可以考虑适用工厂模式。或者当系统需要良好的扩展性的时候，也可以考虑工厂模式。

4. 实例2

创建一个电脑类(Computer)：由显示器(LCD) 和 主机(Host)构成。

代码如下

//主机实现代码
public class Host implements IHost {
    @Override
    public void show() {
        System.out.println("This is Computer's Host...");
    }
}

//显示器实现代码
public class LCD implements ILCD {
    @Override
    public void show() {
        System.out.println("This is Computer's LCD...");
    }
}

//电脑实现代码
public class Computer implements IComputer{

    private IHost host;
    private ILCD lcd;

    public Computer(IHost host, ILCD lcd){
        this.host = host;
        this.lcd = lcd;
    }

    @Override
    public void show(){
        host.show();
        lcd.show();
    }

}

若不使用工厂模式：

public class TestMain {
    public static void main(String[] args) {
        IHost host = new Host();
        ILCD lcd = new LCD();
        Computer computer = new Computer(host, lcd);
        computer.show();
    }
}

我们需要一个个创建实例，然后再组合成一个电脑。

使用工厂模式后：

public class Factory implements IFactory {
    @Override
    public IComputer getComputer() {
        IHost host = new Host();
        ILCD lcd = new LCD();
        IComputer computer = new Computer(host, lcd);
        return computer;
    }
}

public class TestMain {
    public static void main(String[] args) {
        IFactory factory = new Factory();
        IComputer computer = factory.getComputer();
        computer.show();
    }
}

很明显，我们不用关心电脑是怎么创建的，只在用到电脑的时候通过工厂创建出一个电脑。这样大大减少了耦合度，对于扩展性，如果我们电脑需要其他组件，再在工厂中增加相应的东西的就行了，对于客户端代码无需改动。此代码相比于之前的代码，灵活性和稳定性都得到了极大的提高。