Android 工厂方法模式

源码地址

使用场景

当需要创建复杂对象时,适合使用工厂模式。

4大模块

  1. 抽象工厂类,是工厂方法模式的核心;
  2. 具体工厂类,实现了具体的业务逻辑;
  3. 抽象产品类,是所创建产品的父类;
  4. 具体产品类,是实现抽象产品的具体产品对象。

示例

  1. 抽象产品类

    public abstract class Product {
        /**
         * 产品类的抽象方法,由具体的产品类实现
         */
        public abstract void method();
    }
    
  2. 具体产品类 A

    public class ConcreteProductA extends Product {
        @Override
        public void method() {
            System.out.println("我是具体的产品A");
        }
    }
    
  3. 具体产品类 B

    public class ConcreteProductB extends Product {
        @Override
        public void method() {
            System.out.println("我是具体的产品B");
        }
    }
    
  4. 抽象工厂类(第一种方式)

    public abstract class Factory {
        /**
         * 抽象工厂方法
         * 具体生产什么由子类实现
         */
        public abstract Product createProduct();
    }
    
  5. 具体工厂类(通过 new 的方式创建)

    public class ConcreteFactory extends Factory {
        @Override
        public Product createProduct() {
            return new ConcreteProductA();
    //        return new ConcreteProductB();
        }
    }
    
  6. 客户类

    public class Client {
        public static void main(String[] args) {
            Factory factory = new ConcreteFactory();
            Product product = factory.createProduct();
            product.method();
    
            //Factory2 factory2 = new ConcreteFactory2();
            //ConcreteProductB product2 = factory2.createProduct(ConcreteProductB.class);
            //product2.method();
        }
    }
    
  7. 抽象工厂类(第二种方式)

    public abstract class Factory2 {
        /**
         * 抽象工厂方法
         * @param clz   产品对象类类型
         * @return  具体的产品对象
         */
        public abstract <T extends Product> T createProduct(Class<T> clz);
    }
    
  8. 具体工厂类(通过反射的方式创建)

    public class ConcreteFactory2 extends Factory2 {
        @Override
        public <T extends Product> T createProduct(Class<T> clz) {
            Product product = null;
            try {
                product = ((Product) Class.forName(clz.getName()).newInstance());
            } catch (Exception e) {
                e.printStackTrace();
            }
            return (T) product;
        }
    }
    

简单工厂模式 / 静态工厂模式:去掉抽象工厂类。

public class Factory {
    public static Product createProduct() {
        return new ConcreteProductA()
        //return new ConcreteProductB()
    }
}

简单实现

说明:小明的汽车厂需要组装某款车,如Q3、Q5、Q7,具体代码如下:

  1. 抽象车型

    public abstract class AudiCar {
        /**
         * 汽车启动
         */
        public abstract void drive();
    
        /**
         * 汽车自动巡航
         */
        public abstract void selfNavigation();
    }
    
  2. 具体车型 Q3

    public class AudiQ3 extends AudiCar {
        @Override
        public void drive() {
            System.out.println(" Q3 起飞~~~ ");
        }
    
        @Override
        public void selfNavigation() {
            System.out.println(" Q3 开始自动巡航~~~ ");
        }
    }
    
  3. 具体车型 Q5

    public class AudiQ5 extends AudiCar {
        @Override
        public void drive() {
            System.out.println(" Q5 起飞~~~ ");
        }
    
        @Override
        public void selfNavigation() {
            System.out.println(" Q5 开始自动巡航~~~ ");
        }
    }
    
  4. 具体车型 Q7

    public class AudiQ7 extends AudiCar {
        @Override
        public void drive() {
            System.out.println(" Q7 起飞~~~ ");
        }
    
        @Override
        public void selfNavigation() {
            System.out.println(" Q7 开始自动巡航~~~ ");
        }
    }
    
  5. 抽象工厂

    public abstract class AudiFactory {
        /**
         * 生产车
         * @param clz   具体型号类型
         * @return  具体型号车对象
         */
        public abstract <T extends AudiCar> T createAudiCar(Class<T> clz);
    }
    
  6. 具体生产工厂

    public class AudiCarFactory extends AudiFactory {
        @Override
        public <T extends AudiCar> T createAudiCar(Class<T> clz) {
            AudiCar car = null;
            try {
                car = ((AudiCar) Class.forName(clz.getName()).newInstance());
            } catch (Exception e) {
                e.printStackTrace();
            }
            return (T) car;
        }
    }
    
  7. 流水线(客户类)

    public class Client {
        public static void main(String[] args) {
            //构造一个制造汽车的工厂对象
            AudiFactory factory = new AudiCarFactory();
            //生产 Q3 并启动
            AudiQ3 audiQ3 = factory.createAudiCar(AudiQ3.class);
            audiQ3.drive();
            audiQ3.selfNavigation();
            //生产 Q5 并启动
            AudiQ5 audiQ5 = factory.createAudiCar(AudiQ5.class);
            audiQ5.drive();
            audiQ5.selfNavigation();
            //生产 Q7 并启动
            AudiQ7 audiQ7 = factory.createAudiCar(AudiQ7.class);
            audiQ7.drive();
            audiQ7.selfNavigation();
        }
    }
    

Android 源码中的实现

ArrayList 中创建 Iterator 对象;Activity 中 onCreate 方法 setContentView 创建布局对象。

总结

  • 优点

    使用简单,依赖于抽象的架构,扩展性好。

  • 缺点

    每次添加新的产品时就要编写一个新的产品类,同时需要引入抽象层,会使得类结构复杂化。

推荐阅读更多精彩内容