Car_Factory.png

什么是工厂模式

• 工厂模式是一种广泛使用的设计模式，被广泛使用与JDK和一些框架中，比如著名的Spring和Struts框架。
• 工厂模式使用的场景：当有多个子类有一个相同的基类，根据不同的输入，产生不同的子类对象的输出，在高层次设计好之后被Client类调用。Cilent只需要告诉Factory它需要什么类型的对象，Factory就给它生成对应的对象。
• 举个例子：比如我们写俄罗斯方块这个小游戏，有各种各样的图形，但它们都继承自一个Shape的基类，我们在游戏中需要随机产生图形对象，那么此时就可以使用工厂设计模式。

工厂模式如何实现

Super class(父类)

--Super class in factory pattern can be an interace，abstract class or nomal java class.
--作为父类可以是一个接口，一个抽象类或者是一个正常的java类
--看一个例子：Computer.java
--这是一个抽象的基类
<code>
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();
}
}
</code>

Sub Class(子类)

--这里有两个Computer的实现类：PC和Server；

• PC.java
  <code>
  package com.journaldev.design.model;
  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;
  }

}</code>

• Server.java
  <code>
  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;
}

}</code>

• 注意：以上两个类都是继承自Computer，实际工程中我们还可以有其他的若干子类

Factory Class(工厂类)

--已经有了父类和基类，那么接下来我们可以写我们的工厂类了，下面是一个基本的实现：

• ComputerFactory.java
  <code>
  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;
  

  }
  }
  </code>
  --此处，我们可以当工厂类为单例或者让返回不同对象的工厂方法为public static的。
  --注意：工厂方法根据不同的输入参数，返回不同的子类对象

• 下面是一个简单的模型图：

  
  
  factory-model.png

• TestFatory.java
  <code>
  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);
}

}
out:
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
</code>

工厂模式的好处

--使用工厂模式，我们把创建对象的代码从Client脱离出来，Client只需要调用我们提供的接口方法，而具体实现被我们所隐藏，使得代码更健壮，高内聚，易扩展。比如，我们可以轻易的改变PC的实现代码因为Client程序并不知道它原来的具体实现。