Android常用设计模式（工厂设计模式）

java有23中设计模式，Android中也用到了很多的设计模式，本篇就来介绍Android中常用的几种设计模式

一、普通工厂设计模式

普通工厂设计模式，就是创建一个工厂类负责创建对象 ，用户根据需求来从工厂类中获取自己想要的产品。这里涉及到的三个

词分别是：工厂 、产品和用户；这里要说明的是产品是有共同特征的，把共同特征提取出来生成一个接口，所有的产品都去实现这个接口

然后工厂类负责创建这些产品，用户需要什么产品去工厂类里获取；

代码实现如下：

产品共同特征接口

/**
 * 产品共同特征接口
 * 
 * @author jiaocg
 * 
 */
public interface MyProduct {
    // 有什么共同特征都可以在这里定义
    public void createProduct(String product);
}

苹果类

1 public class Apple implements MyProduct {
2 
3     @Override
4     public void createProduct(String product) {
5         System.out.println("我是苹果");
6     }
7 
8 }

梨类

1 public class Pear implements MyProduct {
2 
3     @Override
4     public void createProduct(String product) {
5         System.out.println("我是梨");
6     }
7 }

工厂类

 1 /**
 2  * 工厂类
 3  * 
 4  * @author jiaocg
 5  * 
 6  */
 7 public class ProductFactory {
 8 
 9     public MyProduct getProduct(String puduct) {
10         if ("苹果".equals(puduct)) {
11             return new Apple();// 要苹果就返回苹果
12         }
13         return new Pear();// 要梨就返回梨
14     }
15 }

使用工厂类

1 ProductFactory productFactory = new ProductFactory();
2 // 我想要苹果
3 MyProduct apple = productFactory.getProduct("苹果");
4 // 我想要梨
5 MyProduct pear = productFactory.getProduct("梨");

 

二、工厂方法设计模式

工厂方法设计模式是对普通工厂设计模式的拓展，普通工厂设计模式的缺点是，如果有新的产品出现，我们就要修改工厂类，去添加新的产品，

这样破坏了程序封闭性原则，而工厂方法设计模式则解决了这个问题。就是把工厂也独立出来，如上例说到的工厂类既可以创建苹果又可以创建梨

而工厂方法就是一个工厂类只负责创建一个产品（或多个已知产品），因此就生成了单独的工厂，如苹果工厂只生成苹果，梨工厂只生产梨，你添加了新的产品，我就创建新

的工厂类；由于工厂被独立出来，又拥有共同的特性，所以要提取出来一个接口，所有的工厂都去实现这个接口；这就是工厂方法设计模式；

代码示例如下：

苹果和梨对象还是上面的对象

我们首先提取工厂类接口

 1 /**
 2  * 工厂类接口
 3  * 
 4  * @author jiaocg
 5  * 
 6  */
 7 public interface MyFactory {
 8 
 9     public MyProduct createProduct();
10 }

苹果工厂

 1 /**
 2  * 苹果工厂
 3  * 
 4  * @author jiaocg
 5  * 
 6  */
 7 public class AppleFactory implements MyFactory {
 8 
 9     @Override
10     public MyProduct createProduct() {
11         return new Apple();
12     }

梨工厂

 1 /**
 2  * 梨工厂
 3  * 
 4  * @author jiaocg
 5  * 
 6  */
 7 public class PearFactory implements MyFactory {
 8 
 9     @Override
10     public MyProduct createProduct() {
11         return new Pear();
12     }

使用工厂创建对象

1 AppleFactory appleFactory=new AppleFactory();
2 // 我想要苹果
3 MyProduct apple = appleFactory.createProduct();
4         
5 PearFactory pearFactory=new PearFactory();
6 // 我想要梨
7 MyProduct pear = pearFactory.createProduct();

以上就是简单的工厂方法设计模式，如果有新的产品出现，我们只需要去创建一个新的工厂类即可；

 

三、抽象工厂设计模式

有时候当产品种类很多的时候，我们只知道我们要这种产品，但是我们不确定要这种产品的哪一种。比如我们想要苹果

但是苹果有很多种类比如我们分为红苹果和青苹果，有红梨也有青梨，这时我们就可以根据产品的特点划分出产品的种类，

根据产品的种类来定义不同的工厂，我们把工厂共有的特性提取出一个抽象的工厂类，所有的工厂类都继承这个抽象的工厂类

然后来生产不同种类的产品；

代码示例如下：

首先是产品 提取出来一个抽象的产品类

 1 /**
 2  * 抽象苹果类
 3  * 
 4  * @author jiaocg
 5  * 
 6  */
 7 public abstract class Apples {
 8 
 9     public abstract void createApple();
10 
11 }

红苹果

 1 /**
 2  * 抽象苹果的子类 红苹果
 3  * 
 4  * @author jiaocg
 5  * 
 6  */
 7 public class RedApple extends Apples {
 8 
 9     @Override
10     public void createApple() {
11         System.out.println("红苹果");
12     }
13 }

青苹果

 1 /**
 2  * 抽象苹果的子类 青苹果
 3  * 
 4  * @author jiaocg
 5  * 
 6  */
 7 public class BlueApple extends Apples {
 8 
 9     @Override
10     public void createApple() {
11         System.out.println("青苹果");
12     }
13 
14 }

第二种产品

 1 /**
 2  * 抽象梨
 3  * 
 4  * @author jiaocg
 5  * 
 6  */
 7 public abstract class Pears {
 8 
 9     public abstract void createPear();
10 }

红梨

 1 /**
 2  * 抽象梨的子类 红梨
 3  * 
 4  * @author jiaocg
 5  * 
 6  */
 7 public class RedPear extends Pears {
 8 
 9     @Override
10     public void createPear() {
11         System.out.println("红梨");
12     }
13 
14 }

青梨

 1 /**
 2  * 抽象梨的子类 青梨
 3  * 
 4  * @author jiaocg
 5  * 
 6  */
 7 public class BluePear extends Pears {
 8 
 9     @Override
10     public void createPear() {
11         System.out.println("青梨");
12     }
13 
14 }

然后我们提取出来一个抽象工厂

 1 /**
 2  * 抽象工厂类
 3  * 
 4  * @author jiaocg
 5  * 
 6  */
 7 public abstract class FruitFactory {
 8 
 9     public abstract Apples createApples();
10 
11     public abstract Pears createPears();
12 }

红色种类工厂

 1 /**
 2  * 红色种类工厂
 3  * 
 4  * @author jiaocg
 5  * 
 6  */
 7 public class RedFactory extends FruitFactory {
 8 
 9     @Override
10     public Apples createApples() {
11         // 返回红苹果
12         return new RedApple();
13     }
14 
15     @Override
16     public Pears createPears() {
17         // 返回红梨
18         return new RedPear();
19     }
20 
21 }

青色种类工厂

 1 /**
 2  * 青色种类生产工厂
 3  * 
 4  * @author jiaocg
 5  * 
 6  */
 7 public class BlueFactory extends FruitFactory {
 8 
 9     @Override
10     public Apples createApples() {
11         // 返回青苹果
12         return new BlueApple();
13     }
14 
15     @Override
16     public Pears createPears() {
17         // 返回青梨
18         return new BluePear();
19     }
20 
21 }

代码示例使用

1 // 从红色种类工厂获取红色种类的水果
2 RedFactory redFactory = new RedFactory();
3 RedApple redApple = (RedApple) redFactory.createApples();
4 RedPear redPear = (RedPear) redFactory.createPears();
5 
6 // 从青色种类工厂获取青色种类的水果
7 BlueFactory blueFactory = new BlueFactory();
8 BlueApple blueApple = (BlueApple) blueFactory.createApples();
9 BluePear bluePear = (BluePear) blueFactory.createPears();

这样我们就可以对产品进行分类，并创建对应的工厂，我们不知道要什么产品不重要，我们所有种类的工厂

都有，你想要什么种类的产品就创建什么样的工厂，我都能给你。

抽象工厂设计模式的关键在于 抽象产品和抽象工厂类，把所有的产品和工厂进行对应的分类才是关键。