封装、继承、多态

1. OOP（面向对象编程）的特征，原则并解释
   OOP，Object Oriented Programming
   OOD（面向对象的设计）
   OOA（面向对象的分析）
   特征：
       1- 封装，继承，多态
           1- 封装：
               1- 隐藏内部细节（提供私有属性），提供公有的方法访问（get,set方法），
               在这些方法中增加逻辑控制，限制对数据的不合理访问
               2- 把字段（成员变量）和实现细节隐藏起来，不允许外部直接访问
               把方法暴露出来，让方法控制这些成员变量进行安全的访问和操作
               优点：
                   1. 良好的封装能够减少耦合。
                   2. 类内部的结构可以自由修改，提高代码的可维护性。
                   3. 隐藏信息，实现细节，可以对成员变量进行更精确的控制。
                   4. 提高代码的复用性
                   5. 方便数据检查，有利于保护对象信息的完整性
               （private, public ,构造方法，this）
   
           2- 继承：(派生)
               1. 从多个已有类中提取共有的属性和方法，作为新类，让已有类继承，
                   已有类就可以去除相同的代码，通过extends继承新类的属性和方法
                    1- 新类（父类，基类，超类，根类，派生类）
                    2- 已有类（子类）
                    3- extends    this 类  super 父类
                    4- 继承的是public 和 protected (default)
                       权限修饰符能访问到的信息
                    5- 继承是单一继承，只能有一个直接父类，【但是可以多层继承】
                       继承关系是传递的
                    6- 所有的Java类都直接或间接地继承Java.lang.Object类。
                       Object类是所有java类的祖先。
                    7- 继承过程中，父类方法对某些子类不通用，
                       子类可以重写父类的不通用的方法(只重写方法体)
                       1- 子类重写方法权限修饰符>=父类
                       2- 子类重写方法异常<=父类
                    8- 类型转换
                       1- 子--》父 （自动类型提升-上转）
                       2- 父--》子 （强制类型转换-下转）
                    9- 父类：通用，子类：具体（扩展）
               优点：
                   1. 降低代码的耦合度（冗余度）
                   2. 提高了复用性
                   3. 提高了可维护性（修改方便）
                   4. 提高代码的健壮性（稳定性）
           3-多态：
               多态是同一个行为(方法)具有多个不同表现形式
               同一个接口(方法)，使用不同的实例而执行不同操作
           优点： boolean equals(Object object)
               1. 消除类型之间的耦合关系
               2. 可替换性
               3. 可扩充性
               4. 接口性
               5. 灵活性
               6. 简化性
           多态的前提：
               多态存在的三个必要条件
               1- 继承
               2- 重写
               3- 类型上转->父类引用指向子类对象：Parent p = new Child();
   
   七个原则：
       1- 单一职责原则：一个类应该只负责一件事情
       2- 开闭原则：
           软件中的对象(类，模块，函数等)应该对于扩展是开放的，但是对于修改是关闭的。
       3- 里氏替换原则：
           子类可以扩展父类功能，但是不能改变其原有的功能（必须继承父类提供的所有可以继承到的方法）。
       4- 依赖倒置原则：
           高层模块不应该依赖底层模块， 二者都应该依赖其抽象。
           抽象不应该依赖细节；细节应该依赖抽象。
           底层设计时，尽量使用接口或抽象类
      5- 接口隔离原则
           建立单一接口，不要建立庞大臃肿的接口，
           尽量细化接口，接口中的方法尽量少。
           各个类建立专用的接口，
           而不要试图去建立一个很庞大的接口供所有依赖它的类去调用
           1- A(1)
           2- B(2,3)
           3- C(4,5)
           A(1,2,3)  B(1,2,3) C(1,4,5) D(1,4,5)
      6- 迪米特法则:最少知识原则
           1- 一个对象和被调用方法的对象之间有最少的耦合关系，
               无需关注被调用方法具体实现，只关注调用（方法名，形参，返回值）
      7- 组合/聚合复用原则