JAVA面向对象三大特征之一（2）继承

本文链接：https://blog.youkuaiyun.com/cfw19990927/article/details/117376228

１．父类和子类中成员变量的访问区别

1.1 举例展示：

               //this.变量名 访问本类的变量
               // super.变量名 访问父类的变量

public class person {
         int age=10;
}
public class student extends person{
        int age=20;
       public void show (){
         int age=30;
         System.out.println(age);        // 30
         System.out.println(this.age);   // 20　　
         System.out.println(super.age);  // 10   
   }
}

1.2 总结一下：

1. 在类的成员方法中有一个与成员变量同名的变量：
如果用变量名来访问，那么访问的是成员方法中定义的变量。
如果用 this.变量名来访问，那么访问的是成员变量。

2. 在子类中有一个与父类同名的成员变量：
this.变量名访问的是子类的成员变量
super.变量名访问的是父类的成员变量

２．父法和子类中成员方法的访问区别

　2.1 举例展示：

public class person{
     public void show(){
       System.out.print("父类的show方法");
    }
     public void out() {
    	 System.out.print("父类的out方法");
    }
}
public class student extends person{
      public void show() {
    	 System.out.print("子类的show方法");
     }
      public static void main(String[] args){
         student one=new student();
         one.show();    // "子类的show方法"
         one.out();     // "父类的out方法"
     }
}

2.2 总结一下：

1. 子类和父类的成员方法同名时：

通过子类对象访问成员方法时，访问的是子类的成员方法。

2. 通过子类对象访问的方法在子类没有时，那么在父类寻找该方法。

３．成员方法的覆盖重写

3.1 举例展示：

3.1.1 与父类方法的名字相同，参数列表相同（重写的正确格式）

*补充：

· 重写 (@Override) 可以放在子类重写函数的开头，判断重写函数格式正确与否

· 重载 (@Overload)

  public class person {
     public void show(){
     System.out.printlin("person的show方法");
    }
  }
    public class student extends person{
      @Override 
      public void show(){
        System.out.println("student的show方法");
     }
      public static void main(String[] args){
             student one=new student();
             one.show()     // "student的show方法"
     }
  }

错误的写法如下：

 public class person {
     public void show(){
     System.out.printlin("person的show方法");
    }
  }
    public class student{
      @Override 
      public void show(int i){
        System.out.println("student的show方法");
     }
      public static void main(String[] args){
             student one=new student();
             one.show(1)     //  无法解析的编译问题：类型为 student 的方法 show（int）必须覆盖或实现超类型方法
     }
  }

3.1.2 子类方法的返回值<=父类方法的返回值

*补充

· Java中Object对象是所有对象的超类.String，Integer,Double类都是Object的子类

public class person {
     public Object show(){
      System.out.println("person的show方法");
      return null;
    }
  }
    public class student extends person{
      @Override 
      public Integer show(){
        System.out.println("student的show方法");
         return null;
     }
      public static void main(String[] args){
             student one=new student();
             one.show()  
     }
  }

3.1.3 子类方法的权限>=父类方法的权限

*补充

·public > protected > default(没有修饰符) > private

 public class person {
      Object show(){
      System.out.println("person的show方法");
      return null;
    }
  }
    public class student extends person{
      @Override 
      public Integer show(){
        System.out.println("student的show方法");
         return null;
     }
      public static void main(String[] args){
             student one=new student();
             one.show();
     }
  }

3.2 总结一下：

方法重写的格式：

1. 与父类方法的名字相同，参数列表相同

2. 子类方法的返回值<=父类方法的返回值

3. 子类方法的权限>=父类方法的权限

4. 继承中的构造方法

4.1 举例展示：

4.1.1 子类构造函数中有一个隐式的super()调用 (就是父类的无参构造) ，先执行父类构造，再执行子类构造

public class person {
       public person(){
        System.out.print("父类的构造方法");
     }
  }
    public class student extends person{
       public student(){
        System.out.print("子类的构造方法");
     }
     public static void main(String[] args){
             student one=new student(); 
         //控制台会显示："父类的构造方法"
                        "子类的构造方法"
     }
  }

4.1.2 super();必须是子类构造方法的第一个语句

public class person {
      String name;
       public person(String name){
        System.out.print(name+"的构造方法");
     }
  }
    public class student extends person{
       public student(String name){
        super(name);
     }
     public static void main(String[] args){
             student one=new student("chenfuwei"); 
         //控制台会显示："chenfuwei的构造方法"
     }
  }

4.2 总结一下：

super用法总结：

1. 在子类的成员方法中，访问父类的成员方法.

 public class person {
      public void show(){
       System.out.println("父类的show方法");
    }  
  }
    public class student extends person{
       public void show(){
        super.show();
        System.out.println("子类的show方法");
    }  
     public static void main(String[] args){
             student one=new student(); 
         //控制台会显示："父类的Show方法"
                        "子类的Show方法"
     }
  }

2. 在子类的成员方法中，访问父类的成员变量.

3. 在子类构造方法中，访问父类构造方法.

５. super 和 this 的用法

5.1 super举例展示

5.1.1 在子类的成员方法中，访问父类的成员方法

  public class person {
      public void show(){
       System.out.println("父类的sehow方法");
     }  
   }
     public class student extends person{
       public void show(){
        super.show();
        System.out.println("子类的show方法");
    }  
      public static void main(String[] args){
             student one=new student(); 
         //控制台会显示："父类的Show方法"
                        "子类的Show方法"
     }
  }

5.1.2 在子类的成员方法中，访问父类的成员变量

super.变量名

5.1.3 在子类构造方法中，访问父类构造方法

super();

5.2this举例展示

5.2.1 访问类中的成员变量和成员方法

this.变量名

this.方法名

5.2.2 在构造函数中访问本类的重载构造函数

public class person {
      person(){
       System.out.print("父类的构造方法");
    }
  }
     public class student extends {
      public student(){  
          this("陈福伟");      // 该子类构造方法不会隐式调用super();
    }
      public student(String name){ 
           System.out.print(name+"的构造方法");
     }
      public static void main(String[] args){
             student one=new student(); 
         //控制台会显示："陈福伟的构造方法"
     }
  }