Java学习（52）Java继承——super关键字的使用

1. 问题提出

提出问题：如何才能分辨出方法是继承自父类的方法还是重写自己的方法呢？
(1) 在子类Dog中重写父类Animal中的eat方法：

	 public void eat(){
		 System.out.println(month+"最近没有食欲~~");
	 }

子类Dog中的sleep方法中对eat进行调用：

//睡觉的方法
	 public void sleep(){
		 eat();//调用的哪个eat();
		 System.out.println(this.getName()+"现在"+this.getMonth()+"个月大，它在睡觉~~");
	 }

则在主方法内对Dog进行实例化并调用sleep方法时，会调用子类重写父类的方法，而不是父类自己的方法。
(2) 要想调用父类的eat方法而不是子类重写的eat方法，那么就需要super关键字
super：父类对象的引用

	//睡觉的方法
	 public void sleep(){
		 super.eat();//调用的哪个eat();
			 System.out.println(this.getName()+"现在"+this.getMonth()+"个月大，它在睡觉~~");
	 }

此时，在主方法内对Dog进行实例化并调用sleep方法时，会调用父类的eat方法，而不是调用子类重写的方法。
(3) 父类的构造方法是不允许被继承的
例如：在父类Animal中创建如下构造代码：

	// 父类的构造不允许被继承、不允许被重写，但是会影响子类对象的实例化
	public Animal() {
		
	}

则在其子类Cat的run方法中不能使用此构造方法，即如下代码是会报错的：

	//跑动的方法
	public void run(){
		Animal();
		System.out.println(this.getName()+"是一只"+this.getSpecies()+",它在快乐的奔跑");
	}

2. 父类构造方法的作用

(1) 首先，在父类Animal中定义两个静态成员属性st1与st2：

	public static int st1 = 22;
	private static int st2 = 23;

对父类的属性进行赋值：

private String name = "妮妮";// 昵称
	protected int month;// 月份
	String species = "动物";// 品种
	public  final static int temp=12;

再添加一个静态代码块、一个构造代码块和一个无参构造方法：

	static {
		System.out.println("我是父类的静态代码块");
	}

	{
//		temp=12;
		System.out.println("我是父类的构造代码块");
	}

	 public Animal() {
//		temp=20;
		System.out.println("我是父类的无参构造方法");
	}

(2) 在子类Cat中也加入一个静态成员属性st3，一个静态代码块、一个构造代码块和一个无参构造方法

	public static int st3=44;
	
	static{
		System.out.println("我是子类的静态代码块");
	}
	
	{
		System.out.println("我是子类的构造代码块");
	}
	
	public Cat(){
//		Animal temp=new Animal();
//		temp.name;
//		this.temp=12;
//		this.month=23;
//		this.species="";
		System.out.println("我是子类的无参构造方法");
	}

(3) 在别的包中创建TestTwo主方法用于测试：

package com.study.test;

import com.study.animal.Cat;

public class TestTwo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Cat one=new Cat();
//		Cat one=new Cat("花花",2);
		System.out.println(one.temp);
	}

}

(4) 调试
在Cat one=new Cat();处进行单步调试，发现：
a. 加载类型的过程中会先进入到父类的静态成员，即先加载public static int st1 = 22;和private static int st2 = 23;；
b. 然后，加载父类的静态代码块，打印输出System.out.println("我是父类的静态代码块");；
c. 然后，进入到子类的静态成员中，加载子类的静态成员，以及子类的静态代码块；
d. 然后，返回父类中的属性，进行赋值操作；
e. 然后，执行父类的构造代码块；
f. 然后，回到父类的构造方法中进行输出；
g. 然后，返回子类中的属性，进行赋值操作（这里子类的weight并未赋值）；
h. 然后，执行子类的构造代码块；
i. 然后，回到子类的构造方法中进行输出；
j. 然后，返回调用处，即Cat one=new Cat();；
k. 最后，输出one中的temp的值，即15。
注：Cat是Animal的子类，而Animal是Object的子类，所有类都是Object的子类。
(5) 继承后的初始化顺序
父类静态成员$\to$子类静态成员$\to$父类对象构造$\to$子类对象构造
注：党文修饰符不影响成员加载顺序，跟书写位置有关。例如，父类静态属性写在父类静态代码块后，那么父类静态代码块就会先加载。

3. 子类能否决定使用父类的哪些构造方法呢？

(1) 在子类中创建一个带参构造方法：

	public Cat(String name,int month){
		/* 子类构造默认调用父类无参构造方法
		 * 可以通过super()调用父类允许被访问的其他构造方法
		 * super()必须放在子类构造方法有效代码第一行
		 */
		System.out.println("我是子类的带参构造方法");
	}

(2) 在父类中也创建一个带参构造方法：

	public Animal(String name, int month) {
		this.name = name;
		this.month = month;
		System.out.println("我是父类的带参构造方法");
	}

(3) 在TestTwo中调用双参构造：

package com.study.test;

import com.study.animal.Cat;

public class TestTwo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
//		Cat one=new Cat();
		Cat one=new Cat("花花",2);
		System.out.println(one.temp);
	}

}

(4) 调试执行顺序
父类静态成员$\to$子类静态成员$\to$父类构造代码块$\to$父类无参构造方法$\to$子类构造代码块$\to$子类带参构造方法$\to$15
(5) 父类无参构造方法有重要的作用
子类构造默认调用父类无参构造方法，虽然父类的构造不允许被继承，然而如果将父类中的无参构造方法注释掉，则子类中的构造方法会直接报错，因此无论父类无参构造方法是否有作用，都得创建。

4. 如果要调用父类的双参构造方法，则需要使用super

	public Cat(String name,int month){
		/* 子类构造默认调用父类无参构造方法
		 * 可以通过super()调用父类允许被访问的其他构造方法
		 * super()必须放在子类构造方法有效代码第一行
		 */
		super(name,month); //this
		System.out.println("我是子类的带参构造方法");
	}

上边程序的调试执行顺序：
父类静态成员$\to$子类静态成员$\to$父类构造代码块$\to$父类带参构造方法$\to$子类构造代码块$\to$子类带参构造方法$\to$15
即：可以通过super()调用父类允许被访问的其他构造方法，且super()必须被放在子类构造方法有效代码的第一行。构造方法的调用必须放在构造方法里。

5. 小结

(1) super是代表父类引用
a. 访问父类成员方法：super.print();
b. 访问父类属性：super.name;
c. 访问父类构造方法：super();
(2) 注意事项
a. 子类的构造的过程中必须调用其父类的构造方法；
b. 如果子类的构造方法中没有显式标注，则系统会默认调用其杜磊无参的构造方法；
c. 如果子类构造方法中既没有显式标注，且父类在没有构造方法，则编译出错；
d. 使用super调用父类指定构造方法，必须在子类的构造方法的第一行。

6. super与this的对比

(1) 用途
a. 在一个类中，可以通过this关键字来调用当前类中允许被访问的属性和方法；
b. 通过super关键字可以调用父类中允许被访问的属性和方法。
(2) 静态方法中的this和super不能被调用
this和super都是不能再静态方法中被调用的。例如，如下在子类Cat中的代码是错误的：

	public static void say(){
//		this.weight=20;
//		super.name="aa";
	}

(3) 调用构造方法
a. this调用的是同一类型的构造方法，例如，在子类Cat中的带参构造方法中创建this()，那么这条语句会先调用Cat类中的无参构造方法；
b. this和super不能同时存在于构造方法中。

7. 小结

(1) this：当前类对象的引用
a. 访问当前类的成员方法；
b. 访问当前类的成员属性；
c. 访问当前类的构造方法；
d. 不能在静态方法中使用。
(2) super：父类对象的引用
a. 访问父类的成员方法；
b. 访问父类的成员属性；
c. 访问父类的构造方法；
d. 不能在静态方法中使用。
(3) 构造方法调用时，super和this不能同时出现。