面向对象_04关键字：super使用

Posted 2020-10-17

super关键字：解决当子类重写父类对象方法后，子类对象无法访问父类的成员
1，调用父类成员变量和方法
　　super.成员变量
　　super.成员方法([参数1，参数2.......])
Example:

 1 //super关键字调用父类成员变量及成员方法
 2 package new_Object;
 3 class Animal_03{
 4     String name="动物";
 5     //定义父类shout方法
 6     public void shout(){
 7         System.out.println("super父类方法");
 8     }
 9 }
10 class Dog_03 extends Animal_03{
11     public void shout(){
12         String name ="犬类";
13         super.shout();//访问父类成员方法
14     }
15     //访问父类成员变量
16     void printf(){
17         System.out.println("name="+super.name);
18     }
19 }
20 public class Example03_Extends_super {
21     public static void main(String[] args) {
22         Dog_03 p1=new Dog_03();
23         p1.shout();//调用重写的shut方法
24         p1.printf();
25     }
26 
27 }

2，super调用父类的构造方法
　　super([参数1，参数2.......])
Example

 1 //super关键字访问父类构造方法
 2 package new_Object;
 3 class Animal_04{
 4     //定义Animal_04类有参构造方法
 5     public Animal_04(String name){
 6         System.out.println("这是一匹"+name);
 7     }
 8 }
 9 //继承类
10 class Horse_04 extends Animal_04{
11     public Horse_04(){
12         super("马");//调用父类的构造方法
13     }
14 }
15 public class Example04_Extends_super {
16     public static void main(String[] args) {
17         Horse_04 p=new Horse_04();
18     }
19 }

====================================================================================================================================
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　补充
====================================================================================================================================
在子父类中成员变量、成员函数、构造函数的特点之体现
1，成员变变量

=>当本类中的成员和局部变量同名用this区分
=>当子父类中的成员变量同名用super区分父类

this和super很相似
* =>this：代表一个本类对象的引用
* =>super：代表一个父类空间

 1 //1，成员变量
 2 package new_Object;
 3 class Fu{
 4     int num=6;//定义父类成员变量
 5 }
 6 //子类继承父类
 7 class Zi extends Fu{
 8     int num=8;//定义子类的成员变量
 9     void show(){
10         //super访问父类成员的变量
11         System.out.println(super.num+"......"+super.num);
12         //this调用本类、super调用父类
13         System.out.println(this.num+"......"+super.num);
14     }
15 }
16 public class Extends_02 {
17     public static void main(String[] args) {
18         Zi z=new Zi();
19         z.show();
20     }
21 }

run：6.....6
　　  8.....6

2，成员函数

=>当子父类中出现成员函数一模一样的情况下，会执行子类函数。
* 这现象称覆盖操作，这是函数在子父类中的特性。
* =>函数两特性：
* 1，重载。同一个类中
* 2，覆盖（重写）。子类中。
* 覆盖注意事项：
* 1，子类方法覆盖父类方法时，子类权限>=父类权限
* 2，静态只能被静态覆盖，或者被静态覆盖.

 1 //2，成员函数
 2 package new_Object;
 3 class Fu_1{
 4     void show(){
 5         System.out.println("fu show run");
 6     }
 7 }
 8 class Zi_1 extends Fu_1{
 9     void show(){
10         super.show();//访问父类show
11     }
12 }
13 public class Extends_03 {
14     public static void main(String[] args) {
15         Zi_1 z=new Zi_1();
16         z.show();
17     }
18 }

run：fu show run

2.1 什么时候使用覆盖？
　　=>当一个类进行子类的扩展时，子类需要保留父类功能声明，但要定义子类中该功能的特有内容时。

 1 //覆盖的应用
 2 package new_Object;
 3 //定义一个手机只有显示功能
 4 class Phone{
 5     void show(){
 6         System.out.println("number");
 7     }
 8 }
 9 //新手机继承旧手机的显示功能时又添加新的功能 name pic
10 class NewPhone extends Phone {
11     void show(){
12         System.out.println("name");
13         System.out.println("pic");
14         /*System.out.println("number");*/super.show();
15     }
16 }
17 public class Extends_031 {
18     public static void main(String[] args) {
19         NewPhone p=new NewPhone();
20         p.show();
21     }
22 }

3，构造函数

* =>在子类构造对象时，访问父类的构造函数时，父类构造函数也执行？
*   >在子类的构造函数的第一行有一个默认的隐式语句：super();

* =>子类实例化过程：子类中所有的构造函数都会默认访问父类中的空参数的构造函数
* =>为什么子类实例化的时候要访问父类中的构造函数？
*   >子类继承了父类，获取到父类中的内容（属性），所以在使用父类内容之前，先看父类如何自己初始化。所以在子类构造对象时，必须先访问父类中的构造函数。

* =>如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super明确要调用父类中哪一个构造函数。同时子类构造函数中如果使用this调用本类构造函数时，那么super就不存在，super和this都是定义在第一行。但是可以保证的是子类中肯定会有其他构造函数访问父类的构造函数。

* =>注意：super语句必须定义在子类的构造函数第一行。因为父类的初始化动作先完成。

 1 //3，构造函数
 2 package new_Object;
 3 /*class Fu_04{
 4     //无参
 5     Fu_04(){
 6         System.out.println("Fu构造函数run");
 7     }
 8 }
 9 class Zi_04 extends Fu_04{
10     Zi_04(){
11         //super();=>相当于this();调用的是父类中的空参数构造函数
12         System.out.println("Zi构造函数run");
13     }
14 }
15 /*run:Fu构造函数run
16       Zi构造函数run
17 */
18 class Fu_04{
19     //有参
20     Fu_04(int x){
21     System.out.println("Fu构造函数run");
22     }
23 }
24 class Zi_04 extends Fu_04{
25     Zi_04(){
26     super(1);//调用父类int型构造参数
27     System.out.println("Zi构造函数run");
28     }
29 }
30 public class Extends_04 {
31     public static void main(String[] args) {
32         new Zi_04();
33     }
34 }

Example:

 1 package new_Object;
 2 class Fu_05{
 3     Fu_05(){
 4         super();//隐式语句
 5         show();
 6         return;
 7     }
 8     void show(){
 9         System.out.println("fu show");
10     }
11 }
12 class Zi_05 extends Fu_05{
13     int num=8;
14     Zi_05(){
15         super();
16         /*通过super初始化父类时，子类成员变量未显示初始化变量，super()父类初始化完成后
17         子类才进行成员变量初始化
18         */
19         return;
20     }
21     void show(){
22         System.out.println("zi show..."+num);
23     }
24 }
25 public class Extends_05 {
26     public static void main(String[] args) {
27         Zi_05 z=new Zi_05();
28         z.show();
29     }
30 }