设计模式(三):抽象工厂模式
- [1. 抽象工厂模式的介绍](#1. 抽象工厂模式的介绍)
- [2. 抽象工厂模式的类图](#2. 抽象工厂模式的类图)
- [3. 抽象工厂模式的实现](#3. 抽象工厂模式的实现)
-
- [3.1 创建摩托车的接口](#3.1 创建摩托车的接口)
- [3.2 创建摩托车的具体实现](#3.2 创建摩托车的具体实现)
- [3.3 创建汽车的接口](#3.3 创建汽车的接口)
- [3.4 创建汽车的具体产品](#3.4 创建汽车的具体产品)
- [3.5 创建抽象工厂](#3.5 创建抽象工厂)
- [3.6 创建具体工厂](#3.6 创建具体工厂)
- [3.7 创建工厂生成器](#3.7 创建工厂生成器)
- [3.8 使用工厂生成器获取工厂,通过工厂获取产品](#3.8 使用工厂生成器获取工厂,通过工厂获取产品)
1. 抽象工厂模式的介绍
抽象工厂模式
(Abstract Factory Pattern)属于创建型模式,是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。
在抽象工厂模式
中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
通过使用抽象工厂模式
,可以将客户端与具体产品的创建过程解耦,使得客户端可以通过工厂接口来创建一族产品。
抽象工厂模式
包含4个核心角色:
- 抽象工厂(Abstract Factory):声明了一组用于创建产品对象的方法,每个方法对应一种产品类型。抽象工厂可以是接口或抽象类。
- 具体工厂(Concrete Factory):实现了抽象工厂接口,负责创建具体产品对象的实例。
- 抽象产品(Abstract Product):定义了一组产品对象的共同接口或抽象类,描述了产品对象的公共方法。
- 具体产品(Concrete Product):实现了抽象产品接口,定义了具体产品的特定行为和属性。
2. 抽象工厂模式的类图
3. 抽象工厂模式的实现
3.1 创建摩托车的接口
java
package blog;
/**
* 摩托车
*/
public interface Motorcycle {
void by();
}
3.2 创建摩托车的具体实现
java
package blog;
/**
* 踏板摩托车
*/
public class Scooter implements Motorcycle{
@Override
public void by() {
System.out.println("骑着一辆踏板车");
}
}
java
package blog;
/**
* 弯梁摩托车
*/
public class UnderBone implements Motorcycle{
@Override
public void by() {
System.out.println("骑着一辆弯梁车");
}
}
3.3 创建汽车的接口
java
package blog;
/**
* 汽车
*/
public interface Car {
void drive();
}
3.4 创建汽车的具体产品
java
package blog;
/**
* suv
*/
public class Suv implements Car{
@Override
public void drive() {
System.out.println("开着一辆SUV");
}
}
java
package blog;
/**
* mpv
*/
public class Mpv implements Car{
@Override
public void drive() {
System.out.println("开着一辆MPV");
}
}
3.5 创建抽象工厂
java
package blog;
/**
* 抽象工厂
*/
public interface AbstractFactory {
Car getCar(String type);
Motorcycle getMotorCycle(String type);
}
3.6 创建具体工厂
java
package blog;
/**
* 摩托车工厂
*/
public class MotorCycleFactory implements AbstractFactory {
@Override
public Car getCar(String type) {
return null;
}
@Override
public Motorcycle getMotorCycle(String type) {
try {
Class<?> aClass = Class.forName(type);
return (Motorcycle) aClass.getDeclaredConstructor().newInstance();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
java
package blog;
/**
* 汽车工厂
*/
public class CarFactory implements AbstractFactory {
@Override
public Car getCar(String type) {
try {
Class<?> aClass = Class.forName(type);
return (Car)aClass.getDeclaredConstructor().newInstance();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
public Motorcycle getMotorCycle(String type) {
return null;
}
}
3.7 创建工厂生成器
java
package blog;
/**
* 工厂生成器
*/
public class FactoryProducer {
public static AbstractFactory getFactory(String type) {
if ("car".equals(type)) {
return new CarFactory();
}
if ("motorcycle".equals(type)) {
return new MotorCycleFactory();
}
return null;
}
}
3.8 使用工厂生成器获取工厂,通过工厂获取产品
java
package blog;
public class AbstractFactoryDemo {
public static void main(String[] args) {
// 获取汽车工厂
AbstractFactory carFactory = FactoryProducer.getFactory("car");
// 获取suv
Car suv = carFactory.getCar("blog.Suv");
suv.drive();
// 获取mpv
Car mpv = carFactory.getCar("blog.Mpv");
mpv.drive();
// 获取摩托车工厂
AbstractFactory motorcycleFactory = FactoryProducer.getFactory("motorcycle");
// 获取scooter
Motorcycle scooter = motorcycleFactory.getMotorCycle("blog.Scooter");
scooter.by();
// 获取UnderBone
Motorcycle underBone = motorcycleFactory.getMotorCycle("blog.UnderBone");
underBone.by();
}
}