适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。
适配器模式很好理解,实现起来也很简单.主要是我们要怎么实现,实现方式的不同,决定了该模式的运用的好坏cuiyaonan2000@163.com
场景1需要调用A类的方法,但是a方法的入参是字符串,不能直接调用.所以使用适配器,做个简单的处理,来替代A
package nan.yao.cui.test;
/**
* @Author: cuiyaonan2000@163.com
* @Description: todo
* @Date: Created at 2022-6-6 9:38
*/
public class Test01 {
public class A{
public void doA(String temp){
System.out.println("the temp is :" + temp);
}
}
public interface Target {
public void doTarget(Integer i);
}
public class Adapter implements Target{
private A a;
public Adapter(A a){
this.a = a;
}
@Override
public void doTarget(Integer i) {
a.doA(i.toString());
}
}
}
场景2
官方的例子看着代码多,稍微绕一点.但是其实是适配器模式和工厂模式的整合.根据参数的来选择实例化哪个一个实现对象,来做操作cuiyaonan2000@163.com
https://www.runoob.com/design-pattern/adapter-pattern.html
原型模式原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能.
Object默认提供了clone()方法只能实现浅克隆，即只能将基本类型的值进行复制和引用类型的地址进行复制，没办法将引用类型指向的真正对象进行复制
浅克隆浅克隆很简单.只需要做如下两步就可以了
- 需要被克隆的类实现接口Cloneable
- 重写clone方法
- 在重写clone方法中调用super.clone() --------既然Object已经提供了clone方法,为什么我们不能直自己写个方法调用super.clone()呢cuiyaonan2000@163.com
查看Cloneable可以看到该接口没有方法(就是一个标记),
查看Object中的clone方法声明
综上所述了解到.Object的clone()方法 首先被protected修饰表明该方法只能在子类方法中调用,不能直接通过对象直接调用.
其次被native修饰表明该方法的实现不是使用的Java库,而是通过JNI的方式实现的.即不是java库实现的clone.
所以Cloneable接口只是一个标记,告诉JVM在实例化该对象的时候提供对应的JNI的实现.cuiyaonan2000@163.com
深克隆深克隆主要有三种方式
- 通过new的方式来解决
- 通过嵌套调用clone的方式来解决,---此方法就是说如果要被克隆的对象层级深和复杂的情况下代码比较多cuiyaonan2000@163.com
- 通过序列化和反序列化的方式来解决
这里主要对比下他们之间的效率问题
package nan.yao.cui.test;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
/**
* @Author: cuiyaonan2000@163.com
* @Description: todo
* @Date: Created at 2022-6-6 9:38
*/
public class Test01{
public static void main(String[] args) throws CloneNotSupportedException, IOException, ClassNotFoundException {
series();
newTest();
doclone();
}
public static void series() throws IOException, ClassNotFoundException {
long time = System.currentTimeMillis();
ListstudentList = new ArrayList<>(100000);
Student student_1 = new Student("小明",12, (byte) 1,new Teacher("小明老师",22));
for(int i =1 ; i <= 100000 ; i++){
//序列化
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
objectOutputStream.writeObject(student_1);
//反序列化
ByteArrayInputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
Student roomClone = (Student)objectInputStream.readObject();
studentList.add(roomClone);
}
System.out.print(studentList.size());
System.out.println("序列化 方法耗时"+(System.currentTimeMillis() - time));
}
public static void newTest(){
long time = System.currentTimeMillis();
ListstudentList = new ArrayList<>(100000);
for(int i =1 ; i <= 100000 ; i++){
Student student_1 = new Student("小明",12, (byte) 1,new Teacher("小明老师",22));
studentList.add(student_1);
}
System.out.print(studentList.size());
System.out.println("new 方法耗时"+(System.currentTimeMillis() - time));
}
public static void doclone() throws CloneNotSupportedException {
long time = System.currentTimeMillis();
ListstudentList = new ArrayList<>(100000);
Student student_1 = new Student("小明",12, (byte) 1,new Teacher("小明老师",22));
for(int i =1 ; i <= 100000 ; i++){
Student studentClone = student_1.clone();
Teacher teacherClone = student_1.getTeacher().clone();
studentClone.setTeacher(teacherClone);
studentList.add(studentClone);
}
System.out.print(studentList.size());
System.out.println("clone方法耗时"+(System.currentTimeMillis() - time));
}
}
结果显示如下所示:
综上所述,克隆模式是为了解决重复对象创建效率的问题,所以可以根据你的对象选择满足自己要求的方式cuiyaonan2000@163.com
工厂模式工厂模式 | 菜鸟教程
抽象工厂模式抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。
该超级工厂又称为其他工厂的工厂。
抽象工厂模式 | 菜鸟教程
模板模式此设计模式主要思想是:
- 把一些业务所共有的操作,设计成抽象模板方法.即提供一个抽象类,后使用final修饰一个方法来抽象子类所共有的操作.以减少代码沉余.-----这种的场景其实比较不适用cuiyaonan2000@163.com
- 某些业务的流程肯定是一样的,比如我们要去买东西,一定的流程是1:查找物品 2:检验是否满足要求 3:付钱 4:等收货 5收货. 这时使用模板模式,并使用一个final修饰的方法来 调用1,2,3,4,,5,6这6个抽象方法.而1,2,3,4,5,6则可以由它的子类去实现. 这种的模板模式更能体现它的使用场景cuiyaonan2000@163.com
针对2的场景的用例模板模式 | 菜鸟教程
命令模式命令模式主要思想是: 命令的调用者 不直接去调用 命令的实现者. 命令的实现者将自己的所有命令抽象城1对1的命令对象(比如命令实现者有3个实现方法,则对应3个命令对象). 然后把命令对象注入到命令的调用者那里. 这样就是把命令的调用者和命令实现者进行了解耦.cuiyaonan2000@163.com
package nan.yao.cui.test;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
/**
* @Author: cuiyaonan2000@163.com
* @Description: todo
* @Date: Created at 2022-6-6 9:38
*/
public class Test01{
public static interface Action{
public void execution();
}
public static class DrawAction implements Action{
private Boss boss;
@Override
public void execution() {
boss.draw();
}
public DrawAction(Boss boss) {
this.boss = boss;
}
}
public static class PayAciton implements Action{
private Boss boos;
public PayAciton(Boss boos) {
this.boos = boos;
}
@Override
public void execution() {
boos.pay();
}
}
public static class Boss{
public void draw(){
System.out.println("画饼");
}
public void pay(){
System.out.println("发工资");
}
}
public static class Worker{
private ListactionList = new ArrayList<>();
public ListgetActionList() {
return actionList;
}
public void setActionList(ListactionList) {
this.actionList = actionList;
}
}
public static void main(String[] args) throws Exception {
Boss boss = new Boss();
Action drawAction = new DrawAction(boss);
Action payAction = new PayAciton(boss);
Worker worker = new Worker();
//如此这般woker 可以不直接调用boss的方法,而是通过命令对象进行调用
ListactionList = new ArrayList();
actionList.add(drawAction);
actionList.add(payAction);
worker.setActionList(actionList);
}
}
代理模式
Java Proxy_cuiyaonan2000的博客-CSDN博客
观察者模式
