⾯向对象设计原则+Java设计模式的总结

1.面向对象设计原则

1.开闭原则

简单理解就是当我们有新的功能需要去实现的时候，不用去修改以前的代码，而是添加新的代码。

public interface SELL {
    public void sell();
}

public class SHOP implements SELL {
    @Override
    public void sell() {
        System.out.println("buy something");
    }
}

public class People {
    public void buy(SELL sell){
        sell.sell();
    }
}

public class test {
    public static void main(String[] args) {
        People people=new People();
        people.buy(new SHOP());
    }
}

如果我们想要添加商店的话就只需要添加一个实现接口的类（这里也可以用匿名内部类来处理）

2.单一职责原则

一个对象一个只包含单一的职责，并且该职责被完整地封装在一个类中。每一个类只需要完成自己的那一个任务就可以了。

3.迪米特法则（最少知识原则）

一个类对于其他类知道的越少越好，就是说一个对象应当对其他对象有尽可能少的了解,只和朋友通信，不和陌生人说话。（摘自百度）
一个类应该尽少于其他实体相互作用 。

4.合成复用原则

优先使用对象组合，而不是继承。

public class Test{ 
  public void TestMethod1（）{
 System.out.println("我是Test方法1");
}
  public void TestMethod2（）{
 System.out.println("我是Test方法2");
}
public void TestMethod3（）{
 System.out.println("我是Test方法3");
}
}
}

这个时候我们有另外一个类想调用Test的方法，我们首先想到的肯定是继承来实现。可是如果Test增加了一个方法，与这个类毫无关系。这么办了？

//依赖
public class Test2{
  public void TestMethod1（Test test）{
  System.out.println("调用方法1");
  }
}
//聚合
public class Test3 {
    private Test test;
    public void setTest(Test test){
        test=test;
    }
}
//合成
public class D {
    public Test test=new Test();
}

这样就可以解决问题了。

5.接口隔离原则

将庞大臃肿的接口拆成小的接口。这样可以避免去实现不需要实现的接口。这个我个人感觉和单一职责原则有些相似的地方。

6.依赖倒转原则

高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。其核心思想是：要面向接口编程，不要面向实现编程。我个人觉得这里可以和开闭原则结合起来理解。

7. 里氏代换原则

所有引用基类的地方必须能透明地使用其子类的对象。父类的对象可以转化为子类的对象。但子类的对象不可以反过来转化为父类的对象。

Fruit fruit=new Fruit();
Apple apple=new Apple();
(Fruit)apple;//可行
(Apple)fruit；//不可行

2.一些设计模式

1.单列模式

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

public class SingletonPattern {
    private static final SingletonPattern singletonPattern=new SingletonPattern();

    private SingletonPattern(){

    }

    public static SingletonPattern getSingletonPattern() {
        return singletonPattern;
    }

    public static void Do(){
        
    }

}

2.抽象工厂模式

为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。

3.建造者模式

这个较简单，就是讲生产的过程和结果分开。

4.适配器模式

将一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。Android的Recyclerview的适配器就是一个很好的例子。

5.观察者模式

定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。具体讲解菜鸟教程观察者模式

6.备忘录模式（快照模式）

保存一个对象的某个状态，以便在适当的时候恢复对象。备忘录模式属于行为型模式。就是编程中的后悔药。

public class MementoPattern {
    private String state;

    public MementoPattern(String state){
        this.state=state;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
}
public class Originator {
    private String  state;

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
    public MementoPattern createMemento(){
        return new MementoPattern(state);
    }
    public  void restoreMemento(MementoPattern mementoPattern)
    {
        this.setState(mementoPattern.getState());
    }
}
public class Caretaker {
    private MementoPattern memento;
    public void setMemento(MementoPattern m)
    {
        memento=m;
    }
    public MementoPattern getMemento()
    {
        return memento;
    }
}
public class Test {
    public static void main(String[] args) {
        Originator or=new Originator();
        Caretaker cr=new Caretaker();
        or.setState("S0");
        System.out.println("初始状态:"+or.getState());
        cr.setMemento(or.createMemento()); //保存状态
        or.setState("S1");
        System.out.println("新的状态:"+or.getState());
        or.restoreMemento(cr.getMemento()); //恢复状态
        System.out.println("恢复状态:"+or.getState());
    }
}

7.装饰模式

指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。

8.状态模式

当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类。具体例子，我觉得这位大佬的写得很好

9.责任链模式

为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。我觉得就是一个对于请求判断的执行。

3.总结

     本篇文章是本人的一些简要总结，参照了一些大佬的文章，可能会有一些理解上的错误，还请指出。