设计模式之-工厂模式（Factory Pattern）

工厂模式是造物设计模式之一，它广泛适用于JDK以及像Spring和Struts框架。

工厂设计模式是用来当我们有一个超类多个子类，并根据输入情况，我们需要返回的子类之一。这种模式采取了类的实例化，从客户端程序的工厂类的责任。首先让我们了解如何在Java中实现工厂模式，然后我们将了解它的好处，我们会看到它在JDK中使用。

超类：

在工厂设计模式中可以设计为接口，抽象类，或者一个普通类。在我们这个例子中我们设计为抽象类并重写toString()方法实现测试目的。

Computer.java

package com.journaldev.design.model;
 
public abstract class Computer {
     
    public abstract String getRAM();
    public abstract String getHDD();
    public abstract String getCPU();
     
    @Override
    public String toString(){
        return "RAM= "+this.getRAM()+", HDD="+this.getHDD()+", CPU="+this.getCPU();
    }
}

子类：

这里我们实现两个子类pc及服务器实现computer

PC.java

public class PC extends Computer {
 
    private String ram;
    private String hdd;
    private String cpu;
     
    public PC(String ram, String hdd, String cpu){
        this.ram=ram;
        this.hdd=hdd;
        this.cpu=cpu;
    }
    @Override
    public String getRAM() {
        return this.ram;
    }
 
    @Override
    public String getHDD() {
        return this.hdd;
    }
 
    @Override
    public String getCPU() {
        return this.cpu;
    }
 
}

注意这两个类都需要继承Computer

Server.java

package com.journaldev.design.model;
 
 
public class Server extends Computer {
 
    private String ram;
    private String hdd;
    private String cpu;
     
    public Server(String ram, String hdd, String cpu){
        this.ram=ram;
        this.hdd=hdd;
        this.cpu=cpu;
    }
    @Override
    public String getRAM() {
        return this.ram;
    }
 
    @Override
    public String getHDD() {
        return this.hdd;
    }
 
    @Override
    public String getCPU() {
        return this.cpu;
    }
 
}

工厂类：

我们已经实现好了超类和子类，接下来创建工厂类

package com.journaldev.design.factory;
 
import com.journaldev.design.model.Computer;
import com.journaldev.design.model.PC;
import com.journaldev.design.model.Server;
 
public class ComputerFactory {
 
    public static Computer getComputer(String type, String ram, String hdd, String cpu){
        if("PC".equalsIgnoreCase(type)) return new PC(ram, hdd, cpu);
        else if("Server".equalsIgnoreCase(type)) return new Server(ram, hdd, cpu);
         
        return null;
    }
}

1，工厂类应该设计为单例模式或者使用一个静态方法返回子类实例对象

2，根据参数的不同创建不同子类实例并返回

下面是一个测试程序，根据以上实现工厂模式

package com.journaldev.design.test;
 
import com.journaldev.design.abstractfactory.PCFactory;
import com.journaldev.design.abstractfactory.ServerFactory;
import com.journaldev.design.factory.ComputerFactory;
import com.journaldev.design.model.Computer;
 
public class TestFactory {
 
    public static void main(String[] args) {
        Computer pc = ComputerFactory.getComputer("pc","2 GB","500 GB","2.4 GHz");
        Computer server = ComputerFactory.getComputer("server","16 GB","1 TB","2.9 GHz");
        System.out.println("Factory PC Config::"+pc);
        System.out.println("Factory Server Config::"+server);
    }
 
}

输出结果：

Factory PC Config::RAM= 2 GB, HDD=500 GB, CPU=2.4 GHz

Factory Server Config::RAM= 16 GB, HDD=1 TB, CPU=2.9 GHz

工厂设计模式好处：

1，工厂模式提供的方法来规范接口而不是实现。

2，工厂模式将去除了客户端代码去实现类的实例化，使其更健壮，低少耦合，易于扩展。例如，我们可以很容易地更改电脑类的实现，客户端程序是不必知道这一点。

3，工厂模式通过继承提供了实现和客户端类的抽象。

工厂模式在jdk中得实现：

1，java.util.Calendar中，资源包和NumberFormat的某个getInstance（）方法使用工厂模式。
2，valueOf（）方法中如Boolean，Integer等包装类的方法