Android设计模式：工厂设计模式

一、工厂方法模式

• 定义一个用于创建对象的接口，让子类决定实例化哪个类。
• 工厂设计模式创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。
• 创建接口产品类

    public interface Product {
        void method();
    }

• 创建具体产品类

    public class ProductA implements Product {
        @Override
        public void method() {
            System.out.println("产品A");
        }
    }

    public class ProductB implements Product {
        @Override
        public void method() {
            System.out.println("产品B");
        }
    }

• 创建接口工厂类

    public interface class Factory {
        Product create();
    }

• 创建工厂具体类

    public class FactoryA implements Factory {
        @Override
        public Product create() {
            return new ProductA();
        }
    }

    public class FactoryB implements Factory {
        @Override
        public Product create() {
            return new ProductB();
        }
    }

    public void test() {
        //产品A
        Factory factoryA = new FactoryA();
        factoryA.create().method();
        //产品B
        Factory factoryB = new FactoryB();
        factoryB.create().method();
    }

二、抽象工厂模式

• 工厂方法模式每个工厂只能创建一种类型的产品，而抽象工厂模式则能够创建多种类型的产品。
• 创建抽象产品类

    public abstract class CPU {
        public abstract void showCPU();
    }

    public abstract class Memory {
        public abstract void showMemory();
    }

    public abstract class HD {
        public abstract void showHD();
    }

• 创建具体产品类

public class IntelCPU extends CPU {
        @Override
        public void showCPU() {
            System.out.println("Intet CPU");
        }
    }
    
    public class AmdCPU extends CPU {
        @Override
        public void showCPU() {
            System.out.println("AMD CPU");
        }
    }

    public class SamsungMemory extends Memory {
        @Override
        public void showMemory() {
            System.out.println("三星 内存");
        }
    }
    
    public class KingstonMemory extends Memory {
        @Override
        public void showMemory() {
            System.out.println("金士顿 内存");
        }
    }

    public class SeagateHD extends HD {
        @Override
        public void showHD() {
            System.out.println("希捷 硬盘");
        }
    }

    public class WdHD extends HD {

        @Override
        public void showHD() {
            System.out.println("西部数据 硬盘");
        }
    }

• 创建抽象工厂类

    public abstract class Factory {
        public abstract CPU createCPU();

        public abstract Memory createMemory();

        public abstract HD createHD();
    }

• 创建具体工厂类

    public class LenovoFactory extends Factory{

        @Override
        public CPU createCPU() {
            return new IntelCPU();
        }

        @Override
        public Memory createMemory() {
            return new SamsungMemory();
        }

        @Override
        public HD createHD() {
            return new SeagateHD();
        }
    }
    
    public class AsusFactory extends Factory {

        @Override
        public CPU createCPU() {
            return new AmdCPU();
        }

        @Override
        public Memory createMemory() {
            return new KingstonMemory();
        }

        @Override
        public HD createHD() {
            return new WdHD();
        }
    }
    
    public class HpFactory extends Factory{

        @Override
        public CPU createCPU() {
            return new IntelCPU();
        }

        @Override
        public Memory createMemory() {
            return new KingstonMemory();
        }

        @Override
        public HD createHD() {
            return new WdHD();
        }
    }

• 测试方法

    public void test() {
        Factory lenovoFactory = new LenovoFactory();
        lenovoFactory.createCPU().showCPU();
        lenovoFactory.createMemory().showMemory();
        lenovoFactory.createHD().showHD();

        Factory asusFactory = new AsusFactory();
        asusFactory.createCPU().showCPU();
        asusFactory.createMemory().showMemory();
        asusFactory.createHD().showHD();
        
        Factory hpFactory = new HpFactory();
        hpFactory.createCPU().showCPU();
        hpFactory.createMemory().showMemory();
        hpFactory.createHD().showHD();
    }

• 代码解耦，创建实例的工作与使用实例的工作分开，使用者不必关心类对象如何创建。
• 如果增加新的产品，则修改抽象工厂和所有的具体工厂，违反了开放封闭原则。
• 在工厂方法模式中具体工厂负责生产具体的产品，每一个具体工厂对应一种具体产品，工厂方法具有唯一性。
• 抽象工厂模式则可以提供多个产品对象，而不是单一的产品对象。