前言：
最近对设计模式很是着迷，虽然心里念念不忘Rxjava操作符，但是没有看过源码，就想自己实现起来还是很难得，况且再下能力还不达标，所以闲暇时间就想看下简单的，比如设计模式，想着以后自己也能多get一项技能，至少让代码看起来更加美观那样咯
关于java的设计模式，我百度到了一些，原本想全部一一讲诉，后来发现还是有些难度，有些设计模式从来没见过，应该是见识短浅，于是就挑了一些比较感兴趣的来介绍
设计模式分3种，分别是创建型，结构型，行为型
1.创建型设计模式
1.1 工厂模式：
这个设计模式就是使用一个静态方法返回同一个接口不同实现类，比如定义一个接口IModule
public interface IModule {
void action();
}
分别有3个实现类
public class ModuleA implements IModule
public class ModuleB implements IModule
public class ModuleC implements IModule
然后使用静态方法可以根据不同类型返回对应实现类，比如：
public class ModuleFactory {
public static IModule getModule(int type){
switch (type) {
case 0:
return new ModuleA();
case 1:
return new ModuleB();
default:
return new ModuleC();
}
}
}
1.2 抽象工厂模式：
这个设计模式相当于提取1.1里面工程类ModuleFactory的方法作为接口，然后创建该接口的指定实现类，如下：
public interface IFactory {
IModule getModule();
}
然后创建该接口实现类工厂：
public class ModuleAFatory implements IFactory {
@Override
public IModule getModule() {
return new ModuleA();
}
}
public class ModuleBFactory implements IFactory {
@Override
public IModule getModule() {
return new ModuleB();
}
}
public class ModuleCFactory implements IFactory {
@Override
public IModule getModule() {
return new ModuleC();
}
}
上面创建ABC的指定生产工厂，然后在需要的时候使用：
IModule moduleA = new ModuleAFactory().getModule();
IModule moduleB = new ModuleBFactory().getModule();
IModule moduleC = new ModuleCFactory().getModule();
这样做的好处就是让指定工厂来生产特定商品，但是比1.1多出了接口文件和几个实现的工厂类
1.3 建造者模式
这种设计模式就是为了方便构建有很多属性的变量，在初始化情况下有很多默认值可以设置或者不设置，而且该对象不能直接new产生，只能由内部类生成，用于保护对象
举个例子：
定义一个接口：
public interface IAction {
void doSomething();
}
使用建造者模式返回一个实现对象：
public class SingleManager implements IAction{
private String arg1;
private String arg2;
private int avg1;
private int avg2;
private SingleManager(){}
void setArg1(String arg1) {
this.arg1 = arg1;
}
void setAvg1(int avg1) {
this.avg1 = avg1;
}
@Override
public void doSomething() {
//do other things
}
public static class Builder{
private String arg1 = "default";
private String arg2 = "default";
private int avg1 = 1;
private int avg2 = 2;
public Builder setArg1(String arg1) {
this.arg1 = arg1;
return this;
}
public Builder setArg2(String arg2) {
this.arg2 = arg2;
return this;
}
public Builder setAvg1(int avg1) {
this.avg1 = avg1;
return this;
}
public Builder setAvg2(int avg2) {
this.avg2 = avg2;
return this;
}
public IAction build(){
SingleManager singleManager = new SingleManager();
singleManager.setArg1(this.arg1);
singleManager.setAvg1(this.avg1);
return singleManager;
}
}
}
这是一个简单的类，里面有4个参数，使用builder内部类创建，有默认值可以被覆盖，使用build方法来产生该对象，或者返回该对象实现的接口，增加接口，提取方法，这样做的好处就是可以很好封装这个类，让外部只能初始化一次，并且只能通过接口访问其方法，很好隐藏里面内容的实现，缺点也有，就是多了内部类，然后代码也有些重复
1.4 单例模式
这个模式我想见过的人太多了，只讲3种同步的实现
第一种：静态初始化
public class SingleTon {
public static SingleTon singleTon = new SingleTon();
}
第二种：双重锁
public class SingleTon {
private SingleTon() {
}
private static SingleTon instance;
public static SingleTon getInstance(){
if(instance==null){
synchronized(SingleTon.class){
if(instance==null){
instance=new SingleTon();
}
}
}
return instance;
}
}
第三种：内部类
public class SingleTon {
static class Creator{
public static SingleTon singleTon = new SingleTon();
}
private SingleTon() {
}
public static SingleTon getInstance(){
return Creator.singleTon;
}
}
1.5 原型模式
该设计模式就是将一个类型复制，返回复制之后的对象，一般实现Cloneable接口表示这个对象可以被拷贝，否则调用clone会出错
public class MyObject implements Cloneable{
@Override
public MyObject clone() throws CloneNotSupportedException {
return new MyObject();
}
}
结构性设计模式
2.1 适配器模式
使用适配器模式有2种情况，第一种是扩展新方法，继承原类，并且实现新的接口，这个方法我感觉不好，但是能用，返回类型会定死，第二种就是引用原类，修改之前的接口方法，这个方法需要修改之前定义的接口，个人感觉也不是很好，毕竟需要适配嘛
假设有一个接口定义如下：
public interface IAction {
void execute();
}
实现类：
public class ModuleAction implements IAction{
@Override
public void execute() {
//do something
}
}
然后现在由于功能变更，需要加入新的功能。那么就可以这样：
第一种方式：
添加新的接口
public interface IAction2 {
void doAction();
}
类继承扩展实现新接口
public class IAction2Impl extends ModuleAction implements IAction2{
@Override
public void doAction() {
}
}
第二种方式
接口扩展：
public interface IActionSub extends IAction{
void doAction();
}
然后适配原先的类型：
public class IActionAdapter implements IActionSub{
IAction parent;
public IActionAdapter(IAction parent) {
this.parent = parent;
}
@Override
public void execute() {
this.parent.execute();
}
@Override
public void doAction() {
//other action
}
}
这样IActionAdapter不会修改之前的类型，也对其进行扩展了doAction方法
以上2种方法我个人偏爱第二种，不过具体情况具体分析咯
2.2 装饰模式
这种模式用于对一个类型变量进行引用装饰，并添加额外的操作或者修饰，主体部分调用类的相同的方法
举个例子：
刚才上面我们看到IActionAdapter 实现了IActionSub接口，如果我们需要调用这个接口需要相同方法并且加入一些其他操作该怎么包装呢？
下面看这个包装类可行不？
public class IModuleDecr implements IActionSub{
private IActionSub sub;
public IModuleDecr(IActionSub sub) {
this.sub = sub;
}
@Override
public void execute() {
sub.execute();
//add process others op
}
@Override
public void doAction() {
sub.doAction();
//add process action op
}
}
这个方法对IActionSub的实现类进行引用，然后也实现这个接口，在接口实现体里面进行引用调用，然后//add process 用于进一步操作或者修饰这个方法，这就保证之前的动作不被修改，而且也对之前的操作进行了修饰，这就是装饰模式，引用原类，实现相同接口，调用原类方法并添加额外操作。
2.3 代理模式
关于代理模式，顾名思义，就是外部通过代理类来访问，而代理类实现细节，具体实现由目标对象实现，这样可以增加或者扩展目标对象的功能
说的有些懵，直接上代码：
public class IActionProxy implements IActionSub{
private IActionSub mActionSub;
public IActionProxy() {
mActionSub = new IActionAdapter(new ModuleAction());
}
@Override
public void execute() {
mActionSub.execute();
}
@Override
public void doAction() {
mActionSub.doAction();
}
}
承接上面接口，这是一个代理类，他对外的方法只有接口方法，但是具体实现却是由IActionAdapter来实现的，我们把IActionAdapter看成目标对象，那么IActionProxy就是代理对象，这样就好像外部使用IActionProxy来调用接口方法，但是真正的实现是目标对象IActionAdapter来实现的，这就是代理，对外部不可见，具体实现由目标对象实现，方便扩展于修改
到这里，读者或者有些奇怪，适配器模式，装饰模式，代理模式有什么区别呢，怎么看上去都是一样的呢，笔者刚刚学习的时候也会产生这样的想法，后来仔细做了一些比较还是发现了一点点不同的。
——适配器模式：继承类并实现新扩展接口或者引用类实现继承扩展的新接口，这个都是对原类引用。
——装饰模式：也是对原类引用，但是却实现原类相同接口，并在接口方法调用引用对象的方法，然后再方法内部做一些其他操作起到装饰作用。
——代理模式：这个模式不会引用原类，其实只对外提供接口方法，但是具体实现由目标对象，真正的实现类来实现，这就相当于封装之类，外面不知道究竟谁实现了，只管使用。
未完待续
