秋招准备-Java-设计模式（总）
1.单例模式
一个类仅有一个实例，并提供它的全局访问点。
1.饿汉单例
线程安全，非Lazy Loading（延迟加载）,类加载时就初始化。较为常用。
class Singleton
{
private static Singleton instance = new Singleton();//初始化可以放到static{}代码块中
private Singleton() {}
public static Singleton getInstance()
{ return instance; }
}2.懒汉单例（非线程安全）
由于某种执行时序下可能执行返回两个new Singleton()，因此线程不安全。实现Lazy Loading。
class Singleton
{
private static Singleton instance =null;
private Singleton() {}
public static Singleton getInstance()
{ if(instance==null)
instance = new Singleton();
return instance; }
}3.懒汉单例（线程安全）
通过对静态方法getInstance()添加类锁，完成同步。线程安全，实现Lazy Loading，但因为synchronized而使多线程运行时频繁阻塞，影响效率。
4.双检锁（DCL）
同样是添加类锁，但不对方法加锁，而使用synchronized代码块，对instance=null判断语句后的情况加类锁，然后再次进行判断（考虑到在第一个拿锁者实例化之前，其他线程进入也进入到该区域阻塞）。
5.静态内部类实现
写个静态内部类，在里边放个静态的外部类对象的实例。
6.枚举enum
支持自动序列化，线程安全，绝对防止多次实例化。
Singleton.Instance.set(5)这样来访问单例。
enum Singleton
{
Instance;
private int value;
public void set(int i) {value=i;}
}2.工厂模式
1.简单工厂（Single Factory）模式
专门定义一个工厂类来（根据参数不同）创建其他类（产品）的实例。，被创建的实例通常拥有共同的父类。
缺点：增添一个新的产品生成类需要改动整个工厂类
class SingleFactory
{
public static Product createProduct(T t,……)
{
/**
* Product是抽象类或者接口，含有代表其作用的抽象函数func();
* Product1,2…是继承或者实现了Product，重写func()后的实现类，通过if-else分支来实例化与返回相应的对象
*/
if(exp1) return new Product1();
else if(exp2) return new Product2();
else if(exp3) return new Product3();
……
//调用SingleFactory.createProduct(参数),就可以完成对应对象的实例化，用的静态方法所以也叫静态工厂
}
}2.多工厂方法
实际上是在简单工厂的基础上，将if-else的分支判断改成了多个static的方法。
即本来应该是单个静态方法传入参数，根据参数与分支条件来判断返回哪个实例。
现在变为多个写入多个返回不同Product子类对象的static方法，然后通过调用时选择方法来返回实例。
这样，增添修改对应的产品类实例时，就只需要在对应的静态方法中作修改。
3.工厂方法（Factory Method）模式
在基类中定义创建对象的一个接口，让子类决定实例化哪个类。工厂方法让一个类的实例化延迟到子类中进行
结构是，先定义一个工厂的接口，这个接口是需要返回产品的，接口有个抽象函数创建产品。
interface FactoryMethod
{
public Product createProduct();
}然后再实现不同的子工厂类，这些工厂类重写createProduct()方法，返回相应的产品对象
class Factory1 implements FactoryMethod
{
public Product createProduct()
{ return new Product1(); }
}
class Factory2 implements FactoryMethod
{
public Product createProduct()
{ return new Product2(); }
}
……和简单工厂比较，其实就是将if-else分支，变成了选择工厂类。我要产生产品1，那就:
FactoryMethod factory = new Factory1();
Product product = factory.createProduct();
评价：实际上和多方法工厂比较更合适，多工厂方法是在要添加修改产品类时，操作相应的静态方法。工厂方法则是操作相应的工厂类。产品类是两者都要修改的。工厂方法会在产品过多时，造成工厂类也很多的问题。
4.抽象工厂（Abstract Factory）
在工厂方法的基础上，由单产品系，变成了多产品系。
可以理解为其起作用的抽象方法createProduct()变成了createSizeOne()+createSizeTwo()+……
工厂方法的具体工厂类，本身有Product的单子类来决定。
抽象工厂则是从ProductSize1()里选一种，再从ProductSize2()里选一种，构成具体工厂。
interface AbstractFactory
{
public SizeOne createSizeOne();
public SizeTwo createSizeTwo();
……
}
class Factory1 implements AbstractFactory
{
/**
* 抽象类或者接口SizeOne代表某个产品线（平板），SizeOne1(ipad2),SizeOne2(ipadmini)……是这个产品的实现
* 抽象类或者接口SizeTwo代表另一个产品线（手机），SizeTwo1(iphone8),SizeOne2(iphoneX)……是这个产品的实现
*/
public SizeOne createSizeOne()
{ return new SizeOne1(); }
public SizeTwo createSizeTwo()
{ return new SizeTwo1(); }
//那么这个具体工厂Factory就是生产SizeOne1(ipad2)与SizeTwo1(iphone8)的工厂
}3.适配器模式
将一个类的接口转换成客户端所需要的另一种接口。
主要适用于“望复用一些现存的类，但接口又与复用环境要求不一致。”的情况，在遗留代码复用，类库迁移等方面有用。
1.Adapter_Class适配器类
通过写一个类，继承现有类且实现所需要的接口，然后在该接口含有的抽象方法中，利用现有类的方法，实现预想的功能。
2.Adapter_Object适配器对象
与适配器类的区别，是关系从继承变成了组合，在编写的类中，不是继承现有类，而是定义一个该类的对象，并且在构造函数或者其他中完成该对象的初始化，然后再利用该对象的方法，来完成接口抽象方法需要的功能。
3.接口适配器模式
当不需要全部实现接口提供的方法时，可以先设计一个抽象类实现该接口，然后在该抽象类中编写其抽象方法的默认方法（一般为空？），那么该抽象类的子类可以有选择的重写抽象类中的方法。
在java.awt包中处理监听时运用了许多Adapter，MouseAdatper（MouseMotionAdapter）就是用到接口适配器模式的抽象类，可以继承它然后有选择的重写其中的方法，完成鼠标点击的事件监听。
4.装饰器模式
允许向一个现有的对象添加新的功能，同时又不改变其结构。
在JavaIO流中运用较多，如BufferedInputStream对FileInputStream的读入进行了一个缓冲优化，就是实现了装饰器模式。
实际上，就是装饰类中应该含有被装饰类的引用，然后通过构造函数读入被装饰类的引用完成构造，再对其中的一些功能做优化。
比如，FileInputStream类中的read()方法，不管是读入单个字节，还是读入一个byte数组的长度（或者给定length），一次read就是一次IO读入，这个操作就比较耗时。而在BufferedInputStream中，同样是通过FileInputStream对象来读入，只是它有一个内置的byte[]数组当缓冲区，那么一次read()后，先将一个默认长度的byte[]数据读入到缓冲区，然后再从缓冲区读入数据。那么在没有将缓冲区内容读完前，调用read()方法都不需要再进行IO的读写操作，因此效率得到了提高。
5.享元模式
享元实际上是对不可变类的对象进行的一种共享模式，以获得在内存开销上的优化。
最简单的例子就是String对象。
6.观察者模式
……