设计模式之工厂模式

工厂模式

工厂模式：实现了创建者和调用者的分离。
详细分类：简单工厂模式、工厂方法模式、抽象工厂模式。

面向对象设计的基本原则：
1）OCP(开闭原则，Open-Closed Principle):一个软件的实体应当对扩展开放，对修改关闭
2）DIP(依赖倒转原则，Dependence Inversion Principle):要针对接口编程，不要针对实现编程
3）LOD（迪米特法则，Law of Demeter）:只与你直接的朋友通信，而避免和陌生人通信

核心本质：
1）实例化对象，用工厂方法代替new操作
2）将选择实现类、创建对象统一管理和控制，从而将调用者和实现者解耦

工厂模式：
简单工厂模式：用来生产统一的等级的任意产品（对于增加的新的产品，需要修改已有代码）
工厂模式方法：用来生产同一等级结构中的固定产品（支持增加任意产品）
抽象工厂模式：用来生产不同产品族的全部产品（对于新增加的产品，无能为力；支持增加产品族）

简单工厂模式也叫静态工厂模式，就是工厂类一般使用静态方法，通过接收的参数不同来返回不同的对象实例。对于增加新产品无能为力，不修改代码无法进行扩展。

简单工厂模式：

实例：

public interface Car {
	void run();
}
public class Audi implements Car {
	@Override
	public void run() {
		System.out.println("奥迪在跑！");
	}
}
public class Byd implements Car {
	@Override
	public void run() {
		System.out.println("比亚迪在跑！");
	}
}

/**
 * 测试在没有工厂模式的情况下
 *
 */
public class Client01 {   //调用者
	public static void main(String[ ] args) {
		Car c1 = new Audi();
		Car c2 = new Byd();
		
		c1.run();
		c2.run();
}

/**
 * 汽车工厂类：可以创建各种汽车对象
 *
 */
public class CarFactory {
	public static  Car createAudi(){
		return new Audi();
	}
	public static Car createByd(){
		return new Byd();
	}
}

public class Client02 {   //调用者
	public static void main(String[] args) {
		Car c1 =CarFactory.createCar("奥迪");
		Car c2 = CarFactory.createCar("比亚迪");
		
		c1.run();
		c2.run();
	}
}

工厂方法设计模式：

//使用上面的奥迪和比亚迪类
/**
  *工厂方法设计模式接口：
  */
package com.factory.factoryMethod;

public interface CarFactory {
public Car createCar();
}

/**
  *工厂方法设计模式
  */
package com.factory.factoryMethod;

public class AudiFactory implements CarFactory {

@Override
public Car createCar() {
return new Audi();
}
}

/**
  *工厂方法设计模式
  */
package com.factory.factoryMethod;

public class BydFactory implements CarFactory {

@Override
public Car createCar() {
return new Byd();
}
}

如果要增加一种车，则可直接增加一个类和一个工厂方法设计模式模式

根据设计理论建议：工厂方法设计模式，但实际上一般采用简单工厂模式

抽象方法设计模式：
用来生产不同产品族的全部产品

//Engine类
package com.factory.abstractFactory;

public interface Engine {
public void run();
public  void start();
}

class LuxuryEngine implements Engine {
@Override
public void run() {
System.out.println("转的快");
}

@Override
public void start() {
System.out.println("启动快，可以自动启动");
}
}

class LowEngine implements Engine {
@Override
public void run() {
System.out.println("转的慢");
}

@Override
public void start() {
System.out.println("启动慢，不可以自动启动");
}
}

//Seat类
package com.factory.abstractFactory;

public interface Seat {
public void massage();
}

class LuxurySeat implements Seat {
@Override
public void massage() {
System.out.println("可以自动按摩");
}
}

class LowSeat implements Seat {
@Override
public void massage() {
System.out.println("不可以自动按摩");
}
}

//Tyre类
package com.factory.abstractFactory;

public interface Tyre {
public void revolve();
}

class LuxuryTyre implements Tyre {
@Override
public void revolve() {
System.out.println("磨损慢");
}
}

class LowTyre implements Tyre {
@Override
public void revolve() {
System.out.println("磨损快");
}
}

/**
 * 抽象工厂模式接口
 */
package com.factory.abstractFactory;

public interface CarFactory {
public Engine createEngine();
public Seat createSeat();
public Tyre createType();

}

//接口的具体实现
package com.factory.abstractFactory;

public class LuxuryCarFactory implements CarFactory {
@Override
public Engine createEngine() {
return new LuxuryEngine();
}

@Override
public Seat createSeat() {
return new LuxurySeat();
}

@Override
public Tyre createType() {
return new LuxuryTyre();
}
}

package com.factory.abstractFactory;

public class LowFactory implements CarFactory {
@Override
public Engine createEngine() {
return new LowEngine();
}

@Override
public Seat createSeat() {
return new LowSeat();
}

@Override
public Tyre createType() {
return new LowTyre();
}
}

工厂模式要点：
简单工厂模式（静态工厂模式）：虽然某种程度不符合设计原则，但实际使用最多
工厂方法模式：不修改已有类的前提下，通过增加新的工厂类实现扩展
抽象工厂模式：不可以增加产品，可以增加产品族

工厂模式应用场景如下：
1.JDK中Calendar的getInstance方法。
2.JDBC中Connection对象的获取。
3.Hibernate中SessionFactory创建Session。
4.Spring中IOC容器创建管理bean对象。
5.XML解析时的DocumentBuilderFactory创建解析器对象。
6.反射中Class对象的newInstance()。