在最初的学习过程中对把简单的东西搞得复杂的现象很不理解，随着经验的增长，慢慢发现我所理解的“简单”其实是针对设计的简单，这种代码缺少灵活性，目的仅仅是为了解决现有问题。而“复杂”恰恰是针对一类问题的万能方案，他可以让代码变得优雅，灵活不再是一个臃肿的胖子。
在对模式的学习过程中很容易误入歧途，陷入形式主义，对模式细节的过多关注恰恰使我们越陷越深，子曾经曰过：“学而不思则罔”，文档中的类图和实现代码往往并不能代表模式的全部，我们学习模式的重点要放在模式的意图上。
设计模式代表了最佳的实践，是开发人员在开发过程中面临一般问题的解决方案，是众多前辈们在经过相当长一段时间的试验和错误中总结出来的。
什么是设计模式
设计模式：是一套被反复使用、多数人知晓、经过分类编目的代码设计经验的总结。
使用设计模式的目的
使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码的可靠性。
设计模式的分类
- 创建型模式：创建型模式涉及对象的实例化，用于解耦对象的实例化过程，不让用户代码依赖于对象的创建或排列方式，避免用户直接使用new创建对象。。
- 结构型模式：把类或对象结合在一起形成一个更大的结构，和类有关的结构型模式涉及如何合理使用继承机制；和对象有关的结构型模式涉及如何合理的使用对象组合机制。。
- 行为型模式： 行为型模式涉及怎样合理的设计对象之间的交互通信，以及怎样合理为对象分配职责，让设计富有弹性，易维护，易复用。
工厂模式
意图：定义一个创建对象的接口。让其子类决定实例化哪一个类。使其实例化过程延迟到子类进行。
工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
三个工厂
-
简单工厂模式
简单工厂模式又叫静态工厂方法模式，实际不能算作一种设计模式。
GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式与抽象工厂模式。将简单工厂模式看为工厂方法模式的一种特例，两者归为一类。
意图：定义一个用于创建对象的接口
具体实现：
抽象一个产品基类，(接口也可以)
/**
* @Author: chichapaofan
* @CreateDate: 2018/10/24
* @Description：产品的抽象类
*/
public abstract class Coffee {
/**
* 展示产品详情
*/
public abstract void details();
}
产品的具体实现
/**
* @Author: chichapaofan
* @CreateDate: 2018/10/24
* @Description: 美式咖啡
*/
public class Americano extends Coffee {
@Override
public void details() {
System.out.print("美式咖啡,不便宜");
}
}
/**
* @Author: chichapaofan
* @CreateDate: 2018/10/24
* @Description:拿铁咖啡
*/
public class Latte extends Coffee {
@Override
public void details() {
System.out.print("拿铁咖啡,不便宜");
}
}
/**
* @Author: chichapaofan
* @CreateDate: 2018/10/24
* @Description:雀巢咖啡
*/
public class Nescafe extends Coffee {
@Override
public void details() {
System.out.print("雀巢咖啡,喝得起");
}
}
简单工厂来创建不同类型的咖啡实例
/**
* @Author: chichapaofan
* @CreateDate: 2018/10/24
* @Description: 简单工厂
*/
public class SimpleFactory {
/**
* 通过传递过来的类型创建不同实例
* @param type
* @return
*/
public static Coffee createInstance(String type) {
if (type.equals("Americano")) {
return new Americano();
} else if (type.equals("Latte")) {
return new Latte();
} else if (type.equals("Nescafe")) {
return new Nescafe();
} else {
throw new RuntimeException("没有匹配到可实例化[" + type + "]对象");
}
}
}
使用
/**
* @Author: chichapaofan
* @CreateDate: 2018/10/24
* @Description:
*/
public class Test {
public static void main(String[] args) {
Coffee latte = SimpleFactory.createInstance("Latte");
latte.details();
Coffee americano = SimpleFactory.createInstance("Americano");
americano.details();
Coffee nescafe = SimpleFactory.createInstance("Nescafe");
nescafe.details();
}
}
简单工厂模式在实际使用过程中，对产品部分来说是符合开闭原则的，但是对于工厂部分，每增加一个新产品，都要在工厂类中增加相应的创建逻辑，这显然违背了开闭原则。
不知道设计模式六大原则的同学请自行补课
http://www.runoob.com/design-pattern/design-pattern-intro.html
-
工厂方法模式
意图：提供一个用于创建对象的接口(工厂接口)，让其实现类(工厂实现类)决定实例化哪一个类(产品类)，并且由该实现类创建对应类的实例。
可以理解为不同地区只生产自己类型的咖啡，美国America只生产Americano，德国Germany只生产Latte和Nescafe。
具体实现：
产品基类及实现同上
定义一个工厂基类，（使用接口的方式会更好）
/**
* @Author: chichapaofan
* @CreateDate: 2018/10/24
* @Description:定义一个抽象咖啡工厂
*/
public abstract class CoffeeFactory {
/**
* 用于生产咖啡
* @return
*/
public abstract Coffee createCoffee(String type);
}
咖啡工厂的具体实现
/**
* @Author: chichapaofan
* @CreateDate: 2018/10/24
* @Description:美国咖啡工厂
*/
public class AmericaCoffeeFactory extends CoffeeFactory{
@Override
public Coffee createCoffee(String type) {
return new Americano();
}
}
/**
* @Author: chichapaofan
* @CreateDate: 2018/10/24
* @Description:德国咖啡工厂
*/
public class GermanyCoffeeFactory extends CoffeeFactory {
@Override
public Coffee createCoffee(String type) {
if (type.equals("Latte")) {
return new Latte();
} else if (type.equals("Nescafe")) {
return new Nescafe();
} else {
throw new RuntimeException("没有匹配到可实例化[" + type + "]对象");
}
}
}
使用
public class Test {
public static void main(String[] args) {
/**
* 工厂方法模式的使用方法
*/
CoffeeFactory americaCoffeeFactory = new AmericaCoffeeFactory();
Coffee americaCoffees = americaCoffeeFactory.createCoffee("");
americaCoffees.details();
CoffeeFactory germanyCoffeeFactory = new GermanyCoffeeFactory();
Coffee latteCoffees = germanyCoffeeFactory.createCoffee("Latte");
latteCoffees.details();
Coffee nescafeCoffees = germanyCoffeeFactory.createCoffee("Nescafe");
nescafeCoffees.details();
}
}
工厂方法模式非常符合“开闭原则”，当需要增加一个新的产品时，我们只需要增加一个具体的产品类和与之对应的具体工厂即可，无须修改原有系统。但是由于每新增一个新产品时就需要增加两个类，这样势必会导致系统的复杂度增加。
-
抽象工厂模式
场景：当需要创建的对象是一系列相互关联或相互依赖的产品族时，便可以使用抽象工厂模式。
意图：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。抽象工厂为不同产品族的对象创建提供接口。
关键点在于如何在一个工厂里聚合多个同类产品。
具体实现：
抽象出饮料制造工厂
/**
* @Author: chichapaofan
* @CreateDate: 2018/10/24
* @Description:
*/
public interface AbstractDrinksFactory {
/**
* 制造咖啡
* @return
*/
Coffee createCoffee();
/**
* 制造碳酸饮料
* @return
*/
Sodas createSodas();
/**
* 制造茶
* @return
*/
Tea createTea();
}
饮料工厂的具体实现
/**
* @Author: chichapaofan
* @CreateDate: 2018/10/24
* @Description:美国饮料工厂
*/
public class AmericaDrinksFactory implements AbstractDrinksFactory{
@Override
public Coffee createCoffee() {
return new Latte();
}
@Override
public Sodas createSodas() {
return new CocaCola();
}
@Override
public Tea createTea() {
return null;
}
}
/**
* @Author: chichapaofan
* @CreateDate: 2018/10/24
* @Description:中国饮料工厂
*/
public class ChinaDrinksFactory implements AbstractDrinksFactory{
@Override
public Coffee createCoffee() {
return new Latte();
}
@Override
public Sodas createSodas() {
return new CocaCola();
}
@Override
public Tea createTea() {
return new Dragon_Well();
}
}
使用
/**
* @Author: chichapaofan
* @CreateDate: 2018/10/24
* @Description:
*/
public class Test {
public static void main(String[] args) {
/**
* 抽象工厂测试
*/
AbstractDrinksFactory chinaDrinksFactory = new ChinaDrinksFactory();
Coffee coffee = chinaDrinksFactory.createCoffee();
Sodas sodas = chinaDrinksFactory.createSodas();
Tea tea = chinaDrinksFactory.createTea();
if (coffee != null) {
coffee.details();
}
if (sodas != null) {
sodas.details();
}
if (tea != null) {
tea.details();
}
}
}
抽象工厂模式最主要的优点就是可以在类的内部对产品族进行约束，而不必专门引入一个新的类来进行管理。
当然抽象工厂模式的缺点也非常明显，那就是产品族的不易扩展，使产品族中每需要增加一个新的产品，则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时，对产品等级结构的划分是非常重要的。
参考文章：
http://www.runoob.com/design-pattern/abstract-factory-pattern.html
https://www.cnblogs.com/zailushang1996/p/8601808.html
https://www.cnblogs.com/carryjack/p/7709861.html