Android常用设计模式-工厂模式_android 工厂模式-CSDN博客

本文链接：https://blog.csdn.net/maoning20080808/article/details/147042016

android 系统或第三方库提供的工厂模式有哪些？

(1) LayoutInflater（布局加载工厂）
作用：通过 XML 布局文件动态创建 View 实例。
工厂角色：
LayoutInflater.Factory / Factory2：允许自定义 View 的创建过程（如换肤、动态替换组件）。

(2) BitmapFactory（位图创建工厂）(通过传递不同参数)
作用：通过不同来源（资源、文件、流）创建 Bitmap 对象。
工厂方法：
Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.image);
Bitmap bitmap = BitmapFactory.decodeFile("/sdcard/image.png");
Bitmap bitmap = BitmapFactory.decodeStream(inputStream);

工厂模式是Java中最常用的创建型设计模式之一，主要用于封装对象(解耦)的创建过程，使代码更加灵活和可维护。Java中主要有三种工厂模式：

1. 简单工厂模式(Simple Factory)
简单工厂模式也称为静态工厂模式，它通过一个工厂类根据传入的参数决定创建哪一种产品类的实例。

特点：
一个工厂类负责创建所有产品
通过静态方法创建对象
客户端只需要知道产品对应的参数，无需知道具体创建细节

优缺点：
优点：客户端与具体产品解耦，客户端只需要知道产品类型
缺点：违反开闭原则，添加新产品需要修改工厂类

2. 工厂方法模式(Factory Method)
工厂方法模式定义了一个创建对象的接口，但让子类决定实例化哪一个类。工厂方法让类的实例化推迟到子类。

特点：
每个具体产品对应一个具体工厂
通过继承实现，子类决定创建哪种对象
符合开闭原则，添加新产品只需添加新工厂

优缺点：
优点：符合开闭原则，系统扩展性好
缺点：每增加一个产品就要增加一个工厂类，增加了系统复杂度

3. 抽象工厂模式(Abstract Factory)
抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

特点：
创建的是产品族，而不是单个产品
一个工厂可以创建多个相关产品
适合产品之间有约束或关联关系的场景

优缺点：
优点：可以保证同一工厂生产的产品相互兼容
缺点：扩展产品族困难，需要修改抽象工厂接口

1. 简单工厂模式(Simple Factory)

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 15:13
 * Description : 简单工厂模式，简单工厂模式也称为静态工厂模式，它通过一个工厂类根据传入的参数决定创建哪一种产品类的实例。
 * 特点：
 * 一个工厂类负责创建所有产品
 * 通过静态方法创建对象
 * 客户端只需要知道产品对应的参数，无需知道具体创建细节
 *
 * 优缺点：
 * 优点：客户端与具体产品解耦，客户端只需要知道产品类型
 * 缺点：违反开闭原则，添加新产品需要修改工厂类
 */
public class SimpleFactoryHelper {


    public static void test(){

        //生产苹果
        IProduct productApple = SimpleFactory.createProduct("Apple");
        productApple.use();

        //生产香蕉
        IProduct productBanana = SimpleFactory.createProduct("Banana");
        productBanana.use();

    }

}

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 15:18
 * Description : 简单工厂
 */
public class SimpleFactory {

    //创建产品
    public static IProduct createProduct(String type){
        switch (type) {
            case "Apple":
                return new ProductApple();

            case "Banana":
                return new ProductBanana();

            default:
                throw new IllegalArgumentException("产品未知类型错误");
        }
    }

}

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 15:14
 * Description : 产品接口
 */
public interface IProduct {

    public void use();

}

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 15:15
 * Description : 具体产品Apple
 */
public class ProductApple implements IProduct{

    @Override
    public void use() {
        LogUtils.Companion.d("AAA", "简单工厂-产品Apple- use()");
    }

}

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 15:17
 * Description : 具体产品Banana
 */
public class ProductBanana implements IProduct{

    @Override
    public void use() {
        LogUtils.Companion.d("AAA", "简单工厂-产品Banana- use()");
    }

}

2. 工厂方法模式(Factory Method)

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 15:37
 * Description : 工厂方法模式定义了一个创建对象的接口，但让子类决定实例化哪一个类。工厂方法让类的实例化推迟到子类。(每个产品对应一个工厂)
 *
 * 特点：
 * 每个具体产品对应一个具体工厂
 * 通过继承实现，子类决定创建哪种对象
 * 符合开闭原则，添加新产品只需添加新工厂
 *
 * 优缺点：
 * 优点：符合开闭原则，系统扩展性好
 * 缺点：每增加一个产品就要增加一个工厂类，增加了系统复杂度
 *
 */
public class FactoryMethodHelper {

    public static void test(){
        //苹果工厂
        IFactory appleFactory = new AppleFactory();
        //生成苹果
        IProduct productApple = appleFactory.createProduct();
        productApple.use();

        //香蕉工厂
        IFactory bananaFactory = new BananaFactory();
        //生产香蕉
        IProduct productBanner = bananaFactory.createProduct();
        productBanner.use();
    }
}

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 15:36
 * Description : 香蕉工厂
 */
public class BananaFactory implements IFactory{

    //生成香蕉
    @Override
    public IProduct createProduct() {
        return new ProductBanana();
    }

}

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 15:34
 * Description : 苹果工厂
 */
public class AppleFactory implements IFactory{

    //生成苹果
    @Override
    public IProduct createProduct() {
        return new ProductApple();
    }

}

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 15:33
 * Description : 工厂接口
 */
public interface IFactory {

    //生产产品
    public IProduct createProduct();

}

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 15:14
 * Description : 产品接口
 */
public interface IProduct {

    public void use();

}

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 15:15
 * Description : 具体产品Apple
 */
public class ProductApple implements IProduct {

    @Override
    public void use() {
        LogUtils.Companion.d("AAA", "工厂方法-产品Apple- use()");
    }

}

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 15:17
 * Description : 具体产品Banana
 */
public class ProductBanana implements IProduct {

    @Override
    public void use() {
        LogUtils.Companion.d("AAA", "工厂方法-产品Banana- use()");
    }

}

3. 抽象工厂模式(Abstract Factory)

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 16:07
 * Description : 抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
 *
 * 特点：
 * 创建的是产品族，而不是单个产品
 * 一个工厂可以创建多个相关产品
 * 适合产品之间有约束或关联关系的场景
 *
 * 优缺点：
 * 优点：可以保证同一工厂生产的产品相互兼容
 * 缺点：扩展产品族困难，需要修改抽象工厂接口
 */
public class AbstractFactoryHelper {

    public static void test(){
        LogUtils.Companion.d("AAA", "1号工厂----------");
        //使用第1个工厂
        IAbstractFactory factory1 = new Real1Factory();
        //生产水果
        IAbstractProductFruit abstractProductFruit1 = factory1.createProductFruit();
        abstractProductFruit1.eat();
        //生产动物
        IAbstractProductAnimal abstractProductAnimal1 = factory1.createProductAnimal();
        abstractProductAnimal1.run();

        LogUtils.Companion.d("AAA", "2号工厂----------");
        //使用第2个工厂
        IAbstractFactory factory2 = new Real2Factory();
        //生产水果
        IAbstractProductFruit abstractProductFruit2 = factory2.createProductFruit();
        abstractProductFruit2.eat();
        //生产动物
        IAbstractProductAnimal abstractProductAnimal2 = factory2.createProductAnimal();
        abstractProductAnimal2.run();
    }
}

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 15:58
 * Description : 具体工厂 - 1号工厂
 */
public class Real1Factory implements IAbstractFactory{

    //生产苹果
    @Override
    public IAbstractProductFruit createProductFruit() {
        return new ProductApple();
    }

    //生产狗
    @Override
    public IAbstractProductAnimal createProductAnimal() {
        return new ProductDog();
    }

}

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 16:05
 * Description : 具体工厂 - 2号工厂
 */
public class Real2Factory implements IAbstractFactory{

    @Override
    public IAbstractProductFruit createProductFruit() {
        return new ProductBanana();
    }

    @Override
    public IAbstractProductAnimal createProductAnimal() {
        return new ProductCat();
    }
}

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 15:56
 * Description : 抽象工厂
 */
public interface IAbstractFactory {

    //生产水果
    IAbstractProductFruit createProductFruit();

    //生产动物
    IAbstractProductAnimal createProductAnimal();

}

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 15:50
 * Description : 抽象产品-动物
 */
public interface IAbstractProductAnimal {

    public void run();

}

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 15:52
 * Description : 抽象产品 - 水果
 */
public interface IAbstractProductFruit {

    public void eat();

}

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 15:51
 * Description : 具体产品-苹果
 */
public class ProductApple implements IAbstractProductFruit{

    @Override
    public void eat() {
        LogUtils.Companion.d("AAA", "吃苹果");
    }

}

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 15:53
 * Description : 具体产品 - 香蕉
 */
public class ProductBanana implements IAbstractProductFruit{

    @Override
    public void eat() {
        LogUtils.Companion.d("AAA", "吃香蕉");
    }
}

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 15:55
 * Description : 具体产品 - 猫
 */
public class ProductCat implements IAbstractProductAnimal{

    @Override
    public void run() {
        LogUtils.Companion.d("AAA", "猫在跑。。。");
    }

}

/**
 * Author : wn
 * Email : maoning20080808@163.com
 * Date : 2025/4/5 15:54
 * Description : 具体产品 - 狗
 */
public class ProductDog implements IAbstractProductAnimal{

    @Override
    public void run() {
        LogUtils.Companion.d("AAA", "狗在跑。。。");
    }

}