您当前的位置： 首页 > 学无止境 > 心得笔记 网站首页心得笔记

【第6章：面向对象（高级）】_继承的进一步研究

发布时间：2020-12-15 17:40:05编辑：雪饮阅读（）

 子类被实例化时候静默调用父类构造

class Person{
       private String name ;
       private int age ;
       public Person(){
              System.out.println("父类构造");
       }
       public void setName(String name){
              this.name = name;
       }
       public void setAge(int age){
              this.age = age ;
       }
       public String getName(){
              return this.name ;
       }
       public int getAge(){
              return this.age ;
       }
}
class Student extends Person{
       private String school;
       public Student(){
              System.out.println("子类构造");
       }
       public void setSchool(String school){
              this.school=school;
       }
       public String getSchool(){
              return this.school;
       }
}
public class Hello{
   public static void main(String args[]){
              Student stu = new Student();
   }
}
 
D:\>javac Hello.java
 
D:\>java Hello
父类构造
子类构造
静默调用的是父类的无参构造
子类静默调用父类无参构造相当于super()默认静默调用，即便子类中显式super()调用，也不会重复被调用。
class Person{
       private String name ;
       private int age ;
       public Person(){
              System.out.println("父类构造");
       }
       public void setName(String name){
              this.name = name;
       }
       public void setAge(int age){
              this.age = age ;
       }
       public String getName(){
              return this.name ;
       }
       public int getAge(){
              return this.age ;
       }
}
class Student extends Person{
       private String school;
       public Student(){
              super();
              System.out.println("子类构造");
       }
       public void setSchool(String school){
              this.school=school;
       }
       public String getSchool(){
              return this.school;
       }
}
public class Hello{
   public static void main(String args[]){
              Student stu = new Student();
   }
}
D:\>javac Hello.java
 
D:\>java Hello
父类构造
子类构造
方法覆写与权限修饰符
子类中可以对父类的某个方法进行覆盖，但覆盖后的方法的访问权限不得低于父类的对应方法
class Person{
       private String name ;
       private int age ;
       public Person(){
              System.out.println("父类构造");
       }
       public void setName(String name){
              this.name = name;
       }
       public void setAge(int age){
              this.age = age ;
       }
       public String getName(){
              return this.name ;
       }
       public int getAge(){
              return this.age ;
       }
       void fun(){
              System.out.println("父类的default修饰fun");
       }
}
class Student extends Person{
       private String school;
       public Student(){
              System.out.println("子类构造");
       }
       public void setSchool(String school){
              this.school=school;
       }
       public String getSchool(){
              return this.school;
       }
       public void fun(){
              System.out.println("子类的public修饰fun");
       }
}
public class Hello{
   public static void main(String args[]){
              Student stu = new Student();
              stu.fun();
   }
}
D:\>javac Hello.java
 
D:\>java Hello
父类构造
子类构造
子类的public修饰fun
如果子类没有覆写父类的指定方法，则调用的时候默认调用父类的。
class Person{
       private String name ;
       private int age ;
       public Person(){
              System.out.println("父类构造");
       }
       public void setName(String name){
              this.name = name;
       }
       public void setAge(int age){
              this.age = age ;
       }
       public String getName(){
              return this.name ;
       }
       public int getAge(){
              return this.age ;
       }
       void fun(){
              System.out.println("父类的default修饰fun");
       }
}
class Student extends Person{
       private String school;
       public Student(){
              System.out.println("子类构造");
       }
       public void setSchool(String school){
              this.school=school;
       }
       public String getSchool(){
              return this.school;
       }
}
public class Hello{
   public static void main(String args[]){
              Student stu = new Student();
              stu.fun();
   }
}
D:\>javac Hello.java
 
D:\>java Hello
父类构造
子类构造
父类的default修饰fun
覆写权限如果颠倒过来了，都无法通过编译
class Person{
       private String name ;
       private int age ;
       public Person(){
              System.out.println("父类构造");
       }
       public void setName(String name){
              this.name = name;
       }
       public void setAge(int age){
              this.age = age ;
       }
       public String getName(){
              return this.name ;
       }
       public int getAge(){
              return this.age ;
       }
       public void fun(){
              System.out.println("父类的public修饰fun");
       }
}
class Student extends Person{
       private String school;
       public Student(){
              System.out.println("子类构造");
       }
       public void setSchool(String school){
              this.school=school;
       }
       public String getSchool(){
              return this.school;
       }
       void fun(){
              System.out.println("子类的default修饰fun");
       }
}
public class Hello{
   public static void main(String args[]){
              Student stu = new Student();
              stu.fun();
   }
}
D:\>javac Hello.java
Hello.java:34: Student 中的 fun() 无法覆盖 Person 中的 fun()；正在尝试指定更低的访问权限；为 public
        void fun(){
             ^
1 错误
子类可以通过super关键字显式声明调用的方法为父类的方法
class Person{
       private String name ;
       private int age ;
       public Person(){
              System.out.println("父类构造");
       }
       public void setName(String name){
              this.name = name;
       }
       public void setAge(int age){
              this.age = age ;
       }
       public String getName(){
              return this.name ;
       }
       public int getAge(){
              return this.age ;
       }
       public void print(){
              System.out.println("父类的print方法");
       }
}
class Student extends Person{
       private String school;
       public Student(){
              System.out.println("子类构造");
       }
       public void setSchool(String school){
              this.school=school;
       }
       public String getSchool(){
              return this.school;
       }
       void fun(){
              super.print();
       }
}
public class Hello{
   public static void main(String args[]){
              Student stu = new Student();
              stu.fun();
   }
}
D:\>javac Hello.java
 
D:\>java Hello
父类构造
子类构造
父类的print方法
这里不用super关键字也会默认去父类查找对应方法，因为子类中根本没有print方法
class Person{
       private String name ;
       private int age ;
       public Person(){
              System.out.println("父类构造");
       }
       public void setName(String name){
              this.name = name;
       }
       public void setAge(int age){
              this.age = age ;
       }
       public String getName(){
              return this.name ;
       }
       public int getAge(){
              return this.age ;
       }
       public void print(){
              System.out.println("父类的print方法");
       }
}
class Student extends Person{
       private String school;
       public Student(){
              System.out.println("子类构造");
       }
       public void setSchool(String school){
              this.school=school;
       }
       public String getSchool(){
              return this.school;
       }
       void fun(){
              print();
       }
}
public class Hello{
   public static void main(String args[]){
              Student stu = new Student();
              stu.fun();
   }
}
D:\>javac Hello.java
 
D:\>java Hello
父类构造
子类构造
父类的print方法
private修饰覆写为default修饰不能称为方法的覆盖
就是你覆盖了，照样调用父类的方法。
class Person{
       private String name ;
       private int age ;
       public Person(){
              System.out.println("父类构造");
       }
       public void setName(String name){
              this.name = name;
       }
       public void setAge(int age){
              this.age = age ;
       }
       public String getName(){
              return this.name ;
       }
       public int getAge(){
              return this.age ;
       }
       private void print(){
              System.out.println("父类的public修饰print方法");
       }
}
class Student extends Person{
       private String school;
       public Student(){
              System.out.println("子类构造");
       }
       public void setSchool(String school){
              this.school=school;
       }
       public String getSchool(){
              return this.school;
       }
       void print(){
              System.out.println("父类的default修饰print方法");
       }
}
public class Hello{
   public static void main(String args[]){
              Student stu = new Student();
              stu.print();
   }
}
D:\>javac Hello.java
 
D:\>java Hello
父类构造
子类构造
父类的default修饰print方法
属性的覆写
class Person{
       private String name ;
       private int age ;
       public String info="snowDrink";
}
class Student extends Person{
       private String school;
       public String info="duMinJie";
}
public class Hello{
   public static void main(String args[]){
              Student stu = new Student();
              System.out.println(stu.info);
   }
}
D:\>javac Hello.java
 
D:\>java Hello
duMinJie
super也可以调用父类的属性
class Person{
       private String name ;
       private int age ;
       public String info="snowDrink";
}
class Student extends Person{
       private String school;
       public String info="duMinJie";
       public void print(){
              System.out.println(super.info);
       }
}
public class Hello{
   public static void main(String args[]){
              Student stu = new Student();
              stu.print();
   }
}
 
D:\>javac Hello.java
 
D:\>java Hello
snowDrink
子类实例化时默认调用父类无参构造，所以当父类显式声明了构造（有参），则此时子类就无法正常实例化
class Person{
       private String name ;
       private int age ;
       public Person(String name,int age){
              this.name=name;
              this.age=age;
       }
}
class Student extends Person{
       public Student(String name,int age){}
}
public class Hello{
   public static void main(String args[]){
              Student stu = new Student("snowDrink",24);
   }
}
D:\>javac Hello.java
 
D:\>javac Hello.java
Hello.java:10: 找不到符号
符号： 构造函数 Person()
位置： 类 Person
        public Student(String name,int age){
                                           ^
1 错误
可以用super调用父类有参构造来解决父类显式声明有参构造的情况
class Person{
       private String name ;
       private int age ;
       public Person(String name,int age){
              this.name=name;
              this.age=age;
       }
}
class Student extends Person{
       public Student(String name,int age){
              super(name,age);
       }
}
public class Hello{
   public static void main(String args[]){
              Student stu = new Student("snowDrink",24);
   }
}