【Java设计模式】一、工厂模式、建造者模式、原型设计模式

文章目录

1、简单工厂模式
2、工厂方法模式
3、抽象工厂模式
4、建造者模式
5、原型设计模式

设计模式即总结出来的一些最佳实现。23种设计模式可分为三大类：

创建型模式：隐藏了创建对象的过程，通过逻辑方法进行创建对象，而不是直接new
结构型模式：主要关注类和对象的组合关系。继承的概念被用来组合接口和定义组合对象，获得新的功能方式
行为型模式：主要关注对象之间的通信

1、简单工厂模式

即由一个工厂决定创建哪一种产品类型的实例。

java 复制代码

//抽象的课程类
public abstract class Course{
	//有一个制作课程的抽象方法
	public abstract void make();
}

以上抽象类的两个实现类：

java 复制代码

public class JavaCourse extends Course{

	@Override
	public void make(){
		System.out.println("制作Java课程");
	}
}

java 复制代码

public class PythonCourse extends Course{

	@Override
	public void make(){
		System.out.println("制作Python课程");
	}
}

创建工厂类：

java 复制代码

public class CourseFactory{
	
	//获取课程对象，返回类型为抽象类Course
	public Course getCourse(String courseKey){  //形参为工厂关键字
	
		if("java".equalsIgnoreCase(courseKey)){
			//创建JavaCourse对象，然会返回
			return new JavaCourse();
		}else if("python".equalsIgnoreCase(courseKey)){
			//创建PythonCourse对象，然会返回
			return new PythonCourse();
		}
		return null;
	}
}

测试下效果：

java 复制代码

public class Test{

	public static void mian(String[] args){
		
		//创建工厂对象
		CourseFactory factory = new CourseFactory();
		//获取javaCourse 对象
		Course javaCourse = factory.getCourse("java");
		//完成制作Java课程功能
		javaCourse.make();
		//获取pythonCourse 对象
		Course pythonCourse = factory.getCourse("python");
		//完成制作python课程功能
		pythonCourse.make();
	}
}

2、工厂方法模式

定义一个接口或者一个抽象的工厂类，让它的实现类（也是一个工厂）来决定创建哪一个实例对象。
根据每个工厂不同的方法，来产生不同的所需要的对象

先定义一个基类（接口或者抽象的工厂类）：

java 复制代码

public abstract class CourseFactory{

	public abstract Course getCourse();
}

写实现类：

java 复制代码

public class JavaCourseFactory extends CourseFactory{

	@Override
	public Course getCourse(){
		return new JavaCourse();
	}
}

java 复制代码

public class PythonCourseFactory extends CourseFactory{

	@Override
	public Course getCourse(){
		return new PythonCourse();
	}
}

测试：

java 复制代码

public class Test{

	public static void mian(STring[] args){
		
		JavaCourseFactory javaCourseFactory = new JavaCourseFactory();
		//获取javaCourse 对象
		Course javaCourse = javaCourseFactory.getCourse();
		//完成制作Java课程功能
		javaCourse.make();
		
		PythonCourseFactory pythonCourseFactory = new PythonCourseFactory();
		//获取pythonCourse 对象
		Course pythonCourse = factory.getCourse();
		//完成制作python课程功能
		pythonCourse.make();
	}
}

3、抽象工厂模式

前面的工厂方法模式，生产的都是相同系列的对象，如Java课程、python课程。抽象工厂模式则是提供创建一系列相关或相互依赖对象的接口。比如生产汽车，将汽车分为车架、车门、底盘等各个零部件进行生产。

java 复制代码

public interface CarFactory{

	//获取车门对象
	public CarDoor getCarDoor();
	//获取车架对象
	public CarFrame getCarFrame();
	//获取底盘对象
	public CarBasePlate getCarBasePlate();
	//制作汽车
	public void make();
}

java 复制代码

//车门工厂
public abstract class CarDoorFactory{
	
	public abstract void make();
}

java 复制代码

//底盘工厂
public abstract class CarBasePlateFactory{
	
	public abstract void make();
}

java 复制代码

//车架工厂
public abstract class CarFrameFactory{
	
	public abstract void make();
}

java 复制代码

//车门
public class CarDoor extends CarDoorFactory{
	@Override
	public abstract void make(){
		System.out.println("制作车门");
	}
}

java 复制代码

//底盘
public class CarBasePlate extends CarBasePlateFactory{
	
	public abstract void make(){
		System.out.println("制作车底盘");
	}
}

java 复制代码

//车架工厂
public class CarFrame extends CarFrameFactory{
	
	public abstract void make(){
		System.out.println("制作车架");
	}
}

java 复制代码

public class Car implements CarFactory{

	private CarDoor carDoor = null;
	private CarFrame carFrame = null;
	private CarBasePlate carBasePlate = null;

	@Override
	public CarDoor getCarDoor(){
		carDoor = new CarDoor();
		return carDoor;
	}

	@Override
	public CarFrame getCarFrame(){
		carFrame = new new CarFrame();
		return carFrame;
	}
	
	@Override
	public CarBasePlate getCarBasePlate(){
		carBasePlate = new CarBasePlate();
		return carBasePlate;
	}

	@Override
	public void make(){
		carDoor.make();
		carFrame.make();
		carBasePlate.make();
		System.out.print("小汽车制作完成");
	}
}

测试：

java 复制代码

public class Test{

	public static void mian(STring[] args){
		
		Car car  = new Car();
		car.getCarBasePlate();
		car.getCarFrame();
		car.getCarDoor();
		car.make();
	}
}

运行：

4、建造者模式

将复杂的对象的创建和属性赋值所分离
建造的过程和细节我们不需要知道，只需要通过构建者去进行操作

java 复制代码

@Data
public class Car{

	private String basePlate;   //车底盘

	private String frame;	//车架

	private String door; 	//车门
}

java 复制代码

public abstract class Builder{
	
	//车底盘
	public abstract void buildBasePlate(String basePlate);
	//车架
	public abstract void buildCarFrame(String carFrame);
	//车门
	public abstract void buildCarDoor(String carDoor);
	//制作车
	public abstract Car makeCar();
}

写实现类：

java 复制代码

public class CarBuilder extends Builder{

	private Car car = new Car();

	@Overrid
	public abstract void buildBasePlate(String basePlate){
		car.setBasePlate(basePlate);
	}
	@Override
	public abstract void buildCarFrame(String carFrame){
		car.setFrame(frame);
	}
	@Override
	public abstract void buildCarDoor(String carDoor){
		car.setDoor(carDoor);
	}
	@Override
	public abstract Car makeCar(){
		return this.car;
	}
	
}

创建一个工程师：

java 复制代码

public class Engineer{
	
	private CarBuilder carBuilder;

	//自动注入、构造方法、set方法都行，能完成赋值就行，这里写set
	public void setCarBuilder(CarBuilder carBuilder){
		this.carBuilder = carBuilder;
	}

	public Car mekeCar(String basePlate, String frame, String door){
		carBuilder.buildBasePlate(basePlate);
		carBuilder.buildCarFrame(frame);
		carBuilder.buildCarDoor(door);
		return carBuilder.makeCar();
	}
}

测试：

java 复制代码

public class Test{

	public static void mian(STring[] args){
		Engineer engineer = new Engineer();
		CarBuilder carBuilder = new CarBuilder();
		engineer.setCarBuilder(carBuilder);
		Car car = engineer.makeCar("制作汽车底盘","制作汽车车架","制作汽车车门");
		System.out.println(car);
	}
}

运行：

5、原型设计模式

用于创建重复的对象，能够保证创建对象的性能
是创建对象的最佳方式

java 复制代码

@Data
public class Pig{

	private String name;   //名字
	private String doSomething;  //喜欢做的事
	
}

现在要表示佩奇一家，正常创建流程如下：

java 复制代码

public class Test{

	public static void mian(STring[] args){
		Pig peki = new Pig();
		peki.setName("佩琪");
		peki.setDoSomething("喜欢吃蛋糕");
		System.out.println(peki);

		Pig george = new Pig();
		george.setName("乔治");
		george.setDoSomething("喜欢睡觉");
		System.out.println(george);

		Pig pigDad = new Pig();
		pigDad.setName("猪爸爸");
		pigDad.setDoSomething("喜欢开车");
		System.out.println(pigDad);

		Pig pigMum = new Pig();
		pigMum.setName("猪妈妈");
		pigMum.setDoSomething("喜欢做饭");
		System.out.println(pigMum);
	}
}

运行：

采用原型设计模式后：实体类实现Cloneable接口

java 复制代码

@Data
public class Pig implements Cloneable{

	public Pig() {
		System.out.println("小猪被初始化了...");
	}
	private String name;   //名字
	private String doSomething;  //喜欢做的事
	
	@Override
	protected Object clone() throws CloneNotSupportedException{
		return super.clone();
	}
}

再次创建佩奇一家：

java 复制代码

public class Test{

	public static void mian(STring[] args){
		Pig peki = new Pig();    //先new一个
		peki.setName("佩琪");
		peki.setDoSomething("喜欢吃蛋糕");
		System.out.println(peki);

		Pig george = (Pig) peki.clone();    //后面就克隆
		george.setName("乔治");    //如果这里不赋值，那克隆出来的属性和克隆样本一样
		george.setDoSomething("喜欢睡觉");
		System.out.println(george);

		Pig pigDad = (Pig) peki.clone() ;
		pigDad.setName("猪爸爸");
		pigDad.setDoSomething("喜欢开车");
		System.out.println(pigDad);

		Pig pigMum = (Pig) peki.clone() ;
		pigMum.setName("猪妈妈");
		pigMum.setDoSomething("喜欢做饭");
		System.out.println(pigMum);
	}
}

运行：

发现构造方法只被调用了一次 ，且出来的也照样是不同的对象。因此，当对象属性很多，而又要创建大量这种对象时，就可以用原型设计模式。该模式产生的对象，虽然都是不同的对象，单如果不重新赋值，属性却是与克隆样本保持一致的，即使是一个新的对象。