文章目录
- 1、简单工厂模式
- 2、工厂方法模式
- 3、抽象工厂模式
- 4、建造者模式
- 5、原型设计模式
设计模式即总结出来的一些最佳实现。23种设计模式可分为三大类:
- 创建型模式:隐藏了创建对象的过程,通过逻辑方法进行创建对象,而不是直接new
- 结构型模式:主要关注类和对象的组合关系。继承的概念被用来组合接口和定义组合对象,获得新的功能方式
- 行为型模式:主要关注对象之间的通信
1、简单工厂模式
即由一个工厂决定创建哪一种产品类型的实例。
//抽象的课程类
public abstract class Course{
//有一个制作课程的抽象方法
public abstract void make();
}
以上抽象类的两个实现类:
public class JavaCourse extends Course{
@Override
public void make(){
System.out.println("制作Java课程");
}
}
public class PythonCourse extends Course{
@Override
public void make(){
System.out.println("制作Python课程");
}
}
创建工厂类:
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;
}
}
测试下效果:
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、工厂方法模式
- 定义一个接口或者一个抽象的工厂类,让它的实现类(也是一个工厂)来决定创建哪一个实例对象。
- 根据每个工厂不同的方法,来产生不同的所需要的对象
先定义一个基类(接口或者抽象的工厂类):
public abstract class CourseFactory{
public abstract Course getCourse();
}
写实现类:
public class JavaCourseFactory extends CourseFactory{
@Override
public Course getCourse(){
return new JavaCourse();
}
}
public class PythonCourseFactory extends CourseFactory{
@Override
public Course getCourse(){
return new PythonCourse();
}
}
测试:
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课程。抽象工厂模式则是提供创建一系列相关或相互依赖对象的接口。比如生产汽车,将汽车分为车架、车门、底盘等各个零部件进行生产。
public interface CarFactory{
//获取车门对象
public CarDoor getCarDoor();
//获取车架对象
public CarFrame getCarFrame();
//获取底盘对象
public CarBasePlate getCarBasePlate();
//制作汽车
public void make();
}
//车门工厂
public abstract class CarDoorFactory{
public abstract void make();
}
//底盘工厂
public abstract class CarBasePlateFactory{
public abstract void make();
}
//车架工厂
public abstract class CarFrameFactory{
public abstract void make();
}
//车门
public class CarDoor extends CarDoorFactory{
@Override
public abstract void make(){
System.out.println("制作车门");
}
}
//底盘
public class CarBasePlate extends CarBasePlateFactory{
public abstract void make(){
System.out.println("制作车底盘");
}
}
//车架工厂
public class CarFrame extends CarFrameFactory{
public abstract void make(){
System.out.println("制作车架");
}
}
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("小汽车制作完成");
}
}
测试:
public class Test{
public static void mian(STring[] args){
Car car = new Car();
car.getCarBasePlate();
car.getCarFrame();
car.getCarDoor();
car.make();
}
}
运行:
4、建造者模式
- 将复杂的对象的创建 和 属性赋值所分离
- 建造的过程和细节我们不需要知道,只需要通过构建者去进行操作
@Data
public class Car{
private String basePlate; //车底盘
private String frame; //车架
private String door; //车门
}
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();
}
写实现类:
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;
}
}
创建一个工程师:
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();
}
}
测试:
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、原型设计模式
- 用于创建重复的对象,能够保证创建对象的性能
- 是创建对象的最佳方式
@Data
public class Pig{
private String name; //名字
private String doSomething; //喜欢做的事
}
现在要表示佩奇一家,正常创建流程如下:
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接口
@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();
}
}
再次创建佩奇一家:
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);
}
}
运行:
发现构造方法只被调用了一次,且出来的也照样是不同的对象。因此,当对象属性很多,而又要创建大量这种对象时,就可以用原型设计模式。该模式产生的对象,虽然都是不同的对象,单如果不重新赋值,属性却是与克隆样本保持一致的,即使是一个新的对象。