工厂设计模式（重点）

工厂设计模式（重点）

• 简单工厂模式
  缺点：添加具体产品需要修改工厂，违反OCP开闭原则。
  专门定义一个类，用来创建其他类的实例，被创建的实例通常都具有共同的父类。
  代码：

package com.irilia.FactoryDesignPattern;
import java.util.Scanner;
/*1.一个抽象产品类(接口：用来生产产品)  
2.具体产品类  
3.工厂* */
interface Computer{    
    void printComputer();
}
class MacBookComputer implements Computer{    
    @Override    
    public void printComputer() {        
        System.out.println("This is a MacBookComputer");    
    }
}
class SurfaceBookCmputer implements Computer{    
    @Override    
    public void printComputer() {        
        System.out.println("This is a SurfaceBookCmputer");    
    }
}
class Factory{    
    public static Computer MakeComputer(String type){        
        Computer computer = null;        
        if(type.equals("macbookComputer")){            
            computer = new MacBookComputer();        
        }else if(type.equals("surfaceBookComputer")){            
            computer = new SurfaceBookCmputer();        
        }        
        return computer;    
    }
}
//客户端
public class SimpleFactory {    
    public void buyComputer(Computer computer){
        computer.printComputer();
    }
    public static void main(String[] args) {    
        SimpleFactory simpleFactory = new SimpleFactory();    
        Scanner in = new Scanner(System.in);    
        String type = in.nextLine();
        simpleFactory.buyComputer(Factory.MakeComputer(type));
    }
}

• 工厂方法模式
  缺点：当有新的产品族时，就违反OCP开闭原则

1. 一个抽象产品
2. 多个具体产品
3. 一个抽象工厂
4. 多个具体工厂
   工厂方法模式是针对每个产品提供一个工厂类，在客户端中判断使用哪个工厂类去创建对象。
   简单工厂模式里如果要新加类就要打开工厂修改，如果一公司想往新的方向发展，就必须要在工厂里创建更多的生产类实例化，所以将工厂也抽象，这样如果有产品的改动，只要新加工厂就可以了。

代码：

package com.irilia.FactoryDesignPattern;
interface Computer2{    
    void printComputer();
}
class MacBookComputer2 implements Computer2{    
    @Override    
    public void printComputer() {        
        System.out.println("This is a MacBookComputer");    
    }
}
class SurfaceBookCmputer2 implements Computer2{    
    @Override    
    public void printComputer() {        
        System.out.println("This is a SurfaceBookCmputer");    
    }
}
interface Factory2{    
    Computer2 creatComputer();
}
class MSFactory implements Factory2{    
    @Override    
    public Computer2 creatComputer() {        
        return new SurfaceBookCmputer2();    
    }
}
class AppleFactory implements Factory2{    
    @Override    
    public Computer2 creatComputer() {        
        return new MacBookComputer2();    
    }
 }
 public class FactoryMethod {    
    public void buyComputer2(Computer2 computer2{
        computer2.printComputer();    
    }    
    public static void main(String[] args) {        
        FactoryMethod factoryMethod = new FactoryMethod();        
        Factory2 factory2 = new AppleFactory();        
        Computer2 computer2 = factory2.creatComputer();       
        factoryMethod.buyComputer2(computer2);    
    }
}

• 抽象工厂模式
  缺点：扩展产品族时违反OCP原则

1. 多个产品抽象类
2. 多个具体产品类
3. 抽象工厂类（声明一组返回抽象产品的方法）
4. 具体工厂类（生成一组具体产品）

package com.irilia.FactoryDesignPattern;
/** 1.多个产品抽象类* 
2.多个具体的产品类* 
3.工厂业务组抽象类* 
4.具体工厂业务组类*/
//卖电脑，卖处理器
interface Computer3 {    
    void printComputer3();
}
interface OperatingSystem{    
    void printOperatingSystem();
}
//电脑的具体类
class MacBookCumputer implements Computer3{   
    @Override   
    public void printComputer3() {        
        System.out.println("This is a MacBookComputer");    
    }
}
class SurfaceBookComputer implements Computer3{    
    @Override    
    public void printComputer3() {        
        System.out.println("This is a SurfaceBookComputer");    
    }
}
//处理器的具体类
class Windows8System implements OperatingSystem{    
    @Override    
    public void printOperatingSystem() {        
        System.out.println("This is a Windows8System");    
    }
}
class MacOsSystem implements OperatingSystem{    
    @Override    
    public void printOperatingSystem() {        
        System.out.println("This is a MacOsSystem");   
    }
}
//抽象工厂的业务组
interface ProductionFactory{    
    Computer3 creatComputer3();    
    OperatingSystem creatOperation();
}
//具体工厂的业务组
class AppleFactory2 implements ProductionFactory{    
    @Override    
    public Computer3 creatComputer3() {        
        return new MacBookCumputer();   
    }   
    @Override    
    public OperatingSystem creatOperation() {        
        return new MacOsSystem();   
    }
}
class MSFactory2 implements ProductionFactory{    
    @Override    
    public Computer3 creatComputer3() {        
        return new SurfaceBookComputer();    
    }    
    @Override    
    public OperatingSystem creatOperation() {       
        return new Windows8System();    
    }
}
public class AbstractFactory {   
    public void buyComputer(Computer3 computer3,OperatingSystem 
operatingSystem){        
        computer3.printComputer3();        
        operatingSystem.printOperatingSystem();    
    }
    public static void main(String[] args) {        
         AbstractFactory abstractFactory = new AbstractFactory();       
         ProductionFactory productionFactory = new AppleFactory2();       
         Computer3 computer3 = productionFactory.creatComputer3(); 
         OperatingSystem operatingSystem = productionFactory.creatOperation();
         abstractFactory.buyComputer(computer3,operatingSystem);   
    }
}