面试篇：设计模式
设计模式分类
Java 中一般认为有 23 种设计模式。
总体来说设计模式分为三大类：
创建型模式，共 5 种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共 7 种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共 11 种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘 录模式、状态模式、访问者模式、中介者模式、解释器模式。
工厂设计模式（Factory）
工厂设计模式，顾名思义，就是用来生产对象的，在 java 中，万物皆对象，这些对象都需要创建，如果创建的时候直接 new 该对象，就会对该对象耦合严重，假如我们要更换对象，所有new 对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则，如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；
所以说，工厂模式最大的优点就是：解耦。
简单工厂（Simple Factory）
定义
一个工厂方法，依据传入的参数，生成对应的产品对象；
角色
1、抽象产品
2、具体产品
3、具体工厂
4、产品使用者
案例使用
先将产品类抽象出来，比如，苹果和梨都属于水果，抽象出来一个水果类 Fruit，苹果和梨就是具体的产品类，然后创建一个水果工厂，分别用来创建苹果和梨。代码如下：
水果接口:
public interface Fruit {
void whatIm();
}苹果类：
public class Apple implements Fruit {
@Override
public void whatIm() {
System.out.println("苹果");
}
}梨类：
public class Pear implements Fruit {
@Override
public void whatIm() {
System.out.println("梨");
}
}水果工厂
public class FruitFactory {
public Fruit createFruit(String type) {
if (type.equals("apple")) {
// 生产苹果
return new Apple();
} else if (type.equals("pear")) {
// 生产梨
return new Pear();
}
return null;
}
}使用工厂生产产品：
public class FruitApp {
public static void main(String[] args) {
FruitFactory mFactory = new FruitFactory();
// 获得苹果
Apple apple = (Apple) mFactory.createFruit("apple");
// 获得梨
Pear pear = (Pear) mFactory.createFruit("pear");
apple.whatIm(); p
ear.whatIm();
}
}以上的这种方式，每当添加一种水果，就必然要修改工厂类，违反了开闭原则；
所以简单工厂只适合于产品对象较少，且产品固定的需求，对于产品变化无常的需求来说显然不合适。
工厂方法（Factory Method）
定义
将工厂提取成一个接口或抽象类，具体生产什么产品由子类决定；
角色
1、抽象产品
2、具体产品
3、抽象工厂
4、具体工厂
案例使用
和上例中一样，产品类抽象出来，这次我们把工厂类也抽象出来，生产什么样的产品由子类来决定。
水果接口、苹果类和梨类代码和上例一样.
抽象工厂接口：
public interface FruitFactory {
// 生产水果
Fruit createFruit();
}苹果工厂：
public class AppleFactory implements FruitFactory {
@Override
public Apple createFruit() {
return new Apple();
}
}梨工厂：
public class PearFactory implements FruitFactory {
@Override
public Pear createFruit() {
return new Pear();
}
}使用工厂生产产品：
public class FruitApp {
public static void main(String[] args){
AppleFactory appleFactory = new AppleFactory();
PearFactory pearFactory = new PearFactory();
// 获得苹果
Apple apple = appleFactory.createFruit();
// 获得梨
Pear pear = pearFactory.createFruit();
apple.whatIm();
pear.whatIm();
}
}抽象工厂（Abstract Factory）
定义
为创建一组相关或者是相互依赖的对象提供的一个接口，而不需要指定它们的具体类。
角色
1、抽象产品
2、具体产品
3、抽象工厂
4、具体工厂
案例使用
抽象工厂和工厂方法的模式基本一样，区别在于，工厂方法是生产一个具体的产品，而抽象工厂可以用来生产一组相同，有相对关系的产品；重点在于一组，一批，一系列；
举个例子，假如生产小米手机，小米手机有很多系列，小米note、红米 note 等；假如小米 note 生产需要的配件有 825 的处理器，6英寸屏幕，而红米只需要 650 的处理器和 5 寸的屏幕就可以了。
用抽象工厂来实现：
cpu 接口和实现类：
public interface Cpu {
void run();
}
class Cpu650 implements Cpu {
@Override
public void run() {
System.out.println("650 也厉害");
}
}
class Cpu825 implements Cpu {
@Override
public void run() {
System.out.println("825 更强劲");
}
}屏幕接口和实现类：
public interface Screen {
void size();
}
class Screen5 implements Screen {
@Override public void size() {
System.out.println("5 寸");
}
}
class Screen6 implements Screen {
@Override
public void size() {
System.out.println("6 寸");
}
}抽象工厂接口：
public interface PhoneFactory {
// 使用的 cpu
Cpu getCpu();
// 使用的屏幕
Screen getScreen();
}小米手机工厂：
public class XiaoMiFactory implements PhoneFactory {
@Override
public Cpu.Cpu825 getCpu() {
// 高性能处理器
return new Cpu.Cpu825();
}
@Override
public Screen.Screen6 getScreen() {
// 6寸大屏
return new Screen.Screen6();
}
}红米手机工厂：
public class HongMiFactory implements PhoneFactory {
@Override public Cpu.Cpu650 getCpu() {
// 高效处理器
return new Cpu.Cpu650();
}
@Override public Screen.Screen5 getScreen() {
// 小屏手机
return new Screen.Screen5();
}
}使用工厂生产产品：
public class PhoneApp {
public static void main(String[] args){
HongMiFactory hongMiFactory = new HongMiFactory();
XiaoMiFactory xiaoMiFactory = new XiaoMiFactory();
Cpu.Cpu650 cpu650 = hongMiFactory.getCpu();
Cpu.Cpu825 cpu825 = xiaoMiFactory.getCpu();
cpu650.run(); cpu825.run();
Screen.Screen5 screen5 = hongMiFactory.getScreen();
Screen.Screen6 screen6 = xiaoMiFactory.getScreen();
screen5.size();
screen6.size();
}
}以上例子可以看出，抽象工厂可以解决一系列的产品生产的需求，对于大批量，多系列的产品，用抽象工厂可以更好的管理和扩展。
三种工厂方式总结
1、对于简单工厂和工厂方法来说，两者的使用方式实际上是一样的，如果对于产品的分类和名称是确定的，数量是相对固定的，推荐使用简单工厂模式；
2、抽象工厂用来解决相对复杂的问题，适用于一系列、大批量的对象生产。
