设计模式七大设计原则，和单例模式的8种写法（java实现）

设计模式七大设计原则，和单例模式的8种写法（java实现）

七大设计原则

1.单一职责原则

对于类来说，即一个类应该只负责一项职责，否则职责二变更会造成职责一的错误（例如有个dao类即负责user表的操作又负责oder表的操作，则违反了单一职责原则，应该拆分成为2个dao类分别负责user和oder表）。

2.接口隔离原则

客户端不应该依赖它不需要的接口 ，即一个类对另一个类的依赖应该建立在最小的接口上。解决的方法：将接口拆分成多个接口

3.依赖倒置原则

（1）高层模块不应该依赖低层模块，二者都应依赖其抽象

（2）抽象不应依赖细节，细节应该依赖抽象。

（3）中心思想是面向接口编程。

4.里氏替换原则

使用继承时，遵循里氏替换原则，子类中尽量不要重写父类的方法。继承让两个类的耦合性增强了，适当的情况下可以通过聚合，组合，依赖来解决问题。

5.开闭原则

一个软件实体如类，模块和函数应该对扩展开放，对修改关闭（开发人员扩展开放，使用方不用修改）。

软件需求发生变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。

6.迪米特法则

一个对象应该对其他对象保持最少的了解

类与类关系越密切，耦合度越大。

又称为最少知道原则，即一个类对自己依赖的类知道的越少越好。即被依赖的类最好将逻辑封装在类的内部，除了对外提供public方法，不泄露任何信息。

即与直接朋友（成员变量，方法参数，方法返回值中的类为直接朋友）进行通信，陌生的类最好不以局部变量的形式出现在类的内部。

7.合成复用原则

尽量使用合成/聚合的方式，而不是使用继承。

采用设计模式的目的

（1）代码重用性（2）可读性（3）可扩展性（4）可靠性（5）使程序出现高内聚低耦合的特性。

单例模式

1.静态常量饿汉式

class Singleton {
    //构造器私有化，外部不能new
    private Singleton(){
        
    }
    //本类内部创建对象实例
    private final static Singleton instance=new Singleton();
    //提供一个公用的静态方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    } 
}

public class SingletonTest(){
    public static void main(String args[]){
        Singleton singleton=Singleton.getInstance();
        Singleton singleton1=Singleton.getInstance();
        //singleton1==singleton为true。
    }
}

优点： 在类装载的时候就完成了实例化，避免了线程同步的问题。

缺点： 在类装载时完成实例化，没有达到懒加载的效果，从开始到结束都没用到该实例就会造成内存的浪费。

结论： 可以使用该单例模式，但可能会造成内存的浪费。

2.饿汉式（静态代码块）

class Singleton {
    //构造器私有化，外部不能new
    private Singleton(){
        
    }
    //本类内部创建对象实例
    private static Singleton instance;
    //在静态代码块中创建单例对象。
    static{
        instance=new Singleton();
    }
    //提供一个公用的静态方法，返回实例对象
    public static Singleton getInstance(){
        return instance;
    } 
}

public class SingletonTest(){
    public static void main(String args[]){
        Singleton singleton=Singleton.getInstance();
        Singleton singleton1=Singleton.getInstance();
        //singleton1==singleton为true。
    }
}

优点： 在类装载的时候就完成了实例化，避免了线程同步的问题。

缺点： 在类装载时完成实例化，没有达到懒加载的效果，从开始到结束都没用到该实例就会造成内存的浪费。

结论： 可以使用该单例模式，但可能会造成内存的浪费。

3.懒汉式(线程不安全)

class Singleton {
    //构造器私有化，外部不能new
    private Singleton(){
        
    }
    //本类内部创建对象实例
    private static Singleton instance;
    
    //提供一个公用的静态方法,当使用到该方法时才返回实例对象
    public static Singleton getInstance(){
        if(instance==null){
            instance=new Singleton();
        }
        return instance;
    } 
}

public class SingletonTest(){
    public static void main(String args[]){
        Singleton singleton=Singleton.getInstance();
        Singleton singleton1=Singleton.getInstance();
        //单线程情况下singleton1==singleton为true。
    }
}

优点： 的确起到了懒加载的效果，但只能在单线程下使用。

缺点： 在多线程下，一旦有其他线程进入了 if(instance==null){}的语句块，本线程还没来得及向下执行，就会产生多个实例，所以实际开发中不要使用该方式。

结论： 不要使用该单例模式，线程不安全。

4.懒汉式（线程安全，同步方法）

class Singleton {
    //构造器私有化，外部不能new
    private Singleton(){
        
    }
    //本类内部创建对象实例
    private static Singleton instance;
    
    //提供一个公用的静态方法,当使用到该方法时才返回实例对象
    //加入了同步代码，不会有多个线程同时执行getInstance方法，解决线程不安全问题。
    public static synchronized Singleton getInstance(){
        if(instance==null){
            instance=new Singleton();
        }
        return instance;
    } 
}

public class SingletonTest(){
    public static void main(String args[]){
        Singleton singleton=Singleton.getInstance();
        Singleton singleton1=Singleton.getInstance();
        //单线程情况下singleton1==singleton为true。
    }
}

优点： 解决了线程不安全问题。

缺点： 效率太低了，每个线程想获得实例时，执行该方法都要进行同步，效率太低了，后面线程想获得该实例直接return就可以了。

结论： 不推荐使用该模式，效率太低。

5.错误的懒汉式

class Singleton {
    //构造器私有化，外部不能new
    private Singleton(){
        
    }
    //本类内部创建对象实例
    private static Singleton instance;
    
    //提供一个公用的静态方法,当使用到该方法时才返回实例对象
    public static  Singleton getInstance(){
        if(instance==null){
            synchronized(Singleton.class){
               instance=new Singleton(); 
            }
            
        }
        return instance;
    } 
}

public class SingletonTest(){
    public static void main(String args[]){
        Singleton singleton=Singleton.getInstance();
        Singleton singleton1=Singleton.getInstance();
        //单线程情况下singleton1==singleton为true。
    }
}

与不安全的懒汉式没有区别，直接是一种错误的写法。

6.双重检查（线程安全的懒汉式）

class Singleton {
    //构造器私有化，外部不能new
    private Singleton(){
        
    }
    //本类内部创建对象实例,加入了volatile关键字
    private static volatile Singleton instance;
    
    //提供一个公用的静态方法,当使用到该方法时才返回实例对象
    //进行了双重检查，解决了线程安全问题
    public static  Singleton getInstance(){
        if(instance==null){
            synchronized(Singleton.class){
                if(instance==null){
                 	instance=new Singleton();    
                }
            }
            
        }
        return instance;
    } 
}

public class SingletonTest(){
    public static void main(String args[]){
        Singleton singleton=Singleton.getInstance();
        Singleton singleton1=Singleton.getInstance();
        //singleton1==singleton为true。
    }
}

比较优秀的写法，解决了低效率和线程不安全的问题，推荐使用。

7.静态内部类实现单例模式

class Singleton {
    //构造器私有化，外部不能new
    private Singleton(){
        
    }
    //写一个静态内部类，该类中有一个静态属性Singleton
    private static class SingletonInstance{
     	private static final Singleton INSTACNE=new Singleton();
    }
    
    //返回该静态内部类的INSTANCE属性。
    public static  Singleton getInstance(){
        return SingletonInstance.INSTANCE;
    } 
}

public class SingletonTest(){
    public static void main(String args[]){
        Singleton singleton=Singleton.getInstance();
        Singleton singleton1=Singleton.getInstance();
        //singleton1==singleton为true。
    }
}

优点： Singleton类在装载的时候，静态内部类并不会被装载，从而懒加载是可以使用的，当调用getInstance()方法时，会导致内部类的装载，jvm的类加载机制保证了线程是安全的。

总结： 推荐使用。

8.枚举实现单例

enum Singleton{
	INSTACE;
	public void method(){
		System.out.print("something");
	}
}
//使用枚举可以实现单例。
public class SingletonTest{
    public static void main(String args[]){
        Singleton instance=Singleton.INSTANCE;
        Singleton instance2=Singleton.INSTANCE;
        //instance==instance2返回的是true；
    }
}

优点： enum枚举方式不仅解决了懒加载多线程同步问题，还可以防止反序列化创建新的对象。

总结： 推荐使用。