一、工厂模式概述
实现了创建者和调用者的分离
（1）分类
①简单工厂模式
虽然某种程度不符合设计原则，但实际使用最多。
②工厂方法模式
不修改已有类的前提下，通过增加新的工厂类实现扩展。
③抽象工厂模式
不可以增加产品，可以增加产品族。
二、不使用工厂模式时
1.创建一个汽车的接口
public interface Car {
void run();
}
2.创建两个实现汽车接口的类：
public class Audi implements Car {
public void run() {
System.out.println("奥迪在跑...");
}
}
public class Byd implements Car {
public void run() {
System.out.println("比亚迪在跑...");
}
}
3.客户端创建实例：
public class Client {
public static void main(String[] args) {
Car c1 = new Audi();
Car c2 = new Byd();
c1.run();
c2.run();
}
}
控制台输出：
奥迪在跑...
比亚迪在跑...
当客户没有需求改动时，完全可以不使用工厂模式。但是当需要创建更多实例或者需要频繁更改时，只需要引入工厂或者更改工厂类中的代码就可以了，这样就实现了解耦，是工厂模式的一大好处。
三、简单工厂（simplefactory）
简单工厂模式也叫静态工厂模式，就是工厂类一般使用静态方法，通过接收的参数的不同来返回不同的对象实例。
缺点：对于增加新产品无能为力！不修改代码的话，是无法扩展的。
1.创建接口和实现类
public interface Car {
void run();
}
public class Audi implements Car {
public void run() {
System.out.println("奥迪在跑...");
}
}
public class Byd implements Car {
public void run() {
System.out.println("比亚迪在跑...");
}
}
2.创建简单工厂类
public class CarFactory {
public static Car creatCar(String type) {
if (type.equals("奥迪")) {
return new Audi();
} else if (type.equals("比亚迪")){
return new Byd();
}
return null;
}
}
3.测试
public class Client {
public static void main(String[] args) {
Car c1 = CarFactory.creatCar("奥迪");
Car c2 = CarFactory.creatCar("比亚迪");
c1.run();
c2.run();
}
}
控制台输出：
奥迪在跑...
比亚迪在跑...
4.或者创建另一种简单（静态）工厂类
public class CarFactory {
public static Car creatAudi() {
return new Audi();
}
public static Car creatByd() {
return new Byd();
}
}
5.测试
public class Client {
public static void main(String[] args) {
Car c1 = CarFactory.creatAudi();
Car c2 = CarFactory.creatByd();
c1.run();
c2.run();
}
}
控制台输出：
奥迪在跑...
比亚迪在跑...
通过工厂类创建实例，实现解耦。
四、工厂方法（factorymethod）
一个类对应一个工厂实现类，避免了开闭原则的弊端，更容易扩展代码。但是从复杂度来分析，简单工厂模式更优，因为对客户而言，简单工厂更简单。
1.创建汽车接口和汽车工厂接口
public interface Car {
void run();
}
public interface CarFactory {
Car createCar();
}
2.创建汽车的接口和汽车工厂方法的实现类
public class Audi implements Car {
public void run() {
System.out.println("奥迪在跑...");
}
}
public class AudiFactory implements CarFactory {
public Car createCar() {
return new Audi();
}
}
public class Byd implements Car {
public void run() {
System.out.println("比亚迪在跑...");
}
}
public class BydFactory implements CarFactory {
public Car createCar() {
return new Byd();
}
}
3.测试
public class Client {
public static void main(String[] args) {
Car c1 = new AudiFactory().createCar();
Car c2 = new BydFactory().createCar();
c1.run();
c2.run();
}
}
控制台输出：
奥迪在跑...
比亚迪在跑...
不再与实际类打交道，而通过工厂来创建对象，实现解耦。增加新的产品也更加方便。
4.增加新的产品
public class Benz implements Car {
public void run() {
System.out.println("奔驰在跑...");
}
}
public class BenzFactory implements CarFactory {
public Car createCar() {
return new Benz();
}
}
5.测试
public class Client {
public static void main(String[] args) {
Car c1 = new AudiFactory().createCar();
Car c2 = new BydFactory().createCar();
Car c3 = new BenzFactory().createCar();
c1.run();
c2.run();
c3.run();
}
}
控制台输出：
奥迪在跑...
比亚迪在跑...
奔驰在跑...
五、抽象工厂
抽象工厂模式用来生产不同产品族的全部产品。（对于新增加某一个完整的产品，无能为力；仅支持增加产品族；）
产品族： 发动机 座椅 轮胎 是汽车的一个产品族
抽象工厂模式是工厂模式的一种特殊版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。
1.创建高低端产品族的接口和实现类
/**
* 创建汽车产品族中的发动机接口
* @author CL
*
*/
public interface Engine {
void run();
void start();
} /**
* 高端发动机实现类
*/
class LuxuryEngine implements Engine { public void run() {
System.out.println("转速高!");
} public void start() {
System.out.println("可以自动启停！");
} } /**
* 低端发动机实现类
*/
class LowEngine implements Engine {
public void run() {
System.out.println("转速慢!");
} public void start() {
System.out.println("不可以自动启停！");
} }
/**
* 创建汽车产品族中的座椅接口
* @author CL
*
*/
public interface Seat {
void massage();
} /**
* 高端座椅的实现类
*/
class LuxurySeat implements Seat { public void massage() {
System.out.println("可以按摩！");
} } /**
* 低端座椅的实现类
*/
class LowSeat implements Seat { public void massage() {
System.out.println("不可以按摩！");
} }
/**
* 创建汽车产品族的轮胎接口
* @author CL
*
*/
public interface Tyre {
void abrasion();
} /**
* 高端轮胎的实现类
*/
class LuxuryTyre implements Tyre { public void abrasion() {
System.out.println("磨损慢！");
} } /**
* 低端轮胎的实现类
*/
class LowTyre implements Tyre { public void abrasion() {
System.out.println("磨损快！");
} }
2.创建高端汽车工厂和低端汽车工厂
/**
* 创建高端汽车的实现类工厂
* @author CL
*
*/
public class LuxuryCarFactory implements CarFactory { /**
* 制造高端发动机
*/
public Engine creatEngine() {
return new LuxuryEngine();
} /**
* 制造高端座椅
*/
public Seat creatSeat() {
return new LuxurySeat();
} /**
* 制造高端轮胎
*/
public Tyre creatTyre() {
return new LuxuryTyre();
} }
/**
* 创建低端汽车的实现类工厂
* @author CL
*
*/
public class LowCarFactory implements CarFactory { /**
* 制造低端发动机
*/
public Engine creatEngine() {
return new LowEngine();
} /**
* 制造低端座椅
*/
public Seat creatSeat() {
return new LowSeat();
} /**
* 制造低端轮胎
*/
public Tyre creatTyre() {
return new LowTyre();
} }
3.测试
/**
* 使用抽象工厂模式创建高端汽车发动机
* 创建低端汽车轮胎
* @author CL
*
*/
public class Client { public static void main(String[] args) {
//需要低端发动机
CarFactory factory = new LowCarFactory();
Engine e = factory.creatEngine();
e.run();
e.start(); System.out.println("----------------"); //需要高端轮胎
CarFactory carFactory = new LuxuryCarFactory();
Tyre t = carFactory.creatTyre();
t.abrasion();
} }
控制台输出：
转速慢!
不可以自动启停！
----------------
磨损慢！
六、如何选择工厂模式
实际应用：简单工厂模式
增加产品：工厂方法模式
增加产品族：抽象工厂模式
七、工厂模式常见应用场景
（1）JDK中Calendar的getInstance方法；
（2）JDBC中Connection对象的获取；
（3）Hibernate中sessionFactory创建Session；
（4）Spring中IOC容器创建管理bean对象；
（5）XML解析时的DocumentBuilderFactory创建解析器对象；
（6）反射中Class对象的newInstance()；
（7）………………