Java小记之方法重写与继承中的构造方法的规则

方法重写：

具有相同的方法名称，返回类型和参数列表（特别容易出错）

重写方法不能使用比被重写方法更严格的访问权限。

super关键字，来引用基类成分：

class FatherClass{

}

class ChildClass extends FatherClass{

}

继承中的构造方法

1.子类的构造过程中必须调用其父类（基类）的构造方法（没有父类就没有子类）；

2. 子类可以在自己的构造方法中使用super（argument_list）来调用基类构造方法；

     ·使用this（）调用本类的另外的构造方法；

     ·如果调用super，必须写在子类构造方法的第一行；

3. 子类构造方法中没写super，子类默认找到super中没写参数的构造方法；

    但是，如果子类方法中既没写super，super中也没有无参数的构造方法，程序报错。

例如：

class SuperClass{

private int n;

       SuperClass(){

        System.out.println("SuperClass()");  

     }

       SuperClass(int n){

      System.out.println("SuperClass("+n+")");  

      this.n = n;

      }

}

class SubClass extends SuperClass{

   private int n;

   SubClass (int n){

    System.out.println("SuperClass("+ n +")");

    this.n = n;  

   }  

   SubClass() {

   super(300);   // 调用父类中的构造方法;

    System.out.println("SuperClass()");  

   } 

}

  public class TestSuperSub {

   public static void main (String arg[]){

   SubClass sc1= new SubClass（）；

   SubClass sc2= new SubClass(400);

   }  

}

情况1：SubClass sc1= new SubClass（），并注释掉super（300）；调用子类的构造方法，程序出错。因为子类的构造方法中必须调用父类构造方法；

情况2：super（300）写在System.语句的后面，程序出错。因为先调用父类构造方法，后子类；

情况3：注释掉 SubClass sc1= new SubClass（）；程序调用了子类的带参数的构造方法，结果为： 先打印 SuperClass（）；再打印SuperClass（400）。因为在子类的构造方法中未写出调用父类构造方法的语句，所以系统自动调用super中无参数的构造方法，也就是SuperClass（）；然后再打印自己的构造方法中的SuperClass（400）。

情况4：注释父类中无参数构造方法和SubClass sc1= new SubClass（）语句，执行  SubClass sc2= new SubClass(400)，程序报错。因为子类构造方法中为调用super（）构造方法并且父类中没有不带参数的构造方法，则程序报错。

练习1：

分析输出结果，比较构造函数和一般成员函数的区别。

class A  {

protected void print（String s）{

System.out.println(s);

}

A(){print("A()");}

public void f() {print("A:f()");}

}

class B extends A{

 B() {print("B()");  }

public void f() {print("B:f()");}

public static void main(String args[]) {

 B b = new B();

 b.f();

}

}

输出结果为：

A（）；

B：f（）；

解释：main 函数中，new出来的对象b 首先调用自己的构造方法，但是本身的构造方法并没有调用父类的构造方法，那么系统默认调用无参数的父类构造方法

A（）； 该方法为打印出“A（）”；然后，b.f() 调用了自身的类的方法f（），该方法为打印“B：f（）”。

练习2：

class Person {

private String name;

       private String location;

  Person (String name) {

    this.name = name;

    location = "Beijing";}

  Person (String name, String location) {

   this.name = name; 

       this.location = location;

  }

  public String info() {

    return "name:"+name+

                  "location:"+location;

}

}

class Student extends Person  {

private String school;

        Student(String name, String school){

this (name,"beijing",school);  //this 调用类中的其他构造函数；

}

Student (String n, String l, String school){

super(n,l);

        this.school=school; 

}

public String info (){

return super.info()+"school:"+school; 

}

}

Public class Test {

  public static void main(String[] args){

     Person p1 = new Person ("A");  // 调用了person（String name）

        Person p2 = new Person ("B","Shanghai"); //调用了person（String name，String location）

        Student s1 = new Student("C", "S1");  //调用了Student（String name，String school）

        Student s2 = new Student ("C","Shanghai","S2"); //调用相应的student里的构造函数方法；

        System.out.println(p1.info());

System.out.println(p2.info());

    System.out.println(s1.info());

    System.out.println(s2.info());

    }

}

分析给出，结果自行解答。