一 简单工厂模式
1 概述
工厂,顾名思义,是用来生产对象的,其好处是实现了类与类实例化之间的解耦,类实例化的过程可能是无比复杂的,当这种复杂实例化的类多起来之后,每次实例化都要重复的编写过程代码;有了工厂模式后,工厂隐藏了对象实例化的过程,用户只需通知工厂要生产的类,即可获得要生产的类;
2 使用示例
阅读笔记时,应先从产品(即main方法)出发,了解产物是如何运作的,从而反推设计;
package cn.pattern.创建型.factory;
import cn.pattern.创建型.factory.simple.producer.AppleFactory;
import cn.pattern.创建型.factory.simple.producer.CherryFactory;
import cn.pattern.创建型.factory.simple.product.Food;
/**
* 简单工厂模式应用
*
* @author:wjm
* @date:2020/6/30 23:02
*/
public class Test {
public static void main(String[] args) {
/**
* 需求:工厂隐藏对象复杂的实例化方法,只对外提供一个实例化对象的方法,便可以简单的使用对象工厂生产对象的实例;
*/
/**
* 使用不同的对象工厂生产不同的实例,不同的实例都实现/抽象自同一接口/抽象类(多态化的体现)
*/
Food apple = new AppleFactory().create();
Food cherry = new CherryFactory().create();
apple.description();
cherry.description();
}
}
一个子工厂生产一个类对象,通过对外提供create()进行实例化,隐藏了复杂的创建对象细节;
接下来是工厂模式要生产对象的介绍;
package cn.pattern.创建型.factory.simple.product;
/**
* 产出物:食品接口
*
* @author:wjm
* @date:2020/6/30 22:50
*/
public interface Food {
/**
* 提供一个方法
*/
void description();
}
package cn.pattern.创建型.factory.simple.product;
/**
* 产出物:苹果
*
* @author:wjm
* @date:2020/6/30 22:54
*/
public class Apple implements Food {
@Override
public void description() {
System.out.println("这是苹果");
}
}
package cn.pattern.创建型.factory.simple.product;
/**
* 产出物:樱桃
*
* @author:wjm
* @date:2020/6/30 22:54
*/
public class Cherry implements Food {
@Override
public void description() {
System.out.println("这是樱桃");
}
}
接下来对简单工厂模式中工厂的介绍;
package cn.pattern.创建型.factory.simple.producer;
import cn.pattern.创建型.factory.simple.product.Food;
/**
* 生产者:工厂
*
* @author:wjm
* @date:2020/6/30 22:57
*/
public interface Factory {
/**
* 可以生产所有实现了Food的子类
*
* @return
*/
Food create();
}
package cn.pattern.创建型.factory.simple.producer;
import cn.pattern.创建型.factory.simple.product.Apple;
import cn.pattern.创建型.factory.simple.product.Food;
/**
* 生产苹果的工厂
*
* @author:wjm
* @date:2020/6/30 22:58
*/
public class AppleFactory implements Factory {
@Override
public Food create() {
return new Apple();
}
}
package cn.pattern.创建型.factory.simple.producer;
import cn.pattern.创建型.factory.simple.product.Cherry;
import cn.pattern.创建型.factory.simple.product.Food;
/**
* 生产樱桃的工厂
*
* @author:wjm
* @date:2020/6/30 22:58
*/
public class CherryFactory implements Factory {
@Override
public Food create() {
return new Cherry();
}
}
3 总结
- 工厂隐藏了对象实例化的过程,用户只需通知工厂要生产的类,即可获得要生产的类;
- 一个类对象对应一个子工厂,若生产的类对象繁多,则对应的子工厂也会很多;
二 抽象工厂模式
1 概述
抽象工厂,意味着工厂的泛化,也就是说对多个工厂共通行为的抽取及概括;
抽象工厂与工厂的区别:抽象工厂相比普通工厂定义了更多的抽象行为,也就是多个工厂方法于抽象工厂中,抽象工厂模式是工厂模式的变种;
2 使用示例
需求:
食品 | 一级品 | 二级品 | 三级品 |
---|---|---|---|
水果 | 一级水果 | 二级水果 | 三级水果 |
牛排 | 一级牛排 | 二级牛排 | 三级牛排 |
根据以上需求,如果按照普通工厂来生产食品,那就需要每个等级每种食品都分别有相应的工厂来创建;
由于等级和食品是有关联的,可以抽象为一级食品、二级食品、三级食品; 使用抽象工厂:抽象为水果工厂、牛排工厂,每个工厂分别提供生产一级、二级、三级对应工厂的食品,代码示例:
阅读笔记时,应先从产品(即main方法)出发,了解产物是如何运作的,从而反推设计;
package cn.pattern.创建型.factory.abstracts;
import cn.pattern.创建型.factory.abstracts.producer.Factory;
import cn.pattern.创建型.factory.abstracts.producer.FruitFactory;
import cn.pattern.创建型.factory.abstracts.producer.SteakFactory;
import cn.pattern.创建型.factory.abstracts.product.Food;
/**
* 抽象工厂模式应用
*
* @author:wjm
* @date:2020/6/30 23:02
*/
public class Test {
public static void main(String[] args) {
/**
* 根据需求,产出物的结构为:xx级xx食品;<p>
* 先在创建工厂的时候,确定食品的类型,再通过工厂创建xx级别的食品,当然,也可以反过来;
*/
Factory fruitFactory = new FruitFactory();
Food bestFruit = fruitFactory.createBestFood();
Food mediumFruit = fruitFactory.createMediumFood();
Food worstFruit = fruitFactory.createWorstFood();
Factory steakFactory = new SteakFactory();
Food bestSteak = steakFactory.createBestFood();
Food mediumSteak = steakFactory.createMediumFood();
Food worstSteak = steakFactory.createWorstFood();
bestFruit.description();
mediumFruit.description();
worstFruit.description();
bestSteak.description();
mediumSteak.description();
worstSteak.description();
}
}
抽象工厂利用了两两组合的特性,从而可以产生更多类型的对象,相比简单工厂一个类需要对应一个工厂要更友好;
接下来是工厂模式要生产对象的介绍;
package cn.pattern.创建型.factory.abstracts.product;
/**
* 产出物:食品接口
*
* @author:wjm
* @date:2020/7/1 20:24
*/
public interface Food {
/**
* 提供一个方法
*/
void description();
}
package cn.pattern.创建型.factory.abstracts.product;
/**
* 产出物:一级水果
*
* @author:wjm
* @date:2020/7/1 20:24
*/
public class FruitBest implements Food {
@Override
public void description() {
System.out.println("这是一级水果");
}
}
package cn.pattern.创建型.factory.abstracts.product;
/**
* 产出物:二级水果
*
* @author:wjm
* @date:2020/7/1 20:24
*/
public class FruitMedium implements Food {
@Override
public void description() {
System.out.println("这是二级水果");
}
}
package cn.pattern.创建型.factory.abstracts.product;
/**
* 产出物:三级水果
*
* @author:wjm
* @date:2020/7/1 20:24
*/
public class FruitWorst implements Food{
@Override
public void description() {
System.out.println("这是三级水果");
}
}
package cn.pattern.创建型.factory.abstracts.product;
/**
* 产出物:一级牛排
*
* @author:wjm
* @date:2020/7/1 20:24
*/
public class SteakBest implements Food{
@Override
public void description() {
System.out.println("这是一级牛排");
}
}
package cn.pattern.创建型.factory.abstracts.product;
/**
* 产出物:二级牛排
*
* @author:wjm
* @date:2020/7/1 20:24
*/
public class SteakMedium implements Food{
@Override
public void description() {
System.out.println("这是二级牛排");
}
}
package cn.pattern.创建型.factory.abstracts.product;
/**
* 产出物:三级牛排
*
* @author:wjm
* @date:2020/7/1 20:24
*/
public class SteakWorst implements Food{
@Override
public void description() {
System.out.println("这是三级牛排");
}
}
接下来对抽象工厂模式中工厂的介绍;
package cn.pattern.创建型.factory.abstracts.producer;
import cn.pattern.创建型.factory.abstracts.product.Food;
/**
* 生产者:工厂
*
* @author:wjm
* @date:2020/7/1 20:18
*/
public interface Factory {
/**
* 生产一级食品
*
* @return
*/
Food createBestFood();
/**
* 生产二级食品
*
* @return
*/
Food createMediumFood();
/**
* 生产三级食品
*
* @return
*/
Food createWorstFood();
}
package cn.pattern.创建型.factory.abstracts.producer;
import cn.pattern.创建型.factory.abstracts.product.Food;
import cn.pattern.创建型.factory.abstracts.product.FruitBest;
import cn.pattern.创建型.factory.abstracts.product.FruitMedium;
import cn.pattern.创建型.factory.abstracts.product.FruitWorst;
/**
* 生产者:不同级别的水果
*
* @author:wjm
* @date:2020/7/1 20:18
*/
public class FruitFactory implements Factory{
@Override
public Food createBestFood() {
return new FruitBest();
}
@Override
public Food createMediumFood() {
return new FruitMedium();
}
@Override
public Food createWorstFood() {
return new FruitWorst();
}
}
package cn.pattern.创建型.factory.abstracts.producer;
import cn.pattern.创建型.factory.abstracts.product.Food;
import cn.pattern.创建型.factory.abstracts.product.SteakBest;
import cn.pattern.创建型.factory.abstracts.product.SteakMedium;
import cn.pattern.创建型.factory.abstracts.product.SteakWorst;
/**
* 生产者:不同级别的牛排
*
* @author:wjm
* @date:2020/7/1 20:18
*/
public class SteakFactory implements Factory {
@Override
public Food createBestFood() {
return new SteakBest();
}
@Override
public Food createMediumFood() {
return new SteakMedium();
}
@Override
public Food createWorstFood() {
return new SteakWorst();
}
}
3 总结
使用各族工厂对种类繁多的产品进行了划分、归类,产品虽然繁多,但总得有等级、品牌、型号之分,以各族工厂和产品线划界,分而治之,横向拆分产品家族,纵向则拆分产品等级。
三 类UML图
简单工厂模式:
抽象工厂模式:
源码地址:我的GitHub
来源:oschina
链接:https://my.oschina.net/u/4530399/blog/4428143