文章目录
- 1、简单工厂模式
- 2、工厂方法模式
- 3、抽象工厂模式
- 4、建造者模式
- 5、原型设计模式
设计模式即总结出来的一些最佳实现。23种设计模式可分为三大类:
- 创建型模式:隐藏了创建对象的过程,通过逻辑方法进行创建对象,而不是直接new
- 结构型模式:主要关注类和对象的组合关系。继承的概念被用来组合接口和定义组合对象,获得新的功能方式
- 行为型模式:主要关注对象之间的通信
1、简单工厂模式
即由一个工厂决定创建哪一种产品类型的实例。
//抽象的课程类
public abstract class Course{//有一个制作课程的抽象方法public abstract void make();
}
以上抽象类的两个实现类:
public class JavaCourse extends Course{@Overridepublic void make(){System.out.println("制作Java课程");}
}
public class PythonCourse extends Course{@Overridepublic void make(){System.out.println("制作Python课程");}
}
创建工厂类:
public class CourseFactory{//获取课程对象,返回类型为抽象类Coursepublic 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{@Overridepublic Course getCourse(){return new JavaCourse();}
}
public class PythonCourseFactory extends CourseFactory{@Overridepublic 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{@Overridepublic 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;@Overridepublic CarDoor getCarDoor(){carDoor = new CarDoor();return carDoor;}@Overridepublic CarFrame getCarFrame(){carFrame = new new CarFrame();return carFrame;}@Overridepublic CarBasePlate getCarBasePlate(){carBasePlate = new CarBasePlate();return carBasePlate;}@Overridepublic 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();@Overridpublic abstract void buildBasePlate(String basePlate){car.setBasePlate(basePlate);}@Overridepublic abstract void buildCarFrame(String carFrame){car.setFrame(frame);}@Overridepublic abstract void buildCarDoor(String carDoor){car.setDoor(carDoor);}@Overridepublic abstract Car makeCar(){return this.car;}}
创建一个工程师:
public class Engineer{private CarBuilder carBuilder;//自动注入、构造方法、set方法都行,能完成赋值就行,这里写setpublic 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; //喜欢做的事@Overrideprotected 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);}
}
运行:
发现构造方法只被调用了一次,且出来的也照样是不同的对象。因此,当对象属性很多,而又要创建大量这种对象时,就可以用原型设计模式。该模式产生的对象,虽然都是不同的对象,单如果不重新赋值,属性却是与克隆样本保持一致的,即使是一个新的对象。