3.1 简单工厂模式
3.1.1 创建型模式
创建型设计模式将对象的创建过程和对象的使用过程分离,用户使用对象时无需关注对象的创建细节,外界对于这些对象只需要知道它们共同的接口,而不用清楚其实现细节,使得整个系统的设计更加符合单一职责原则。软件的结构也更为清晰。
3.1.2 简单工厂模式的定义
专门定义一个类来负责创建其他类的实例,可以根据参数的不同返回不同类的实例,被创建的实例通常都具有共同的父类。
3.1.3 简单工厂模式的分析与实现
-
工厂角色:即工厂类,简单工厂模式的核心,负责实现创建所有实例的内部逻辑;工厂类可被外部直接调用,创建所需的产品对象;工厂类中提供了静态的工厂方法(它返回一个抽象产品类Product,所有具体产品都是抽象产品的子类。
-
工厂类中只有简单的逻辑判断代码。不关心具体的业务处理过程,满足“单一职责原则”。
-
调用工厂类的工厂方法时,由于工厂方法时静态方法,使用很方便,可通过类名直接调用,只需要传入一个简单的参数即可。
3.1.4 简单工厂模式的案例
某电视机厂专为各知名电视机品牌代工生产各类电视机,当需要海尔牌电视机时只需要在调用该工厂的工厂方法时传入参数“Haier”,需要海信电视机时只需要传入参数“Hisense”,工厂可以根据传入的不同参数返回不同品牌的电视机。现使用简单工厂模式来模拟该电视机工厂的生产过程。
- 抽象产品类和具体产品类
public interface TV {
public void play();
}
public class HaierTV implements TV{
@Override
public void play() {
System.out.println("Haier电视正在播放");
}
}
public class HisenseTV implements TV{
@Override
public void play() {
System.out.println("hisense电视正在播放");
}
}
- 工厂类
public class TVFactory {
public static TV getTVMethod(String flag) throws Exception {
if ("Haier".equalsIgnoreCase(flag)) {
return new HaierTV();
} else if ("Hisense".equalsIgnoreCase(flag)) {
return new HisenseTV();
} else {
throw new Exception("抱歉没有此类电视");
}
}
- Main类
public class Main {
public static void main(String[] args) {
String tvName = XMLUtilTV.getTVName();
try {
TV tvMethod = TVFactory.getTVMethod(tvName);
tvMethod.play();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
public class XMLUtilTV {
public static String getTVName() {
try {
//创建文本对象
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document document = db.parse(new File("src/main/resources/TVBrand.xml"));
//通过DOM获取文本元素
NodeList brandName = document.getElementsByTagName("brandName");
Node content = brandName.item(0).getFirstChild();
return content.getNodeValue();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
<?xml version="1.0" encoding="ISO-8859-1"?>
<config>
<brandName>Hisense</brandName>
</config>
3.1.5 简单工厂模式的优缺点
优点 | 缺点 |
---|---|
1.实现了对象的创建和使用分离 | 1.工厂类职责太重,不宜维护 |
2.无需知道类名,只需要知道参数 | 2.系统扩展难度大,且工厂类为静态类不能进行扩展 |
3.1.6 简单工厂模式适用场景
- 工厂类负责创建的对象比较少,由于创建对象比较少。
- 客户端只知道传入工厂类的参数,对于如何创建对象不关心。
3.2 工厂模式
3.2.1 工厂模式的定义
动机:为了解决简单工厂模式不易扩展以及工厂类职责太重的为问题。
在工厂方法模式中,工厂父类负责定义创建产品对象的公共接口, 而工厂子类则负责生成具体的产品对象,这样做的目的是将产品类的实例化操作延迟到工厂子类中完成,即通过工厂子类来确定 究竟应该实例化哪一个具体产品类。
3.2.2 工厂模式的分析与实现
-
核心的工厂类不再负责所有产品的创建,而是将具体创建工作交给其子类去完成
-
可以允许系统在不修改工厂角色的情况下引进新产品,增加具体产品–>增加具体工厂,符合“开闭原则”。
3.2.3 工厂模式的案例
将原有的电视机工厂进行分割,为每种品牌的电视机提 供一个子工厂,海尔工厂专门负责生产海尔电视机,海 信工厂专门负责生产海信电视机,如果需要生产TCL电视 机或创维电视机,只需要对应增加一个新的TCL工厂或创 维工厂即可,原有的工厂无须做任何修改,使得整个系 统具有更加的灵活性和可扩展性。
- 产品类
public interface TV {
public void play();
}
public class HaierTV implements TV{
@Override
public void play() {
System.out.println("Haier电视正在播放");
}
}
public class HisenseTV implements TV{
@Override
public void play() {
System.out.println("Hisense电视正在播放");
}
}
- 工厂类
public interface TVFactory {
public TV produceTV();
}
public class HaierTVFactory implements TVFactory{
@Override
public TV produceTV() {
System.out.println("海尔电视已经被制造");
return new HaierTV();
}
}
public class HisenseTVFactory implements TVFactory{
@Override
public TV produceTV() {
System.out.println("海信电视已被制造");
return new HisenseTV();
}
}
- 调用(为了更好的满足开闭原则,这里使用Java的反射机制来代替new关键字)
public class XMLUtilTVFactory {
public static Object getTVFactoryMethod() throws Exception{
//获取文本对象
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(new File("src/main/resources/TVFactoryMethod.xml"));
//获取文本内容
NodeList nodeList = doc.getElementsByTagName("factoryName");
Node firstChild = nodeList.item(0).getFirstChild();
String nodeValue = firstChild.getNodeValue();
//通过反射获取对象
Class className = Class.forName(nodeValue);
Object obj = className.newInstance();
return obj;
}
}
public class Main {
public static void main(String[] args) {
try {
HisenseTVFactory tvFactoryMethod = (HisenseTVFactory) XMLUtilTVFactory.getTVFactoryMethod();
TV tv = tvFactoryMethod.produceTV();
tv.play();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
xml:
<?xml version="1.0" encoding="UTF-8" ?>
<config>
<factoryName>com.tyut.factory_method.example2.HisenseTVFactory</factoryName>
</config>
3.2.4 工厂模式的优缺点
优点 | 缺点 |
---|---|
1.实现了对象的创建和使用分离,将对象的创建细节全部封装在工厂中 | 1.系统中的类的个数成对出现,加重系统的负担 |
2.在系统中添加新产品,完全符合开闭原则 |
3.2.5 工厂模式的适用场景
- 客户端不需要知道具体 产品类的类名,只需要知道所对应的工厂即可,具体产品对 象由具体工厂类创建
- 抽象工厂类通过其子类来指定创建哪个对象
3.3 抽象工厂模式
3.3.1 抽象工厂模式的定义
动机:需要一个工厂,生产多个对象
产品等级结构:产品的继承结构(一个产品的不同表现形式:名词)
产品族:指由同一个工厂生产的,位于不同产品等级结构中的一组产品(形容词)
定义:提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类。
3.3.2 抽象工厂模式的分析与实现
- 抽象工厂中定义了多个方法,每一个方法代表一个产品等级
- 具体工厂即表示每一个产品族的工厂
3.3.3 抽象工厂的案例
一个电器工厂可以产生多种类型的电器,如海尔工厂可以生产海尔电视机、海尔空调等,TCL工厂可以生产TCL电视机、TCL空调等,相同品牌的电器构成一个产品族,而相同类型的电器构成了一个产品等级结构,现使用抽象工厂模式模拟该场景。
- 产品类
public interface TV {
public void play();
}
public class HaierTV implements TV{
@Override
public void play() {
System.out.println("海尔电视正在播放");
}
}
public class HisenseTV implements TV{
@Override
public void play() {
System.out.println("海信电视正在播放");
}
}
public interface Conditioner {
public void work();
}
public class HaierConditioner implements Conditioner{
@Override
public void work() {
System.out.println("海尔空调正在工作");
}
}
public class HisenseConditioner implements Conditioner{
@Override
public void work() {
System.out.println("海信空调正在工作");
}
}
- 工厂类
public interface BrandFactory {
public TV creatTV();
public Conditioner createConditioner();
}
public class HisenseFactory implements BrandFactory{
@Override
public TV creatTV() {
System.out.println("海信电视已被制作");
return new HisenseTV();
}
@Override
public Conditioner createConditioner() {
System.out.println("海信空调已被制作");
return new HisenseConditioner();
}
}
public class HaierFactory implements BrandFactory{
@Override
public TV creatTV() {
System.out.println("海尔电视已被制作");
return new HaierTV();
}
@Override
public Conditioner createConditioner() {
System.out.println("海尔空调已被制作");
return new HaierConditioner();
}
}
- Main类
public class Main {
public static void main(String[] args) {
try {
BrandFactory factory = (HisenseFactory) XMLUtilBrandFactory.getFactory();
TV tv = factory.creatTV();
tv.play();
Conditioner conditioner = factory.createConditioner();
conditioner.work();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
public class XMLUtilBrandFactory {
public static Object getFactory() throws Exception{
//获取XML文本
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(new File("src/main/resources/BrandFactory.xml"));
//获取工厂名字
NodeList nodeList = doc.getElementsByTagName("brandFactory");
Node firstChild = nodeList.item(0).getFirstChild();
String className = firstChild.getNodeValue();
//通过反射获取工厂对象
Class<?> aClass = Class.forName(className);
Object obj = aClass.newInstance();
return obj;
}
}
3.3.4 抽象工厂的优缺点
优点 | 缺点 |
---|---|
1.实现了对象的创建和使用分离。 | 1.增加新的产品等级结构麻烦,违背了开闭原则 |
2.当一个产品族中的多个对象被设计成一起工作时,它能够保证客户端始终只使用同一个产品族中的对象 |
3.3.5从抽象工厂模式的适用场景
- 系统中有多于一个的产品族,但每次只使用其中某一产品族
- 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节