设计模式——面向对象设计原则

面向对象设计原则

都是为了高内聚低耦合原则。编程时基本都要遵守

单一职责原则

分类原则：一种人只干一种事。

举例：（比较简单就不代码了）

人可以干的事情有很多：敲代码、唱歌、跳舞、打篮球….以人设置成一个类，里面的方法就太多太杂了。所以可以有多个类：程序员（敲代码）、音乐人（唱歌）、爱豆（跳舞）、NBA球员（打篮球）。这样类就具体化了，可以干的事情也就具体了，一旦需要用哪个方法就知道从哪个类里调用了。

开闭原则

开：提供方提供 抽象类/接口/方法 等，实现类可以决定行为。闭：调用方调用时，尽量不需要修改代码。

定义：一个软件实体，比如类、模块和函数应该对扩展开放，对修改关闭。其中，对扩展开放是针对提供方来说的，对修改关闭是针对调用方来说的。

举例：

//接口 public interface AccountService {     //实现注册账户     void createAccount(String username,String password,String email);  }  //实现类 public class AccountServiceImpl implements AccountService {         public void createAccount(String username,String password,String email) {             ....         } } 

里氏替换原则

对子类的特别定义：父类方法非抽象方法，子类不可以重载（覆盖）。但如果父类有抽象方法则子类必须实现父类的抽象方法，子类也可以编写自己的方法

里氏替换原则（Liskov Substitution Principle）是对子类型的特别定义。所有引用基类的地方必须能透明地使用其子类的对象。

白话：子类可以扩展父类的功能，但不能改变父类原有的功能。有以下四原则：（重点在一二）

1. 子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。
2. 子类可以增加自己特有的方法。
3. 当子类的方法重载父类的方法时，方法的前置条件（即方法的输入/入参）要比父类方法的输入参数更宽松。
4. 当子类的方法实现父类的方法时（重写/重载或实现抽象方法），方法的后置条件（即方法的输出/返回值）要比父类更严格或与父类一样。

如：子类继承了父类，但没有修改父类的非抽象方法

public abstract class Coder {      public abstract void eat();   //这个行为还是定义出来，但是不实现      public void coding() {         System.out.println("我会打代码");     }       class JavaCoder extends Coder{         public void game(){  //子类自己的额外的方法             System.out.println("艾欧尼亚最强王者已上号");         }                  public void eat(){ //子类实现父类的抽象方法（必须）             System.out.println("干啥啥不行，干饭第一名！")         }     } } 

依赖倒转原则

使用Spring注解 注入接口，这样需求更改后实现类可以自由编写，不会影响到controller层（将每一层都分隔开来降低耦合性）

定义：高层模块不应依赖于底层模块，它们都应该依赖抽象。抽象不应依赖于细节，细节应该依赖于抽象。

传统：没有接口而是类与类之间的对象创建。一旦需求变化，类就需要重写，这样其他类也需要修改

public class Main {      public static void main(String[] args) {         UserController controller = new UserController();     }      static class UserMapper {         //CRUD...     }      static class UserServiceNew {   //由于UserServiceNew发生变化，会直接影响到其他高层模块         UserMapper mapper = new UserMapper();         //业务代码....     }      static class UserController {   //焯，干嘛改底层啊，我这又得重写了         UserService service = new UserService();   //哦豁，原来的不能用了         UserServiceNew serviceNew = new UserServiceNew();   //只能修改成新的了         //业务代码....     } } 

Spring框架：使用注解注入接口bean，这样实现类可随便改，只要最后的实现类实现了该接口即可

//controller public class LoginApiController {     @Autowired //Spring注解注入接口bean     private VerifyService verifyService;      @GetMapping("/verify-code")     public RestBean<Void> verifyCode(@RequestParam("email") String email) {         try {             verifyService.sendVerifyCode(email);             return new RestBean<>(200, "邮箱发送成功!");         } catch (Exception e) {             return new RestBean<>(500, "邮箱发送失败!");         }     } }           

接口隔离原则

对接口进行细分，避免接口中定义的方法，在实现类中用不上。

举例：定义一个接口，有方法：设备芯片、设备名称、设备内存。这样的接口只有电脑、手机等实现类才可以实现，而对于风扇、台灯等普通设备实现类而言确只有设备名称才是有效的方法。于是就需要把接口进行细化成两个接口。

interface SmartDevice {   //智能设备才有getCpu和getMemory     String getCpu();     String getType();     String getMemory(); }  interface NormalDevice {   //普通设备只有getType     String getType(); }  //电脑就是一种电子设备，那么我们就继承此接口 class Computer implements SmartDevice {      @Override     public String getCpu() {         return "i9-12900K";     }      @Override     public String getType() {         return "电脑";     }      @Override     public String getMemory() {         return "32G DDR5";     } }  //电风扇也算是一种电子设备 class Fan implements NormalDevice {     @Override     public String getType() {         return "风扇";     } } 

合成复用原则

优先使用对象组合，而不是通过继承来达到复用的目的。

合成复用原则（Composite Reuse Principle）的核心就是委派。

情况：如果A类里写了想要的方法，为了不在B类不重复编写代码，可以在B类中设置一个方法：将A类的对象作为参数并在设置的方法里通过对象获取到A类中想要的方法。【此时不建议使用继承，因为容易引起安全隐患，如：A中有一下信息(密码字段)不方便传递】

举例：

class A {     public void connectDatabase(){         System.out.println("我是连接数据库操作！");     } }  class B {          A a;     public B(A a){   //在构造时就指定好         this.a = a;     }          public void test(){         System.out.println("我是B的方法，我也需要连接数据库！");         a.connectDatabase();   //也是通过对象A去执行     } } 

迪米特法则

每一个软件单位对其他单位都只有最少的知识，而且局限于那些与本单位密切相关的软件单位。

迪米特法则（Law of Demeter）又称最少知识原则，是对程序内部数据交互的限制。

简单来说就是，一个类/模块对其他的类/模块有越少的交互越好。当一个类发生改动，那么，与其相关的类（比如用到此类啥方法的类）需要尽可能少的受影响（比如修改了方法名、字段名等，可能其他用到这些方法或是字段的类也需要跟着修改）这样我们在维护项目的时候会更加轻松一些。

白话：在设计方法参数的时候，保证不多给方法多余的参数。例如：方法只需要一个用户的ip地址就可以执行，方法参数就不要写成需要输入用户对象，然后在方法里面通过对象再去调用其ip出来；而是在调用方法前就把用户对象的ip取出来，然后作为参数来调用方法。

举例：

正面教材

public class Main {     public static void main(String[] args) throws IOException {         Socket socket = new Socket("localhost", 8080);         Test test = new Test();         test.test(socket.getLocalAddress().getHostAddress());  //在外面解析好就行了     }      static class Test {         public void test(String str){   //一个字符串就能搞定，就没必要丢整个对象进来             System.out.println("IP地址："+str);         }     } } 

反面教材

public class Main {     public static void main(String[] args) throws IOException {         Socket socket = new Socket("localhost", 8080);   //假设我们当前的程序需要进行网络通信         Test test = new Test();         test.test(socket);   //现在需要执行test方法来做一些事情     }      static class Test {         /**          * 比如test方法需要得到我们当前Socket连接的本地地址          */         public void test(Socket socket){             System.out.println("IP地址："+socket.getLocalAddress());         }     } }