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

02-27 阅读 0评论

文章目录

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

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

    【Java设计模式】一、工厂模式、建造者模式、原型设计模式,【Java设计模式】一、工厂模式、建造者模式、原型设计模式,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,我们,接口,方法,第1张
    （图片来源网络，侵删）
    • 创建型模式：隐藏了创建对象的过程，通过逻辑方法进行创建对象，而不是直接new
    • 结构型模式：主要关注类和对象的组合关系。继承的概念被用来组合接口和定义组合对象，获得新的功能方式
    • 行为型模式：主要关注对象之间的通信

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

      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、工厂方法模式

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

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

        【Java设计模式】一、工厂模式、建造者模式、原型设计模式,【Java设计模式】一、工厂模式、建造者模式、原型设计模式,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,我们,接口,方法,第3张
        （图片来源网络，侵删）
        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();
	}
}

        运行：

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

        【Java设计模式】一、工厂模式、建造者模式、原型设计模式,【Java设计模式】一、工厂模式、建造者模式、原型设计模式,词库加载错误:未能找到文件“C:\Users\Administrator\Desktop\火车头9.8破解版\Configuration\Dict_Stopwords.txt”。,我们,接口,方法,第5张
        （图片来源网络，侵删）

        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);
	}
}

          运行：

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

          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);
	}
}

            运行：

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

            采用原型设计模式后：实体类实现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);
	}
}

            运行：

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

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


相关阅读：

1、已解决javax.xml.datatype.DatatypeConfigurationException异常的正确解决方法，亲测有效！！！

2、Java 面试题篇 Sleep()方法与Wait() 方法的区别

3、Java的日期类常用方法

4、【菜狗学前端】在原生微信小程序使用腾讯地图API接口

5、后端接口返回文件流，前端下载（java+vue）

免责声明
本网站所收集的部分公开资料来源于AI生成和互联网，转载的目的在于传递更多信息及用于网络分享，并不代表本站赞同其观点和对其真实性负责，也不构成任何其他建议。
文章版权声明：除非注明，否则均为主机测评原创文章，转载或复制请以超链接形式并注明出处。

相关阅读

发表评论

快捷回复： 表情：
评论列表 （暂无评论，人围观）

还没有评论，来说两句吧...

目录[+]