标签：方法 sts 场景 stat uil 设计 XML ace ioc
一、工厂模式（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();
}
}
标签：方法 sts 场景 stat uil 设计 XML ace ioc
原文地址：http://www.cnblogs.com/zfc-java/p/6666765.html
