目标：
1）掌握子类对象实例化过程
2）掌握方法覆盖概念和实现。
3）掌握super关键字的作用。
一，子类对象实例化过程
子类对象在实例化之前，必须先调用父类中的构造方法，再调用子类中的构造方法。
class Person{ // 定义Person类
private String name ; // 定义name属性
private int age ; // 定义age属性
public Person(){
System.out.println("父类Person中的构造。") ;
}
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{ // 定义Student类
private String school ; // 定义school属性
public Student(){
super() ; // 默认隐藏
System.out.println("子类Student中的构造。") ;
}
public void setSchool(String school){
this.school = school ;
}
public String getSchool(){
return this.school ;
}
};
public class InstanceDemo{
public static void main(String arsg[]){
Student stu = new Student() ;// 实例化子类对象
stu.setName("张三") ; // 此方法在Student类中没有明确定义
stu.setAge(30) ;
stu.setSchool("清华大学") ;
System.out.println("姓名：" + stu.getName() + "，年龄：" + stu.getAge() + "，学校：" + stu.getSchool() ) ;
}
};
运行结果：
父类Person中的构造。
子类Student中的构造。
姓名：张三，年龄：30，学校：清华大学
在生活中也很好理解，没有父亲就没有孩子。
实际上，对于子类的构造方法中，隐含了一个“super()”的语句。有时候，也将父类称为超类，所以调用父类构造方法，用super（）。
super关键字必须写在构造方法的首行。
二，方法的复写
方法覆写就是指：子类中定义了与父类中同名的方法。
1）但是在方法覆写时必须考虑访问权限，即：被子类覆写的方法，不能拥有比父类更严格的访问权限。
2）所以，如果在父类中使用public定义的方法，子类的访问权限必须是public，否则无法编译。
3）private<default<public。
class Person{ // 定义父类
void print(){ // 默认的访问权限
System.out.println("Person --> void print()。") ;
}
};
class Student extends Person{ // 定义继承关系
public void print(){
System.out.println("Student --> void print()。") ;
}
};
public class OverrideDemo01{
public static void main(String args[]){
Student s = new Student() ;
s.print() ;
}
};
运行结果：
Student-->void print()。
访问权限：
private：最小的访问权限。
default：什么都不写，例如：string name;
public:最大的访问权限。
以下是访问权限出问题的错误操作。
package methoud;
class Person{ // 定义父类
public void print(){ // public的访问权限
System.out.println("Person --> void print()。") ;
}
};
class Student extends Person{ // 定义继承关系
void print(){ // 错误的，降低了访问权限
System.out.println("Student --> void print()。") ;
}
};
public class ThisDemo06{
public static void main(String args[]){
Student s = new Student() ;
s.print() ;
}
};
由于子类的访问权限default小于public，所以编译通过不了。
从之前正确操作可以看出，如果子类将父类的方法覆写了，调用的时候，肯定是调用被覆写过的方法，那么如果非要调用父类的方法。
通过“super”关键字可以完成功能，super关键字可以从子类访问父类的内容。
如果要访问被覆写过的方法的方法：super.方法（）；
例如：
class Person{ // 定义父类
void print(){ // 默认的访问权限
System.out.println("Person --> void print()。") ;
}
};
class Student extends Person{ // 定义继承关系
public void print(){
super.print() ; // 访问父类中被子类覆写过的方法
System.out.println("Student --> void print()。") ;
}
};
public class OverrideDemo03{
public static void main(String args[]){
Student s = new Student() ;
s.print() ;
}
};
运行结果：
Person --> void print()。
Student --> void print()。
如果要使用“super”不一定非要在方法覆写之后使用，也可以明确表示某个方法是从父类中继承而来的。
使用super只是更加明确的说直接从父类中寻找，就不从子类找了。因为没有super调用方法，首先从子类寻找，如果子类没有才到父类寻找。
例如：如果上面那个例子中super.print（）把super去掉，就会造成无限期循环递归，自己调用自己。
三，问题:
如果父类中使用private关键字声明一个方法，那么在子类中使用default权限算是扩大权限，覆写吗？
答案是：NO，不算覆写。
正常覆写：
class Person{ // 定义父类
void print(){ // 默认的访问权限
System.out.println("Person --> void print()。") ;
}
public void fun(){ // 定义一个fun方法
this.print() ; // 调用print()方法
}
};
class Student extends Person{ // 定义继承关系
void print(){ // 覆写父类中的方法
System.out.println("Student --> void print()。") ;
}
};
public class OverrideDemo04{
public static void main(String args[]){
Student s = new Student() ;
s.fun() ;
}
};
运行结果：
Student --> void print()。
这里因为正常覆写，所以直接调用了子类中的覆写方法。
错误的覆写：
package methoud;
class Person{ // 定义父类
private void print(){ // private的访问权限
System.out.println("Person --> void print()。") ;
}
public void fun(){ // 定义一个fun方法
this.print() ; // 调用print()方法
}
};
class Student extends Person{ // 定义继承关系
void print(){ // 覆写父类中的方法
System.out.println("Student --> void print()。") ;
}
};
public class ThisDemo06{
public static void main(String args[]){
Student s = new Student() ;
s.fun() ;
}
};
运行结果：
Person-->void print();
可见，这里并没有调用子类中的“覆写”方法，而是调用父类中默认的方法。说明这里并没有达到覆写的作用，子类中的方法其实是另外定义了一个方法。
这点需要注意！。
四，属性的覆盖。
覆盖，就是指子类中声明了父类中同名的属性。
class Person{ // 定义父类
public String info = "MLDN" ; // 定义一个公共属性
};
class Student extends Person{ // 定义继承关系
public String info = "LXH" ; // 定义了一个与父类中属性名称一致的属性
void print(){ // 覆写父类中的方法
System.out.println("父类中的属性：" + super.info) ;
System.out.println("子类中的属性：" + this.info) ;
}
};
public class OverrideDemo05{
public static void main(String args[]){
Student s = new Student() ;
s.print() ;
}
};
可见，要使用被覆盖的父类中的属性，需要使用super关键字。
五，方法覆盖与重载的区别
六，super关键字
super表示的是从子类调用父类中的指定操作。例如调用属性，方法，构造等等。
因为在子类实例化的时候，会默认调用父类中的无参数构造方法（“super（）”）。如果想调用有参构造方法，则必须在子类中明确声明。
class Person{ // 定义Person类
private String name ; // 定义name属性
private int age ; // 定义age属性
public Person(String name,int age){
this.setName(name) ;
this.setAge(age) ;
}
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 String getInfo(){
return "姓名：" + this.getName() + "；年龄：" + this.getAge() ;
}
};
class Student extends Person{ // 定义Student类
private String school ; // 定义school属性
public Student(String name,int age,String school){
super(name,age) ; // 明确调用父类中有两个参数的构造
this.school = school ;
}
public void setSchool(String school){
this.school = school ;
}
public String getSchool(){
return this.school ;
}
public String getInfo(){
return super.getInfo() + "；学校：" + this.getSchool() ;
}
};
public class SuperDemo01{
public static void main(String arsg[]){
Student stu = new Student("张三",30,"清华大学") ;// 实例化子类对象
System.out.println(stu.getInfo()) ;
}
};
不管任何时候，子类实例化的时候，永远要先去调用父类中的构造方法，默认调用的是无参构造方法。
1）对于this和super本身都可以调用构造方法，而且调用的时候都必须放在构造方法的首行。所以这两个方法肯定不能同时出现。