Java学习笔记 设计模式

---

一、设计原则

1. 开闭原则（Open Close Principle）
   对扩展开放对修改关闭，为了使程序的扩展性好，易于维护和升级。
2. 里氏代换原则
   任何基类可以出现的地方，子类一定可以出现，多使用多态的方式。
3. 依赖倒转原则
   尽量多依赖于抽象类或接口而不是具体实现类，对子类具有强制性和规范性
4. 接口隔离原则
   尽量多使用小接口而不是大接口，避免接口的污染，降低类之间耦合度。
5. 迪米特法则（最少知道原则）
   一个实体应当尽量少与其他实体之间发生相互作用，使系统功能模块相对独立。
   高内聚，低耦合。
6. 合成复用原则
   尽量多使用合成/聚合的方式，而不是继承的方式。

二 .创建型模式

单例设计模式

懒汉式和饿汉式区别：

实例化方面：懒汉式默认不会实例化，外部什么时候调用什么时候new。饿汉式在类加载的时候就实例化，并且创建单例对象。

线程安全方面：饿汉式线程安全 (在线程还没出现之前就已经实例化了，因此饿汉式线程一定是安全的)。懒汉式线程不安全( 因为懒汉式加载是在使用时才会去new 实例的，那么你去new的时候是一个动态的过程，是放到方法中实现的，比如：public static synchronized Lazy getInstance(){ if(lazy==null){ lazy=new Lazy(); } 如果这个时候有多个线程访问这个实例，这个时候实例还不存在，还在new，就会进入到方法中，有多少线程就会new出多少个实例。一个方法只能return一个实例，那最终return出哪个呢？是不是会覆盖很多new的实例？这种情况当然也可以解决，那就是加同步锁，避免这种情况发生) 。
执行效率上：饿汉式没有加任何的锁，因此执行效率比较高。懒汉式一般使用都会加同步锁，效率比饿汉式差。
性能上：饿汉式在类加载的时候就初始化，不管你是否使用，它都实例化了，所以会占据空间，浪费内存。懒汉式什么时候需要什么时候实例化，相对来说不浪费内存。

//饿汉式

public class Singleton{
	private Singleton(){}
	// 类加载的时候就实例化，并且创建单例对象
	private static final Singleton sin=new Singleton();
	public static Singleton getInstance(){
		return sin;
	}
}

 	//懒汉式

public class Singleton {

    // 2.声明本类类型的引用指向本类类型的对象并使用private static关键字修饰
    private static Singleton sin = null;

    // 1.私有化构造方法，使用private关键字修饰
    private Singleton() {}

    // 3.提供公有的get方法负责将上述对象返回出去，使用public static关键字修饰
    public static /*synchronized*/ Singleton getInstance() {
        /*synchronized (Singleton.class) {
            if (null == sin) {
                sin = new Singleton();
            }
            return sin;
        }*/
        if (null == sin) {
            synchronized (Singleton.class) {
                if (null == sin) {
                    sin = new Singleton();
                }
            }
        }
        return sin;
    }
}

普通工厂模式

有点乱 下次整理

三、 结构型模式

1.装饰器模式

装饰器模式就是给一个对象动态的增加一些新功能，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。

优缺点
可以实现一个类功能的扩展。
可以动态的增加功能，而且还能动态撤销（继承不行）。
缺点：产生过多相似的对象，不易排错。

public class SourceableTest {

    public static void main(String[] args) {

        Sourceable sourceable = new Source();
        sourceable.method();

        System.out.println("---------------------------------------------------");
        // 接下来使用装饰类实现功能
        Sourceable sourceable1 = new Decorator(sourceable);
        sourceable1.method();

        System.out.println("---------------------------------------------------");
        Sourceable sourceable2 = new Proxy();
        sourceable2.method();
    }
}

public class Decorator implements Sourceable {
    private Sourceable source;

    public Decorator(Sourceable source) {
        this.source = source;
    }

    @Override
    public void method() {
        source.method(); // 保证原有功能不变
        System.out.println("化妆之后你会更美！");
    }
}

public class Source implements Sourceable {
    @Override
    public void method() {
        System.out.println("素颜美可以如此之美！");
    }
}

2、代理模式

代理模式就是找一个代理类替原对象进行一些操作。

实际意义
如果在使用的时候需要对原有的方法进行改进，可以采用一个代理类调用原有方法，并且对产生的结果进行控制，这种方式就是代理模式。
使用代理模式，可以将功能划分的更加清晰，有助于后期维护。

代理模式和装饰器模式的比较
装饰器模式通常的做法是将原始对象作为一个参数传给装饰者的构造器，而代理模式通常在一个代理类中创建一个被代理类的对象。
装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。

四、行为型模式

模板方法模式

待补充