深入理解super关键字

1.super
(1)super关键字表示超(父)类，可以使用super访问父类中被子类隐藏的或覆盖(重写)的方法。当前类如果是从超类继承而来的，当使用super.XX()就是调用了超类版本的XX()方法。
示例1：

class Father {
		public void print() {
			System.out.println("Father's print method!!");
		}
         }
       class Son extends Father {
		public void print() {
			System.out.println("Son's print method!!");
			super.print();
		}
        }
        public class TestSuper01 {
		public static void main(String[] args) {
			Son s = new Son();
			s.print();
		}
         }

运行结果：

Son's print method!!
        Father's print method!!

(2)使用super调用基类中的某个构造方法。
示例：

class Person {
		public static void print(String str) {
			System.out.println(str);
		}
		public Person() {
			print("A Person");
		}
		public Person(String name) {
		print("A person named:" + name);
		}
        }
        class Male extends Person{
		public Male() {
			super();	//调用父类无参构造方法；
			print("A male");
		}
		public Male(String name) {
			super(name);	//调用父类具有相同形参的构造方法
			print("A Male named:" + name);
		}
        }
        public class TestSuper02 {
		public static void main(String[] args) {
			Male male = new Male();
			male = new Male("Heaven");
		}
        }

运行结果：

A Person
A male
A person named:Heaven
A Male named:Heaven

如果将两个调用父类构造方法的语句注释掉，将发现运行结果一样。这是为什么呢？这就要从Java对象的构造方法说起。
2.构造方法
在多数情况下，初始化一个对象的最终步骤是去调用这个对象的构造方法。构造方法负责对象的初始化工作，为实例变量赋予合适的初始值
(1)构造方法的语法规则如下：
     A. 方法名必须与类名相同。
     B. 不要声明返回类型；
     C. 不能被static，final，synchronized，abstract和native修饰。构造方法不能被子类继承，所以用final和abstract修饰没有意义。构造方法用于初始化一个新建的对象，所以用static修饰没有意义。多个线程不会同时创建内存地址相同的同一个对象，因此用synchronized修饰没有必要。此外，Java语言不支持native类型的构造方法
可以通过重载构造方法来表达对象的多种初始化行为。在一个类的多个构造方法中，可能会出现一些重复操作。为了提高代码的可重用性，Java语言允许在一个构造方法中，用this语句来调用另一个构造方法。用this语句来调用其他构造方法时，语法规则如下：
    A． 假如在一个构造方法中使用this语句，那么它必须作为构造方法的第一条语句(不考虑注释语句).
    B． 只能在一个构造方法中用this来调用类的其他构造方法，而不能在实例方法中用this语句来调用类的其他构造方法
    C． 只能this语句来调用其他构造方法，而不能通过方法来直接调用构造方法。
(2)默认构造方法：
默认构造方法是没有参数的构造方法。可分两种：
           A． 隐含的默认构造方法；
           B． 程序中显式定义的默认构造方法(可以是任意的访问级别)。
在Java语言中，每个类至少有一个构造方法。为了保证这一点，如果用户定义的类中没有提供任何构造方法，那么Java语言将自动提供一个隐含的默认构造方法。
如果类中显式定义了一个或多个构造方法，并且所有的构造方法都带有参数，那么这个类就失去了默认构造方法。
示例如下：

class Sample1 {}
class Sample2 {
	public Sample2(int a) {
		System.out.println("My Constructor");
	}
}
class Sample3 {
	public Sample3() {
		System.out.println("My Default Constructor");
	}
}
public class TestSuper03 {
	public static void main(String[] args) {
		Sample1 s1 = new Sample1(); //合法，自动提供了一个隐含的默认构造方法
		Sample2 s2 = new Sample2();	//编译出错
		Sample3 s3 = new Sample3();//合法，显式定义了默认构造方法
	}
}

(3)子类调用父类的构造方法
父类的构造方法不能被子类继承。
示例：

class Base {
	public Base(){}
	public Base(String msg) {
		System.out.println(msg)
	}
}
class Derive extends Base {
	Derive d = new Derive("Derive Constructor");
}

以上的定义是不合法的。因为Derive并不能继承Base的构造方法。
但在子类的构造方法中，可以通过super语句来调用父类的构造方法。
示例：

class Base {
	public Base(){}
	public Base(String msg) {
		System.out.println(msg);
	}
}
class Derive extends Base {
	public Derive() {
		super("调用父类的构造方法");
	}
}

用super语句来调用父类的构造方法时，语法规则如下：
A． 在子类的构造方法中，不能直接通过父类方法名调用父类的构造方法，而是要使用super语句
B． 假如在子类的构造方法中有super语句，它必须作为构造方法的第一条语句。
在创建子类的对象时，JVM首先执行父类的构造方法，然后再执行子类的构造方法。在多级继承的情况下，将从继承树的最上层的父类开始，依次执行各个类的构造方法，这可以保证子类对象从所有直接或间接父类中继承的实例变量都被正确的初始化。
示例：

class Base {
	private int a;
	public Base(int a) {
		this.a = a;
	}
	public int getA() {
		return a;
	}
}
class Sub extends Base {
	private int b;
	public Sub(int a, int b) {
		super(a);
		this.b = b;
	}
	public int getB() {
		return b;
	}
}

public class TestSuper05 {
	public static void main(String[] args) {
		Sub sub = new Sub(1,2);
		System.out.println("a=" + sub.getA() + "b=" + sub.getB());
	}
}

结果：

a=1b=2

也许我们会疑问为什么会是这样的一个结果。分析如下：
正如前文所说明的那样，“在创建子类的对象时，JVM首先执行父类的构造方法，然后再执行子类的构造方法。”那么当我们new一个Sub类的实例时，先把new Sub(1,2)中的两个参数传递给Sub的构造方法，然后执行父类的构造方法，这个所谓的“执行父类的构造方法”实际上是这样的：如果子类的构造方法没有用super语句显式调用父类的构造方法，那么通过这个构造方法构建子类对象时，JVM会自动先调用父类的默认构造方法。但在以上示例中Base父类中定义只定义了一个有参的构造方法，那么根据前文所说的：“如果类中显式的定义了一个或多个构造方法，并且所有的构造方法都带有参数，那么这个类就失去了默认构造方法”，就是说在Sub子类的构造方法当中JVM找不到要自动调用的父类的默认构造方法。我们做个试验，把Sub子类的构造方法中的super(a)语句注释掉，编译一下，发现发生以下异常：

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	Implicit super constructor Base() is undefined. Must explicitly invoke another constructor

	at Sub.<init>(TestSuper05.java:12)
	at TestSuper05.main(TestSuper05.java:23)

综上所述，“在创建子类的对象时，JVM首先要执行父类的构造方法”应该这样理解：在子类的构造方法之中，必须先执行父类的构造方法，如果父类的默认构造方法没有“失去”的话(失去的定义见前文)，JVM会自动调用该默认方法(如果没有显式调用的话，JVM自动插入)，但如果父类失去了它的默认构造方法(如本例)，那么在子类的构造方法中就必须显式调用(执行)父类的有参构造方法！