Android 抽象工厂模式

源码地址

使用场景

一个对象族有相同的约束时可以使用此模式。

例如:Android、iOS 都有短信软件和拨号软件,但是具体代码的实现逻辑不不一样,这个时候可以考虑使用抽象工厂模式来生产 Android、iOS 下的短信软件和拨号软件。

主要角色

AbstractFactory:抽象工厂角色。对应 AbstractFactory。

ConcreteFactory:具体工厂角色。对应 ConcreteFactory1 和 ConcreteFactory2。

AbstractProduct:抽象产品角色。对应 AbstractProductA 和 AbstractProductB。

ConcreteProduct:具体产品角色。对应 ConcreteProductA1、ConcreteProductA2、 ConcreteProductB1、ConcreteProductB2。

示例代码:

抽象产品类A

public abstract class AbstractProductA {
    /**
     * 每个具体的产品子类需要实现的方法
     */
    public abstract void method();
}

抽象产品类B

public abstract class AbstractProductB {
    /**
     * 每个具体的产品子类需要实现的方法
     */
    public abstract void method();
}

具体产品类A1

public class ConcreteProductA1 extends AbstractProductA {
    @Override
    public void method() {
        System.out.println("具体产品A1的方法");
    }
}

具体产品类A2

public class ConcreteProductA2 extends AbstractProductA {
    @Override
    public void method() {
        System.out.println("具体产品A2的方法");
    }
}

具体产品类B1

public class ConcreteProductB1 extends AbstractProductB {
    @Override
    public void method() {
        System.out.println("具体产品B1的方法");
    }
}

具体产品类B2

public class ConcreteProductB2 extends AbstractProductB {
    @Override
    public void method() {
        System.out.println("具体产品B2的方法");
    }
}

抽象工厂类

public abstract class AbstractFactory {
    /**
     * 创建产品A的方法
     */
    public abstract AbstractProductA createProductA();

    /**
     * 创建产品B的方法
     */
    public abstract AbstractProductB createProductB();
}

具体工厂1

public class ConcreteFactory1 extends AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}

具体工厂2

public class ConcreteFactory2 extends AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB2();
    }
}

简单实现

需求:小明的车厂需要生产Q3、Q7两种类型的汽车,但是它们的零部件差别比较大。比如轮胎、发动机、制动系统。

  1. 轮胎相关类

    public interface ITire {
        /**
         * 轮胎
         */
        void tire();
    }
    
    public class NormalTire implements ITire {
        @Override
        public void tire() {
            System.out.println("普通轮胎");
        }
    }
    
    public class SUVTire implements ITire {
        @Override
        public void tire() {
            System.out.println("越野轮胎");
        }
    }
    
  2. 发动机相关类

    public interface IEngine {
        /**
         * 发动机
         */
        void engine();
    }
    
    public class DomesticEngine implements IEngine {
        @Override
        public void engine() {
            System.out.println("国产发动机");
        }
    }
    
    public class ImportEngine implements IEngine {
        @Override
        public void engine() {
            System.out.println("进口发动机");
        }
    }
    
  3. 制动系统相关类

    public interface IBrake {
        void brake();
    }
    
    public class NormalBrake implements IBrake {
        @Override
        public void brake() {
            System.out.println("普通制动");
        }
    }
    
    public class SeniorBrake implements IBrake {
        @Override
        public void brake() {
            System.out.println("高级制动");
        }
    }
    
  4. 抽象车厂类

    public abstract class CarFactory {
        /**
         * 生产轮胎
         */
        public abstract ITire createTire();
    
        /**
         * 生产发动机
         */
        public abstract IEngine createEngine();
    
        /**
         * 生产制动系统
         */
        public abstract IBrake createBrake();
    }
    
  5. Q3 工厂类

    public class Q3Factory extends CarFactory {
        @Override
        public ITire createTire() {
            return new NormalTire();
        }
    
        @Override
        public IEngine createEngine() {
            return new DomesticEngine();
        }
    
        @Override
        public IBrake createBrake() {
            return new NormalBrake();
        }
    }
    
  6. Q7 工厂类

    public class Q7Factory extends CarFactory {
        @Override
        public ITire createTire() {
            return new SUVTire();
        }
    
        @Override
        public IEngine createEngine() {
            return new ImportEngine();
        }
    
        @Override
        public IBrake createBrake() {
            return new SeniorBrake();
        }
    }
    
  7. 测试

    public class Client {
        public static void main(String[] args) {
            Q3Factory factoryQ3 = new Q3Factory();
            factoryQ3.createTire().tire();
            factoryQ3.createEngine().engine();
            factoryQ3.createBrake().brake();
    
            System.out.println("-----------------");
    
            Q7Factory factoryQ7 = new Q7Factory();
            factoryQ7.createTire().tire();
            factoryQ7.createEngine().engine();
            factoryQ7.createBrake().brake();
        }
    }
    

    输出结果如下:

    普通轮胎
    国产发动机
    普通制动
    -----------------
    越野轮胎
    进口发动机
    高级制动
    

这里只有Q3 和Q7 的工厂,如果需要增加Q5的工厂,那么需要增加响应的类文件,这样会造成类文件非常多。因此,在开发中需要权衡慎用。

Android 源码中的实现

相对较少。Android 底层 MediaPlayer 的创建。

总结

  • 优点:

    分离接口与实现,客户端使用抽象工厂来创建需要的对象,而客户端无需知道具体的实现类是哪个,使其实现面向接口编程,使得该模式在切换产品类时更加灵活、容易。

  • 缺点:

    1. 类文件陡增;
    2. 不太容易扩展新的产品类,因为每当增加一个产品类就需要修改工厂,那么所有的具体工厂类均会被修改。

所以其在实际开发中使用较少,了解即可。

推荐阅读更多精彩内容

  • Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具(例如配置管理,服务发现,断路器,智...
    卡卡罗2017阅读 121,269评论 16 134
  • 面向对象的六大原则 单一职责原则 所谓职责是指类变化的原因。如果一个类有多于一个的动机被改变,那么这个类就具有多于...
    JxMY阅读 515评论 0 2
  • 小编费力收集:给你想要的面试集合 1.C++或Java中的异常处理机制的简单原理和应用。 当JAVA程序违反了JA...
    八爷君阅读 3,668评论 1 115
  • 1 场景问题# 1.1 选择组装电脑的配件## 举个生活中常见的例子——组装电脑,我们在组装电脑的时候,通常需要选...
    七寸知架构阅读 2,288评论 6 57
  • 在这个越来越现实的社会,我们越来越重视金钱,为了挣钱可谓是无所不用其极,碰瓷的,装残疾的,装孕妇的等等。...
    躲在墙角晒太阳阅读 87评论 0 1