一、简单工厂模式一个具体工厂创建一种产品

源代码

public interface Cpu {
public void calculate();
}public class IntelCpu implements Cpu {
/**
    * CPU的针脚数
    */
   private int pins = 0;
public IntelCpu(int pins){
this.pins = pins;
}
@Override
   public void calculate() {
System.out.println("Intel CPU的针脚数：" + pins);
}
}

public class AmdCpu implements Cpu {
/**
    * CPU的针脚数
    */
   private int pins = 0;
public AmdCpu(int pins){
this.pins = pins;
}
@Override
   public void calculate() {
System.out.println("AMD CPU的针脚数：" + pins);
}
}
 public interface Mainboard {
public void installCPU();
}
public class IntelMainboard implements Mainboard {
/**
    * CPU插槽的孔数
    */
   private int cpuHoles = 0;
/**
    * 构造方法，传入CPU插槽的孔数
    * @param cpuHoles
    */
   public IntelMainboard(int cpuHoles){
this.cpuHoles = cpuHoles;
}
@Override
   public void installCPU() {
System.out.println("Intel主板的CPU插槽孔数是：" + cpuHoles);
}
}public class AmdMainboard implements Mainboard {
/**
    * CPU插槽的孔数
    */
   private int cpuHoles = 0;
/**
    * 构造方法，传入CPU插槽的孔数
    * @param cpuHoles
    */
   public AmdMainboard(int cpuHoles){
this.cpuHoles = cpuHoles;
}
@Override
   public void installCPU() {
System.out.println("AMD主板的CPU插槽孔数是：" + cpuHoles);
}
}public class CpuFactory {
public static Cpu createCpu(int type){
Cpu cpu = null;
if(type == 1){
cpu = new IntelCpu(755);
}else if(type == 2){
cpu = new AmdCpu(938);
}
return cpu;
}
}public class MainboardFactory {
public static Mainboard createMainboard(int type){
Mainboard mainboard = null;
if(type == 1){
mainboard = new IntelMainboard(755);
}else if(type == 2){
mainboard = new AmdMainboard(938);
}
return mainboard;
}
}public class ComputerEngineer {
/**
    * 定义组装机需要的CPU
    */
   private Cpu cpu = null;
/**
    * 定义组装机需要的主板
    */
   private Mainboard mainboard = null;
public void makeComputer(int cpuType , int mainboard){
/**
        * 组装机器的基本步骤
        */
       //1:首先准备好装机所需要的配件
       prepareHardwares(cpuType, mainboard);
//2:组装机器
       //3:测试机器
       //4：交付客户
   }
private void prepareHardwares(int cpuType , int mainboard){
//这里要去准备CPU和主板的具体实现，为了示例简单，这里只准备这两个
       //可是，装机工程师并不知道如何去创建，怎么办呢？
       //直接找相应的工厂获取
       this.cpu = CpuFactory.createCpu(cpuType);
this.mainboard = MainboardFactory.createMainboard(mainboard);
//测试配件是否好用
       this.cpu.calculate();
this.mainboard.installCPU();
}
}public class Client {
public static void main(String[]args){
ComputerEngineer cf = new ComputerEngineer();
cf.makeComputer(1,1);
}
}
二、工厂方法模式一个抽象的工厂接口创建一种抽象的产品，由具体的子类工厂创建具体的一种产品。

源代码

　public interface ExportFile {
public boolean export(String data);
}
public interface ExportFactory {
public ExportFile factory(String type);
}
public class ExportFinancialHtmlFile implements ExportFile{
@Override
   public boolean export(String data) {
/**
        * 业务逻辑
        */
       System.out.println("导出财务版HTML文件");
return true;
}
}

public class ExportStandardHtmlFile implements ExportFile{
@Override
   public boolean export(String data) {
/**
        * 业务逻辑
        */
       System.out.println("导出标准HTML文件");
return true;
}
}

public class ExportFinancialPdfFile implements ExportFile{
@Override
   public boolean export(String data) {
/**
        * 业务逻辑
        */
       System.out.println("导出财务版PDF文件");
return true;
}
}

public class ExportStandardPdfFile implements ExportFile {
@Override
   public boolean export(String data) {
/**
        * 业务逻辑
        */
       System.out.println("导出标准PDF文件");
return true;
}
}

public class ExportHtmlFactory implements ExportFactory{
@Override
   public ExportFile factory(String type) {
if("standard".equals(type)){
return new ExportStandardHtmlFile();
}else if("financial".equals(type)){
return new ExportFinancialHtmlFile();
}else{
throw new RuntimeException("没有找到对象");
}
}
}

public class ExportPdfFactory implements ExportFactory {
@Override
   public ExportFile factory(String type) {
if("standard".equals(type)){
return new ExportStandardPdfFile();
}else if("financial".equals(type)){
return new ExportFinancialPdfFile();
}else{
throw new RuntimeException("没有找到对象");
}
}
}
public class Test {
/**
    * @param args
    */
   public static void main(String[] args) {
String data = "";
ExportFactory exportFactory = new ExportHtmlFactory();
ExportFile ef = exportFactory.factory("financial");
ef.export(data);
}
}
三、抽象工厂模式一个抽象的工厂接口创建多种（一族）抽象的产品，由具体的子类工厂创建多种（一族）具体的产品。

源代码

　　public interface AbstractFactory {
/**
    * 创建CPU对象
    * @return CPU对象
    */
   public Cpu createCpu();
/**
    * 创建主板对象
    * @return 主板对象
    */
   public Mainboard createMainboard();
}public class IntelFactory implements AbstractFactory {
@Override
   public Cpu createCpu() {
return new IntelCpu(755);
}
@Override
   public Mainboard createMainboard() {
return new IntelMainboard(755);
}
}
public class AmdFactory implements AbstractFactory {
@Override
   public Cpu createCpu() {
return new IntelCpu(938);
}
@Override
   public Mainboard createMainboard() {
return new IntelMainboard(938);
}
}public class ComputerEngineer {
/**
    * 定义组装机需要的CPU
    */
   private Cpu cpu = null;
/**
    * 定义组装机需要的主板
    */
   private Mainboard mainboard = null;
public void makeComputer(AbstractFactory af){
/**
        * 组装机器的基本步骤
        */
       //1:首先准备好装机所需要的配件
       prepareHardwares(af);
//2:组装机器
       //3:测试机器
       //4：交付客户
   }
private void prepareHardwares(AbstractFactory af){
//这里要去准备CPU和主板的具体实现，为了示例简单，这里只准备这两个
       //可是，装机工程师并不知道如何去创建，怎么办呢？
       //直接找相应的工厂获取
       this.cpu = af.createCpu();
this.mainboard = af.createMainboard();
//测试配件是否好用
       this.cpu.calculate();
this.mainboard.installCPU();
}
}public class Client {
public static void main(String[]args){
//创建装机工程师对象
       ComputerEngineer cf = new ComputerEngineer();
//客户选择并创建需要使用的产品对象
       AbstractFactory af = new IntelFactory();
//告诉装机工程师自己选择的产品，让装机工程师组装电脑
       cf.makeComputer(af);
}
}

工厂方法模式和简单工厂模式

　　工厂方法模式和简单工厂模式在结构上的不同很明显。工厂方法模式的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。　　工厂方法模式退化后可以变得很像简单工厂模式。设想如果非常确定一个系统只需要一个具体工厂类，那么不妨把抽象工厂类合并到具体工厂类中去。由于只有一个具体工厂类，所以不妨将工厂方法改为静态方法，这时候就得到了简单工厂模式。　　如果系统需要加入一个新的导出类型，那么所需要的就是向系统中加入一个这个导出类以及所对应的工厂类。没有必要修改客户端，也没有必要修改抽象工厂角 {MOD}或者其他已有的具体工厂角 {MOD}。对于增加新的导出类型而言，这个系统完全支持“开-闭原则”。工厂方法模式和抽象工厂模式            将工厂方法的抽象工厂类的抽象方法从一个扩展到多个就形成了抽象工厂模式。一个工厂生产一种产品变成一个工厂可以生产一族产品。

欢迎关注我的微信公众号：