三、设计模式
4. 工厂模式(Factory Method Pattern)
4.1 简介
工厂模式专门负责将大量有共同接口的类实例化。工厂模式可以动态决定将哪一个类实例化,不必事先知道每次要实例化哪一个类。
4.2 分类
- 简单工厂模式(Simple Factory)
- 工厂方法模式(Factory Method)
- 抽象工厂模式(Abstract Factory)
核心本质:
- 实例化对象,用工厂方法代替new操作。
- 将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦
①简单工厂模式
定义
简单工厂模式(Simple Factory Pattern):又称为静态工厂方法(Static Factory Method)模式,它属于类创建型模式。在简单工厂模式中,可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。
结构
分配角色:
- Factory:工厂角色
工厂角色负责实现创建所有实例的内部逻辑
- Product:抽象产品角色
抽象产品角色是所创建的所有对象的父类,负责描述所有实例所共有的公共接口
- ConcreteProduct:具体产品角色
具体产品角色是创建目标,所有创建的对象都充当这个角色的某个具体类的实例
结构图
代码实现
公共接口
public interface Car {
void run();
}
实例
Benze public class Benze implements Car {
[@Override](https://my.oschina/u/1162528)
public void run() {
System.out.println("奔驰再跑------");
}
}
Audi
public class Audi implements Car {
[@Override](https://my.oschina/u/1162528)
public void run() {
System.out.println("奥迪再跑------");
}
}
定义工厂类
public class CarFactory {
public static Car creatCar(String type) {
if("奥迪".equals(type)) {
return new Audi();
}else if ("奔驰".equals(type)) {
return new Benze();
}else {
return null;
}
}
}
测试类
import com.tcwong.Car;
import com.tcwong.CarFactory;
public class Test {
@org.junit.Test
public void test() {
Car car1 = CarFactory.creatCar("奔驰");
Car car2 = CarFactory.creatCar("奥迪");
car1.run();
car2.run();
}
}
输出
优点
- 工厂类含有必要的判断逻辑,可以决定在什么时候创建哪一个产品类的实例,客户端可以免除直接创建产品对象的责任,而仅仅“消费”产品;简单工厂模式通过这种做法实现了对责任的分割,它提供了专门的工厂类用于创建对象。
- 客户端无须知道所创建的具体产品类的类名,只需要知道具体产品类所对应的参数即可,对于一些复杂的类名,通过简单工厂模式可以减少使用者的记忆量。
- 通过引入配置文件,可以在不修改任何客户端代码的情况下更换和增加新的具体产品类,在一定程度上提高了系统的灵活性。
缺点
- 由于工厂类集中了所有产品创建逻辑,一旦不能正常工作,整个系统都要受到影响。
- 使用简单工厂模式将会增加系统中类的个数,在一定程序上增加了系统的复杂度和理解难度。
- 系统扩展困难,一旦添加新产品就不得不修改工厂逻辑,在产品类型较多时,有可能造成工厂逻辑过于复杂,不利于系统的扩展和维护。
- 简单工厂模式由于使用了静态工厂方法,造成工厂角色无法形成基于继承的等级结构。
使用环境
- 工厂类负责创建的对象比较少:由于创建的对象较少,不会造成工厂方法中的业务逻辑太过复杂。
- 客户端只知道传入工厂类的参数,对于如何创建对象不关心:客户端既不需要关心创建细节,甚至连类名都不需要记住,只需要知道类型所对应的参数。
②工厂方法模式
定义
工厂方法模式(Factory Method Pattern)又称为工厂模式,也叫虚拟构造器(Virtual Constructor)模式或者多态工厂(Polymorphic Factory)模式,它属于类创建型模式。在工厂方法模式中,工厂父类负责定义创建产品对象的公共接口,而工厂子类则负责生成具体的产品对象,这样做的目的是将产品类的实例化操作延迟到工厂子类中完成,即通过工厂子类来确定究竟应该实例化哪一个具体产品类。
分配角色
- Product:抽象产品
- ConcreteProduct:具体产品
- Factory:抽象工厂
- ConcreteFactory:具体工厂
结构图
代码实现
公共实体接口
public interface Car {
void run();
}
实体类1
public class Audi implements Car {
[@Override](https://my.oschina/u/1162528)
public void run() {
System.out.println("奥迪再跑------");
}
}
实体类2
public class Benze implements Car {
[@Override](https://my.oschina/u/1162528)
public void run() {
System.out.println("奔驰再跑------");
}
}
公共工厂接口
public interface ICarFactory {
Car creatCar();
}
实例工厂1
public class AudiFactory implements ICarFactory {
@Override
public Car creatCar() {
return new Audi();
}
}
实例工厂2
public class BenzeFactory implements ICarFactory {
@Override
public Car creatCar() {
return new Benze();
}
}
测试类
public class Test1 {
@Test
public void test() {
Car audi = new AudiFactory().creatCar();
Car bense = new BenzeFactory().creatCar();
audi.run();
bense.run();
}
}
输出
优点
- 在工厂方法模式中,工厂方法用来创建客户所需要的产品,同时还向客户隐藏了哪种具体产品类将被实例化这一细节,用户只需要关心所需产品对应的工厂,无须关心创建细节,甚至无须知道具体产品类的类名。
- 基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够使工厂可以自主确定创建何种产品对象,而如何创建这个对象的细节则完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式,是因为所有的具体工厂类都具有同一抽象父类。
- 使用工厂方法模式的另一个优点是在系统中加入新产品时,无须修改抽象工厂和抽象产品提供的接口,无须修改客户端,也无须修改其他的具体工厂和具体产品,而只要添加一个具体工厂和具体产品就可以了。这样,系统的可扩展性也就变得非常好,完全符合“开闭原则”。
缺点
-
在添加新产品时,需要编写新的具体产品类,而且还要提供与之对应的具体工厂类,系统中类的个数将成对增加,在一定程度上增加了系统的复杂度,有更多的类需要编译和运行,会给系统带来一些额外的开销。
-
由于考虑到系统的可扩展性,需要引入抽象层,在客户端代码中均使用抽象层进行定义,增加了系统的抽象性和理解难度,且在实现时可能需要用到DOM、反射等技术,增加了系统的实现难度。
使用范围
- 一个类不知道它所需要的对象的类:在工厂方法模式中,客户端不需要知道具体产品类的类名,只需要知道所对应的工厂即可,具体的产品对象由具体工厂类创建;客户端需要知道创建具体产品的工厂类。
- 一个类通过其子类来指定创建哪个对象:在工厂方法模式中,对于抽象工厂类只需要提供一个创建产品的接口,而由其子类来确定具体要创建的对象,利用面向对象的多态性和里氏代换原则,在程序运行时,子类对象将覆盖父类对象,从而使得系统更容易扩展。
- 将创建对象的任务委托给多个工厂子类中的某一个,客户端在使用时可以无须关心是哪一个工厂子类创建产品子类,需要时再动态指定,可将具体工厂类的类名存储在配置文件或数据库中。
③抽象工厂模式
定义
抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类。抽象工厂模式又称为Kit模式,属于对象创建型模式。
分配角色
- AbstractFactory:抽象工厂
- ConcreteFactory:具体工厂
- AbstractProduct:抽象产品
- Product:具体产品
结构图
代码实现
定义实体公共接口
public interface Engine {
void run();
void start();
}
public interface Seat {
void massege();
}
public interface Tyre {
void revolve();
}
实体具体类
public class LuxuryEngine implements Engine {
@Override
public void run() {
System.out.println("跑的快");
}
@Override
public void start() {
System.out.println("自启动");
}
}
public class LowEngine implements Engine {
@Override
public void run() {
System.out.println("跑的慢");
}
@Override
public void start() {
System.out.println("手动启动");
}
}
public class LuxurySeat implements Seat {
@Override
public void massege() {
System.out.println("真皮沙发");
}
}
public class LowSeat implements Seat {
@Override
public void massege() {
System.out.println("假皮沙发");
}
}
public class LuxuryTyre implements Tyre {
@Override
public void revolve() {
System.out.println("寿命长");
}
}
public class LowTyre implements Tyre {
@Override
public void revolve() {
System.out.println("寿命短");
}
}
工厂接口
public interface ICarAbstractFactory {
Engine createEngine();
Seat createSeat();
Tyre createTyre();
}
工厂实现
public class LuxuryCarFactory implements ICarAbstractFactory {
@Override
public Engine createEngine() {
return new LuxuryEngine();
}
@Override
public Seat createSeat() {
return new LuxurySeat();
}
@Override
public Tyre createTyre() {
return new LuxuryTyre();
}
}
public class LowCarFactory implements ICarAbstractFactory {
@Override
public Engine createEngine() {
return new LowEngine();
}
@Override
public Seat createSeat() {
return new LowSeat();
}
@Override
public Tyre createTyre() {
return new LowTyre();
}
}
测试类
public class Test3 {
@Test
public void test() {
LuxuryCarFactory luxuryCarFactory = new LuxuryCarFactory();
Engine engine = luxuryCarFactory.createEngine();
Seat seat = luxuryCarFactory.createSeat();
Tyre tyre = luxuryCarFactory.createTyre();
seat.massege();
tyre.revolve();
engine.run();
engine.start();
LowCarFactory lowCarFactory = new LowCarFactory();
Engine engine2 = lowCarFactory.createEngine();
Seat seat2 = lowCarFactory.createSeat();
Tyre tyre2 = lowCarFactory.createTyre();
seat2.massege();
tyre2.revolve();
engine2.run();
engine2.start();
}
}
优点
- 抽象工厂模式隔离了具体类的生成,使得客户并不需要知道什么被创建。由于这种隔离,更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工厂中定义的那些公共接口,因此只需改变具体工厂的实例,就可以在某种程度上改变整个软件系统的行为。另外,应用抽象工厂模式可以实现高内聚低耦合的设计目的,因此抽象工厂模式得到了广泛的应用。
- 当一个产品族中的多个对象被设计成一起工作时,它能够保证客户端始终只使用同一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说,是一种非常实用的设计模式。
- 增加新的具体工厂和产品族很方便,无须修改已有系统,符合“开闭原则”。
缺点
- 在添加新的产品对象时,难以扩展抽象工厂来生产新种类的产品,这是因为在抽象工厂角色中规定了所有可能被创建的产品集合,要支持新种类的产品就意味着要对该接口进行扩展,而这将涉及到对抽象工厂角色及其所有子类的修改,显然会带来较大的不便。
- 开闭原则的倾斜性(增加新的工厂和产品族容易,增加新的产品等级结构麻烦)。
4.3 面向对象设计的基本原则
- OCP(开闭原则,Open-Closed Principle):一个软件的实体应当对扩展开放,对修改关闭。
- DIP(依赖倒转原则,Dependence Inversion Principle):要针对接口编程,不要针对实现编程。
- LoD(迪米特法则,Law of Demeter):只与你直接的朋友通信,而避免和陌生人通信
转载于:https://my.oschina/tcwong/blog/3047641
更多推荐
设计模式之工厂模式
发布评论