设计模式(1)——工厂模式

2018-04-11

设计模式

• 工厂模式

  • 简单工厂模式

    • 工厂类代替new方法，用户告诉工厂创建什么对象，然后由工厂创建；客户端就不需要感知具体对象是如何产生的，只需要将必要的信息提供给工厂即可。

    interface Computer {
        public void printComputer();
    }
    
    class MacbookProComputer implements Computer {
        public void printComputer() {
            System.out.println("This is a macbook pro");
        }
    }
    
    class SurfaceBookComputer implements Computer {
        public void printComputer() {
            System.out.println("This is a surface book");
        }
    }
    
    class ComputerFactory {
        public Computer createComputer(String type) {
            Computer c = null;
            if(type.equals("macbook")) {
                c = new MacbookProComputer();
            }else if(type.equals("surface")) {
                c = new SurfaceBookComputer();
            }
            return c;
        }
    }
    
    public class Client {
        public void buy(Computer c){
            System.out.println("I buy a computer");
            c.printComputer();
        }
        public static void main(String[] args) {
    
            Client c = new Client();
            ComputerFactory cf = new ComputerFactory();
    
            Computer computer = cf.createComputer("macbook");
            c.buy(computer);
        }
    }
    

    • 其中包含角色：工厂类，抽象产品类，具体产品类
    • 简单工厂模式的缺点：简单工厂模式是违反“开闭原则”，即对扩展开放，对修改关闭；因为如果要新增具体产品，就需要修改工厂类的代码。

  • 工厂模式

    • 对简单工厂模式进行扩展，定义一个工厂接口，针对每个产品实现一个工厂类，由客户决定用哪一个工厂创建；

    interface Computer {
        public void printComputer();
    }
    
    class MacbookProComputer implements Computer {
        public void printComputer() {
            System.out.println("This is a macbook pro");
        }
    }
    
    class SurfaceBookComputer implements Computer {
        public void printComputer() {
            System.out.println("This is a surface book");
        }    
    }
    interface ComputerFactory {
        public Computer createComputer();
    }
    
    class MsFactory implements ComputerFactory {
        public Computer createComputer(){
            return new SurfaceBookComputer();
        }
    }
    
    class AppleFactory implements ComputerFactory {
        public Computer createComputer() {
            return new MacbookProComputer();
        }
    }
    
    public class Client {
        public void buy(Computer c){
            System.out.println("I buy a computer");
            c.printComputer();
        }
        public static void main(String[] args) {
    
            Client c = new Client();
            ComputerFactory cf = new AppleFactory();
    
            Computer computer = cf.createComputer();
            c.buy(computer);
        }
    }
    

    • 其中包含角色：抽象工厂类，具体工厂类，抽象产品类，具体产品类

  • 抽象工厂模式

    • 工厂方法模式和抽象工厂模式基本类似，可以这么理解：当工厂只生产一个产品的时候，即为工厂方法模式，而工厂如果生产两个或以上的商品即变为抽象工厂模式。

    interface Computer {
        public void printComputer();
    }
    
    class MacbookProComputer implements Computer {
        public void printComputer() {
            System.out.println("This is a macbook pro");
        }
    }
    
    class SurfaceBookComputer implements Computer {
        public void printComputer() {
            System.out.println("This is a surface book");
        }
    }
    
    interface OperatingSystem {
        public void printSystem();
    }
    
    class MacOsSystem implements OperatingSystem {
        public void printSystem() {
            System.out.println("This is a mac os");
        }
    }
    
    class Windows8System implements OperatingSystem {
        public void printSystem() {
            System.out.println("This is a window 8");
        }
    }
    
    interface ProductionFactory {
        public Computer createComputer();
        public OperatingSystem createSystem();
    }
    
    class AppleFactory implements ProductionFactory {
        public Computer createComputer() {
            return new MacbookProComputer();
        }
        public OperatingSystem createSystem() {
            return new MacOsSystem();
        }
    }
    
    class MsFactory implements ProductionFactory {
        public Computer createComputer() {
            return new SurfaceBookComputer();
        }
        public OperatingSystem createSystem() {
            return new Windows8System();
        }
    }
    
    public class Client {
    
        public void buy(Computer c){
            System.out.println("I buy a computer");
            c.printComputer();
        }
        public void use(OperatingSystem s) {
            System.out.println("Operating System");
            s.printSystem();
        }
        public static void main(String[] args) {
        	
            ProductionFactory pf = new AppleFactory();
            Computer c = pf.createComputer();
            OperatingSystem s = pf.createSystem();
    
            Client client = new Client();
            client.buy(c);
            client.use(s);
    
        }
    }
    

    • 抽象工厂模式的缺点在于产品类的扩展，将会是十分费力的，假如在需要加入新的产品，那么几乎所有的工厂类都需要进行修改，所以在使用抽象工厂模式时，对产品等级结构的划分是十分重要的。

  • 适用场景

    无论是简单工厂模式，工厂方法模式还是抽象工厂模式，它们都具有类似的特性，适用场景也十分类似。

    无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。

    所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。使用工厂方法后，调用端的耦合度大大降低了。并且对于工厂来说，是可以扩展的，以后如果想组装其他的产品，只需要再增加一个工厂类的实现就可以。无论是灵活性还是稳定性都得到了极大的提高。