Java设计模式GOF之工厂模式

Posted 2020-09-08 勇闯天涯zfc

一、工厂模式（Factory）

1、实现了创建者和调用者的分离

2、应用场景
　　①JDK中 Calendar 的 getInstance()；
　　②JDBC 的 Connection 对象的获取；
　　③Hibernate 的 SessionFactory 创建 Session 对象；
　　④Spring 的 IOC 容器创建管理 Bean 对象；
　　⑤XML 的解析时 DocumentBuilderFactory 创建解析器对象；
　　⑥反射中 Class 对象的 newInstance()。

 

3、分类：
　　①简单工厂模式（也叫静态工厂模式，经常使用）
　　　　1、用来生产同一等级结构中的任意产品；
　　　　2、对于新增的产品，需要修改已有的代码。
　　　　3、不满足开闭原则（对扩展开放，对修改关闭）

　　②工厂方法模式
　　　　1、用来生产同一等级结构中的固定产品；
　　　　2、支持增加任意产品。

　　③抽象工厂模式
　　　　1、用来生产不同产品族的全部产品；
　　　　2、增加新的产品（一个），无能为力；
　　　　3、支持增加产品

二、工厂模式的代码实现

1、简单工厂模式

1.1、简单工厂模式产品的接口： Car.java

package cn.com.zfc.gof01.factory.simplefactoy;

/**
*
* @title Car
* @describe 简单工厂模式产品的接口 Car
* @author 张富昌
* @date 2017年4月4日下午8:44:42
*/
public interface Car {
　　public abstract void run();

}

1.2、简单工厂模式产品接口 Car 的实现类： Audi.java

package cn.com.zfc.gof01.factory.simplefactoy;

/**
*
* @title Audi
* @describe 简单工厂模式产品接口 Car 的实现类： Audi.java
* @author 张富昌
* @date 2017年4月4日下午8:45:48
*/
public class Audi implements Car {

　　@Override
　　public void run() {
　　　　System.out.println("奥迪在行驶");
　　}

}

1.3、 简单工厂模式产品接口 Car 的实现类 :Benz.java

package cn.com.zfc.gof01.factory.simplefactoy;

/**
*
* @title Benz
* @describe 简单工厂模式产品接口 Car 的实现类： Benz.java
* @author 张富昌
* @date 2017年4月4日下午8:45:48
*/
public class Benz implements Car {

　　@Override
　　public void run() {
　　　　System.out.println("奔驰在行驶");
　　}

}

1.4、简单工厂模式产品接口 Car 的实现类：Bmw.java

package cn.com.zfc.gof01.factory.simplefactoy;

/**
*
* @title Bmw
* @describe 简单工厂模式产品接口 Car 的实现类 Bmw
* @author 张富昌
* @date 2017年4月4日下午8:45:48
*/
public class Bmw implements Car {

　　@Override
　　public void run() {
　　　　System.out.println("宝马在行驶");
　　}

}

1.5、简单工厂模式的工厂类：CarFactory.java

package cn.com.zfc.gof01.factory.simplefactoy;

/**
*
* @title CarFactory
* @describe 简单工厂，一般使用静态的方法
* @author 张富昌
* @date 2017年4月4日下午8:50:08
*/
public class CarFactory {

　　// 获取 Bmw 的实例
　　public static Car getBmw() {
　　　　return new Bmw();
　　}

　　// 获取 Benz 的实例
　　public static Car getBenz() {
　　　　return new Benz();
　　}

　　// 获取 Audi 的实例
　　public static Car getAudi() {
　　　　return new Audi();
　　}

}

1.6、测试没有工厂类的前提下，创建 Audi、Benz、Bmw：TestNoFactory.java

package cn.com.zfc.gof01.factory.simplefactoy.test;

import cn.com.zfc.gof01.factory.simplefactoy.Audi;
import cn.com.zfc.gof01.factory.simplefactoy.Benz;
import cn.com.zfc.gof01.factory.simplefactoy.Bmw;
import cn.com.zfc.gof01.factory.simplefactoy.Car;

/**
*
* @title TestNoFactory
* @describe 没有工厂类，创建 Audi、Benz、Bmw
* @author 张富昌
* @date 2017年4月4日下午8:52:37
*/
public class TestNoFactory {
　　public static void main(String[] args) {
　　　　// 需要知道接口和其实现类
　　　　Car c1 = new Audi();
　　　　Car c2 = new Benz();
　　　　Car c3 = new Bmw();
　　　　c1.run();
　　　　c2.run();
　　　　c3.run();
　　}

}

1.7、测试在有工厂类的前提下，创建 Audi、Benz、Bmw：TestSimpleFactory.java

package cn.com.zfc.gof01.factory.simplefactoy.test;

import cn.com.zfc.gof01.factory.simplefactoy.Car;
import cn.com.zfc.gof01.factory.simplefactoy.CarFactory;

/**
*
* @title TestSimpleFactory
* @describe 测试简单工厂模式，有工厂类，创建 Audi、Benz、Bmw
* @author 张富昌
* @date 2017年4月4日下午8:56:39
*/
public class TestSimpleFactory {
　　　public static void main(String[] args) {
　　　　// 需要知道接口和工厂类
　　　　Car c1 = CarFactory.getAudi();
　　　　Car c2 = CarFactory.getBenz();
　　　　Car c3 = CarFactory.getBmw();
　　　　c1.run();
　　　　c2.run();
　　　　c3.run();
　　}
}

2、工厂方法模式

2.1、简单工厂模式产品的接口： Car.java

package cn.com.zfc.gof01.factory.factorymethod;

/**
*
* @title Car
* @describe 简单工厂模式产品的接口 Car
* @author 张富昌
* @date 2017年4月4日下午8:44:42
*/
public interface Car {
　　public abstract void run();
}

2.2、工厂方法模式产品接口 Car 的实现类 ：Audi.java

package cn.com.zfc.gof01.factory.factorymethod;

/**
*
* @title Audi
* @describe 工厂方法模式产品接口 Car 的实现类 Audi
* @author 张富昌
* @date 2017年4月4日下午8:45:48
*/
public class Audi implements Car {

　　@Override
　　public void run() {
　　　　System.out.println("奥迪在行驶");
　　}

}

2.3、工厂方法模式产品接口 Car 的实现类 Benz

package cn.com.zfc.gof01.factory.factorymethod;

/**
*
* @title Benz
* @describe 工厂方法模式产品接口 Car 的实现类 ：Benz.java
* @author 张富昌
* @date 2017年4月4日下午8:45:48
*/
public class Benz implements Car {

　　@Override
　　public void run() {
　　　　System.out.println("奔驰在行驶");
　　}

}

2.4、工厂方法模式产品接口 Car 的实现类：Bmw.java

package cn.com.zfc.gof01.factory.factorymethod;

/**
*
* @title Bmw
* @describe 工厂方法模式产品接口 Car 的实现类 Bmw
* @author 张富昌
* @date 2017年4月4日下午8:45:48
*/
public class Bmw implements Car {

　　@Override
　　public void run() {
　　　　System.out.println("宝马在行驶");
　　}

}

2.5、工厂方法模式的工厂接口：CarFactory.java

package cn.com.zfc.gof01.factory.factorymethod;

/**
*
* @title CarFactory
* @describe 工厂方法模式的工厂接口 CarFactory
* @author 张富昌
* @date 2017年4月4日下午9:05:18
*/
public interface CarFactory {
　　Car getCar();
}

2.6、 工厂方法模式的工厂类，需要实现工厂接口：AudiFactory .java

package cn.com.zfc.gof01.factory.factorymethod;

/**
*
* @title AudiFactory
* @describe 工厂方法模式的工厂类，需要实现工厂接口
* @author 张富昌
* @date 2017年4月4日下午9:07:08
*/
public class AudiFactory implements CarFactory {

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

}

2.7、工厂方法模式的工厂类，需要实现工厂接口：BenzFactory .java

package cn.com.zfc.gof01.factory.factorymethod;

/**
*
* @title BenzFactory
* @describe 工厂方法模式的工厂类，需要实现工厂接口
* @author 张富昌
* @date 2017年4月4日下午9:07:08
*/
public class BenzFactory implements CarFactory {

　　@Override
　　public Car getCar() {
　　　　return new Benz();
　　}

}

2.8、工厂方法模式的工厂类，需要实现工厂接口：CarFactory .java

package cn.com.zfc.gof01.factory.factorymethod;

/**
*
* @title BmwFactory
* @describe 工厂方法模式的工厂类，需要实现工厂接口
* @author 张富昌
* @date 2017年4月4日下午9:07:08
*/
public class BmwFactory implements CarFactory {

　　@Override
　　public Car getCar() {
　　　　return new Bmw();
　　}

}

2.9、测试工厂方法模式：TestFactoryMethod.java

package cn.com.zfc.gof01.factory.factorymethod.test;

import cn.com.zfc.gof01.factory.factorymethod.AudiFactory;
import cn.com.zfc.gof01.factory.factorymethod.BenzFactory;
import cn.com.zfc.gof01.factory.factorymethod.BmwFactory;
import cn.com.zfc.gof01.factory.factorymethod.Car;

/**
*
* @title TestFactoryMethod
* @describe 测试工厂方法模式
* @author 张富昌
* @date 2017年4月4日下午9:09:34
*/
public class TestFactoryMethod {
　　public static void main(String[] args) {
　　　　// 需要知道接口和各自的工厂类
　　　　Car c1 = new AudiFactory().getCar();
　　　　Car c2 = new BenzFactory().getCar();
　　　　Car c3 = new BmwFactory().getCar();
　　　　c1.run();
　　　　c2.run();
　　　　c3.run();
　　}
}

3、抽象工厂模式

3.1、抽象工厂的产品接口，发动机：Engine.java

package cn.com.zfc.gof01.factory.abstractfactory;

/**
*
* @title Engine
* @describe 抽象工厂的产品接口，发动机
* @author 张富昌
* @date 2017年4月4日下午9:27:21
*/
public interface Engine {
　　// 发动机效率
　　void efficiency();
}

 

3.2、抽象接口的产品接口，座位：Seat.java

package cn.com.zfc.gof01.factory.abstractfactory;

/**
*
* @title Seat
* @describe 抽象接口的产品接口，座位
* @author 张富昌
* @date 2017年4月4日下午9:38:21
*/
public interface Seat {
　　// 座位舒适
　　void comfort();

}

3.3、抽象工厂的产品接口，轮胎：Tyre.java

package cn.com.zfc.gof01.factory.abstractfactory;

/**
*
* @title Tyre
* @describe 抽象工厂的产品接口，轮胎
* @author 张富昌
* @date 2017年4月4日下午9:39:06
*/
public interface Tyre {
　　// 轮胎磨损
　　void wear();
}

3.4、抽象工厂模式的产品实现类，低端发动机:LowEngine.java

package cn.com.zfc.gof01.factory.abstractfactory;
/**
*
* @title LowEngine
* @describe 抽象工厂模式的产品实现类，低端发动机
* @author 张富昌
* @date 2017年4月4日下午9:55:02
*/
public class LowEngine implements Engine {

　　@Override
　　public void efficiency() {
　　　　System.out.println("低端发动机工作效率低");
　　}

}

3.5、抽象工厂模式的产品实现类，高端发动机：LuxuryEngine.java

package cn.com.zfc.gof01.factory.abstractfactory;

/**
*
* @title LuxuryEngine
* @describe 抽象工厂模式的产品实现类，高端发动机
* @author 张富昌
* @date 2017年4月4日下午9:48:05
*/
public class LuxuryEngine implements Engine {

　　@Override
　　public void efficiency() {
　　　　System.out.println("高端发动机工作效率高");
　　}

}

3.6、抽象工厂模式的产品实现类，低端座位：LowSeat.java

package cn.com.zfc.gof01.factory.abstractfactory;

/**
*
* @title LowSeat
* @describe 抽象工厂模式的产品实现类，低端座位
* @author 张富昌
* @date 2017年4月4日下午9:55:32
*/
public class LowSeat implements Seat {

　　@Override
　　public void comfort() {
　　　　System.out.println("低端座位舒适度低");
　　}

}

3.7、抽象工厂模式的产品实现类，高端座位:LuxurySeat.java

package cn.com.zfc.gof01.factory.abstractfactory;
/**
*
* @title LuxurySeat
* @describe 抽象工厂模式的产品实现类，高端座位
* @author 张富昌
* @date 2017年4月4日下午9:55:49
*/
public class LuxurySeat implements Seat {

　　@Override
　　public void comfort() {
　　　　System.out.println("高端座位舒适度高");
　　}

}

3.8、抽象工厂模式的产品实现类，低端轮胎:LowTyre.java

package cn.com.zfc.gof01.factory.abstractfactory;
/**
*
* @title LowTyre
* @describe 抽象工厂模式的产品实现类，低端轮胎
* @author 张富昌
* @date 2017年4月4日下午9:55:40
*/
public class LowTyre implements Tyre {

　　@Override
　　public void wear() {
　　　　System.out.println("低端轮胎易磨损");
　　}

}

3.9、抽象工厂模式的产品实现类，高端轮胎：LuxuryTyre.java

package cn.com.zfc.gof01.factory.abstractfactory;
/**
*
* @title LuxuryTyre
* @describe 抽象工厂模式的产品实现类，高端轮胎
* @author 张富昌
* @date 2017年4月4日下午9:55:55
*/
public class LuxuryTyre implements Tyre {

　　@Override
　　public void wear() {
　　　　System.out.println("高端轮胎不易磨损");
　　}

}

3.10、抽象工厂的产品族工厂接口：CarFactory.java

package cn.com.zfc.gof01.factory.abstractfactory;

/**
*
* @title CarFactory
* @describe 抽象工厂的产品族工厂接口
* @author 张富昌
* @date 2017年4月4日下午9:54:28
*/
public interface CarFactory {
　　Engine getEngine();

　　Seat getSeat();

　　Tyre getTyre();
}

3.11、抽象工厂的产品族工厂接口的实现类，低端工厂:LowCarFactory.java

package cn.com.zfc.gof01.factory.abstractfactory;

/**
*
* @title LowCarFactory
* @describe 抽象工厂的产品族工厂接口的实现类，低端工厂
* @author 张富昌
* @date 2017年4月4日下午10:07:40
*/
public class LowCarFactory implements CarFactory {

　　@Override
　　public Engine getEngine() {
　　　　return new LowEngine();
　　}

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

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

}

3.12、抽象工厂的产品族工厂接口的实现类，高端工厂:LuxuryCarFactory.java

package cn.com.zfc.gof01.factory.abstractfactory;

/**
*
* @title LuxuryCarFactory
* @describe 抽象工厂的产品族工厂接口的实现类，高端工厂
* @author 张富昌
* @date 2017年4月4日下午9:59:38
*/
public class LuxuryCarFactory implements CarFactory {

　　@Override
　　public Engine getEngine() {
　　　　return new LuxuryEngine();
　　}

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

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

}

3.13、测试抽象工厂模式:TestAbstractFactory.java

package cn.com.zfc.gof01.factory.abstractfactory.test;

import cn.com.zfc.gof01.factory.abstractfactory.CarFactory;
import cn.com.zfc.gof01.factory.abstractfactory.Engine;
import cn.com.zfc.gof01.factory.abstractfactory.LuxuryCarFactory;

/**
*
* @title TestAbstractFactory
* @describe 测试抽象工厂模式
* @author 张富昌
* @date 2017年4月4日下午10:18:39
*/
public class TestAbstractFactory {
　　public static void main(String[] args) {
　　　　CarFactory carFactory = new LuxuryCarFactory();
　　　　Engine engine = carFactory.getEngine();
　　　　engine.efficiency();
　　}
}