Java设计模式GOF之工厂模式

一、工厂模式（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();
　　}
}

时间： 2024-10-02 21:39:39

Java设计模式GOF之工厂模式的相关文章

Java设计模式之二工厂模式

在上一篇中我们学习了单例模式,介绍了单例模式创建的几种方法以及最优的方法.本篇则介绍设计模式中的工厂模式,主要分为简单工厂模式.工厂方法和抽象工厂模式. 简单工厂模式 简单工厂模式是属于创建型模式,又叫做静态工厂方法模式.简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例.调用只需要告诉工厂类所需要的类型,工厂类就会返回需要的产品类工厂的子类. 可以说是工厂模式中最简单的一种. 打个比方,我们在电脑经常玩游戏,我们只需要告诉电脑我们要玩什么游戏,电脑就会打开这个游戏,我们并不需要关心游戏是

Java设计模式学习三-----工厂模式

工厂模式 工厂模式(Factory Pattern)是Java中最常用的设计模式之一.这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式. 在工厂模式中,创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象. 工厂模式的思路:定义一个创建对象的接口,让其子类自己决定实例化哪一个工厂类,工厂模式使其创建过程延迟到子类进行.使用过程中做好接口选择. 优点:1.一个调用者向创建一个对象,只要知道名称就可以了.2.扩展性高,如果想增加一个产品,只要扩展一个工厂

JAVA设计模式之抽象工厂模式 （转）

前面已经介绍过简单工厂模式和工厂方法模式,这里继续介绍第三种工厂模式-抽象工厂模式,还是以汽车的制造为例. 例子背景: 随着客户的要求越来越高,宝马车需要不同配置的空调和发动机等配件.于是这个工厂开始生产空调和发动机,用来组装汽车.这时候工厂有两个系列的产品:空调和发动机.宝马320系列配置A型号空调和A型号发动机,宝马230系列配置B型号空调和B型号发动机. 概念: 抽象工厂模式是工厂方法模式的升级版本,他用来创建一组相关或者相互依赖的对象.比如宝马320系列使用空调型号A和发动机型号A,而宝

java设计模式2--抽象工厂模式（Abstract Factory）

本文地址:http://www.cnblogs.com/archimedes/p/java-abstract-factory-pattern.html,转载请注明源地址. 抽象工厂模式(别名:配套) 提供一个创建一系列(相互依赖)对象的接口,而无需指定它们具体的类. 概述 当系统准备为用户提供一系列相关的对象,又不想让用户代码和创建这些对象的类形成耦合时,就可以使用抽象工厂方法模式来设计系统.抽象工厂模式的关键是在一个抽象类或接口中定义若干个抽象方法,这些抽象方法分别返回某个类的实例,该抽象类或

(1)java设计模式之简单工厂模式

一:简单工厂模式的优点          --->在阎宏博士的<JAVA与模式>一书中开头是这样描述简单工厂模式的:简单工厂模式是类的创建模式,又叫做静态工厂方法(Static Factory Method)模式.简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例. --->模式的核心是工厂类.这个类含有必要的逻辑判断,可以决定在什么时候创建哪一个登录验证类的实例,而调用者则可以免除直接创建对象的责任.简单工厂模式通过这种做法实现了对责任的分割,当系统引入新的登录方式的时候无

浅谈JAVA设计模式之——抽象工厂模式(AbstractFactoty)

转载请注明出处:http://blog.csdn.net/l1028386804/article/details/45440309 一.概述: 提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类. 二.为何使用     工厂模式是我们最常用的模式了,著名的Jive论坛 ,就大量使用了工厂模式,工厂模式在Java程序系统可以说是随处可见. 为什么工厂模式是如此常用?因为工厂模式就相当于创建实例对象的new,我们经常要根据类Class生成实例对象,如A a=new A() 工厂模式也

JAVA设计模式之抽象工厂模式

本文继续介绍23种设计模式系列之抽象工厂模式. 前面已经介绍过简单工厂模式和工厂方法模式,这里继续介绍第三种工厂模式-抽象工厂模式,还是以汽车的制造为例. 例子背景: 随着客户的要求越来越高,宝马车需要不同配置的空调和发动机等配件.于是这个工厂开始生产空调和发动机,用来组装汽车.这时候工厂有两个系列的产品:空调和发动机.宝马320系列配置A型号空调和A型号发动机,宝马230系列配置B型号空调和B型号发动机. 概念: 抽象工厂模式是工厂方法模式的升级版本,他用来创建一组相关或者相互依赖的对象.比如

Java 设计模式之抽象工厂模式

抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂.该超级工厂又称为其他工厂的工厂.这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式. 在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类.每个生成的工厂都能按照工厂模式提供对象. 介绍 意图 提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类. 主要解决 主要解决接口选择的问题. 何时使用 系统的产品有多于一个的产品族,而系统只消费其中某一族的产品

【JAVA设计模式】---之工厂模式

一  工厂模式的概念 实例化对象,用工厂方法代替new操作.工厂模式包括工厂方法模式和抽象工厂模式. 抽象工厂模式是工厂方法模式的扩展. 二  工厂模式的意图 定义一个接口来创建对象,但是让子类来决定哪些类需要被实例化. 工厂方法把实例化的操作推迟到子类中去实现. 三  工厂模式的适用范围 工厂模式适合用于一类对象的创建. 在编码时不能预见需要创建的那些类的实例.