Java设计模式（工厂模式＞抽象工厂模式和原型模式）
2024-05-23 18:54:30
Java设计模式Ⅱ
- 1.工厂模式
- 1.1 简单工厂模式
- 1.2 工厂方法模式
- 2.抽象工厂模式
- 3.总结
- 4.原型模式
- 4.1 原型模式
- 4.2 浅拷贝
- 4.3 深拷贝
- 5.建造者模式
1.工厂模式
1.1 简单工厂模式
（1）基本介绍
a.简单工厂模式是属于创建模式，是工厂模式的一种，简单工厂模式是由一个工厂对象创建出哪一种产品类的实例。简单工厂模式是工厂模式家族里最简单使用的模式b.定义了一个创建对象的类，有这个类封装实例化对象的行为c.在软件开发中。当我们会用到大量的创建某类，或者某批对象时，就会使用到工厂模式
(2)代码展示
1.先定义一个抽象类，将不同的点设置为抽象方法
package com.pattern.设计模式.工厂模式和抽象工厂模式.简单工厂模式;public abstract class Car {private String name;// 因为车的品牌不一样，所以设置为抽象方法public abstract void log();public void tyre(){System.out.println(name + "的轮胎");}public void frame(){System.out.println(name + "的车架");}public void engine(){System.out.println(name + "的引擎");}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Car{" +"name='" + name + '\'' +'}';}
}2.继承该抽象方法去重写其抽象方法（可以多创建一些车品牌）
package com.pattern.设计模式.工厂模式和抽象工厂模式.简单工厂模式;public class AudiCar extends Car{@Overridepublic void log() {System.out.println("奥迪");}
}3.制作什么品牌的车自己输入
package com.pattern.设计模式.工厂模式和抽象工厂模式.简单工厂模式;import java.util.Scanner;public class MakeCar {private CarFactory factory;private Car car;public MakeCar(CarFactory factory){this.factory = factory;}public void makeCar(){String log = "";do {log = getLog();car = this.factory.createCar(log);if (car != null){car.log();car.tyre();car.frame();car.engine();} else {System.out.println("输入有误！没有该品牌的车型！！！");break;}} while (true);}public String getLog() {Scanner scanner = new Scanner(System.in);System.out.println("请输入要制作的品牌:");String log = scanner.next();return log;}
}4.创建工厂类
package com.pattern.设计模式.工厂模式和抽象工厂模式.简单工厂模式;public class CarFactory {public Car createCar(String log){Car car = null;if ("宝马".equals(log)){car = new BmwCar();car.setName("宝马");}else if ("奔驰".equals(log)){car = new BenzCar();car.setName("奔驰");}else if ("奥迪".equals(log)){car = new AudiCar();car.setName("奥迪");}return car;}
}5.测试类
package com.pattern.设计模式.工厂模式和抽象工厂模式.简单工厂模式;public class Test {public static void main(String[] args) {CarFactory factory = new CarFactory();MakeCar makeCar = new MakeCar(factory);makeCar.makeCar();}
}1.2 工厂方法模式
（1）基本介绍
a.工厂方法模式：定义一个创建对象的抽象方法，由子类决定要实例化的类，工厂方法模式将对象的实例化推迟到子类。
（2）代码展示
1.跟简单工厂模式一样
package com.pattern.设计模式.工厂模式和抽象工厂模式.工厂方法模式;public abstract class Car {private String name;public abstract void getCar();public void tyre(){System.out.println(name + "的轮胎");}public void frame(){System.out.println(name + "的车架");}public void engine(){System.out.println(name + "的引擎");}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Car{" +"name='" + name + '\'' +'}';}
}2.跟简单工厂模式一样，可增加
package com.pattern.设计模式.工厂模式和抽象工厂模式.工厂方法模式;public class ChinaBenzCar extends Car{@Overridepublic void getCar() {setName("中国的奔驰汽车");System.out.println("中国的奔驰汽车 准备制作");}
}3.跟简单工厂模式一样，可增加
package com.pattern.设计模式.工厂模式和抽象工厂模式.工厂方法模式;public class USABenzCar extends Car{@Overridepublic void getCar() {setName("美国的奔驰汽车");System.out.println("美国的奔驰汽车 准备制作");}
}4.制作
package com.pattern.设计模式.工厂模式和抽象工厂模式.工厂方法模式;import java.util.Scanner;public abstract class MakeCar {// 定义一个抽象方法，让各个工厂子类自己去实现abstract Car createCar(String log);// 构造器public MakeCar(){Car car = null;String log; // 制作的车品牌do {log = getLog();car = createCar(log);if (car != null){car.getCar();car.tyre();car.frame();car.engine();}else {System.out.println("你输入的品牌不对");break;}} while (true);}public String getLog(){Scanner scanner = new Scanner(System.in);System.out.println("请输入要制作的品牌汽车:");String log = scanner.next();return log;}
}5.测试
package com.pattern.设计模式.工厂模式和抽象工厂模式.工厂方法模式;public class Test {public static void main(String[] args) {// 创建中国的车
// new ChinaMakeCar();// 创建美国的汽车new USAMakeCar();}
}2.抽象工厂模式
（1）基本介绍
a.抽象工厂模式：定义了一个interface用于创建相关或有依赖关系的对象簇，而无需知名具体的类。b.抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合c.抽象工厂模式就是对简单工厂模式的改进d.将工厂抽象成两层，absfactory（抽象工厂）和具体实现的工厂子类，程序员可以根据创建对象类型使用对应的工厂子类，这样将单个的简单工厂类变成了工厂簇。更利于代码的维护和扩展。
（2）代码展示
1.还是Car类
package com.pattern.设计模式.工厂模式和抽象工厂模式.抽象工厂模式;public abstract class Car {private String name;public abstract void getCar();public void tyre(){System.out.println(name + "的轮胎");}public void frame(){System.out.println(name + "的车架");}public void engine(){System.out.println(name + "的引擎");}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Car{" +"name='" + name + '\'' +'}';}
}2.中国奔驰类(可增加)
package com.pattern.设计模式.工厂模式和抽象工厂模式.抽象工厂模式;public class ChinaBenzCar extends Car{@Overridepublic void getCar() {setName("China");System.out.println("中国的奔驰汽车》》开始制作");}
}3.mg的类
package com.pattern.设计模式.工厂模式和抽象工厂模式.抽象工厂模式;public class USABenzCar extends Car{@Overridepublic void getCar() {setName("USA");System.out.println("美国的奔驰汽车》》开始制作");}
}4.创建一个抽象工厂
package com.pattern.设计模式.工厂模式和抽象工厂模式.抽象工厂模式;public interface AbsFactory {public Car createCar(String log);
}5.制作
package com.pattern.设计模式.工厂模式和抽象工厂模式.抽象工厂模式;import java.util.Scanner;public class MakeCar {AbsFactory absFactory;public MakeCar(AbsFactory absFactory){setAbsFactory(absFactory);}private void setAbsFactory(AbsFactory absFactory){Car car = null;String log = "";this.absFactory = absFactory;do {log = getLog();car = absFactory.createCar(log);if (car != null){car.getCar();car.tyre();car.frame();car.engine();}else {System.out.println("输入有误:");break;}}while (true);}public String getLog(){Scanner scanner = new Scanner(System.in);System.out.println("请输入:");String log = scanner.next();return log;}
}6.测试
package com.pattern.设计模式.工厂模式和抽象工厂模式.抽象工厂模式;public class Test {public static void main(String[] args) {new MakeCar(new ChinaMakeCar());}
}3.总结
（1）工厂模式的意义
a.将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展的维护性
(2) 根据的是设计模式的依赖抽象原则
a.创建对象实例时，不要直接new类，而是把这个new类的动作放在一个工厂的方法中，并返回，有的书上说，变量不要直接持有具体类的引用b.不要让类继承具体类，而是继承抽象类或者是实现接口c.不要覆盖基类中已经实现的方法
PS:JDK在Calendar类中的getInstance，使用了简单工厂模式
4.原型模式
4.1 原型模式
(1) 基本介绍
①原型模式（Prototype）：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象②原型模式是一种创建型设计模式，允许一个对象可以再创建另外一个可定制的对象，无需知道如何创建的细节③工作原理：通过将一个原型对象传给那个要发动创建的对象，这个要发动的对象通过请求原型对象拷贝它们自己来实现创建，即对象。Clone()④在Spring中原型模式bean的创建就用到了原型模式
4.2 浅拷贝
(1) 浅拷贝的介绍
①对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值赋值一份新的对象②对于数据是引用数据类型的成员变量。那么浅拷贝会进行引用传递。也就是将该成员变量的引用值赋值给新的对象，因为实际上两个对象的成员变量都指向同一个实例，在这中情况下，在一个对象中修改该成员变量的值，会影响到另一个对象的成员变量的值③浅拷贝是使用默认的clone()方法来实现拷贝的.
（2）代码展示
1.重写clone()是关键
package com.pattern.设计模式.原型模式.浅拷贝;public class Car implements Cloneable{private String name;private Integer id;private String colour;public Car() {}public Car(String name, Integer id, String colour) {this.name = name;this.id = id;this.colour = colour;}public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getColour() {return colour;}public void setColour(String colour) {this.colour = colour;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Car{" +"name='" + name + '\'' +", id=" + id +", colour='" + colour + '\'' +'}';}// 重写clone()方法@Overrideprotected Object clone() throws CloneNotSupportedException {Car car = null;car = (Car) super.clone();return car;}
}2.测试类
package com.pattern.设计模式.原型模式.浅拷贝;import java.util.ArrayList;
import java.util.List;public class Test {public static void main(String[] args) throws CloneNotSupportedException {Car car = new Car("宝马", 12138, "红色");System.out.println(car);Car car1 = (Car) car.clone();Car car2 = (Car) car.clone();Car car3 = (Car) car.clone();Car car4 = (Car) car.clone();System.out.println(car1);System.out.println(car == car1);List<Car> list = new ArrayList<>();list.add(car1);list.add(car2);list.add(car3);list.add(car4);System.out.println(list);}
}4.3 深拷贝
(1) 深拷贝的介绍
①赋值对象的所有基本数据类型的成员变量值②为所有引用数据类型的成员变量申请储存空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象，也就是说，对象深拷贝要对整个对象进行拷贝③深拷贝实现方法1：重写clone()方法④深拷贝实现方法2：通过对象序列化
（2）代码展示
1.Tyre类
package com.pattern.设计模式.原型模式.深拷贝;import java.io.Serializable;public class Tyre implements Serializable, Cloneable {private static final Long serialVersionUID = 1L;private String name;public Tyre() {}public Tyre(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Tyre{" +"name='" + name + '\'' +'}';}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}2.Car类
package com.pattern.设计模式.原型模式.深拷贝;import java.io.*;public class Car implements Serializable, Cloneable {private static final Long serialVersionUID = 1L;private String log;private Tyre tyre;public Car() {}public Car(String log, Tyre tyre) {this.log = log;this.tyre = tyre;}public String getLog() {return log;}public void setLog(String log) {this.log = log;}public Tyre getTyre() {return tyre;}public void setTyre(Tyre tyre) {this.tyre = tyre;}@Overridepublic String toString() {return "Car{" +"log='" + log + '\'' +", tyre=" + tyre +'}';}// 方式1 深拷贝 重写clone()方法@Overrideprotected Object clone() throws CloneNotSupportedException {// 基本数据类型直接cloneObject d = null;d = super.clone();// 对引用数据类型单独拿出来cloneCar car = (Car) d;car.tyre = (Tyre) tyre.clone();return car;}// 方式2 深拷贝 通过对象的序列化实现public Object getClone() throws IOException, ClassNotFoundException {// 创建流对象ByteArrayOutputStream byteArrayOutputStream = null;ObjectOutputStream objectOutputStream = null;ByteArrayInputStream byteArrayInputStream = null;ObjectInputStream objectInputStream = null;// 序列化byteArrayOutputStream = new ByteArrayOutputStream();objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);objectOutputStream.writeObject(this); // 当前对象以对象流的方式输出// 反序列化byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());objectInputStream = new ObjectInputStream(byteArrayInputStream);Car car = (Car) objectInputStream.readObject();return car;}}3.测试类
package com.pattern.设计模式.原型模式.深拷贝;import java.io.IOException;public class Test {public static void main(String[] args) throws CloneNotSupportedException, IOException, ClassNotFoundException {Car car = new Car();car.setLog("奔驰");car.setTyre(new Tyre("轮胎"));// 方式1 深拷贝
// Car car1 = (Car) car.clone();
// System.out.println(car);
// System.out.println(car1);
// System.out.println(car.hashCode());
// System.out.println(car1.hashCode());// 方式2 深拷贝Car car2 = (Car) car.getClone();System.out.println(car);System.out.println(car2);System.out.println(car.hashCode());System.out.println(car2.hashCode());}
}5.建造者模式
建造者模式 等等
Java设计模式（工厂模式＞抽象工厂模式和原型模式）相关推荐
- java设计模式六（抽象工厂模式）
java设计模式-抽象工厂模式 一.概述 抽象工厂模式是在工厂模式的基础上,加上了一个管理工厂的超级工厂.也就是说,工厂的作用是管理各种有相似功能的类,而超级工厂的作用是管理这些工厂. 二.模式示例: ...
- 【四】Java设计模式GOF23之抽象工厂模式
目录 CarFactory.java public interface CarFactory {Engine createEngine();Seat createSeat();Tyre createT ...
- Java设计模式—工厂方法模式抽象工厂模式
工厂方法模式与抽象工厂模式都是设计模式中重要而且常见的模式. 工厂方法模式:定义一个用于创建对象的接口,让子类决定实例化哪一个类.工厂方法使一个类的实例化延迟到其子类. 通用类图如下: 在 ...
- Java描述设计模式(04)：抽象工厂模式
一.抽象工厂模式 1.生活场景 汽车生产根据用户选择的汽车类型,指定不同的工厂进行生产,选择红旗轿车,就要使用中国工厂,选择奥迪轿车,就要使用德国工厂. 2.抽象工厂模式 抽象工厂模式:定义了一个in ...
- Java设计模式（1）工厂模式（Factory模式）
工厂模式定义:提供创建对象的接口. 为何使用工厂模式 工厂模式是我们最常用的模式了,著名的Jive论坛,就大量使用了工厂模式,工厂模式在Java程序系统可以说是随处可见. 为什么工厂模式是如此常用?因 ...
- （创建模式 上）设计模式——工厂、抽象工厂 C++/Python3实现
简介 设计模式是为了解决一些出现的问题设计的解决方案.是长时间经验的总结,是根据不同问题从而提出并且实践出来的解决办法.使用不同的设计模式可以解决不同的问题. 设计模式可以分为三种大类别:分别是创建型 ...
- 设计模式学习笔记——抽象工厂(Abstract Factory)模式
设计模式学习笔记--抽象工厂(Abstract Factory)模式 @(设计模式)[设计模式, 设计模式中文名, 设计模式英文名] 设计模式学习笔记抽象工厂Abstract Factory模式 基本 ...
- 研磨23种大话设计模式------简单工厂模式 + 工厂方法模式 + 抽象工厂模式
大家好,我是一位在java学习圈中不愿意透露姓名并苟且偷生的小学员,如果文章有错误之处,还望海涵,欢迎多多指正 如果你从本文 get 到有用的干货知识,请帮忙点个赞呗,据说点赞的都拿到了offer 简 ...
- 设计模式二、抽象工厂模式
设计模式part2 1. 抽象工厂模式 工厂方法模式有一个问题就是,类的创建依赖工厂类,也就是说,如果想要拓展程序,必须对工厂类进行修改,这违背了闭包原则,所以,从设计角度考虑,有一定的问题, ...
- JAVA设计模式之3种工厂模式
转自 JAVA设计模式之3种工厂模式 创建型模式 创建型模式(Creational Pattern)对类的实例化过程进行了抽象,能够将软件模块中对象的创建和对象的使用分离.为了使软件的结构更加清晰,外 ...
最新文章
- mysql dba系统学习（10）innodb引擎的redo log日志的原理 mysql dba系统学习（11）管理innodb引擎的redo log日志的一个问题
- sp_updatestats和update statistics的区别
- 三、操作系统——生产者-消费者问题（两个同步一个互斥）
- python---字符编码
- Android_Service组件详解
- 旷视科技Face++进军机器人业务
- MATLAB模糊控制解析及simulink仿真示例（附fis代码和simulink仿真slx文件以及文件使用视频）
- k均值聚类算法原理和TensorFlow实现
- 经纬度转化为xy坐标系_Arcgis添加经纬度矢量点
- 工作感想-软件测试工程师
- 从期刊层面看科研！计算机顶级期刊大盘点（上）
- 基于Python-OpenCV的图片覆盖技术——即把一个图片P到另一个图片上
- 从军事走向民用，惯导定位能否破解室内导航难题？
- ZTree学习(三)，ztree树扩展
- 信息安全系统设计基础期中总结
- 如何理解广义线性回归分析Logistic输出的OR值？
- 软件测试工程师如何优雅的“甩锅”
- 艾乐云后台伪装404恶搞页，后台恶搞伪装单页
- 【大厂面试】三面三问Spring循环依赖，请一定要把这篇看完（建议收藏）
- 三、IDEA+Docker-Compose的简单使用