# 1、设计模式
### 1.1 单例模式
* ##### **饿汉式【可用】**
~~~
public class Singleton {
private static final Singleton INSTANCE = new Singleton();
// 构造方法私有化
private Singleton(){}
public static Singleton getInstance(){
return INSTANCE;
}
}
~~~
优点：简单、线程安全
缺点：非懒加载模式，在类加载时进行初始化，如果自始至终都没有使用过该对象，那么就造成了内存的浪费
* ##### **懒汉式【不推荐使用】**
~~~
public class Singleton {
private static Singleton instance = null;
private Singleton(){}
public static Singleton getInstance(){
if (instance == null){
instance = new Singleton();
}
return instance;
}
}
~~~
优点：使用了懒加载的模式，在第一次使用该对象时实例化该对象
缺点：线程不安全，在单线程中可使用，多线程中无效
* ##### 懒汉改进式【不推荐使用】
* ~~~
public class Singleton {
private static Singleton instance = null;
private Singleton(){}
public static Singleton getInstance(){
synchronized (Singleton.class){
if (instance == null){
instance = new Singleton();
}
return instance;
}
}
}
~~~
优点：在使用懒加载的基础上实现了线程安全
缺点：每次获取对象时多需要进行加锁，效率比较低。
* ##### 双重校验锁【推荐使用】
* ~~~
public class Singleton {
private static Singleton INSTANCE = null;
private Singleton(){}
public static Singleton getInstance(){
if (INSTANCE == null){
synchronized (Singleton.class){
if (INSTANCE == null){
INSTANCE = new Singleton();
}
}
}
return INSTANCE;
}
}
~~~
优点：只在第一次调用时加锁，之后直接返回对象实例。**延迟加载、线程安全、效率较高**
* **静态内部类【推荐使用】**
~~~
public class Singleton{
private Singleton(){}
private static class SingleObject{
private static Singleton INSTANCE = new Singleton();
}
public static Singleton getInstance(){
return SingleObject.INSTANCE;
}
}
~~~
优点：线程安全、延迟加载、效率较高。
（静态内部类在第一次调用时进行加载，实现了延时加载；INSTANCE是一个静态变量，JVM在实例化时保证了变量的唯一和线程安全）
* ##### 枚举【推荐使用】
~~~
public enum Singleton{
INSTANCE;
Singleton(){}
}
~~~
优点：系统内存中只存在一个实例对象，节省了系统资源
缺点：当想要实例化一个对象时，需要记住相应的方法，而不是new XXX()，会给其他开发者造成困扰，特别是在看不到源码的情况下。
### 1.2 工厂模式
~~~
public abstract class Sender{
abstract void send();
}
public class SMSSender extends Sender{
@Override
public void send() {
System.out.println("This is SMS Sender");
}
}
public class MailSender extends Sender{
@Override
void send() {
System.out.println("This is Email Sender");
}
}
~~~
* ##### 简单工厂模式
~~~
public class SimpleFactory {
public Sender getSender(String senderType){
switch (senderType){
case "sms":
return new SMSSender();
case "mail":
return new MailSender();
default:
return null;
}
}
public static void main(String[] args) {
Sender sender = new SimpleFactory().getSender("sms");
sender.send();
}
}
~~~
缺点：如果传递的字符串错误，则不能正确的创建对象
* 静态工厂方法模式
~~~
public class StaticMethodFactory {
public static Sender getSMSSender(){
return new SMSSender();
}
public static Sender getMailSender(){
return new MailSender();
}
public static void main(String[] args) {
Sender sender = StaticMethodFactory.getMailSender();
sender.send();
}
}
~~~
缺点：如果需要新增一个WXSender，则需要重新对Factory进行增添和补充，违反了闭包原则
* 抽象工厂模式
在简单工厂模式和工厂方法模式中，工厂的功能比较单一（只能生产Sender），而在抽象工厂方法中，工厂中可以有多个方法（生产Sender、Provider等）。如
~~~
public interface Provider {
Sender produce();
}
public class MailSenderProvider implements Provider {
@Override
public Sender produce() {
return new MailSender();
}
}
public class SMSSenderProvider implements Provider {
@Override
public Sender produce() {
return new SMSSender();
}
}
public class AbstractFactory {
public static void main(String[] args) {
Provider provider = new SMSSenderProvider();
Sender sender = provider.produce();
sender.send();
}
}
~~~
> 设计模式代码产出：[http://git.sankuai.com/users/duoshilin/repos/android-practices/browse/java\_design\_patter](http://git.sankuai.com/users/duoshilin/repos/android-practices/browse/java_design_patter "http://git.sankuai.com/users/duoshilin/repos/android-practices/browse/java_design_patter")
>
> 设计模式参考文章：[http://www.runoob.com/design-pattern/abstract-factory-pattern.html](http://www.runoob.com/design-pattern/abstract-factory-pattern.html "http://www.runoob.com/design-pattern/abstract-factory-pattern.html")
