文章目录
前言
软件设计模式之工厂模式。
一、引入
具体类的设计如下:
二、简单工厂模式
1.实现
现在使用简单工厂对上面案例进行改进,类图如下:
public class SimpleCoffeeFactory {
public Coffee createCoffee(String type) {
Coffee coffee = null;
if("americano".equals(type)) {
coffee = new AmericanoCoffee();
} else if("latte".equals(type)) {
coffee = new LatteCoffee();
}
return coffee;
}
}
2.优缺点
- 优点:
- 封装了创建对象的过程,可以通过参数直接获取对象。
- 把对象的创建和业务逻辑层分开,这样以后就避免了修改客户代码,如果要实现新产品直接修改工厂类,而不需要在原代码中修改,这样就降低了客户代码修改的可能性,更加容易扩展。
- 缺点:
- 增加新产品时还是需要修改工厂类的代码,违背了“开闭原则”。
3.扩展
静态工厂
public class SimpleCoffeeFactory {
public static Coffee createCoffee(String type) {
Coffee coffee = null;
if("americano".equals(type)) {
coffee = new AmericanoCoffee();
} else if("latte".equals(type)) {
coffee = new LatteCoffee();
}
return coffe;
}
}
三、工厂方法模式
1.实现
代码如下:
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: Coffee
* @Description: 咖啡类
* @Date: 2023/12/21 16:27
*/
public abstract class Coffee {
public abstract String getName();
public void addMilk() {
System.out.println("加奶");
}
public void addSugar() {
System.out.println("加糖");
}
}
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: AmericanCcoffee
* @Description: 美式咖啡类
* @Date: 2023/12/21 16:29
*/
public class AmericanCoffee extends Coffee{
@Override
public String getName() {
return "美式咖啡";
}
}
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: LatteCoffee
* @Description: 拿铁咖啡类
* @Date: 2023/12/21 16:35
*/
public class LatteCoffee extends Coffee{
@Override
public String getName() {
return "拿铁咖啡";
}
}
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: CoffeeFactory
* @Description: 咖啡工厂接口
* @Date: 2023/12/21 16:36
*/
public interface CoffeeFactory {
Coffee createCoffee();
}
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: AmericanCoffeeFactory
* @Description: 美式咖啡工厂
* @Date: 2023/12/21 16:37
*/
public class AmericanCoffeeFactory implements CoffeeFactory{
@Override
public Coffee createCoffee() {
return new AmericanCoffee();
}
}
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: LatteCoffeeFactory
* @Description: 拿铁咖啡工厂
* @Date: 2023/12/21 16:38
*/
public class LatteCoffeeFactory implements CoffeeFactory{
@Override
public Coffee createCoffee() {
return new LatteCoffee();
}
}
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: CoffeeStore
* @Description: 咖啡店类
* @Date: 2023/12/21 16:39
*/
public class CoffeeStore {
private CoffeeFactory factory;
public void setFactory(CoffeeFactory factory) {
this.factory = factory;
}
public Coffee orderCoffee() {
Coffee coffee = factory.createCoffee();
coffee.addMilk();
coffee.addSugar();
return coffee;
}
}
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: Client
* @Description: 测试类
* @Date: 2023/12/21 16:44
*/
public class Client {
public static void main(String[] args) {
CoffeeStore store = new CoffeeStore();
store.setFactory(new LatteCoffeeFactory());
Coffee coffee = store.orderCoffee();
System.out.println(coffee.getName());
}
}
2.优缺点
- 优点:
- 用户只需要知道具体工厂的名称就可得到所要的产品,无须知道产品的具体创建过程;
- 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类,无须对原工厂进行任何修改,满足开闭原则;
- 缺点:
- 每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类,这增加了系统的复杂度。
四、抽象工厂模式
1.实现
代码如下:
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: Coffee
* @Description: 咖啡类
* @Date: 2023/12/21 16:27
*/
public abstract class Coffee {
public abstract String getName();
public void addMilk() {
System.out.println("加奶");
}
public void addSugar() {
System.out.println("加糖");
}
}
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: LatteCoffee
* @Description: 拿铁咖啡类
* @Date: 2023/12/21 16:35
*/
public class LatteCoffee extends Coffee {
@Override
public String getName() {
return "拿铁咖啡";
}
}
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: AmericanCcoffee
* @Description: 美式咖啡类
* @Date: 2023/12/21 16:29
*/
public class AmericanCoffee extends Coffee {
@Override
public String getName() {
return "美式咖啡";
}
}
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: Dessert
* @Description: 甜点类
* @Date: 2023/12/21 17:30
*/
public abstract class Dessert {
public abstract void show();
}
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: MatcheMousse
* @Description: 抹茶慕斯类
* @Date: 2023/12/21 17:31
*/
public class MatcheMousse extends Dessert{
@Override
public void show() {
System.out.println("抹茶慕斯");
}
}
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: Tiramisu
* @Description: 提拉米苏类
* @Date: 2023/12/21 17:30
*/
public class Tiramisu extends Dessert{
@Override
public void show() {
System.out.println("提拉米苏");
}
}
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: DessertFactory
* @Description: 甜品工厂
* @Date: 2023/12/21 17:33
*/
public interface DessertFactory {
Coffee createCoffee();
Dessert createDessert();
}
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: AmericanDessertFactory
* @Description: 美式风味工厂类
* 生产美式咖啡和抹茶慕斯
* @Date: 2023/12/21 17:34
*/
public class AmericanDessertFactory implements DessertFactory{
@Override
public Coffee createCoffee() {
return new AmericanCoffee();
}
@Override
public Dessert createDessert() {
return new MatcheMousse();
}
}
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: ItalyDessertFactory
* @Description: 意大利风味工厂
* 生产拿铁咖啡和提拉米苏
* @Date: 2023/12/21 17:35
*/
public class ItalyDessertFactory implements DessertFactory{
@Override
public Coffee createCoffee() {
return new LatteCoffee();
}
@Override
public Dessert createDessert() {
return new Tiramisu();
}
}
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: Client
* @Description: 测试类
* @Date: 2023/12/21 17:36
*/
public class Client {
public static void main(String[] args) {
ItalyDessertFactory italyDessertFactory = new ItalyDessertFactory();
Dessert dessert = italyDessertFactory.createDessert();
Coffee coffee = italyDessertFactory.createCoffee();
System.out.println(coffee.getName());
dessert.show();
}
}
2.优缺点
- 优点:
- 当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。
- 缺点:
- 当产品族中需要增加一个新的产品时,所有的工厂类都需要进行修改。
3.使用场景
- 当需要创建的对象是一系列相互关联或相互依赖的产品族时,如电器工厂中的电视机、洗衣机、空调等。
- 系统中有多个产品族,但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
- 系统中提供了产品的类库,且所有产品的接口相同,客户端不依赖产品实例的创建细节和内部结构。
- 如:输入法换皮肤,一整套一起换。生成不同操作系统的程序。
五、模式扩展
简单工厂+配置文件解除耦合
第一步:定义配置文件
使用properties文件作为配置文件,名称为bean.properties
american=com.itheima.pattern.factory.config_factory.AmericanCoffee
latte=com.itheima.pattern.factory.config_factory.LatteCoffee
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: Coffee
* @Description: 咖啡类
* @Date: 2023/12/21 16:27
*/
public abstract class Coffee {
public abstract String getName();
public void addMilk() {
System.out.println("加奶");
}
public void addSugar() {
System.out.println("加糖");
}
}
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: AmericanCcoffee
* @Description: 美式咖啡类
* @Date: 2023/12/21 16:29
*/
public class AmericanCoffee extends Coffee {
@Override
public String getName() {
return "美式咖啡";
}
}
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: LatteCoffee
* @Description: 拿铁咖啡类
* @Date: 2023/12/21 16:35
*/
public class LatteCoffee extends Coffee {
@Override
public String getName() {
return "拿铁咖啡";
}
}
/**
* @Version: 1.0.0
* @Author: Dragon_王
* @ClassName: CoffeeFactory
* @Description: 咖啡工厂类
* @Date: 2023/12/21 21:06
*/
public class CoffeeFactory {
//定义容器对象存储咖啡对象
private static Map<String,Coffee> map = new HashMap();
// 加载配置文件,只需要加载一次
static {
// 创建Properties对象
Properties p = new Properties();
// 调用p对象中的load方法进行配置文件的加载
InputStream is = CoffeeFactory.class.getClassLoader().getResourceAsStream("bean.properties");
try {
p.load(is);
//遍历Properties集合对象
Set<Object> keys = p.keySet();
for (Object key : keys) {
//根据键获取值(全类名)
String className = p.getProperty((String) key);
//获取字节码对象
Class clazz = Class.forName(className);
Coffee obj = (Coffee) clazz.newInstance();
map.put((String)key,obj);
}
} catch (Exception e) {
e.printStackTrace();
}
}
// 根据名称获取对象
public static Coffee createCoffee(String name) {
return map.get(name);
}
}
六、JDK源码解析
public class Demo {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("令狐冲");
list.add("风清扬");
list.add("任我行");
//获取迭代器对象
Iterator<String> it = list.iterator();
//使用迭代器遍历
while(it.hasNext()) {
String ele = it.next();
System.out.println(ele);
}
}
}
Collection接口是抽象工厂类,ArrayList是具体的工厂类;Iterator接口是抽象商品类,ArrayList类中的Iter内部类是具体的商品类。在具体的工厂类中iterator()方法创建具体的商品类的对象。
总结
以上就是设计模式工厂模式的讲解。