在开始之前，我们先讲下面向对象设计模式的六大原则
单一职责原则
就一个类而言，应该仅有一个引起它变化的原因。简单来说，一个类中应该是一组相关性很高的函数，数据的封装。
我们在App中往往会用到很多的公共方法，比如获取系统的时间，这个功能可能在App中的很多地方都要用到。这个时候我们一般会单独写个工具类，把处理时间相关的方法都放到这个类里面，这样就能减少重复代码，App的结构会更加清晰。当需要添加其他跟时间相关的方法时，就可以都加到这个TimeUtils类里面，这就是我们平时遵循的单一职责原则。
开闭原则
软件中的对象(类，模块，函数等)，应该是对于扩展是开放的，对于修改是封闭的。
我们在软件开发过程中就要考虑到后续的扩展和修改。比如说，我们在开发一款类似于universal-image-loader的图片加载框架，可能一开始我们的功能比较简单，图片缓存只有内存缓存。当我们新版本需要添加SD卡缓存时，就要注意尽可能的减少对原来代码的修改，因为这样很可能会引入新的bug。而要做到开闭原则，一般有2中途径，一是通过继承原有的类；二是通过抽象和接口。
里式替换原则
所有引用基类的地方必须能透明的使用其子类。通俗的说，就是只要父类能出现的地方子类就可以出现，而且替换为子类以后不会出现任何错误或者异常。反过来就不行了，子类出现的地方父类不一定能适应。
要实现里氏替换原则，一般需要一个抽象的父类，父类中定义了子类的公共方法，子类继承或是实现父类以后扩展不同的功能，这样一来可以实现根据不同的需要来应用对应的子类，从而达到应用不同的功能的目的，程序的扩展性大大增强。同时这也体现了开闭原则，即当需要增加新功能时，只要继承或实现父类，实现新增的功能就达到了扩展的目的，而不是直接修改原来的代码，也即对扩展开放，对修改封闭。
依赖倒置原则
依赖倒置原则在Java中的表现就是：模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或者抽象类产生的。
一句话就是依赖抽象而不依赖具体的实现。比如上面我们说开发一个图片加载框架，那我们肯定会根据单一职责原则划分不同的模块，比如网络加载模块，图片缓存模块，以及主模块等。主模块肯定会调用图片缓存模块，如果我们调用的是图片缓存模块的具体实现，那么当我们修改图片模块时就很可能需要对应修改主模块，这就是耦合了，一个比较好的做法是将图片缓存模块抽象出来，而主模块调用这个抽象即可，这样也就是依赖抽象了。
接口隔离原则
类间的依赖关系应该建立在最小的接口上。
接口隔离原则就是让客户端依赖的接口尽可能的小。就是在上面提到的依赖倒置(依赖抽象而不是实现)原则的基础上，增加一个最小化依赖的原则。说白了就是在依赖接口的基础上依赖尽可能小的接口。
迪米特原则(又称最少知道原则)
一个对象应该对其他的对象有最小的了解。
通俗的讲，一个类应该对自己需要耦合或者调用的类知道得最小，调用者或者依赖者只要知道它需要的方法即可。要做到这个原则，需要我们对各个模块之间的功能进行很好的区分和分配，把相互之间的依赖和耦合减小到最小。
1.单例模式
所谓的单例设计指的是一个类只允许产生一个实例化对象。是最好理解的一种设计模式，分为懒汉式和饿汉式。
饿汉式:构造方法私有化，外部无法产生新的实例化对象，只能通过static方法获取到实例化对象。
public class Singleton {
//饿汉式
public static Singleton singleton=new Singleton();
//private 声明构造方法
private Singleton(){
}
public static Singleton getInstance(){
return singleton;
}
}
//Kotlin实现
object Singleton
线程安全的懒汉式:当第一次去使用Singleton对象的时候才会为其产生实例化对象的操作。
//Java实现
public class SingletonDemo {
private static SingletonDemo instance;
private SingletonDemo(){}
public static synchronized SingletonDemo getInstance(){//使用同步锁
if(instance==null){
instance=new SingletonDemo();
}
return instance;
}
}
//Kotlin实现
class SingletonDemo private constructor() {
companion object {
private var instance: SingletonDemo? = null
get() {
if (field == null) {
field = SingletonDemo()
}
return field
}
@Synchronized
fun get(): SingletonDemo{
return instance!!
}
}
}
大家都知道在使用懒汉式会出现线程安全的问题，需要使用使用同步锁，在Kotlin中，如果你需要将方法声明为同步，需要添加@Synchronized注解。
双重校验锁式:
public class LazySingleton {
//volatile保证了：1 instance在多线程并发的可见性
// 2 禁止instance在操作时的指令重排序
private static volatile LazySingleton instance=null;
private LazySingleton(){
}
public static LazySingleton getInstance(){
if(instance==null){ //第一次判空 保证不必要的同步
synchronized (LazySingleton.class){// synchronized对Singleton加全局锁，保证每次只要一个线程创建实例
if(instance==null){//第二次判空为了在null的情况下创建实列
instance=new LazySingleton();
}
}
}
return instance;
}
}
//kotlin实现
class LazySingleton private constructor() {
companion object {
val instance: LazySingleton by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
LazySingleton () }
}
}
当多个线程并发执行getInstance方法时，懒汉式会存在线程安全的问题，所以用到了synchronized来实现线程的同步，当一个线程获得锁的时候其他线程就只能再外等待其执行完毕。而饿汉式不存在线程安全的问题。
静态内部类
public class Singleton{
private static class SingletonHolder{
private staitc final Singleton INSTANCE=new Singleton();
}
private Singleton(){
}
public static Singleton getInstance(){
return SingletonHolder.INSTANCE;
}
}
//kotlin实现
class Singleton private constructor() {
companion object {
val instance = SingletonHolder.holder
}
private object SingletonHolder {
val holder= Singleton()
}
}
相比饿汉式，这种方式即使加载了Singleton类，也不会创建Singleton实例，因为Singleton的静态变量放到了内部类中，只有内部类被加载了，Singleton实例才会被创建。
枚举
public enum Singleton{
INSTANCE;
public static Singleton getInstance(){
return INSTANCE;
}
}
反编译之后的代码:
public final class Singleton extends java.lang.Enum{
public staitc final Singleton INSTANCE;
staitc{
INSTANCE=new Singleton();
}
public static Singleton getInstance(){
return INSTANCE;
}
}
类加载的逻辑位于synchronized代码块中，是线程安全的，而饿汉式，静态内部类已经枚举方式实现的单例实例化都处于类加载时机，所以它们都是线程安全的。
2.工厂设计模式
工厂模式分为工厂方法模式和抽象工厂模式
工厂方法模式分为三种：
1.普通工厂模式，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建
2.多个工厂方法模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。
3.静态工厂方法模式，将上面的多个工厂方法模式的方法设置为静态的，不需要创建实例，直接调用即可。
2.1 普通工厂模式
建立一个工厂类，对实现了同一接口的一些类进行实例的创建。
public interface Sender {
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 FactoryPattern {
public static void main(String[] args) {
Sender sender=produce("mail");
}
public static Sender produce(String str){
if("mail".equals(str)){
return new MailSender();
}else if("sms".equals(str)){
return new SmsSender();
}else {
System.out.println("输入错误...");
return null;
}
}
}
2.2 多个工厂方法模式
该模式是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。
interface Sender {
void Send();
}
class MailSender implements Sender {
@Override
public void Send() {
System.out.println("This is mail sender...");
}
}
class SmsSender implements Sender {
@Override
public void Send() {
System.out.println("This is sms sender...");
}
}
class SendFactory {
public Sender produceMail() {
return new MailSender();
}
public Sender produceSms() {
return new SmsSender();
}
}
public class FactoryPattern {
public static void main(String[] args) {
SendFactory factory = new SendFactory();
Sender sender = factory.produceMail();
sender.Send();
}
}
2.3 静态工厂方法模式
将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。
interface Sender {
void Send();
}
class MailSender implements Sender {
@Override
public void Send() {
System.out.println("This is mail sender...");
}
}
class SmsSender implements Sender {
@Override
public void Send() {
System.out.println("This is sms sender...");
}
}
class SendFactory {
public static Sender produceMail() {
return new MailSender();
}
public static Sender produceSms() {
return new SmsSender();
}
}
public class FactoryPattern {
public static void main(String[] args) {
Sender sender = SendFactory.produceMail();
sender.Send();
}
}
2.4 抽象工厂模式
工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要扩展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决?
那么这就用到了抽象工厂模式，创建多个工厂类，这样一旦需要新增新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。
public interface Sender {
void send();
}
public interface Provider {
Sender produce();
}
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 SendMailFactory implements Provider {
@Override
public Sender produce() {
return new MailSender();
}
}
public class SendSmsFactory implements Provider {
@Override
public Sender produce() {
return new SmsSender();
}
}
3.适配器模式
适配器模式是将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分三类：类的适配器模式，对象的适配器模式，接口的适配器模式。
3.1 类的适配器模式：
public class Source {
public void method1(){
System.out.println("This is origin method");
}
}
public interface Target {
/**
* 与原类中的方法相同
*/
public void method1();
/**
* 新类的方法
*/
public void mehtod2();
}
public class Adapter extends Source implements Target {
@Override
public void mehtod2() {
System.out.println("This is the target method...");
}
}
public class AdapterPattern {
public static void main(String[] args) {
Target target=new Adapter();
target.method1();
target.mehtod2();
}
}
3.2 对象的适配器模式
基本思路和类的适配器模式相同，只是将Adapter类作修改，这次不继承Source类，而是持有Source类的实例，以达到解决兼容性的问题。
class Source {
public void method1() {
System.out.println("This is original method...");
}
}
interface Targetable {
/**
* 与原类中的方法相同
*/
public void method1();
/**
* 新类的方法
*/
public void method2();
}
class Wrapper implements Targetable {
private Source source;
public Wrapper(Source source) {
super();
this.source = source;
}
@Override
public void method1() {
source.method1();
}
@Override
public void method2() {
System.out.println("This is the targetable method...");
}
}
public class AdapterPattern {
public static void main(String[] args) {
Source source = new Source();
Targetable targetable = new Wrapper(source);
targetable.method1();
targetable.method2();
}
}
3.3 接口的适配器模式
接口的适配器是这样的:有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。
/**
* 定义端口接口 ,提供通信服务
*/
public interface Port {
/**
* 远程SSH端口为22
*/
void SSH();
/**
* 网络端口80
*/
void NET();
/**
* Tomcat容器8080
*/
void Tomcat();
/***
* MySQL 数据库端口为3306
*/
void MySQL();
}
public abstract class Wrapper implements Port{
@Override
public void SSH() {
}
@Override
public void NET() {
}
@Override
public void Tomcat() {
}
@Override
public void MySQL() {
}
}
public class Chat extends Wrapper {
@Override
public void NET() {
System.out.println("Hello World...");
}
}
public class Server extends Wrapper {
@Override
public void SSH() {
super.SSH();
System.out.println("Connect success");
}
@Override
public void NET() {
super.NET();
System.out.println("WWW...");
}
@Override
public void Tomcat() {
super.Tomcat();
System.out.println("Tomcat is running...");
}
@Override
public void MySQL() {
super.MySQL();
System.out.println("MySQL is running...");
}
}
public class AdapterPattern {
static Port chatPort=new Chat();
static Port serverPort=new Server();
public static void main(String[] args) {
chatPort.NET();
serverPort.SSH();
serverPort.NET();
serverPort.Tomcat();
serverPort.MySQL();
}
}
4.装饰模式
就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。
就增加功能来说，装饰模式比生成子类更为灵活。
public interface Shape {
void draw();
}
/**
* 实现接口的实体类
*/
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Shap:Rectangle...");
}
}
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Shap:Circle...");
}
}
/**
* 创建实现了Shape接口的抽象装饰类
*/
public abstract class ShapDecorator implements Shape {
protected Shape decoratedShap;
public ShapDecorator(Shape decoratedShap){
this.decoratedShap=decoratedShap;
}
@Override
public void draw() {
decoratedShap.draw();
}
}
/***
* 创建扩展自ShapeDecorator类的实体装饰类
*/
public class RedShapDecorator extends ShapDecorator {
public RedShapDecorator(Shape decoratedShap) {
super(decoratedShap);
}
@Override
public void draw() {
super.draw();
setReeBorder();
}
private void setReeBorder(){
System.out.println("Border Color:Red");
}
}
public class DecoratorPattern {
public static void main(String[] args) {
Shape circle=new Circle();
Shape redCircle=new RedShapDecorator(new Circle());
Shape redRectangle=new RedShapDecorator(new Rectangle());
}
}
5.享元模式
简单描述一下就是一批对象中既有相同的内容也有不同的内容，相同的内容采用共享的方式，不同的内容通过动态传递的方式，来尽量减少对象的产生。
使用场景
最常见的一个场景就是Java JDK里面的String字符串类，因为JVM中有常量池，常量池的实现就是一种享元模式，避免多个相同对象的存在。另外线程池以及很多用到缓冲池的地方也采用了享元模式，比如Integer类中默认缓存了-128-127之间的整数。等
public interface IFlyweight{
void setDetail(int width,int height);
}
public class FlyweightImpl implements IFlyweighet{
private Color color;
private int width;
private int height;
@Override
public void setDetail(int width,int height){
this.width=width;
this.height=height;
System.out.println(toString());
}
public FlyweightImpl(Color color){
this.color=color;
}
}
public class FlyweightFactory{
private Map colorFlyweightMap=new HashMap<>()
//根据名称获取对象
public FlyweightImpl getFlyweight(String colorName){
if(colorflyweightMap.containsKey(colorName)){
return colorFlyweightMap.get(colorName)
}else{
Color color=new Color(colorName);
FlyweightImpl impl=new FlyweightImpl(color);
colorFlyweightMap.put(colorName,impl);
return impl;
}
}
}
//Color类
public class Color{
private String type;
public Color(String type){
this.type=type;
}
}
public static void main(String[] args){
FlyweightFactory factory=new FlyweightFactory();
IFlyweight flyweight0=factory.getFlyweight("red");
flyweight0.setDetail(100,200);
IFlyweight flyweight1=factory.getFlyweight("red");
flyweight1.setDetail(300,400);
IFlyweight flyweight2=factory.getFlyweight("green");
flyweight2.setDetail(500,600);
System.out.println(flyweight0==flyweight1)
System.out.println(flyweight0==flyweight2)
}
上面测试类中，我们分别定义了两种颜色的三个对象，由于相同颜色的对象已经被缓存了，所以我们输出的结果如下
true
false
从上面的运行结果中，我们可以看出，flyweight0 与flyweight1 其实是同一个对象，虽然他们的 width 和 height 属性值不一样，但是他们的底层对应的是同一个对象本身。这就是享元模式的核心内容，通过共享变量，来减少对象的产生，从而减少内存的使用。