如何网站建设平台,wordpress文件详解,中华门窗网怎么做网站,wordpress优惠代码目录
主要参考文章
设计模式的目的
设计模式的七大原则
设计模式的三大分类及关键点
1、创建型模式#xff08;用于解耦对象的实例化过程#xff09;
2、结构型模式
3、行为型模式
23种设计模式#xff08;乱序--现学现写#xff0c;不全面--应付面试为主#xff…目录
主要参考文章
设计模式的目的
设计模式的七大原则
设计模式的三大分类及关键点
1、创建型模式用于解耦对象的实例化过程
2、结构型模式
3、行为型模式
23种设计模式乱序--现学现写不全面--应付面试为主
单例模式
模板模式
哈哈哈哈哈 声明
此文只针对我个人的目前的理解程度来记录的有的我知道的或者觉得没有必要写的内容我就会省略掉。并且主要针对面试介绍的可能不是很全面甚至有的地方不是很正确请包涵。
主要参考文章
设计模式23模式介绍-CSDN博客
12-模板方法模式_12(模板方法模式)-CSDN博客
设计模式的目的
可重用性 (即相同功能的代码不用多次编写)可扩展性 (即当需要增加新的功能时非常的方便称为可维护)可靠性 (即当我们增加新的功能后对原来的功能没有影响)可读性 (即编程规范性, 便于其他程序员的阅读和理解)使程序呈现高内聚低耦合的特性。
设计模式的七大原则
固定记忆单 开 里 依 接 合 迪。 设计模式的三大分类及关键点 1、创建型模式用于解耦对象的实例化过程
单例模式某个类只能有一个实例提供一个全局的访问点。工厂模式一个工厂类根据传入的参量决定创建出哪一种产品类的实例。抽象工厂模式创建相关或依赖对象的家族而无需明确指定具体类。建造者模式封装一个复杂对象的创建过程并可以按步骤构造。原型模式通过复制现有的实例来创建新的实例。
2、结构型模式
装饰器模式动态的给对象添加新的功能。代理模式不修改原始对象通过代理对象来间接访问原始对象并在访问前后执行额外的操作。桥接模式将抽象部分和它的实现部分分离使它们都可以独立的变化。适配器模式将一个类的方法接口转换成客户希望的另一个接口。组合模式将对象组合成树形结构以表示“部分-整体”的层次结构。外观模式对外提供一个统一的方法来访问子系统中的一群接口。享元模式通过共享技术来有效的支持大量细粒度的对象。
3、行为型模式
策略模式定义一系列算法把他们封装起来并且使它们可以相互替换。模板模式抽象父类定义一个算法子类在不改变该算法结构的情况下重定义该算法的某些步骤。命令模式将命令请求封装为一个对象使得可以用不同的请求来进行参数化。迭代器模式一种遍历访问聚合对象中各个元素的方法不暴露该对象的内部结构。观察者模式对象间的一对多的依赖关系。仲裁者模式用一个中介对象来封装一系列的对象交互。备忘录模式在不破坏封装的前提下保持对象的内部状态。解释器模式给定一个语言定义它的文法的一种表示并定义一个解释器。建造者模式允许一个对象在其对象内部状态改变时改变它的行为。责任链模式将请求的发送者和接收者解耦使的多个对象都有处理这个请求的机会。访问者模式不改变数据结构的前提下增加作用于一组对象元素的新功能。 23种设计模式乱序--现学现写不全面--应付面试为主
单例模式--创建型
某个类只能有一个实例提供一个全局的访问点。 单例模式要素 私有构造方法私有静态引用指向自己实例 以自己实例为返回值的公有静态方法 单例模式好处 单例模式只允许创建一个对象因此节省内存避免了频繁的对象创建可以加快对象访问速度。 单例模式场景 需要频繁实例化然后销毁的对象创建对象时耗时过多或者耗资源过多但又经常用到的对象有状态的工具类对象 单例模式的实现方式分类 饿汉式单例 //线程安全的
public class Singleton {//单例模式构造器要私有化。private Singleton() {}//私有的静态的常量--私有静态引用指向自己实例。//【因为是static修饰的属性所以是在类加载的时候就被创建//后期不会再改变所以线程是安全的】private static final Singleton single new Singleton();//以自己实例为返回值的公有静态方法。public static Singleton getInstance() {return single;}
} 懒汉式单例 //有线程安全的问题不推荐使用
//就算是使用了[加锁双重判断]的解救办法性能还是被损耗了。
public class SingletonTest {public static SingletonTest singleton null;public static SingletonTest getInstance(){if(singleton null){singleton new SingletonTest();}return singleton;}//单例模式构造器要私有化private SingletonTest {}
} DCLDouble Check双重判断 Lock加锁懒汉式单例但线程安全推荐使用 //线程安全的
public class Singleton {private volatile static Singleton singleton;public static Singleton getSingleton(){//双重判断之一if(singletonnull){//加锁synchronized (Singleton.class) {//双重判断之二if (singleton null) {singleton new Singleton();}}}return singleton;}//构造函数私有化private Singleton(){}
} 静态内部类懒汉式单例但线程安全 //线程安全的
//外部类加载时并不需要立即加载内部类内部类不被加载则不去初始化INSTANCE故而不占内存。
//第一次调用getInstance()方法会导致虚拟机加载SingleTonHoler类且初始化INSTANCE。
//在创建时是否有并发问题 没有没有类加载时jvm会保证线程安全性
public class Singleton {//静态内部类private static class SingleTonHoler{private static Singleton INSTANCE new Singleton();}public static Singleton getInstance(){return SingleTonHoler.INSTANCE;}//单例模式构造器要私有化private Singleton {}
} 枚举类饿汉式 //枚举单例属于懒汉式还是饿汉式:饿汉式内部枚举类相当于静态成员变量
//类加载时就会创建因此也是线程安全的。
public class SingletonObject7 {private SingletonObject7(){}/*** 枚举类型是线程安全的并且只会装载一次*/private enum Singleton{INSTANCE;private final SingletonObject7 instance;Singleton(){instance new SingletonObject7();}private SingletonObject7 getInstance(){return instance;}}public static SingletonObject7 getInstance(){//内部枚举类相当于静态成员变量return Singleton.INSTANCE.getInstance();}
} 破坏单例模式的场景及解决办法 1、反射是通过调用构造方法生成新对象的除枚举方式外其他方式都会被反射破坏单例所以如果我们想要阻止单例破坏可以在构造方法中进行判断若已有实例则阻止生成新的实例解决办法如下。 private SingletonObject(){if (instance ! null) {throw new RuntimeException(实例已经存在请通过 getInstance()方法获取);}
} 2、如果单例类实现了序列化接口Serializable 就可以通过反序列化破坏单例反序列化不会调用构造函数--反序列化会用到反射但不是通过反射调用构造函数而是ObjectInputStream类的私有的readObject()方法--使用ObjectInputStream.readObject()读取进来之后如果是多次读取就会创建多个实例所以我们可以不实现序列化接口如果非得实现序列化接口可以在单例类中定义反序列化方法readResolve()在反序列化时直接返回单例对象。 import java.io.Serializable;// Singleton Box:
class Box implements Serializable {private static Box instance new Box(TEST);public static Box getInstance() {return Box.instance;}private Box(String name) {this.name name;}private String name;Overridepublic String toString() {return Box name;}//【readResolve()方法】如果不写此方法反序列化时会破坏单例private Object readResolve() {return Box.getInstance();}
} import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;public class Foo {public static void main(String[] args) {Box box Box.getInstance();System.out.println(box.toString());try {ObjectOutputStream o new ObjectOutputStream(new FileOutputStream(e:/box.out));o.writeObject(box);o.close();} catch(Exception e) {e.printStackTrace();}Box box1 null, box2 null;try {ObjectInputStream in new ObjectInputStream(new FileInputStream(e:/box.out));box1 (Box)in.readObject();in.close();} catch(Exception e) {e.printStackTrace();}try {ObjectInputStream in new ObjectInputStream(new FileInputStream(e:/box.out));box2 (Box)in.readObject();in.close();} catch(Exception e) {e.printStackTrace();}System.out.println(box1.equals(box2) : box1.equals(box2));System.out.println(box1);System.out.println(box2);}
} 模板模式--行为型
抽象父类定义一个算法子类在不改变该算法结构的情况下重定义该算法的某些步骤。 算法的整体步骤很固定但其中个别部分易变时这时候可以使用模板方法模式将相同部分的代码放在抽象的父类中而将不同的代码放入不同的子类中提高了代码复用性。 自定义lamabda表达式也符合此设计模式。 案例炒菜的步骤是固定的分为倒油、热油、倒蔬菜、倒调料品、翻炒等步骤。 /*** ClassName: AbstractClass* Description: 抽象类定义模板方法和基本方法* Author: Sevenyear*/
public abstract class AbstractClass {//模板方法定义//【为防止恶意操作模板方法一般都加上 final 关键词】public final void cookProcess() {pourOil();heatOil();pourVegetable();pourSauce();fry();}public void pourOil() {System.out.println(倒油);}//第二步热油是一样的所以直接实现public void heatOil() {System.out.println(热油);}//第三步倒蔬菜是不一样的一个下包菜一个是下菜心public abstract void pourVegetable();//第四步倒调味料是不一样public abstract void pourSauce();//第五步翻炒是一样的所以直接实现public void fry(){System.out.println(炒啊炒啊炒到熟啊);}
}
/*** ClassName: ConcreteClass_BaoCai* Description: 炒包菜类* Author: Sevenyear*/
public class ConcreteClass_BaoCai extends AbstractClass {Overridepublic void pourVegetable() {System.out.println(下锅的蔬菜是包菜);}Overridepublic void pourSauce() {System.out.println(下锅的酱料是辣椒);}
}
/*** ClassName: ConcreteClass_BaoCai* Description: 炒菜心类* Author: Sevenyear*/
public class ConcreteClass_CaiXin extends AbstractClass {Overridepublic void pourVegetable() {System.out.println(下锅的蔬菜是菜心);}Overridepublic void pourSauce() {System.out.println(下锅的酱料是蒜蓉);}
}
public class Client {public static void main(String[] args) {//炒包菜//创建对象ConcreteClass_BaoCai baoCai new ConcreteClass_BaoCai();//调用炒菜的功能baoCai.cookProcess();}
}jdk案例InputStream抽象父类中已经定义好了读取字节数组数据的方法是每次读取一个字节并将其存储到数组的第一个空闲索引位置循环读取len个字节数据。具体如何读取一个字节数据是由子类实现的。
public abstract class InputStream implements Closeable {//抽象方法要求子类必须重写public abstract int read() throws IOException;public int read(byte b[]) throws IOException {return read(b, 0, b.length);}public int read(byte b[], int off, int len) throws IOException {if (b null) {throw new NullPointerException();} else if (off 0 || len 0 || len b.length - off) {throw new IndexOutOfBoundsException();} else if (len 0) {return 0;}int c read(); //调用了无参的read方法该方法是每次读取一个字节数据if (c -1) {return -1;}b[off] (byte)c;int i 1;try {for (; i len ; i) {c read();if (c -1) {break;}b[off i] (byte)c;}} catch (IOException ee) {}return i;}
}
在InputStream类中定义了多个 read() 方法从上面代码可以看到无参的 read() 方法是抽象方法要求子类必须实现。而 read(byte b[]) 方法调用了 read(byte b[], int off, int len) 方法所以在此处重点看的方法是带三个参数的方法。 在该方法中可以看到调用了无参的抽象的 read() 方法。 享元模式--结构型
java常量池字符串常量池、Integer常量池的实现其实是基于享元模式通过共享技术来有效的支持大量细粒度的对象的思想可以节省创建的时间并且节省空间。
字符串常量池在java1.8中是在Java堆中的。在编译期就存在的字符串将会直接存入这个池中在不同代码地方的字面量形式的相同的字符串将会直接引用同一个字符串为什么能这样引用是因为字符串的不可变性。 策略模式--行为型
comparable和comparator
