JAVA的覆盖、继承和多态的详细解说.this和super的用法

Java代码  收藏代码
  1. 1. 继承：  
  2.    (1)子类的构造方法一定会调用父类的构造方法。  
  3.     (2)任何子类构造方法第一行肯定是this();或者super();两个择一。  
  4.    this();调用本类的其它构造方法。(传递相应参数调用相应的方法)  
  5.      super();调用父类的构造方法。  
  6.    (3)如果子类的构造方法中没有显示地调用父类构造方法，也没有使用this关键字调用重载的其它构造方法，则系统默认调用父类无参数的构造方法  
  7.       ---子类创建实例对象的时候是否可以调用父类（抽象类）的构造方法？这里是必须调用的。      
  8.      (4)如果子类构造方法中既未显式调用父类构造方法，而父类中又没有无参的构造方法，则编译出错  
  9.    (5)构造方法不能继承：子类继承父类所有的成员变量和成员方法，但不继承父类的构造方法  
  10.      (6父类构造方法：子类的构造方法必须调用父类的构造方法！  
  11.   
  12. 子类和抽象类：  
  13. （1）父类是抽象类，实例化一个子类，如果子类的构造方法没有显示的用super或者this，则会用默认的this来调用父类的无参的构造方法，而且这  
  14. 个是子类的构造方法中首先执行的方法，即首先调用父类的构造方法，接着再调用子类的构造方法。  
  15. （2）如果在子类的实例中调用了父类的方法，而这个方法子类中没有重写，则会去调父类中的那个方法；如果子类重写了则调用的就是子类的方法。  
  16. （3）如果在父类中调用了父类的抽象方法，则默认的会去调用子类中已经实现了这个抽象方法的子类方法。  
  17.   
  18. 2. 覆盖：  
  19.     子类覆盖父类前提：  
  20.    (1) 同名，同参数列表，同返回类型。  
  21.    (2) 子类覆盖后的方法的访问权限只能比父类相同或者更宽广。  
  22.    (3) 子类覆盖后的方法抛出的异常不能比父类更宽广。  
  23.    (4) is-a:指继承。  
  24.       has-a:指类实例具有对另一个实例的引用。  
  25.    (5) 对于继承关系:当子类的对象来调用父类中的方法时，则执行的是父类只中原有的方法，  
  26.            这和多态不一样，如果子类覆盖掉父类的这个方法时，则调用的是子类的这个方法。  
  27.    (6)继承中注意的问题：  
  28.            重写(也叫覆盖，也叫重构)：重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值类型；  
  29.            重写方法不能使用比被重写方法更严格的访问权限。  
  30.            重写是类与类之间的关系，两者必须是继承关系。重载是方法与方法之间的关系。  
  31.   
  32. 3. 多态：  
  33.    (1) 前提：把子类对象当成父类对象来看。  
  34.    (2) 把子类对象当成父类对象来看时：只能调用父类中定义的属性和方法。  
  35.    (3) 把子类对象当成父类对象来看时：如果子类覆盖了父类中的方法，则调用的  
  36.        是子类覆盖后的这个方法。  
  37.        但是如果调用属性时是调用父类的属性而并非子类的,所以尽量不要定义  
  38.            父子类同名的属性。  
  39.    (4) 把父类强制转换成子类时，则调用的是子类中的方法。  
  40. 4. 静态方法不能叫"多态". 切记！  
  41.      静态方法不可被覆盖，如果子类和父类有重名的静态方法，虽然编译通过，但并不能实现多态，所以不能  
  42.     叫"覆盖"。例如：Animal a = new Bird(); a.move();如果是"多态"的话应该输出的结果为，子类中的结果，  
  43.     但是实际不是，它是调用的是父类中的方法。所以不能叫"覆盖(多态)"。  
Java代码  收藏代码
  1. 多态：  
  2. Animal a = new Bird();  a客观是鸟(客观类型)  
  3. Bird b = (Bird)a ;  
  4. 其中：Animal a，在编译时a为Animal。编译类型叫"编译时多态"，主观。  
  5. new Bird()，叫："运行时多态"，客观。  
  6. Bird b = (Bird)a ;把父类强制转换成子类。  
  7. if(a instanceof Animal)  ----> 编译类型  
  8. if(a instanceof Bird) -----> 客观类型  
  9. if(b instanceof Animal) -----> 自动向上兼容  
Java代码  收藏代码
  1. this的用法：  
  2.    this._ (区分局部变量与全局变量，有重名时用)  
  3.    this(参数类表)  
  4. super的用法：  
  5.   super._(区分子类与父类同名属性，以后建议不要定义相同的同名属性)  
  6.    super(参数列表)  
Java代码  收藏代码
  1. 写一个类时，同时顺手的要加上一个无参的构造方法，有其它类继承它时，  
  2. 加上super();但父类如果没有无参的构造方法就会报错。  
Java代码  收藏代码
  1. 覆盖(重写)和重载的区别：  
  2. 覆盖:(1) 是父子类之间.  
  3.         (2) 父子类同名，相同的参数列表，相同的返回类型。  
  4.      (3) 子类访问的权限比父类要高。  
  5.      (4) 子类抛出的异常比父类小。  
  6. 重载:(1) 多数针对一个类.  
  7.        (2) 方法名相同，参数列表不同，与返回类型无关。  
  8.      (3) 也可能出现在父子类中。  
  9.      (4) 一般会想到构造函数，有无参的构造函数，一个参数的，两个参数的。  

补充：

Java代码  收藏代码
  1. public class Test {  
  2.     public static void main(String[] args){  
  3.         A a = new B(); 这里是把子类当成父类来看,则只能调用父类中定义的属性和方法。  
  4.         //a.hello(5); 如果子类覆盖了父类中的方法，则调用的是子类覆盖后的那个方法。  
  5.           
  6.         B b = (B)a; 这里是把父类强转成子类,这里千万不能写成A a = new A();这样的话运行时会报错,只能是上面的那个A a = new B();  
  7.   
  8.         b.hello(4);强转后调用的是子类中的方法(对覆盖来说)  
  9.         b.hello2();强转后也可以调用父类中的方法  
  10.     }  
  11. }  
  12.   
  13. class A{  
  14.     public void hello(int i){  
  15.         System.out.println("A="+i);  
  16.     }  
  17.       
  18.     public void hello2(){  
  19.         System.out.println("hello2");  
  20.     }  
  21. }  
  22.   
  23. class B extends A{  
  24.     public void hello(int j){  
  25.         System.out.println("B="+j);  
  26.     }  
  27.                 下面的这个方法不是覆盖哦！要看好覆盖的前提哦～！  
  28.                 public void hello(long l){  
  29.                                  System.out.println("B2="+l);  
  30.                 }  
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/ziq711/p/5372563.html