设计模式的目的
是为了让程序,具有更好的
代码重用性,
可读性,
可靠性,
使程序呈现高内聚,低耦合的特性。
设计模式包含了面向对象的精髓,“懂了设计模式,你就懂了面向对象分析和设计(OOA/D)的精要”
设计模式七大原则
设计模式原则,其实就是程序员在编程时,应当遵守的原则,也是各种设计模式的基础(即:设计模式为什么这样设计的依据)
1.单一职责原则
对类来说,即一个类应该只负责一项责任。如类A负责两个不同的职责:职责1,职2
当职责1需要变更而改变A时,可能造成职责1执行错误,所以需要将类A的粒度分
为A1,A2
注意与细节:
- 降低类的复杂度,一个类只负责一项职责。
- 提高类的可读性,可维护性
- 降低变更引起的风险
- 通常情况下,我们应当遵守单一职责原则,只有逻辑足够简单,才可以在代码级违反单一职责原则:只有类方法数量足够少,可以在方法级别保持单一职责原则。
2.接口隔离原则
客户端不用管依赖它不需要的接口,即一个类对另一个类的依赖应该建立在最小的接口上
实例:
类A通过接口Interfacel依赖(使用)B,类C通过接口Interfacel依赖类D,如果接口Interfacel对于类A和类C来说不是最小接口,那么类B和类D必须去实现他们不需要的方法。
按隔离原则应当这样处理:
将接口Interfacel拆分为独立的几个接口,类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则
3.依赖倒转(倒置)原则
- 高层模块不应该依赖底层模块,二者都应该依赖其抽象
- 抽象不应该依赖细节,细节应该依赖抽象
- 依赖倒转的中心思想是面向接口编程
- 依赖倒转原则是基于这样的设计理念:相对于细节的多变性,抽象的东西要稳定的 多。以抽象为基础搭建的架构比细节为基础搭建的架构要稳定的多。在java中,抽象指的是接口或抽象类,细节就是具体的实现。
- 使用接口或抽象类的目的是指定好规范,而不涉及任何具体的操作,把展现细节的任务交给他们的实现类去完成
实现的方法:
- 通过接口实现依赖传递
- 通过构造方法实现依赖传递
- 通过setter方法实现依赖传递
依赖倒转原则的注意事项和细节:
- 底层模块尽量都要有抽象类或接口,或两者都有,程序稳定性更好。
- 变量的声明类型尽量是抽象类或接口,这样我们的变量引用和实际对象间,就存在一个缓冲层,利于程序扩展和优化。
- 继承时遵循里氏替换原则。
4.里氏替换原则
OO中的继承性的思考和说明
如何正确的使用继承 ==》里氏替换原则
基本介绍:
- 里氏替换原则,在1988年,由麻省理工学院的以为姓里的女士提出的。
- 如果对每个类型为T1的对象o1,都有类型为T2对象的o2,使得以T1定义的所有程序P在所有的对象哦都代换成o2时,程序P的行为没有发生改变,那么类型T2是类型T1的子类型,换句话说所有引用基类的地方必须能透明地使用其子类的对象。
- 在使用继承时,遵循历史替换原则,在子类中尽量不要重写父类的方法
- 里氏替换原则告诉我们,继承实际上让两个类耦合性增强了,在适当的情况下,可以通过聚合,组合,依赖来解决问题
5.开闭原则
基本介绍:
- 开闭原则是编程中最基础,最重要的设计原则
- 一个软件实体如类,模块和函数应该对扩展开发(对提供方),对修改关闭(对使用方)。用抽象构建框架,用实现扩展细节。
- 当软件需要变化时,尽量通过扩展软件实体的行为来实现变化,而不是通过修改已有的代码来实现变化。
- 编程中遵循其他原则,以及使用设计模式的目的就是遵循开闭原则。
6.迪米特法则
基本介绍:
- 一个对象应该对其他对象保持最少的了解
- 类与类关系越密切,耦合度越大
- 迪米特法则(Demeter Principle)又叫最少知道原则,即一个类对自己依赖的类知道的越少越好。也就是说,对于被依赖的类不管多么复杂,都尽量将逻辑封装在类部。对外除了提供public方法,不对外泄露任何信息
- 迪米特法则还有个更简单的定义:只与直接的朋友通信
- 直接的朋友:每个对象都会与其他对象有耦合关系,只要两个对象之间有耦合关系,我们就说这两个对象之间是朋友关系。耦合的方式很多,依赖,关联,组合,聚合等。其中,我们称出现成员变量,方法参数,方法返回值中的类为直接的朋友,而出现在局部变量中的类不是直接的朋友,也就是说,陌生的类最好不要以局部变量的形式出现在类的内部
迪米特法则注意事项和细节:
- 迪米特法则的核心是降低类之间的耦合
- 但是注意:由于每个类都减少不必要的依赖,因此迪米特法则只是要求降低类间(对象间)耦合关系,并不是要求完全没有依赖关系
7.合成复用原则
基本介绍:
原则是尽量使用合成/聚合的方式,而不是使用继承
设计原则核心思想
- 找出应用可能需要变化之处,把它们独立出来,不要和那些不需要变化的代码混在一起。
- 针对接口编程,而不是针对实现编程。
- 为了交互对象之间的松耦合设计而努力
设计模式类型
设计模式分为三种类型,共23种
- 创建型模式:单列模式,抽象工厂模式,原型模式,建造者模式,工厂模式。
- 结构型模式:适配器模式,桥接模式,装饰模式,组合模式,外观模式,享元模式,代理模式
- 行为型模式:模板方法模式,命令模式,访问者模式,迭代器模式,观察者模式,中介者模式,备忘录模式,解释器模式(Interpreter模式),状态模式,策略模式,职责链模式(责任链模式)
注意:不同的书籍上对分类和名称略有差别
JAVA设计模式
一 单例设计模式
单例设计模式介绍
所谓类的单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某个只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法。(静态方法)
比如Hibernate的SessionFactory,它充当数据存储源的代理,并负责创建Session对象。SessionFactory并不是轻量级的,一般情况下,一个项目通常只需要一个SessionFactory就够,这就会使用到单例模式。
单例模式有八种方式:
- 饿汉式(静态变量) 可用
- 饿汉式(静态代码块) 可用
- 懒汉式(线程不安全) 不推荐
- 懒汉式(线程安全,同步方法)效率低
- 懒汉式(线程安全,同步代码块)
- 双重检查 推荐
- 静态内部类 推荐
- 枚举 推荐
饿汉式(静态常量)
步骤如下:
- 构造器私有化(防止 new)
- 类的内部创建对象
- 向外暴露一个静态的公共方法。getInstance()
- 代码实现
public class SingletonTest01 { public static void main(String[] args) { //测试 Singleton instance = Singleton.getInstance(); Singleton instance2 = Singleton.getInstance(); System.out.println(instance == instance2); // true System.out.println("instance.hashCode=" + instance.hashCode()); System.out.println("instance2.hashCode=" + instance2.hashCode()); } } //饿汉式(静态变量) class Singleton { new private Singleton() {} 本类内部创建对象实例 private final static Singleton instance = new Singleton(); 提供一个公有的静态方法,返回实例对象 public static Singleton getInstance() { return instance;} }
优缺点:
- 优点:这种写法比较简单,就是在类装载的时候就完成实例化。避免了线程同步问题。
- 缺点:在类装载的时候就完成实例化,没有达到Lazy Loading的效果。如果从始至终未使用过这个实例,则会造成内存浪费
- 这种方法基于classloder机制避免了多线程同步问题,不过,instance在类装载时就实例化,在单例模式中大多数都是调用getInstance方法,但是导致类装载的原因有很多种,因此不能确定有其他方法(或者其他的静态方法)导致类装载,这时候初始化Instance就没有达到lazy loading的效果
结论: 这种单列模式可用,可能造成内存浪费
饿汉式(静态代码块)
优缺点:
- 这种方式和上面的方式其实类似,只不过将类实例化的过程放在了静态代码块中,也是在类装载的时候,就执行静态代码块中的代码,初始化类的实例。优缺点和上面是一样的。
- 代码实现
public class SingletonTest02 { public static void main(String[] args) { //测试 Singleton instance = Singleton.getInstance(); Singleton instance2 = Singleton.getInstance(); System.out.println(instance ==instance2);// true System.out.println("instance.hashCode=" + instance.hashCode()); System.out.println("instance2.hashCode=" + instance2.hashCode()); } } //饿汉式(静态变量) class Singleton { //1. 构造器私有化, 外部能 new private Singleton() {} //2.本类内部创建对象实例 private static Singleton instance; static { // 在静态代码块中,创建单例对象 instance = new Singleton(); } //3. 提供一个公有的静态方法,返回实例对象 public static Singleton getInstance() { return instance;} }
- 优缺点说明:
- 这种方式和上面的方式其实类似,只不过将类实例化的过程放在了静态代码块中,也是在类装载的时候,就执行静态代码块中的代码,初始化类的实例。优缺点和上面是一样的。
- 结论:这种单例模式可用,但是可能造成内存浪费
懒汉式(线程不安全)
- 代码演示:
public class SingletonTest03 {
public static void main(String[] args) {
System.out.println("懒汉式 1 , 线程不安全~"); Singleton instance = Singleton.getInstance(); Singleton instance2 = Singleton.getInstance(); System.out.println(instance == instance2); // true
System.out.println("instance.hashCode=" + instance.hashCode()); System.out.println("instance2.hashCode=" + instance2.hashCode());
}
}
class Singleton {
private static Singleton instance;
private Singleton() {}
//提供一个静态的公有方法,当使用到该方法时,才去创建 instance
//即懒汉式
public static Singleton getInstance() { if(instance == null) {
instance = new Singleton();
}
return instance;
}
}
- 优缺点说明:
- 起到了 Lazy Loading 的效果,但是只能在单线程下使用。
- 如果在多线程下,一个线程进入了 if (singleton == null)判断语句块,还未来得及往下执行,另一个线程也通过了这个判断语句,这时便会产生多个实例。所以在多线程环境下不可使用这种方式
- 结论:在实际开发中,不要使用这种方式.