-
重用性（即：相同功能的代码，不用多次编写）
-
可读性（即：编程规范性，便于其他程序员的阅读和理解）
-
可扩展性（即：当要增加新的功能时，非常的方便.称为可维护）
-
可靠性（即：当我们增加新的功能后，对原来的功能没有影响）
-
使程序呈现高内聚.低耦合的特性
-
单一职责原则：对于类来说，一个类应该只负责一项职责。
-
通常情况下， 我们应当遵守单一职责原则 ，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则
-
接口隔离原则 ISP：一个类对另一个类的依赖，（中间）应该建立在最小的接口上；
-
当一个接口太大时，不需要实现接口的所有方法时，我们需要把他拆分成更小的接口，但不能违反单一职责原则。使用多个专门的接口，不使用单一的总接口。
- 面向接口编程，抽象不依赖于细节，细节应依赖于抽象。
- 抽象：可以看成接口或者抽象类；细节：具体的实现类；接口：其实就是一组规范；
- 引用基类的地方必须能透明的使用其子类的对象
- 在子类中尽量不要重写父类方法（继承实际上让两个类耦合性增强了）
解决方法：将原来的父类和子类都继承一个基类，原有的继承关系去掉，采用依赖、聚合和组合等关系替代
- 组合：在原来子类B中创建一个父类对象 private A a=new A(); 变量的声明类型尽量是抽象类或接口
- 对扩展开放（提供方），对修改关闭（使用方）；
- 当需求变化或者要增加新的功能时尽量不改变原来的代码，而是通过增加代码来实现（也就是扩展）
- 一个对象应当尽量少的与其他对象发生相互作用 最少知道原则
- 类与类的关系越密切，耦合度越大。
- 只和直接的对象通信—>在A中有B的成员对象、在A的方法里面，对象B作为A方法的参数或者在A中的方法，该方法返回值是对象B—这样我们称A和B是直接对象
- 陌生类不要作为局部变量出现
- 尽量使用合成或聚合的方式，而不是继承；
- 就是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分，新的对象通过这些对象的委派达到复用已有功能的目的
1、依赖关系：在类中使用了对方
- 是类的成员属性
- 是类的方法参数类型
- 是类的方法的返回值
2、泛化关系：是依赖关系的特例，其实就是继承关系
3、实现关系：是依赖关系的特例，A类实现B类或者一个类实现接口
4、关联关系：单向一对一（你中有我，我中无你） 双向一对一（你中有我，我中有你） 类与类之间的联系
5、聚合关系：表示整体和部分的关系 ，整体和部分可以分离（private A a；）
- 一个类里面有一个或多个对象变量，称为单聚合或多聚合
6、组合关系：表示整体和部分的关系 ，整体和部分不可以分离（ private A a=new A() ）
- 一个类里面创建new了多个类变量
在整个软件系统中，对某个类只存在一个对象实例，并且该类只提供一个取得对象实例的方法(静态方法)
- 饿汉式（静态常量）–可使用
class Singleton{
// 1、构造器私有化（防止new 外部不能通过new得到对象实例）
private Singleton(){}
// 2、类的内部创建对象
private final static Singleton instance=new Singleton();
//3、提供一个外部可访问的静态公共方法：getInstance
public static Singleton getInstance(){
return instance;
}
}
优点：简单，在类加载时就已经完成了实例化，也就是创建好了对象，避免了线程同步问题
缺点：在类加载时就已经完成了实例化，没有达到懒加载（Lazy Loading）的效果,如果该类从始至终就没有使用过，就会造成内存的浪费。
- 饿汉式（静态代码块） ：优缺点同上一样
class Singleton{
//1、构造器私有化（防止new 不能通过new得到对象实例）
private Singleton(){}
private static Singleton instance;
//2、静态代码块中，创建单例对象
static {
instance=new Singleton();
}
//3、提供一个外部可访问的静态公共方法：getInstance
public static Singleton getInstance(){
return instance;
}
}
- 懒汉式（线程不安全）
//饿汉式（静态代码块-在类被初始化的时候才会去实例化当前对象）
class Singleton{
private static Singleton instance;
private Singleton(){}
//提供一个静态的公共方法，当使用到该类时，才去创建instance
public static Singleton getInstance(){
if (instance==null){
instance=new Singleton();
}
return instance;
}
}
优点：起到了懒加载（Lazy Loading）的效果，我用到就去创建，没有就不创建，避免内存浪费，但只能在单线程下使用。在多线程下，一个线程进入了if (instance==null)，还未来得及往下执行，另一个线程也通过了这个if语句，这会产生多个实例，这将不是单例模式了。
- 懒汉式（线程安全，同步方法）：加入同步synchronized的代码，解决了线程安全
//饿汉式（静态代码块-在类被初始化的时候才会去实例化当前对象）
class Singleton{
private static Singleton instance;
private Singleton(){}
//提供一个静态的公共方法，当使用到该类时，才去创建instance
//加入同步synchronized的代码，解决了线程安全
public static synchronized Singleton getInstance(){
if (instance==null){
instance=new Singleton();
}
return instance;
}
}
缺点：效率低，每个线程在获取该类的实例对象时，都要执行同步，但是该方法只实例化一次就够了，后面想要获取该类实例，直接return就行。
-
双重检查：线程安全、懒加载问题和效率问题 开发常用
volatile：立即更新到主存 防止指令重排
class Singleton{
private static volatile Singleton instance;
private Singleton(){}
//提供一个静态的公共方法，当使用到该类时，才去创建instance
//加入双重检查的代码，解决了线程安全、懒加载问题和效率问题
public static synchronized Singleton getInstance(){
if (instance==null){
synchronized (Singleton.class){
if (instance==null){
instance=new Singleton();
}
}
}
return instance;
}
}
- 静态内部类：外部类加载时静态内部类不会被加载，如下代码所示：在调用公共静态方法时，才会调用静态内部类，这样就解决了懒加载问题，jvm在类装载时线程是安全的 开发常使用
class Singleton{
private Singleton(){}
//写一个静态内部类
public static class SingletonInstance{
//静态属性
private static final Singleton INSTANCE=new Singleton();
}
//直接返回 -INSTANCE
public static synchronized Singleton getInstance(){
return SingletonInstance.INSTANCE;
}
}
- 枚举方式：推荐使用
enum Singleton{
INSTANCE;//属性
public void eat(){
System.out.println("吃");
}
}
2、结构型模式：
3、行为型模式：
