软件开发设计模式

设计模式的六大原则

单一职责原则
一个类应当只有一个职责且应当只有一个引起他变化的原因。
这个主要是为了类的高聚合，低耦合，防止牵一发而动全身的现象出现。
比如说我们有一个Mobile的接口类，里面有CPU，RAM的属性的Getter和Setter，以及打电话，看视频，听音乐的功能。
我们不应该把所有的功能和职责都放一起的，比如说一旦我们加入一个新的属性：像素，那么全部实现该接口的类都会收到影响，所以这个基础上我们可以进一步拆分：MobileProperty接口以及MobileFunction接口，那么如果我们更改了属性的话，只有MobileProperty接口的实现类会受到影响，影响范围就一下子缩小了，再进一步我们可以把MobileFunction划分为：MobileBasicFunction以及MobileExtensionFunction，MobileBasicFunction里有充电和打电话的功能，而其余什么花里胡哨的新增功能比如指纹解锁啊，人脸识别就可以放入MobileExtensionFunction里了。（比如小灵通可能就只实现了MobileBasicFunction接口，那么无论MobileExtensionFunction怎么修改，都不会影响到他，但是如果所有功能都放到一起的话，那小灵通也必须实现各种新奇的功能了。）

里氏替换原则
子类必须能在任何父类出现的地方替换他，且不出现差错
这个主要是因为继承引起的，因为一方面继承提供了代码的复用性和可扩展性但是同时也提高了代码的耦合，这意味着父类的任何修改都要考虑到对子类的影响，很可能造成大范围的影响。

依赖倒置原则
高层模块不应依赖低层模块，两者都应该依赖他们的抽象，抽象不应该依赖细节，细节应该依赖抽象。换句话说：面向接口编程而不是面向实现类编程。
因为实现类是多变的，而抽象类相较实现类趋于稳定。所以为了程序的稳定性和低耦合性，我们都应当遵循这个原则（具体做法就是面向接口编程）
比如说Customer类里有个Buy()的方法，参数要指定一个Shop，那么我们肯定是要把这个Shop变为一个接口而不是一个具体的实现类，不然的话，Ashop要写一个方法，Bshop又要重载一个方法（因为参数不同）。

迪米特法则
也就是“最少知识原则”，也就是一个对象尽量少的与其他对象发生联系。

1. 只与你的朋友通信
2. 不与陌生人通信
3. 尽量只对其他单位保持最少的了解
   这个目的其实也很简单，就是为了降低耦合而已，你与其他类的关系越密切，那么就意味着你们之间的依赖就更多，你们之间的联系就更紧密，这不就是高耦合了嘛。

开闭原则
对扩展开放，对修改关闭
这其实很好理解，为了系统的稳定性，我们不应当修改类本来就有的行为，因为很显然这会造成很多连锁反应，而为了系统的灵活性，我们又要保持开放，在不改变原先行为的前提下增加新的功能。因为类的功能也要与时俱进嘛。

接口隔离原则
不依赖不需要的接口，如果要依赖，确保这是最小的接口。
其实也是为了保证类的“纯净”，实现多个单一功能的接口远好于实现一个具有很多功能的接口，因为这样可以确保类不会被强迫实现那些他不需要的接口！确保了类的纯净。

说说单例模式的优势
单例模式就是指产生一个对象，然后共用该单例，这样做的优点就是：减少多次创建对象的消耗，我们直接创建一个单例，永驻内存中，这样就不需要多次消耗资源创建销毁了。

说说懒汉模式和饿汉模式的区别
懒汉模式就是等用到了再去创建，这就避免了内存泄漏，但是线程不安全。
饿汉模式则是一开始就创建好，所以天生就是线程安全的，但是有一个内存泄漏的问题，因为你可能加载静态代码块的时候创建了但是永远都没有用到，就造成了内存泄漏。

//懒汉模式
public class Singleton {

    private static Singleton singleton;
    
    private Singleton(){}

    public static Singleton getInstance(){
        if(singleton!=null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

//饿汉模式
public class Singleton {

  private static Singleton singleton = new Singleton();
  
  private Singleton(){}
  
  public static Singleton getInstance(){
      return singleton;
  }
}

既然说懒汉模式是线程不安全的如何实现懒汉模式的线程安全？

public class Singleton {

    private static Singleton singleton;

    private Singleton(){}

    synchronized public static Singleton getInstance(){
        if(singleton!=null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

说说你对工厂模式的理解
首先工厂模式主要分简单工厂，工厂方法以及抽象工厂。我们说的工厂模式一般默认指的是工厂方法。
比如说简单工厂，简单工厂就是一个工厂可以产出所有实现了同一接口的实例。比如说：

class ShapeFactory {
         public static Shape getShape(String type) {
             Shape shape = null;
             if (type.equalsIgnoreCase("circle")) {
                 shape = new CircleShape();
             } else if (type.equalsIgnoreCase("rect")) {
                 shape = new RectShape();
             } else if (type.equalsIgnoreCase("triangle")) {
                 shape = new TriangleShape();
             }
             return shape;
         }
  }

所有实现了shape接口的类都可以通过该工厂实例化出来。
这么做的好处其实就是封装代码，避免各个类中重复写实例化对象的代码（尤其是创建过程比较复杂的时候）而工厂方法则是更进一步地细分，比如说为某个类单独设立该类的工厂，而不是所有的类都由一个工厂来实现。

// jpg加载器工厂
class JpgReaderFactory implements ReaderFactory {
    @Override
    public Reader getReader() {
        return new JpgReader();
    }
}
// png加载器工厂
class PngReaderFactory implements ReaderFactory {
    @Override
    public Reader getReader() {
        return new PngReader();
    }
}
// gif加载器工厂
class GifReaderFactory implements ReaderFactory {
    @Override
    public Reader getReader() {
        return new GifReader();
    }
}

这其实就体现了我们设计原则里面的**“单一职责原则”**，好处也显而易见，类间的耦合降低了，很显然所有的类都在一个类中创建的话，那么这个工厂与其他类的耦合肯定是非常高的。但是你遵循单一职责后，耦合就被平均分散了。