《Android源码设计模式》之工厂方法模式

最新推荐文章于 2024-07-05 11:49:40 发布

喧嚣世界

最新推荐文章于 2024-07-05 11:49:40 发布

阅读量1.1k

点赞数

分类专栏：《Android源码设计模式》读书笔记文章标签： android 设计模式

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/qq_16240393/article/details/79715552

版权

《Android源码设计模式》读书笔记专栏收录该内容

24 篇文章 1 订阅

订阅专栏

####工厂方法模式介绍
　　工厂方法模式（Factory Pattern）是创建型设计模式之一。工厂方法模式是一种结构简单的模式，其在我们平时开发中应用很广泛，如Android中的Activity里的各个生命周期方法就可以看作是一个工厂方法。
####工厂方法模式的定义
　　定义一个用于创建对象的接口，让子类决定实例化哪个类。
####工厂方法模式的使用场景
　　在任何需要生成复杂对象的地方，都可以使用工厂方法模式。复杂对象适合使用工厂模式，用new就可以完成创建的对象无需使用工厂模式。
####工厂方法模式的UML类图

![这里写图片描述](https://img-blog.csdn.net/20180323162837211?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2MjQwMzkz/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)

如下是一个工厂方法模式的通用模式代码：

**抽象产品类** ``` package com.guifa.myapplication;

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

<center>**具体产品类A**

package com.guifa.myapplication;

/**

具体产品类A
*/
public class ConcreteProductA extends Product {
@Override
public void method() {
System.out.println(“我是具体的产品A”);
}
}

<center>**具体产品类B**

package com.guifa.myapplication;

/**

具体产品类B
*/
public class ConcreteProductB extends Product {
@Override
public void method() {
System.out.println(“我是具体的产品B”);
}
}

<center>**抽象工厂类**

package com.guifa.myapplication;

/**

抽象工厂类
/
public abstract class Factory {
/*
- 抽象工厂方法
- 具体生产什么由子类去实现
- @return 具体的产品对象
  */
  public abstract Product createProduct();
  }

<center>**具体工厂类**

package com.guifa.myapplication;

public class ConcreteFactory extends Factory {
@Override
public Product createProduct() {
return new ConcreteProductB();
}
}

<center>**客户类**

package com.guifa.myapplication;

public class Client {
public static void main(String[] args) {
Factory factory = new ConcreteFactory();
Product product = factory.createProduct();
product.method();
}
}

**输出结果：**
![这里写图片描述](https://img-blog.csdn.net/20180323173317680?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2MjQwMzkz/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
　　这里的几个角色都很简单，主要分为四大模块，一是抽象工厂，其为工厂方法模式的核心；二是具体工厂，其实现了具体的业务逻辑；三是抽象产品，是工厂方法模式所创建的产品的父类；四是具体产品，为实现抽象产品的某个具体产品的对象。
　　有时候也可以利用反射的方式更简洁地来生产具体产品对象，此时，需要在工厂方法的参数列表中传入一个class类来决定是哪一个产品类：

package com.guifa.myapplication;

/**

抽象工厂类
/
public abstract class Factory {
/*
- 抽象工厂方法
- 具体生产什么由子类去实现
- @param clz 产品对象类类型
- @return 具体的产品对象
  */
  public abstract T createProduct(Class clz);
  }

　　对于具体的工厂类，则通过反射获取类的示例即可：

package com.guifa.myapplication;

public class ConcreteFactory extends Factory {

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

}

　　最后再看看Client中的实现：

package com.guifa.myapplication;

public class Client {
public static void main(String[] args) {
Factory factory = new ConcreteFactory();
Product p = factory.createProduct(ConcreteProductA.class);
p.method();
}
}

　　需要哪一个类的对象就传入哪一个类的类型即可，这种方法比较简洁、动态。还有一种方法，就是为每个产品都定义一个具体的工厂，各司其职：

package com.guifa.myapplication;

public class ConcreteFactoryA extends Factory {
@Override
public Product createProduct() {
return new ConcreteProductA();
}
}

package com.guifa.myapplication;

public class ConcreteFactoryB extends Factory {
@Override
public Product createProduct() {
return new ConcreteProductB();
}
}

package com.guifa.myapplication;

public class Client {
public static void main(String[] args) {
Factory factoryA = new ConcreteFactoryA();
Product productA = factoryA.createProduct();
productA.method();

    Factory factoryB = new ConcreteFactoryB();
    Product productB = factoryB.createProduct();
    productB.method();
}

}

　　像这样有多个工厂的方式我们称为多工厂方法模式，同样地，回到我们最初的那个工厂方法模式，当我们的工厂只有一个的时候，我们还是为工厂提供了一个抽象类，其实如果确定你的工厂类只有一个，我们可以简化掉抽象类，如下：

package com.guifa.myapplication;

/**

抽象工厂类
*/
public class Factory {

public static Product createProduct() {
// return new ConcreteFactoryA();
return new ConcreteFactoryB();
}
}

　　像这样的方式又称为简单工厂模式或静态工厂模式，它是工厂方法模式的一个弱化版本。
　　其实到这里大家应该可以发现，工厂方法模式是完全符合设计原则的，其降低了对象之间的耦合度，而且，工厂方法模式依赖于抽象的架构，其将实例化的任务交由子类去完成，有非常好的扩展性。
####工厂方法模式的简单实现
　　以生产汽车为例，我们粗略的认为内部结构差异不大，一条生产线可以生产多种车型，首先对于该类生产线提供一个抽象类定义：

package com.guifa.myapplication;

public abstract class AudiFactory {
/**
* 某车型的工厂方法
*
* @param clz 具体的型号类型
* @return 具体型号的车对象
*/
public abstract T createAudiCar(Class clz);
}

　　我们假设生产的车型在结构上没什么差异，所以没有必要为每一种车型提供不同的生产线，即一条生产线即可：

package com.guifa.myapplication;

public class AudiCarFactory extends AudiFactory {
@Override
public T createAudiCar(Class clz) {
AudiCar audiCar = null;
try {
audiCar = (AudiCar) Class.forName(clz.getName()).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return (T) audiCar;
}
}

　　对于车型，除了一些车都有的基本共性外，还提供了自动巡航功能，我们都用一个抽象的基类声明：

package com.guifa.myapplication;

public abstract class AudiCar {
/**
* 汽车的抽象产品类
* 定义汽车的一个行为方法，车可以启动开走
*/
public abstract void drive();

/**
 * 汽车的抽象产品类
 * 定义汽车的一个行为方法，车可以自动巡航
 */
public abstract void selfNaviggation();

}

　　接下来就是生产每一种具体的车型了

package com.guifa.myapplication;

public class AudiQ3 extends AudiCar {
@Override
public void drive() {
System.out.println(“Q3启动啦！”);
}

@Override
public void selfNaviggation() {
    System.out.println("Q3开始自动巡航啦！");
}

}

package com.guifa.myapplication;

public class AudiQ5 extends AudiCar {
@Override
public void drive() {
System.out.println(“Q5启动啦！”);
}

@Override
public void selfNaviggation() {
    System.out.println("Q5开始自动巡航啦！");
}

}

package com.guifa.myapplication;

public class AudiQ7 extends AudiCar {
@Override
public void drive() {
System.out.println(“Q7启动啦！”);
}

@Override
public void selfNaviggation() {
    System.out.println("Q7开始自动巡航啦！");
}

}

　　最后我们将各个类组装起来形成一条完整的流水线：

package com.guifa.myapplication;

public class Client {
public static void main(String[] args) {
// 构造一个制造汽车的工厂对象
AudiFactory audiFactory = new AudiCarFactory();

    // 生产Q3并启动
    AudiQ3 audiQ3 = audiFactory.createAudiCar(AudiQ3.class);
    audiQ3.drive();
    audiQ3.selfNaviggation();
    // 生产Q5并启动
    AudiQ5 audiQ5 = audiFactory.createAudiCar(AudiQ5.class);
    audiQ5.drive();
    audiQ5.selfNaviggation();
    // 生产Q7并启动
    AudiQ7 audiQ7 = audiFactory.createAudiCar(AudiQ7.class);
    audiQ7.drive();
    audiQ7.selfNaviggation();
}

}

输出结果如下：
![这里写图片描述](https://img-blog.csdn.net/20180327112418563?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2MjQwMzkz/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
####工厂方法模式实战
　　下面以数据存储为例，做个简单介绍。对数据操作就是增、删、改、查，我们可以将每一种数据操作的方式作为一个产品类，在抽象产品类中定义操作的方法：

package com.guifa.myapplication;

public abstract class IOHandler {
/**
* 添加一条个人信息
*
* @param id 身份证号码
* @param name 名字
*/
public abstract void add(String id, String name);

/**
 * 删除一条个人信息
 *
 * @param id 身份证号码
 */
public abstract void remove(String id);

/**
 * 更新一条个人信息
 *
 * @param id   身份证号码
 * @param name 名字
 */
public abstract void update(String id, String name);

/**
 * 查询身份证对应的人名
 *
 * @param id 身份证号码
 */
public abstract void query(String id);

}

　　对于每一种持久化方式我们都定义一个具体的IO处理类，这里定义三种，分别是普通文件存储、xml文件存储和SQLite数据库存储。

package com.guifa.myapplication;

public abstract class FileHandler extends IOHandler {
@Override
public void add(String id, String name) {
// 业务处理
}

@Override
public void remove(String id) {
    // 业务处理
}

@Override
public void update(String id, String name) {
    // 业务处理
}

@Override
public String query(String id) {
    // 业务处理
    return "GuiFa_File";
}

}

package com.guifa.myapplication;

public class XMLHandler extends IOHandler {
@Override
public void add(String id, String name) {
// 业务处理
}

@Override
public void remove(String id) {
    // 业务处理
}

@Override
public void update(String id, String name) {
    // 业务处理
}

@Override
public String query(String id) {
    // 业务处理
    return "GuiFa_XML";
}

}

package com.guifa.myapplication;

public class DBHandler extends IOHandler {
@Override
public void add(String id, String name) {
// 业务处理
}

@Override
public void remove(String id) {
    // 业务处理
}

@Override
public void update(String id, String name) {
    // 业务处理
}

@Override
public String query(String id) {
    // 业务处理
    return "GuiFa_DB";
}

}

　　这里省略具体存储操作，只设置了不同的返回结果以作区分，接下来就是对工厂类的定义，这里的逻辑都比较简单，故以简单工厂的方式实现：

package com.guifa.myapplication;

public class IOFactory {
public static T getIOHandler(Class clz) {
IOHandler ioHandler = null;
try {
ioHandler = (IOHandler) Class.forName(clz.getName()).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return (T) ioHandler;
}
}

最后，我们在Activity中试着将从不同数据文件中查询得到的数据展示在一个TextView上：

<?xml version="1.0" encoding="utf-8"?>

<TextView
    android:id="@+id/textView"
    android:layout_width="match_parent"
    android:layout_height="50dp"
    android:gravity="center" />

<Button
    android:id="@+id/btnFile"
    android:layout_width="match_parent"
    android:layout_height="50dp"
    android:gravity="center"
    android:text="File" />

<Button
    android:id="@+id/btnXML"
    android:layout_width="match_parent"
    android:layout_height="50dp"
    android:gravity="center"
    android:text="XML" />

<Button
    android:id="@+id/btnDB"
    android:layout_width="match_parent"
    android:layout_height="50dp"
    android:gravity="center"
    android:text="DB" />

``` ``` package com.guifa.myapplication;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    final TextView textView = findViewById(R.id.textView);
    Button btnFile = findViewById(R.id.btnFile);
    Button btnXML = findViewById(R.id.btnXML);
    Button btnDB = findViewById(R.id.btnDB);
    btnFile.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            IOHandler ioHandler = IOFactory.getIOHandler(FileHandler.class);
            String queryFile = ioHandler.query("");
            textView.setText(queryFile);
        }
    });
    btnXML.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            IOHandler ioHandler = IOFactory.getIOHandler(XMLHandler.class);
            String queryFile = ioHandler.query("");
            textView.setText(queryFile);
        }
    });
    btnDB.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            IOHandler ioHandler = IOFactory.getIOHandler(DBHandler.class);
            String queryFile = ioHandler.query("");
            textView.setText(queryFile);
        }
    });
}

}

运行效果：
![这里写图片描述](https://img-blog.csdn.net/20180327164218728?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2MjQwMzkz/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
####总结
　　总的来说，工厂方法模式是一个很好的设计模式，优点很多，但是也有缺点，每次为工厂方法模式添加新的产品时，就要编写一个新的产品类，同时还要引入抽象层，这必然会导致类结构的复杂化，所以使用工厂方法模式前要自己权衡利弊。

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
《Android源码设计模式》之工厂方法模式

工厂方法模式介绍　　工厂方法模式（Factory Pattern）是创建型设计模式之一。工厂方法模式是一种结构简单的模式，其在我们平时开发中应用很广泛，如Android中的Activity里的各个生命周期方法就可以看作是一个工厂方法。工厂方法模式的定义　　定义一个用于创建对象的接口，让子类决定实例化哪个类。工厂方法模式的使用场景　　在任何需要生成复杂对象的地方，都可以使用工厂方法模式。复杂对象适合使
复制链接

扫一扫

专栏目录

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。