工厂模式
在java中, 万物皆对象, 这些对象都需要创建, 如果创建的时候, 直接new对象, 就会对该对象耦合严重, 加入我们要更换对象, 所有new对象的地方都需要修改一遍, 明显违背了软件设计的开闭原则, 如果我们使用工厂来生产对象, 我们只和工厂打交道就ok, 彻底和对象解耦, 如果要更换对象, 直接在工厂里更换该对象即可, 达到了与对象解耦的目的, 所以说, 工厂模式最大的有点就是解耦合
简单工厂模式
结构
简单工厂包含如下角色:
-
抽象产品: 定义了产品的规范, 描述了产品的主要特性和功能
-
具体产品: 实现或继承抽象产品的子类
-
具体工厂: 提供了创建产品的方法, 调用者通过该方法来获取产品对象
实现
现在使用简单工厂对上面案例进行改进
public abstract class Coffee {
//获取咖啡的名字
public abstract String getName();
//加糖
public void addSugar() {
System.out.println("加糖");
}
//加奶
public void addMilk() {
System.out.println("加奶");
}
}public class AmericanCoffee extends Coffee{
@Override
public String getName() {
return "美式咖啡";
}
}public class LatteCoffee extends Coffee{
@Override
public String getName() {
return "拿铁";
}
}public class CoffeeStore {
public Coffee orderCoffee(String type) {
SimpleCoffeeFactory simpleCoffeeFactory = new SimpleCoffeeFactory();
//调用生产咖啡的方法
Coffee coffee = simpleCoffeeFactory.creatCoffee(type);
//加配料
coffee.addMilk();
coffee.addSugar();
return coffee;
}
}public class SimpleCoffeeFactory {
public Coffee creatCoffee(String type) {
//声明coffee类型的变量, 根据不同类型创建不同的cofee子类对象
Coffee coffee = null;
if ("american".equals(type)) {
coffee = new AmericanCoffee();
}else if("latte".equals(type)){
coffee = new LatteCoffee();
} else {
throw new RuntimeException("点错了");
}
return coffee;
}
}工厂处理对象的细节, 一旦有了SimpleCoffeeFactory, CoffeeStore类中的orderCoffee()就变成此对象的客户, 后期如果需要Coffee对象直接从工厂中获取即可, 这样就解除了Coffee实现类的耦合, 同时又产生了新的耦合, CoffeeStore对象和SimpleCoffeeFactory工厂对象之间的耦合, 工厂对象和商品对象的耦合
后期如果再加新品种的咖啡, 我们势必要修改简单工厂的代码, 违背了开闭原则, 工厂类的客户端可能有很多, 比如创建美团外卖等, 这样只需要修改工厂类的代码, 省去其他的修改操作
优缺点
优点
-
封装了创建对象的过程, 可以通过参数直接获取对象, 把对象的创建和业务逻辑层分开, 这样以后就避免了修改客户代码,
-
如果要实现新产品直接修改工厂类, 而不需要在源代码中修改, 这样就降低了客户代码修改的可能性, 更加容易扩展
缺点
-
增加新产品时候还需要修改工厂类的代码, 违背了开闭原则
简单工厂扩展 - 静态工厂
在其他的客户端, 如果我们要从工厂中获取对象的话, 不需要再去创建工厂对象了
public class StaticCoffeeFactory {
public static Coffee creatCoffee(String type) {
//声明coffee类型的变量, 根据不同类型创建不同的cofee子类对象
Coffee coffee = null;
if ("american".equals(type)) {
coffee = new AmericanCoffee();
}else if("latte".equals(type)){
coffee = new LatteCoffee();
} else {
throw new RuntimeException("点错了");
}
return coffee;
}
}工厂方法模式
针对上例中的缺点, 使用工厂方法模式就可以完美的解决, 完全遵循开闭原则
概念
定义一个用于创建对象的接口, 让子类决定实例化哪个产品类对象, 工厂方法使一个产品类的实例化延迟到其工厂的子类
结构
工厂方法模式的主要角色
-
抽象工厂: 提供了创建产品的接口, 调用者通过它访问具体工厂方法来创建产品
-
具体工厂: 主要是实现抽象工厂中的抽象方法, 完成具体产品的创建
-
抽象产品: 定义了产品的规范, 描述了产品的主要特性和功能
-
具体产品: 实现了抽象产品角色所定义的接口, 由具体工厂来创建, 他同具体工厂之间一一对应
实现
抽象工厂：
public interface CoffeeFactory {
Coffee createCoffee();
}具体工厂：
public class LatteCoffeeFactory implements CoffeeFactory {
public Coffee createCoffee() {
return new LatteCoffee();
}
}
public class AmericanCoffeeFactory implements CoffeeFactory {
public Coffee createCoffee() {
return new AmericanCoffee();
}
}咖啡店类：
public class CoffeeStore {
private CoffeeFactory factory;
public CoffeeStore(CoffeeFactory factory) {
this.factory = factory;
}
public Coffee orderCoffee(String type) {
Coffee coffee = factory.createCoffee();
coffee.addMilk();
coffee.addsugar();
return coffee;
}
}优缺点
优点
-
用户只需要知道具体工厂的具体名称就可以得到所要的产品, 无须知道产品的具体创建过程
-
在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类, 无须对原工厂进行任何修改, 就满足开闭原则
缺点
-
每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类, 这增加了系统的复杂度
抽象工厂模式
考虑多等级产品的生产, 将同一个具体工厂所生产的位于不同等级的一组产品, 称为一个产品族
概念
-
是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。
-
抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。
结构
-
抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法，可以创建一个产品族 多个不同等级的产品。
-
具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
-
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
-
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它 同具体工厂之间是多对一的关系。
实现
4.2.4.2 实现
现咖啡店业务发生改变，不仅要生产咖啡还要生产甜点，如提拉米苏、抹茶慕斯等，要是按照工厂方法模式，需要定义提拉米苏类、抹茶慕斯类、提拉米苏工厂、抹茶慕斯工厂、甜点工厂类，很容易发生类爆炸情况。其中拿铁咖啡、美式咖啡是一个产品等级，都是咖啡；提拉米苏、抹茶慕斯也是一个产品等级；拿铁咖啡和提拉米苏是同一产品族（也就是都属于意大利风味），美式咖啡和抹茶慕斯是同一产品族（也就是都属于美式风味）。所以这个案例可以使用抽象工厂模式实现。
代码如下：
抽象工厂：
public interface DessertFactory {
Coffee createCoffee();
Dessert createDessert();
}具体工厂：
//美式甜点工厂
public class AmericanDessertFactory implements DessertFactory {
public Coffee createCoffee() {
return new AmericanCoffee();
}
public Dessert createDessert() {
return new MatchaMousse();
}
}
//意大利风味甜点工厂
public class ItalyDessertFactory implements DessertFactory {
public Coffee createCoffee() {
return new LatteCoffee();
}
public Dessert createDessert() {
return new Tiramisu();
}
}如果要加同一个产品族的话，只需要再加一个对应的工厂类即可，不需要修改其他的类。
优缺点
优点
当一个产品族中多个对象被设计成一起工作时, 他能保证客户端始终只使用同一个产品族的对象
缺点
当产品族中需要增加一个新的产品时, 所有的工厂类都需要进行修改
使用场景
-
当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。
-
系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
-
系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。
如：输入法换皮肤，一整套一起换。生成不同操作系统的程序。
工厂模式扩展
简单工厂 + 配置文件解除耦合
通过工厂模式+配置文件的方式解除工厂对象和产品对象的耦合, 在工厂类中加载配置文件中的全类名, 并且通过反射的方式创建对象, 只需要加载一次然后进行存储, 需要用的时候拿出来用就行, 客户端如果需要对象, 直接进行获取即可
第一步、定义配置文件
为了演示方便，我们使用properties文件作为配置文件，名称为bean.properties
american=com.itheima.pattern.factory.config_factory.AmericanCoffee
latte=com.itheima.pattern.factory.config_factory.LatteCoffee第二步、改进工厂类
public class CoffeeFactory {
/**
* kf 用于存储配置文件的表
*/
private static HashMap<String, Coffee> map = new HashMap<>();
/*
km 加载配置文件, 只需加载一次
*/
static {
//ks 创建Properties对象
Properties p = new Properties();
//kp 调用p对象中的load方法进行配置文件的加载
InputStream is = CoffeeFactory.class.getClassLoader().getResourceAsStream("bean.properties");
try {
//ks 加载配置文件
p.load(is);
//从properties中获取全类名并创建对象
for (Object key : p.keySet()) {
//获取类的全类名
String className = p.getProperty((String) key);
//通过反射创建对象
Class clazz = Class.forName(className);
//调用无参构造实例化一个对象
Coffee coffee = (Coffee) clazz.newInstance();
//将名称和对象存储到容器中
map.put((String) key, coffee);
}
} catch (Exception exception) {
exception.printStackTrace();
}
}
/**
* 根据名称获取对象
*
* @param name
* @return
*/
public static Coffee createCoffee(String name) {
return map.get(name);
}
}静态成员变量用来存储创建的对象(键存储的是名称, 值存储的是对应的对象), 而读取配置文件以及创建对象卸载静态代码中, 目的是只需要执行一次
JDK源码分析 - 迭代器
Collection接口是抽象工厂类，ArrayList是具体的工厂类；Iterator接口是抽象商品类，ArrayList类中的Iter内部类是具体的商品类。在具体的工厂类中iterator()方法创建具体的商品类的对象。
标签：Coffee,对象,coffee,模式,工厂,产品,public From： https://www.cnblogs.com/phonk/p/16961783.html另：
1,DateForamt类中的getInstance()方法使用的是工厂模式；
2,Calendar类中的getInstance()方法使用的是工厂模式；