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());
}
}
分析给出，结果自行解答。