设计模式是一套面向对象的代码设计经验总结，是在编程领域被反复使用、多人知晓的通过了分类整理的代码设计方法。
使用设计模式为了可重用代码，使代码更加容易理解、保证代码的可靠性。合理的设计模式对开发人员和需要开发的系统都是有利的，设计模式可以让代码实现工程化。
设计原则
1. 单一职责原则
定义：对于一个类，应该只有一个引起它变化的原因。
好处： 降低类的复杂度、提高类的可读性、提高系统的可维护性。
2. 里氏代换原则
定义：子类型必须能够替换掉父类型
优点：代码共享、提高了代码重用性、扩展性、产品和项目的开放性。
只有满足里氏代换原则，子类可以代替父类出现并且不影响层序的功能父类才能得到真正的复用，并且子类可以在弗雷德基础上添加新的行为。面向对象思想中，父类和子类的继承关系是抽象化的具体实现。
里氏代换原则是对实现抽象化的具体步骤的规范。
3. 开放封闭原则
定义：程序的实体对象（模块、类、函数等）应该可以进行扩展，但不应该修改。
优点：可扩展性好、耦合度低。
特征
- 对于扩展是开放的
- 对于修改是封闭的
// 未实现开放封闭原则
public class BankWorker {
public void saving() {
System.out.println("存款");
}
public void drawing() {
System.out.println("取款");
}
}
// 实现开放封闭原则
public interface BankWorker {
public void operation();
}
public class SavingBankWorker extends BankWorker {
@Override
public void operation() {
System.out.println("存款");
}
}
public class DrawingBankWorker extends BankWorker {
@Override
public void operation() {
System.out.println("取款");
}
}
开放封闭原则可以通过扩展已有的软件系统提供新的行为，以满足软件的新需求，使变化的软件有一定的灵活性和适应性。对于已有的软件模块，特别是最重要的抽象模块不能再修改，这就是软件系统有了一定的稳定性和延续性。
4. 依赖倒转原则
定义：程序高层模块不应该依赖于低层模块，但两者都应该依赖与抽象，抽象不应该依赖于具体细节，而细节应该依赖与抽象。
优点：可扩展性好、耦合度低。
interface IWorker {
public void work();
}
class Work implements IWorker {
@Override
public void work() {
//......working
}
}
class SeniorWorker implements IWorker {
@Override
public void work() {
//......working much more
}
}
class Manager {
IWorker mWorker;
public void setWorker(IWorker w) {
mWorker = w;
}
public void manage() {
mWorker.work();
}
}
5. 合成/聚合复用原则
定义：尽量不实用类继承、尽量使用合成/聚合。
优点：降低耦合度、提升代码可读性、隐藏实现细节。
缺点：系统中有较多对象需要管理。
- 将军对自己的统领将士保持有引用，就是聚合。
- 皇帝拥有天下，但将军并非拥有全部士兵，所以对将军“拥有”的关系，相当于合成，大将军是这个合成中的一个对象。
6. 迪米特法则
定义：如果两个类之间不必进行直接通信，则这两个类不应该发生直接的相互作用。如果一个类需要调用另一个类的某个方法，则可以通过第三方来转发这个调用。
// 皇帝找一个侍卫，皇帝这么傲娇，一定不会亲自动手啊，所以要通过太监
public abstract class Stranger {
public abstract void operation();
}
public class ShiWei extends Stranger {
@Override
public void operation() {
System.out.println("参见皇上，我是侍卫啊哈哈哈！");
}
}
public class TaiJian extends Stranger {
@Override
public void operation() {
}
// 太监找人啊哈哈
public void findStranger() {
Stranger s = new ShiWei();
s.operation();
}
}
public class HuangDi {
private TaiJian t;
public TaiJian getTaiJian() {
return t;
}
public void setTaiJian(TaiJian t) {
this.t = t;
}
public void operation() {
}
}
public class Test {
public static void main(String[] args){
HuangDi HD = new HuangDi();
// 找个太监，小桌子小凳子啊哈哈
HD.setTaiJian(new TaiJian());
// 来，小桌子，去给我把他找来（这个过程中皇帝并没有和侍卫直接接触）
HD.getTaiJian().findStranger();
}
}
Java设计模式
Java中一般有23种设计模式，这里只介绍一些常用的~
总体来说设计模式分为三大类：
创建型模式，共5种
工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共7种
适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共11种
策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
1. 单例设计模式
定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
适用：
- 当一个类只能有一个实例而却第三方可以从一个公共的访问点访问它时。
- 当一个唯一的实力可以通过子类来扩展，而且第三方需要在不更改代码的情况下就能使用一个扩展的实例时。
- 饿汉式
public class Singleton {
// 直接创建对象
public static Singleton instance = new Singleton();
// 私有化构造函数
private Singleton() {
}
// 返回对象实例
public static Singleton getInstance() {
return instance;
}
}
这种方式比较常用，但容易产生垃圾对象。
优点：没有加锁，执行效率会提高。
缺点：类加载时就初始化，浪费内存。
它基于 Classloader机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用getInstance方法， 但是也不能确定有其他的方式（或者其他的静态方法,比如反射）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。
2、懒汉模式（线程安全）
public class Singletion {
private static Singleton instance;
private Singleton () {
}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
- 为了处理并发，每次调用getInstance方法时都需要进行同步，会有不必要的同步开销。
3、双重检查模式（DCL）
public class Singleton {
private static volatile Singleton instance;
private Singleton {
}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
- 第一次判空，省去了不必要的同步。第二次是在Singleton等于空时才创建实例。
- 使用volatile保证了实例的可见性。
- DCL在一定程度上解决了资源的消耗和多余的同步、线程安全等问题，但是在某些情况下会失效。
假设线程A执行到instance = new Singleton()语句，看起来只有一行代码，但实际上它并不是原子操作，这句代码最终会被编译成多条汇编指令，它大致做了3件事：
1）给instance的实例分配内存。
2）调用Singleton()构造函数，初始化成员字段。
3）将instance对象指向分配的内存空间（此时instance就不是null了）。
原子操作：不需要synchronized，指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，不会切换到另一个线程。
eg：A-B银行转账1000
但是，由于Java编译器允许处理器乱序执行，以及JDK1.5之前JMM中的Cache、寄存器到主内存回写顺序的规定，上面的2和3的顺序是无法保证的，也就是说，执行顺序可能是1-2-3也可能是1-3-2。如果是后者，并且在3执行完毕、2未执行之前，被切换到线程B上，这时候instance因为已经在线程A内执行过了3，instance已经是非空了，所以，线程B直接取走instance，再使用时就会出错，这就是DCL失效问题，而且这种难以跟踪难以重现的错误可能会隐藏很久。
在JDK1.5之后，SUN官方已经注意到这种问题，调整了JVM，具体化了volatile关键字，因此，如果JDK1.5或之后的版本，只需要将instance的定义改成private volatile static Singleton instance = null就可以保证instance对象每次都是从主内存中读取，就可以使用DCL的写法来完成单例模式。当然，volatile或多或少也会影响到性能，但考虑到程序的正确性，这点牺牲也是值得的。
volatile：当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。来保证可见性
DCL优点：资源利用率高，第一次执行getInstance时单例对象才会被实例化，效率高。
缺点：第一次加载稍慢，也由于JMM的原因导致偶尔会失败。在高并发环境下也有一定的缺陷，虽然发生概率很小。DCL模式是使用最多的单例实现方式，它能够在需要时才实例化对象，并且能在绝大多数场景下保证对象的唯一性，除非你的代码在并发场景比较复杂或低于JDK1.6版本下使用，否则，这种方式一般能够满足要求。
4、静态内部类单例模式
public class Singleton() {
private Singleton() {
}
public static Singleton getInstance() {
return SingletonHolder.sInstance;
}
private static class SingletonHolder {
private static final Singleton sInstance = new Singleton();
}
}
- 第一次调用getInstance方法时虚拟机才加载SingletonHolder并初始化sInstance，这样保证了线程安全和实例的唯一性。
- （《JAVA并发编程实践》赞成使用这种方法）
5、枚举单例
public enum Singleton {
INSTANCE;
public void doSomeThing() {
}
}
- 默认枚举实例的创建是线程安全的，并且在任何情况下都是单例。
- 简单、可读性不高。
注意：上面的几种单例模式创建的单例对象被反序列化时会重新创建实例，可以重写readReslove方法返回当前的单例对象。
核心原理：将构造函数私有化，并切通过静态方法获取一个唯一的实例，获取过程中必须保证线程安全、方式反序列化导致重新生成实例对象。
- DCL升级版本？
public class Singleton {
// 声明变量
private static volatile Singleton singleton = null;
// 私有构造函数
private Singleton() {
}
// 提供对外方法
public static Singleton getInstance() {
Singleton mSingleton = singleton; //定义一个临时变量
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
mSingleton = new Singleton();
singleton = mSingleton;
}
}
}
return mSingleton ; // 返回临时变量
}
}
使用volatile
如果没有 volatile 关键字,问题可能会出在singleton = new Singleton() 这句，用伪代码表示：
// 分配内存
inst = allocat();
// 赋值
singleton = inst;
// 真正执行构造函数
constructor(inst);
可能会由于虚拟机的优化等导致赋值操作先执行，而构造函数还没完成，导致其他线程访问得到 singleton 变量不为null，但初始化还未完成，导致程序崩溃。
**定义一个临时变量 mSingleton **
访问 volatile 变量，需要保证一些执行顺序，所以的开销比较大。这里定义一个临时变量，在 sInst 不为空的时候（这是绝大部分的情况），只要在开始访问一次 volatile 变量，返回的是临时变量。如果没有此临时变量，则需要访问两次，而降低了效率。
2. 工厂设计模式
工厂模式分为工厂方法模式和抽象工厂模式。
- 工厂方法模式
工厂方法模式分为三种：
a. 普通工厂模式：建立一个工厂类，对实现了同一接口的一些类进行实例的创建。
b. 多个工厂方法模式：对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。
c. 静态工厂方法模式：将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。
普通工厂模式
建立一个工厂类，对实现了同一接口的一些类进行实例的创建。
// 普通工厂模式
public interface Sender {
public void Send();
}
public class MailSender implements Sender {
@Override
public void Send() {
System.out.println("this is mail sender!");
}
}
public class SmsSender implements Sender {
@Override
public void Send() {
System.out.println("this is sms sender!");
}
}
public class SendFactory {
public Sender produce(String type) {
if ("mail".equals(type)) {
return new MailSender();
} else if ("sms".equals(type)) {
return new SmsSender();
} else {
System.out.println("请输入正确的类型!");
return null;
}
}
}
多个工厂方法模式
对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。
// 多个工厂方法模式
public class SendFactory {
public Sender produceMail() {
return new MailSender();
}
public Sender produceSms() {
return new SmsSender();
}
}
public class FactoryTest {
public static void main(String[] args) {
SendFactory factory = new SendFactory();
Sender sender = factory.produceMail();
sender.send();
}
}
静态工厂方法模式
将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。
// 静态工厂方法模式
public class SendFactory {
public static Sender produceMail() {
return new MailSender();
}
public static Sender produceSms() {
return new SmsSender();
}
}
public class FactoryTest {
public static void main(String[] args) {
Sender sender = SendFactory.produceMail();
sender.send();
}
}
抽象工厂模式
工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。
// 抽象工厂模式
public interface Provider {
public Sender produce();
}
---------------------------------------------------
public interface Sender {
public void send();
}
---------------------------------------------------
public class MailSender implements Sender {
@Override
public void send() {
System.out.println("this is mail sender!");
}
}
public class SmsSender implements Sender {
@Override
public void send() {
System.out.println("this is sms sender!");
}
}
---------------------------------------------------
public class SendSmsFactory implements Provider {
@Override
public Sender produce() {
return new SmsSender();
}
}
public class SendMailFactory implements Provider {
@Override
public Sender produce() {
return new MailSender();
}
}
---------------------------------------------------
public class Test {
public static void main(String[] args) {
Provider provider = new SendMailFactory();
Sender sender = provider.produce();
sender.send();
}
}
3. 建造者模式
将一个复杂对象的构建和它的表示分离，使得同样的构建过程可以创建不同的表示。
建造者有以下角色：
- 导演类：负责安排已有模块的安装顺序，最后通知建造者开始建造。
- 建造者：抽象Builder类，用于规范产品的组建。
- 具体建造者：实现抽象Builder类的所有方法，并返回建造好的对象。
- 产品类。
简单示例
1、产品类
public class Computer {
private String mCpu;
private Stiring mMainboard;
private String mRam;
public void setmCpu(String mCpu) {
this.mCpu = mCpu;
}
public void setmMainboard(String mMainboard) {
this.mMainboard = mMainboard;
}
public void setmRam(String mRam) {
this.mRam = mRam;
}
}
2、抽象建造者
public abstract class Builder {
public abstract void buildCpu(String cpu);
public abstract void buildMainboard(String mainboard);
public abstract void buildRam(String ram);
public abstract Computer create();
}
3、具体建造者
public class MoonComputerBuilder extends Builder {
private Computer mComputer = new Computer();
@Override
public void buildCpu(String cpu) {
mComputer.setmCpu(cpu);
}
@Override
public void buildMainboard(String mainboard) {
mComputer.setmMainboard(mainboard);
}
@Override
public void buildRam(String ram) {
mComputer.setmRam(ram);
}
@Override
public Computer create() {
return mComputer;
}
}
4、导演类
public class Director {
Builder mBuilder = null;
public Director (Builder builder) {
this.mBuilder = builder;
}
public Computer createComputer(String cpu, String mainboard, String ram) {
this.mBuilder.buildCpu(cpu);
this.mBuilder.buildMainboard(mainboard);
this.mBuilder.buildRam(ram);
return mBuilder.create();
}
}
- 屏蔽产品内部组成细节。
- 具体建造者类之间相互独立，容易扩展。
- 会产生多余的建造者对象和导演类。
4.适配器模式
适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。
类的适配器模式
package Pattern;
interface FiveVolt {
public int getVolt5();
}
class Volt220 implements FiveVolt {
@Override
public int getVolt5() {
return 220;
}
}
/**
* 类适配器
*/
class VoltAdapter extends Volt220 implements FiveVolt {
@Override
public int getVolt5() {
return 5;
}
}
public class AdapterTest {
public static void main(String[] args) {
VoltAdapter adapter = new VoltAdapter();
System.out.println("输出电压：" + adapter.getVolt5());
}
}
对象的适配器模式
基本思路和类的适配器模式相同，只是将 Adapter 类作修改，这次不继承 Source 类，而是持有 Source 类的实例，以达到解决兼容性的问题。
/**
* 对象适配器
*/
class VoltAdapter implements FiveVolt {
Volt220 volt220;
public VoltAdapter(Volt220 volt220) {
this.volt220 = volt220;
}
public Volt220 getVolt220() {
return volt220;
}
@Override
public int getVolt5() {
return 5;
}
}
public class AdapterTest {
public static void main(String[] args) {
VoltAdapter adapter = new VoltAdapter(new Volt220());
System.out.println("输出电压：" + adapter.getVolt5());
}
}
接口的适配器模式
接口的适配器是这样的：有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。
5. 装饰模式（Decorator）
装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。
public interface Sourceable {
public void method();
}
----------------------------------------------------
public class Source implements Sourceable {
@Override
public void method() {
System.out.println("the original method!");
}
}
----------------------------------------------------
public class Decorator implements Sourceable {
private Sourceable source;
public Decorator(Sourceable source) {
super();
this.source = source;
}
@Override
public void method() {
System.out.println("before decorator!");
source.method();
System.out.println("after decorator!");
}
}
----------------------------------------------------
public class DecoratorTest {
public static void main(String[] args) {
Sourceable source = new Source();
Sourceable obj = new Decorator(source);
obj.method();
}
}
- 使用组合，动态地扩展对象的功能，在运行时能够使用不同的装饰器实现不同的行为。
- 比继承更易出错，旨在必要时使用。
6. 策略模式（strategy）
策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类），提供辅助函数。策略模式的决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系统中，外部用户只需要决定用哪个算法即可。
public interface ICalculator {
public int calculate(String exp);
}
---------------------------------------------------------
public class Minus extends AbstractCalculator implements ICalculator {
@Override
public int calculate(String exp) {
int arrayInt[] = split(exp, "-");
return arrayInt[0] - arrayInt[1];
}
}
---------------------------------------------------------
public class Plus extends AbstractCalculator implements ICalculator {
@Override
public int calculate(String exp) {
int arrayInt[] = split(exp, "\\+");
return arrayInt[0] + arrayInt[1];
}
}
--------------------------------------------------------
public class AbstractCalculator {
public int[] split(String exp, String opt) {
String array[] = exp.split(opt);
int arrayInt[] = new int[2];
arrayInt[0] = Integer.parseInt(array[0]);
arrayInt[1] = Integer.parseInt(array[1]);
return arrayInt;
}
}
public class StrategyTest {
public static void main(String[] args) {
String exp = "2+8";
ICalculator cal = new Plus();
int result = cal.calculate(exp);
System.out.println(result);
}
}
7. 观察者模式（Observer）
类似于邮件订阅和 RSS 订阅，当我们浏览一些博客或 wiki时，经常会看到 RSS 图标，就这的意思是，当你订阅了该文章，如果后续有更新，会及时通知你。其实，简单来讲就一句话：当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。
public interface Observer {
public void update();
}
public class Observer1 implements Observer {
@Override
public void update() {
System.out.println("observer1 has received!");
}
}
public class Observer2 implements Observer {
@Override
public void update() {
System.out.println("observer2 has received!");
}
}
public interface Subject {
/*增加观察者*/
public void add(Observer observer);
/*删除观察者*/
public void del(Observer observer);
/*通知所有的观察者*/
public void notifyObservers();
/*自身的操作*/
public void operation();
}
public abstract class AbstractSubject implements Subject {
private Vector<Observer> vector = new Vector<Observer>();
@Override
public void add(Observer observer) {
vector.add(observer);
}
@Override
public void del(Observer observer) {
vector.remove(observer);
}
@Override
public void notifyObservers() {
Enumeration<Observer> enumo = vector.elements();
while (enumo.hasMoreElements()) {
enumo.nextElement().update();
}
}
}
public class MySubject extends AbstractSubject {
@Override
public void operation() {
System.out.println("update self!");
notifyObservers();
}
}
public class ObserverTest {
public static void main(String[] args) {
Subject sub = new MySubject();
sub.add(new Observer1());
sub.add(new Observer2());
sub.operation();
}
}
8. 代理模式
- 静态代理
// 诉讼接口
public interface ILawsiut {
// 提交申请
void submit();
// 进行举证
void burden();
// 开始辩护
void defend();
// 诉讼完成
void finish();
}
// 诉讼人
public class XiaoMin implements ILawsiut{
@Override
public void submit() {
System.out.println("申请仲裁");
}
@Override
public void burden() {
System.out.println("提交证据");
}
@Override
public void defend() {
System.out.println("进行辩护");
}
@Override
public void finish() {
System.out.println("诉讼成功");
}
}
// 律师
package proxy;
public class Lawyer implements ILawsiut {
private ILawsiut mLawsuit;
public Lawyer(ILawsiut lawsiut) {
this.mLawsuit = lawsiut;
}
@Override
public void submit() {
mLawsuit.submit();
}
@Override
public void burden() {
mLawsuit.burden();
}
@Override
public void defend() {
mLawsuit.defend();
}
@Override
public void finish() {
mLawsuit.finish();
}
}
public class Client {
public static void main(String[] args){
ILawsiut xiaoMin = new XiaoMin();
ILawsiut lawyer = new Lawyer(xiaoMin);
lawyer.submit();
lawyer.burden();
lawyer.defend();
lawyer.finish();
}
}
- 动态代理
java 提供了一个动态代理接口InvocationHandler,实现该接口需要重写其代理方法invoke。
// 动态代理类
public class DynamicProxy implements InvocationHandler {
private Object obj; // 被代理的类引用
public DynamicProxy(Object obj) {
this.obj = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 调用被代理类对象的方法
Object result = method.invoke(obj,args);
return result;
}
}
//////////////////////////
// 修改后的客户类
import java.lang.reflect.Proxy;
public class Client {
public static void main(String[] args) {
ILawsiut xiaoMin = new XiaoMin();
// 够早一个动态代理
DynamicProxy proxy = new DynamicProxy(xiaoMin);
// 获取被代理类小民的ClassLoader
ClassLoader loader = xiaoMin.getClass().getClassLoader();
// 动态构造一个代理者律师
ILawsiut lawyer = (ILawsiut) Proxy.newProxyInstance(loader, new Class[]{ILawsiut.class}, proxy);
lawyer.submit();
lawyer.burden();
lawyer.defend();
lawyer.finish();
}
}
静态代理与动态代理的区别在于代理类生成的时间不同，即根据程序运行前代理类是否已经存在，可以将代理分为静态代理和动态代理。如果需要对多个类进行代理，并且代理的功能都是一样的，用静态代理重复编写代理类就非常的麻烦，可以用动态代理动态的生成代理类。
设计模式虽多，但不要贪杯啊哈哈哈。
