概述
工厂模式属于创建型模式，需要生成的对象叫产品，生产对象的地方叫工厂。实现了调用者和创建者的分离。
工厂模式的优点
1. 良好的封装性，代码结构清晰。一个对象创建是有约束的，入一个调用者需要一个具体的产品对象，只要知道类名就可以，不用知道创建对象的艰辛过程，降低模块之间的耦合。
2. 工厂模式的扩展也非常的优秀，只要增加适当的工厂类或者扩展一个工厂，就可以实现扩展。
3. 工厂模式使典型的解耦框架。高层模块只需要知道产品的抽象类，其他实现类都不需要关心。
工厂模式的简单分类
1.简单工厂模式
2.工厂方法模式
3.抽象工程模式
简单工程模式实现
/** * 创建汽车接口 */
public interface Car { public void run(); }
/** * 创建宝马车类实现Car接口重写run方法 */
public class BMW implements Car {
@Override public void run() { System.out.println("BWM run"); }
}
/** * 定义汽车工厂类，作用生产汽车 创建者 */
public class simpleFactory {
public static Car factory(String name){
Car car = null;
if("BWM".equals(name)){
return car = new BMW();
}else if("BYD".equals(name)){
return car = new BYD();
}else{
return null;
}
}
}
/** * 测试简单工厂类 调用者*/
public class SimpleFactoryDemo {
public static void main(String[] args) {
Car bwm = simpleFactory.factory("BWM");
Car byd = simpleFactory.factory("BYD");
bwm.run();
byd.run();
}
}
简单工厂模式用来生产同一等级结构中的任意产品。对于新增的东西需要修改已有的代码，违反了面型对象设计的开闭原则。
工厂方法模式
/** * 定义汽车接口 */
public interface Car { public void run(); }
/** * BYD类实现Car接口实现相应的方法 */
public class BYD implements Car{
@Override public void run() {
System.out.println("BYD is run");
}
}
/** * 创建宝马类实现Car接口实现相应的方法 */
public class BWM implements Car{
@Override public void run() {
System.out.println("BWM run");
}
}
/** * CarFactory接口用于生产汽车 */
public interface CarFactory { Car createCar(); }
/** * 创建BYDFactory类实现CarFactory创建BYD */
public class BYDFactory implements CarFactory{
@Override public Car createCar() {
return new BWM();
}
}
/** * 生产BWMFactory类用于生产BWM汽车 */
public class BWMFactory implements CarFactory{
@Override public Car createCar() {
return new BWM();
}
}
/** * 调用者 */
public class Demo {
public static void main(String[] args) {
Car byd = new BYDFactory().createCar();
Car bwm = new BWMFactory().createCar();
byd.run();
bwm.run();
}
}
工厂方法模式避免了简单工厂的缺点OCP原则。
工厂方法模式和简单工厂的另一个区别就是，简单工厂模式只有一个工厂类，而工厂方法模式是有一组实现相同接口的工厂类。
抽象工厂模式
/** * 发动机 */
public interface Engine {
void run();
void statr();
}
class HightEngine implements Engine{
@Override public void run() { System.out.println("跑得快"); }
@Override public void statr() { System.out.println("启动快"); }
}
class LowEngine implements Engine{
@Override public void run() { System.out.println("跑得慢"); }
@Override public void statr() { System.out.println("启动慢"); }
}
/** * 座椅 */
public interface Set { void massage(); }
class HightSet implements Set{
@Override public void massage() { System.out.println("真皮座椅"); }
}
class LowSet implements Set{
@Override public void massage() { System.out.println("普通座椅"); }
}
/** * 轮胎 */
public interface Tire { void tire(); }
class HightTire implements Tire{
@Override public void tire() { System.out.println("橡胶轮胎"); }
}
class LowTire implements Tire{
@Override public void tire() { System.out.println("塑料轮胎");}
}
/** * 制造部件 */
public interface CarFactory {
Engine createEngine();
Set createSet();
Tire createTire();
}
/** * 高端汽车工厂 */
public class HightCarFactory implements CarFactory{
@Override public Engine createEngine() { return new HightEngine(); }
@Override public Set createSet() { return new HightSet(); }
@Override public Tire createTire() { return new HightTire(); }
}
/** * 调用者 */
public class Client {
public static void main(String[] args) {
CarFactory carFactory =new HightCarFactory();
Engine engine = carFactory.createEngine();
engine.run();
engine.statr();
}
}
用来生产不同品族的全部产品，对于新增的产品无能为力。
工厂模式的应用场景
JDBC中Connection对象的获取
SpringIOC容器创建和管理bean
反射中Class对象的newInstance()
总结：
简单工厂模式虽然违背了开闭原则，但是设计简单。工厂方法模式在不修改类的前提下，通过新的工厂类来实现扩展，符合开闭原则的标准。抽象方法模式，不可以增加产品但是可以增加产品族。
