封装

1. 封装概述

利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体。
数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。用户无需知道对象内部的细节，但可以通过对象对外提供的接口来访问该对象。

2. 优点

  • 减少耦合：可以独立地开发、测试、优化、使用、理解和修改
  • 减轻维护的负担：可以更容易被程序员理解，并且在调试的时候可以不影响其他模块
  • 有效地调节性能：可以通过剖析确定哪些模块影响了系统的性能
  • 提高软件的可重用性
  • 降低了构建大型系统的风险：即使整个系统不可用，但是这些独立的模块却有可能是可用的

3.封装的实现—使用访问控制符

Java是使用“访问控制符”来控制哪些细节需要封装，哪些细节需要暴露的。
在Java中有四种访问控制权限，分别为private、default、protected、public。
它们说明了面向对象的封装性，所以我们要利用它们尽可能的让访问权限降到最低，从而提高安全性。

private default protected public
同一类 √ √ √ √
同一包中的类 √ √ √
不同包的子类 √ √
其他包中的类 √
  1. private 表示私有，只有自己类能访问
  2. default表示没有修饰符修饰，只有同一个包的类能访问
  3. protected表示可以被同一个包的类以及其他包中的子类访问
  4. public表示可以被该项目的所有包中的所有类访问


4.使用细节

类的属性的处理

  1. 一般使用private访问权限。
  2. 提供相应的get/set方法来访问相关属性，这些方法通常是public修饰的，以提供对属性的赋值与读取操作 (注意：boolean变量的get方法是 is 开头!) 。
  3. 一些只用于本类的辅助性方法可以用private修饰，希望其他类调用的方法用public修饰。

继承

1. 继承概述

继承实现了 IS-A 关系，例如 Cat 和 Animal 就是一种 IS-A 关系，因此 Cat 可以继承自 Animal，从而获得 Animal 非 private 的属性和方法。
继承应该遵循里氏替换原则，子类对象必须能够替换掉所有父类对象。

Cat 可以当做 Animal 来使用，也就是说可以使用 Animal 引用 Cat 对象。
父类引用指向子类对象称为 向上转型 。

  1. Animal animal = new Cat();

2. 优点

  • 提高了代码的复用性
  • 提高了代码的维护性
  • 在类与之间产生了关系，是多态的前提

3. Java中继承特点

  • Java只支持单继承，不支持多继承
  • Java中类没有多继承，接口有多继承。
  • Java支持多层继承
  • 如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object。

4. Java中继承注意事项

  • 子类只能继承父类所有非私有成员（成员方法和成员变量）
  • 子类不能继承父类的构造方法，但是可以通过super关键在去访问父类构造方法
  • 不要为了部分功能而去继承
  • 继承中类之间体现的是“is a”的关系。

5. 继承中构造方法

  1. 子类中所有的构造方法默认会都会访问父类中空参数的构造方法

原因：因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要完成父类数据的初始化。
每一个子类的构造方法第一条语句默认是：super();

  1. 若父类没有无参的构造方法，则需要主动调用父类的构造方法。

子类通过super去显示调用父类其他的带参的构造方法

6. 继承中成员方法的关系

重写（Override）: 子类和父类中出现了一模一样的方法声明
方法的重写需要符合下面的三个要点：

  1. == ： 方法名、形参列表相同。
  2. ≤ ：返回值类型和声明异常类型，子类小于等于父类。
  3. ≥ ： 访问权限，子类大于等于父类。

注意：

  1. 父类中私有成员方法不能被重写（因为父类中私有成员方法不能被继承）
  2. 子类重写父类中方法时，访问权限不能更低（最好一致）
  3. 父类是静态方法时，子类也必须通过静态方法进行重写。
  4. 子类和父类的声明最好一模一样。

多态

1. 多态概论

  • 多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）
  • 实现多态的技术：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。方法在默认情况下是动态绑定的
  • 多态的作用：消除类型之间的耦合关系。

    2. 多态分类

多态分为编译时多态和运行时多态

  • 编译时多态：主要指方法的重载
  • 运行时多态：指程序中定义的对象引用所指向的具体类型在运行期间才确定，通过动态绑定实现

3.多态的体现

  1. 对象的多种形态
    1. 引用多态：父类的引用可以指向本类对象，父类的引用可以指向子类对象。
    2. 方法多态：创建本类对象时，调用的方法为本类方法。创建子类对象时，调用的方法可以是子类重写的方法或者继承的方法。
  2. 重写(override)
    方法名称、参数个数、类型均一致
  3. 重载(overload)
    具有不同的参数列表。
    方法名称一致，返回类型可以不一致，但参数列表必须不同

  4. 引用类型转换

    1. 向上转型：将导出类看做是它的基类的过程。将子类对象的引用视为父类对象的引用

      1. class A{
      2. public void f()
      3. }
      4. class B extends A{
      5. public void f()
      6. }
      7. public class Test{
      8. public static void play(A a){}
      9. public static void main(String[] args){
      10.   B b=new B();
      11.   play(b); // upcasting
      12. }
      13. }

    2. 向下转型：向下转型为更具体的类型。父类对象可以转换为子类对象，但需强制转换
      运行时类型识别(RTTI)：在运行期间对类型进行检查的行为

      1. class A{
      2. public void f(){}
      3. public void g(){}
      4. }
      5. class B extends A{
      6. public void f(){}
      7. public void g(){}
      8. public void u(){}
      9. }
      10. public class RTTI{
      11. public static void main(String[] args){
      12.   A[] x ={new A(),new B()};
      13.   x[0].f();
      14.   x[1].g();
      15.   // Compile time : method not found in A
      16.   //! x[1].u();
      17.   ((B)x[1]).u(); // Downcast/RTTI
      18.   ((B)x[0]).u(); // Exception thrown
      19. }
      20. }

  5. instanceof
    避免类型转换的安全性问题。
    可以用instanceof判断一个类是否实现某个接口，也可以判断一个实例对象是否属于某个类型或者某个类型的子类
    用法：对象 instanceof 类（或接口）—-> return Boolean值

4. 多态的好处和弊端

好处

提高了代码的维护性（由继承保证）
提高了程序的扩展性（由多态保证）

弊端

不能访问子类特有功能（特有方法）
如何访问子类中的特有功能？

  • 方法一：将父类的引用强制转换为子类的引用，即向下转型
  • 方法二：创建子类对象调用方法（可以，但是不合理，并且占内存）
  1. /**
  2. * 对象间的转型问题：
  3.     向上转型：
  4.         Parent f = new Child();
  5.     向下转型：
  6.         Child z = (Child)f; //要求该f必须是能够转换为Zi的。(父到子)
  7.  */
  8. class Parent {
  9.     public void show() {
  10.         System.out.println("show fu");
  11.     }
  12. }
  14. class Child extends Parent {
  15.     public void show() {
  16.         System.out.println("show zi");
  17.     }
  19.     public void method() {
  20.         System.out.println("method zi");
  21.     }
  23. }
  25. public class PolymorphismDemo {
  26.     public static void main(String[] args) {
  27.          Parent fu=new Child();
  28.         fu.show();
  29.         //fu.method();//不能访问子类特有功能（特有方法）
  31.         Child zi=(Child)fu; //向下转型
  32.         zi.show();
  33.         zi.method();
  34.     }
  35. }

输出结果：

  1. show zi
  2. show zi
  3. method zi
  1. class Animal {
  2.     public void eat(){}
  3. }
  5. class Dog extends Animal {
  6.     public void eat() {}
  8.     public void lookDoor() {
  10.     }
  11. }
  13. class Cat extends Animal {
  14.     public void eat() {
  16.     }
  18.     public void playGame() {
  20.     }
  21. }
  23. public class PolymorphismDemo3 {
  24.     public static void main(String[] args) {
  25.         //内存中的是狗
  26.         Animal a = new Dog();
  27.         Dog d = (Dog)a;
  29.         //内存中是猫
  30.         a = new Cat();
  31.         Cat c = (Cat)a;
  33.         //内存中是猫
  34.         Dog dd = (Dog)a; //ClassCastException
  35.     }
  36. }

5. 多态中的一些问题

  1. /**
  2.  * 多态中的成员访问特点：
  3.      A:成员变量
  4.         编译看左边，运行看左边。
  5.     B:构造方法
  6.          创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
  7.     C:成员方法
  8.         编译看左边，运行看右边。( 由于成员方法存在方法重写，所以它运行看右边。)
  9.     D:静态方法
  10.         编译看左边，运行看左边。(静态和类相关，算不上重写，所以，访问还是左边的)
  11.  */
  12. class Fu{
  13.     public int num=100;
  15.     public void show(){
  16.         System.out.println("show function");
  17.     }
  19.     public static void function(){
  20.         System.out.println("function Fu");
  21.     }
  22. }
  24. class Zi extends Fu {
  25.     public int num = 1000;
  26.     public int num2 = 200;
  28.     @Override
  29.     public void show() {
  30.         System.out.println("show Zi");
  31.     }
  33.     public void method() {
  34.         System.out.println("method zi");
  35.     }
  37.     public static void function() {
  38.         System.out.println("function Zi");
  39.     }
  40. }
  42. public class PolymorphismDemo2 {
  43.     public static void main(String[] args) {
  44.         Fu f = new Zi();
  45.         System.out.println(f.num);
  47.         //System.out.println(f.num2);
  48.         f.show();
  49.         //找不到符号
  50.         //f.method();
  51.         f.function();
  52.     }
  53. }

输出结果：

  1. 100
  2. show Zi
  3. function Fu