工厂设计模式

最新推荐文章于 2024-08-17 15:55:28 发布

待烟火清凉

最新推荐文章于 2024-08-17 15:55:28 发布

阅读量192

点赞数

分类专栏： GOF 设计模式

本文链接：https://blog.csdn.net/gcxzflgl/article/details/77060030

版权

GOF 同时被 2 个专栏收录

21 篇文章 0 订阅

订阅专栏

设计模式

21 篇文章 4 订阅

订阅专栏

工厂设计模式实现了创建者和调用者的分离

详细分为：简单工厂，工厂方法，抽象工厂、

核心本质：

实例化对象，用工厂方法代替new操作。

将选择实现类、创建对象统一管理和控制。从而将调用者跟我们现实类解耦。

要点：

简单工厂：虽然某种程度不符合设计原则，但实际使用最多。

工厂方法：不修改已有类的前提下,通过增加新的工厂类实现扩展。

抽象工厂：不可以增加产品，可以增加产品族！

应用场景:

1.jdk中Calenlar.getInsance方法

2.JDBC中Connection对象的获取

3.Hibernate中SessionFactory创建session

4.spring中ioc容器创建管理bean对象

5.xml解析时的DocumentBuilderFactory创建解析器对象

6.反射中Class对象的newInstance方法

简单工厂：用来生产同一等级结构中的任意产品（对于增加新的产品，需要修改原有代码，违背了开闭原则）

类图：

创建Car接口

package com.gcxzflgl.factory.simplefactory;

public interface Car {
	void run();
}

创建Car的两个子类

package com.gcxzflgl.factory.simplefactory;

public class Audi implements Car {

	@Override
	public void run() {
		System.out.println("奥迪再跑！");
	}

}

package com.gcxzflgl.factory.simplefactory;

public class Byd implements Car {

	@Override
	public void run() {
		System.out.println("比亚迪再跑！");
	}

}

创建一个CarFactory工厂1

package com.gcxzflgl.factory.simplefactory;

public class CarFactory {
	
	public static  Car createCar(String type){
		if("奥迪".equals(type)){
			return new Audi();
		}else if("比亚迪".equals(type)){
			return new Byd();
		}else{
			return null;
		}
	}
	
}

调用者

package com.gcxzflgl.factory.simplefactory;

/**
 * 测试在没有工厂模式的情况下 
 */
public class Client01 { 
	
	public static void main(String[] args) {
		Car c1 = new Audi();
		Car c2 = new Byd();
		
		c1.run();
		c2.run();
		
	}
}

创建工厂Factory工厂二

package com.gcxzflgl.factory.simplefactory;


public class CarFactory2 {
	
	public static  Car createAudi(){
		return new Audi();
	}
	public static  Car createByd(){
		return new Byd();
	}
	
}

调用者

package com.gcxzflgl.factory.simplefactory;

/**
 * 简单工厂情况下
 *
 */
public class Client02 {   //调用者
	
	public static void main(String[] args) {
		Car c1 =CarFactory.createCar("奥迪");
		Car c2 = CarFactory.createCar("比亚迪");
		
		c1.run();
		c2.run();
		
	}
}

工厂方法模式：用来生产同一等级结构中的固定产品（支持增加任意产品）

要点：为了避免简单工厂模式的缺点，不满足ocp（开闭原则）

工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目或者一个独立模块而言）工厂类，

而工厂方法模式有一组实现了相同接口的工厂类。

类图：

创建Car接口

package com.gcxzflgl.factory.factorymethod;

public interface Car {
	void run();
}

创建Car的三个子类

package com.gcxzflgl.factory.factorymethod;

public class Audi implements Car {

	@Override
	public void run() {
		System.out.println("奥迪再跑！");
	}

}

package com.gcxzflgl.factory.factorymethod;

public class Benz implements Car {

	@Override
	public void run() {
		System.out.println("奔驰再跑！");
	}

}

package com.gcxzflgl.factory.factorymethod;

public class Byd implements Car {

	@Override
	public void run() {
		System.out.println("比亚迪再跑！");
	}

}

创建一个汽车工厂

package com.gcxzflgl.factory.factorymethod;

public interface CarFactory {
	Car createCar();
}

创建对应汽车品牌工厂

package com.gcxzflgl.factory.factorymethod;

public class BenzFactory implements CarFactory {

	@Override
	public Car createCar() {
		return new Benz();
	}

}

package com.gcxzflgl.factory.factorymethod;

public class BydFactory implements CarFactory {

	@Override
	public Car createCar() {
		return new Byd();
	}

}

package com.gcxzflgl.factory.factorymethod;

public class AudiFactory implements CarFactory {

	@Override
	public Car createCar() {
		return new Audi();
	}

}

调用者

package com.gcxzflgl.factory.factorymethod;


public class Client {
	public static void main(String[] args) {
		Car c1 = new AudiFactory().createCar();
		Car c2 = new BydFactory().createCar();
		Car c3 = new BenzFactory().createCar();
		c1.run();
		c2.run();
		c3.run();
	}
}

简单工厂和工厂方法的对比：

抽象工厂：用来生产不同产品族的全部产品（对于增加新的产品无能为力，支持增加产品族）

抽象共产模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时,通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

类图：

创建发动机产品族

package com.gcxzflgl.factory.abstractFactory;

public interface Engine {
	void run();
	void start();
}


class LuxuryEngine implements Engine{

	@Override
	public void run() {
		System.out.println("转的快！");
	}

	@Override
	public void start() {
		System.out.println("启动快!可以自动启停！");
	}
	
}

class LowEngine implements Engine{
	
	@Override
	public void run() {
		System.out.println("转的慢！");
	}
	
	@Override
	public void start() {
		System.out.println("启动慢!");
	}
	
}

创建座椅产品族：

package com.gcxzflgl.factory.abstractFactory;

public interface Seat {
	void massage();
}

class LuxurySeat implements Seat {

	@Override
	public void massage() {
		System.out.println("可以自动按摩！");
	}
	
}
class LowSeat implements Seat {

	@Override
	public void massage() {
		System.out.println("不能按摩！");
	}
	
}

创建轮胎产品族

package com.gcxzflgl.factory.abstractFactory;

public interface Tyre {
	void revolve();
}

class LuxuryTyre implements Tyre {

	@Override
	public void revolve() {
		System.out.println("旋转不磨损！");
	}
	
}

class LowTyre implements Tyre {

	@Override
	public void revolve() {
		System.out.println("旋转磨损快！");
	}
	
}

创建汽车工厂

package com.gcxzflgl.factory.abstractFactory;

public interface CarFactory {
	Engine createEngine();
	Seat createSeat();
	Tyre createTyre();
}

创建高级汽车工厂

package com.gcxzflgl.factory.abstractFactory;

public class LuxuryCarFactory implements CarFactory {

	@Override
	public Engine createEngine() {
		return new LuxuryEngine();
	}

	@Override
	public Seat createSeat() {
		return new LuxurySeat();
	}

	@Override
	public Tyre createTyre() {
		return new LuxuryTyre();
	}


}

创建低级汽车工厂

package com.gcxzflgl.factory.abstractFactory;

public class LowCarFactory implements CarFactory {

	@Override
	public Engine createEngine() {
		return new LowEngine();
	}

	@Override
	public Seat createSeat() {
		return new LowSeat();
	}

	@Override
	public Tyre createTyre() {
		return new LowTyre();
	}


}

调用者

package com.gcxzflgl.factory.abstractFactory;

public class Client {

	public static void main(String[] args) {
		CarFactory  factory = new LuxuryCarFactory();
		Engine e = factory.createEngine();
		e.run();
		e.start();
		
		
	}
}

很好的分离开来，各司其职，分工明确！！