工厂模式_黑马程序员笔记

Singcing

已于 2022-04-05 20:41:52 修改

阅读量293

点赞数

分类专栏：设计模式文章标签： java 抽象工厂模式

于 2022-03-28 22:27:12 首次发布

本文链接：https://blog.csdn.net/m0_46306264/article/details/123805132

版权

设计模式专栏收录该内容

19 篇文章 0 订阅

订阅专栏

1.概述

需求：设计一个咖啡店点餐系统。

设计一个咖啡类（Coffee），并定义其两个子类（美式咖啡【AmericanCoffee】和拿铁咖啡【LatteCoffee】）；再设计一个咖啡店类（CoffeeStore），咖啡店具有点咖啡的功能。

具体类的设计如下：

实现：不用设计模式

咖啡类，抽象类

/**
 * 咖啡类
 *
 *
 */
public abstract class Coffee {
	
	public abstract String getName();

	//加糖
	public void addSugar() {
		System.out.println("加糖");
	}
	
	//加奶
	public void addMilk() {
		System.out.println("加奶");
	}
	
	
}

/**
 * 子类：美式咖啡
 *
 */
public class AmericanCoffee extends Coffee{

	@Override
	public String getName() {
		// TODO Auto-generated method stub
		return "美式咖啡";
	}

}

/**
 * 子类：拿铁咖啡
 *
 */
public class LatteCoffee extends Coffee{

	@Override
	public String getName() {
		// TODO Auto-generated method stub
		return "拿铁咖啡";
	}

}

由CoffeStore来制作不同的咖啡

/**
 * 咖啡店，可以点咖啡
 * @author CharlieLiang
 *
 */
public class CoffeeStore {

	public Coffee orderCoffee(String type) {
		//声明Coffee类型变量，根据不同类型创建不同的Coffee子类对象
		Coffee coffee=null;
		if("american".equals(type)) {
			coffee=new AmericanCoffee();
		}else if("latte".equals(type)) {
			coffee=new LatteCoffee();
		}else {
			throw new RuntimeException("对不起，你点的咖啡没有");
		}
		
		//加配料
		coffee.addMilk();
		coffee.addSugar();
		
		return coffee;
	}
}

/**
 * 客户端
 *
 */
public class Client {

	public static void main(String[] args) {
		//1.创建咖啡店
		CoffeeStore store=new CoffeeStore();
		//2.点咖啡
		Coffee coffee= store.orderCoffee("american");
		
		System.out.println(coffee.getName());
	}
}

由CoffeStore来制作不同的咖啡

在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：解耦

2.简单工厂模式。(不是一种设计模式)

2.1简单工厂角色：

抽象产品：定义了产品的规范，描述了产品的主要特性和功能。(Coffee)
具体产品：实现或者继承抽象产品的子类(美式咖啡或拿铁咖啡)
具体工厂：提供了创建产品的方法，调用者通过该方法来获取产品。(生产咖啡的工厂)

实现：

/**
 * 简单咖啡工厂，专门用来生产咖啡
 *
 */
public class SimpleCoffeeFactory {

	public Coffee createCoffee(String type) {
		
		//声明Coffee类型变量，根据不同类型创建不同的Coffee子类对象
		Coffee coffee=null;
		if("american".equals(type)) {
			coffee=new AmericanCoffee();
		}else if("latte".equals(type)) {
			coffee=new LatteCoffee();
		}else {
			throw new RuntimeException("对不起，你点的咖啡没有");
		}
		return coffee;
	}
}

/**
 * 咖啡店使用简单工厂来生产不同咖啡
 * @author CharlieLiang
 *
 */
public class CoffeeStore {

	public Coffee orderCoffee(String type) {
		//调用简单工厂来生产某种类型的咖啡
		SimpleCoffeeFactory factory=new SimpleCoffeeFactory();
		Coffee coffee=factory.createCoffee(type);
		//加配料
		coffee.addMilk();
		coffee.addSugar();
		
		return coffee;
	}
}

/**
 * 简单工厂客户端
 */
public class Client {

	public static void main(String[] args) {
		//创建咖啡店类对象
		CoffeeStore store=new CoffeeStore();
		
		Coffee coffee=store.orderCoffee("latte");
		
		System.out.println(coffee.getName());
	}
}

运行结果。

2.2 优缺点：

优点：

封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻辑层分开，这样以后就避免了修改客户代码，如果要实现新产品直接修改工厂类，而不需要在原代码中修改，这样就降低了客户代码修改的可能性，更加容易扩展。

缺点：

增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。

3 工厂方法模式

针对上例中的缺点，使用工厂方法模式就可以完美的解决，完全遵循开闭原则。

3.1 概念定义一个用于创建对象的接口，让子类决定实例化哪个产品类对象。工厂方法使一个产品类的实例化延迟到其工厂的子类。

3.2 结构：

工厂方法模式的主要角色：

抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。
具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

3.3 实现：

/**
 * 创建咖啡的抽象工厂
 *
 */
public interface CoffeeFactory {

	//创建咖啡的抽象方法
	Coffee createCoffee();
}

/**
 * 美式咖啡工厂，专门生产美式咖啡
 * @author CharlieLiang
 *
 */
public class AmericanCoffeeFactory implements CoffeeFactory{

	@Override
	public Coffee createCoffee() {
		// TODO Auto-generated method stub
		return new AmericanCoffee();
	}

}

/**
 * 拿铁咖啡工厂，专门生产拿铁咖啡
 * @author CharlieLiang
 *
 */
public class LatteCoffeeFactory implements CoffeeFactory {

	@Override
	public Coffee createCoffee() {
		// TODO Auto-generated method stub
		return new LatteCoffee();
	}

}

public class CoffeeStore {

	private CoffeeFactory factory;
	
	public void setFactory(CoffeeFactory factory) {
		this.factory=factory;
	}
	
	//点咖啡功能
	public Coffee orderCoffee() {
		Coffee coffee=factory.createCoffee();
		
		//加配料
		coffee.addMilk();
		coffee.addSugar();
		return coffee;
	}
}

/**
 * 工厂方法客户端演示
 *
 */
public class Client {

	public static void main(String[] args) {
		//创建咖啡店对象
		CoffeeStore store=new CoffeeStore();
		
		//创建对象
		CoffeeFactory factory=new AmericanCoffeeFactory();
		store.setFactory(factory);
		
		//点咖啡
		Coffee coffee=store.orderCoffee();
		System.out.println(coffee.getName());
	}
}

运行结果

从以上的编写的代码可以看到，要增加产品类时也要相应地增加工厂类，不需要修改工厂类的代码了，这样就解决了简单工厂模式的缺点。

工厂方法模式是简单工厂模式的进一步抽象。由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。

3.4优缺点：

优点：

用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程；
在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则；

缺点：

每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。

4.抽象工厂模式

4.1引入：

工厂方法模式只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类）的产品，如电器厂既生产电视机又生产洗衣机或空调，大学既有软件专业又有生物专业等。

抽象工厂模式将考虑多等级产品的生产，将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族，下图所示横轴是产品等级，也就是同一类产品；纵轴是产品族，也就是同一品牌的产品，同一品牌的产品产自同一个工厂。

4.2 概念：抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。例如只生产咖啡。

4.3 角色:

抽象工厂模式的主要角色如下：

抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品。
具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

4.4实现：

现咖啡店业务发生改变，不仅要生产咖啡还要生产甜点，如提拉米苏、抹茶慕斯等，要是按照工厂方法模式，需要定义提拉米苏类、抹茶慕斯类、提拉米苏工厂、抹茶慕斯工厂、甜点工厂类，很容易发生类爆炸情况。其中拿铁咖啡、美式咖啡是一个产品等级，都是咖啡；提拉米苏、抹茶慕斯也是一个产品等级；拿铁咖啡和提拉米苏是同一产品族（也就是都属于意大利风味），美式咖啡和抹茶慕斯是同一产品族（也就是都属于美式风味）。所以这个案例可以使用抽象工厂模式实现。类图如下：

抽象产品：咖啡

/**
 * 咖啡类
 * @author CharlieLiang
 *
 */
public abstract class Coffee {
	
	public abstract String getName();

	//加糖
	public void addSugar() {
		System.out.println("加糖");
	}
	
	//加奶
	public void addMilk() {
		System.out.println("加奶");
	}
	
	
}

具体产品：美式咖啡

/**
 * 美式咖啡
 *
 */
public class AmericanCoffee extends Coffee{

	@Override
	public String getName() {
		// TODO Auto-generated method stub
		return "美式咖啡";
	}

}

具体产品：拿铁咖啡


/**
 * 拿铁咖啡
 *
 */
public class LatteCoffee extends Coffee{

	@Override
	public String getName() {
		// TODO Auto-generated method stub
		return "拿铁咖啡";
	}

}

抽象产品：甜品

/**
 * 甜品抽象类
 * @author CharlieLiang
 *
 */
public abstract class Dessert {

	public abstract void show();
}

具体产品：提拉米苏

/**
 * 提拉米苏类
 * @author CharlieLiang
 *
 */
public class Trimisu extends Dessert{

	@Override
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("提拉米苏");
	}

}

具体产品：抹茶慕斯

/**
 * 抹茶慕斯类
 * @author CharlieLiang
 *
 */
public class MatchaMouse extends Dessert{

	@Override
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("抹茶慕斯");
	}

}

抽象工厂：

public interface DessertFactory {

	//生产咖啡
	Coffee createCoffee();
	//生产甜品
	Dessert createDessert();
}

具体工厂：意大利风味工厂，生产提拉米苏，生产拿铁咖啡

/**
 * 意大利风味工厂
 * 生产提拉米苏
 * 生产拿铁咖啡
 * @author CharlieLiang
 *
 */
public class ItalyDessertFactory implements DessertFactory{

	@Override
	public Coffee createCoffee() {
		// TODO Auto-generated method stub
		return new LatteCoffee();
	}

	@Override
	public Dessert createDessert() {
		// TODO Auto-generated method stub
		return new Trimisu();
	}

	
}

具体工厂：美式风味工厂：生产美式咖啡、抹茶慕斯

/**
 * 美式风味工厂
 * 生产美式咖啡和抹茶慕斯
 * @author CharlieLiang
 *
 */
public class AmericanDessertFactory implements DessertFactory{

	@Override
	public Coffee createCoffee() {
		// TODO Auto-generated method stub
		return new AmericanCoffee();
	}

	@Override
	public Dessert createDessert() {
		// TODO Auto-generated method stub
		return new MatchaMouse();
	}

}

抽象工厂模式客户端演示

/**
 * 抽象工厂客户端演示
 * @author CharlieLiang
 *
 */
public class Client {

	public static void main(String[] args) {
		//创建意大利风味工厂
		DessertFactory factory=new ItalyDessertFactory();
		
		//获取拿铁咖啡和提拉米苏
		Coffee coffee=factory.createCoffee();
		Dessert trimisu=factory.createDessert();
		
		System.out.println(coffee.getName());
		trimisu.show();
	}
}

如果要加同一个产品族的话，只需要再加一个对应的工厂类(法国风味工厂)即可，不需要修改其他的类。

4.5优缺点：

优点：

当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：

当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。

4.6：使用场景

4.2.4.4 使用场景

当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。
系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。

如：输入法换皮肤，一整套一起换。生成不同操作系统的程序。

Singcing

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
工厂模式_黑马程序员笔记

1.概述需求：设计一个咖啡店点餐系统。设计一个咖啡类（Coffee），并定义其两个子类（美式咖啡【AmericanCoffee】和拿铁咖啡【LatteCoffee】）；再设计一个咖啡店类（CoffeeStore），咖啡店具有点咖啡的功能。具体类的设计如下：实现：不用设计模式咖啡类，抽象类/** * 咖啡类 * * */public abstract class Coffee { public abstract String getName(); //加糖 .
复制链接

扫一扫