设计模式之工厂模式
单例模式
- 设计模式总分类
- 创建型模式( 5种 )
- 结构型模式( 7种 )
- 行为型模式( 11种 )
- 工厂模式
- 应用场景
- 作用
- 本质
- 补充 面向对象设计的基本原则
- 分类
- 简单工厂模式
- 工厂方法模式
- 简单工厂模式和抽象工厂模式比较
- 抽象工厂模式
- 工厂模式总结
设计模式总分类
创建型模式( 5种 )
- 单例模式
- 工厂模式
- 抽象工厂模式
- 建造者模式
- 原型模式
结构型模式( 7种 )
- 适配器模式
- 桥接模式
- 装饰模式
- 组合模式
- 外观模式
- 享元模式
- 代理模式
行为型模式( 11种 )
- 模版方法模式
- 命令模式
- 迭代器模式
- 观察者模式
- 中介者模式
- 备忘录模式
- 解释器模式
- 状态模式
- 策略模式
- 职责链模式
- 访问者模式
工厂模式
应用场景
在这里插入图片描述
作用
实现了创建者和调用者的分离。
本质
将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。 实例化对象，用工厂方法代替new操作。
教你区别内聚与耦合
在这里插入图片描述
补充 面向对象设计的基本原则
项目 | Value |
|---|---|
OCP（开闭原则，Open-Closed Principle） | 一个软件的实体应当对扩展开放，对修改关闭。 |
DIP（依赖倒转原则，Dependence Inversion Principle） | 要针对接口编程， 不要针对实现编程。 |
LoD（迪米特法则，Law of Demeter ) | 只与你直接的朋友通信，而避免和 陌生人通信。 |
分类
简单工厂模式
用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码 )
在这里插入图片描述
基础类
package ah.szxy.simplefactory;
public interface car {
void run();
}
package ah.szxy.simplefactory;
public class BenChi implements car{
@Override
public void run() {
System.out.println("奔驰在跑");
}
}
package ah.szxy.simplefactory;
public class BaoMa implements car{
@Override
public void run() {
System.out.println("宝马在跑");
}
}工厂类以及测试类
package ah.szxy.simplefactory;
/**
* 简单工厂模式一
* @author chy
*
*/
public class CarFactory {
public static car createCar(String type) {
if ("BaoMa".equals(type)) {
return new BaoMa();
}else if ("BenChi".equals(type)) {
return new BenChi();
}else {
return null;
}
}
}
package ah.szxy.simplefactory;
/**
* 简单工厂模式二
* @author chy
*
*/
public class CarFactory2 {
public static car createBenChi() {
return new BenChi();
}
public static car createBaoMa() {
return new BaoMa();
}
}
package ah.szxy.simplefactory;
/**
* 测试简单工厂模式
* @author chy
*
*/
public class Client2 {
public static void main(String[] args) {
CarFactory carFactory = new CarFactory();
//car bc = carFactory.createCar("BenChi");
//car bm = carFactory.createCar("BaoMa");
car bm = CarFactory2.createBaoMa();
car bc = CarFactory2.createBenChi();
bc.run();
bm.run();
}
}
在这里插入图片描述
uml图
在这里插入图片描述
工厂方法模式
为了避免简单工厂模式的缺点，不完全满足OCP。 工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目 或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。
在这里插入图片描述
package ah.szxy.simplefactory;
public interface car {
void run();
}
package ah.szxy.simplefactory;
public class BenChi implements car{
@Override
public void run() {
System.out.println("奔驰在跑");
}
}
package ah.szxy.simplefactory;
public class BaoMa implements car{
@Override
public void run() {
System.out.println("宝马在跑");
}
}package ah.szxy.factorymethod;
public interface Factory {
public Car createCar();
}
package ah.szxy.factorymethod;
public class BenChiFactory implements Factory{
@Override
public Car createCar() {
return new BenChi();
}
}
package ah.szxy.factorymethod;
public class BaoMaFactory implements Factory{
@Override
public Car createCar() {
return new BaoMa();
}
}
package ah.szxy.factorymethod;
/**
* 测试工厂方法模式
* @author 曹海洋
*
*/
public class Client{
public static void main(String[] args) {
Car bc = new BenChiFactory().createCar();
Car bm = new BaoMaFactory().createCar();
bc.run();
bm.run();
}
}测试结果
在这里插入图片描述
uml图
在这里插入图片描述
简单工厂模式和抽象工厂模式比较
在这里插入图片描述
根据设计理论建议：工厂方法模式。但实际上，我们一般都用简单工厂模式
抽象工厂模式
用来生产不同产品族的全部产品。（对于增加新的产品，无能为力； 支持增加产品族） 抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务 分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。
package ah.szxy.abstractfactory;
/**
* 引擎
* @author chy
*
*/
public interface Engine {
void run();
}
class luxuryEngine implements Engine{
@Override
public void run() {
System.out.println("跑的快");
}
}
class lowEngine implements Engine{
@Override
public void run() {
System.out.println("跑的慢");
}
}
package ah.szxy.abstractfactory;
/**
* 座位
* @author chy
*
*/
public interface Seat {
void feel();
}
class luxurySeat implements Seat{
@Override
public void feel() {
System.out.println("坐着爽");
}
}
class lowSeat implements Seat{
@Override
public void feel() {
System.out.println("坐着不爽");
}
}
package ah.szxy.abstractfactory;
/**
* 轮胎
* @author chy
*
*/
public interface Tyre {
void moSun();
}
class luxuryTyre implements Tyre{
@Override
public void moSun() {
System.out.println("耐磨损");
}
}
class lowTyre implements Tyre{
@Override
public void moSun() {
System.out.println("不耐磨损");
}
}package ah.szxy.abstractfactory;
public interface CarFactory {
Engine engine();
Seat seat();
Tyre tyre();
}
package ah.szxy.abstractfactory;
public class lowCar implements CarFactory{
@Override
public Engine engine() {
return new lowEngine();
}
@Override
public Seat seat() {
return new lowSeat();
}
@Override
public Tyre tyre() {
return new lowTyre();
}
}
package ah.szxy.abstractfactory;
public class LuxuryCar implements CarFactory {
@Override
public Engine engine() {
return new luxuryEngine();
}
@Override
public Seat seat() {
return new luxurySeat();
}
@Override
public Tyre tyre() {
return new luxuryTyre() ;
}
}
package ah.szxy.abstractfactory;
/**
* 测试抽象方法模式
* @author chy
*
*/
public class Client {
public static void main(String[] args) {
CarFactory luxuryCar = new LuxuryCar();
CarFactory lowCar = new lowCar();
luxuryCar.engine().run();
lowCar.engine().run();
}
}运行结果
在这里插入图片描述
uml类图
在这里插入图片描述
工厂模式总结
分类 | 区别 |
|---|---|
简单工厂模式(静态工厂模式) | 虽然某种程度不符合设计原则，但实际使用最多。 |
工厂方法模式 | 不修改已有类的前提下，通过增加新的工厂类实现扩展。 |
抽象工厂模式 | 不可以增加产品，可以增加产品族 |
本文参与 腾讯云自媒体分享计划，分享自作者个人站点/博客。
原始发表：2019-08-19 ，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读
目录