Java复习笔记8【super的简单用法】

package com.lesson8.test;

/*

 * 简单了解super的用法：

 * */

/*

 * 【super】

 * 1.super可以访问被子类重写的父类同名方法和被子类隐藏的父类的成员变量，super只能在子类中（内部）使用

 * 2.可使用super关键字调用父类构造方法

 * */

class Father{

 protected int money = 100;

//private int money = 100;

 //error,注意访问权限，private私有，子类无法访问,super也不能访问

}

class Son extends Father{

 private int money;

 

 public Son(){

  money = 500;

  System.out.println("-------这是类son----------");

 }

 public void show(){

  System.out.println(this.money);

  System.out.println(super.money);

 }

}

class Son2 extends Father{

 public Son2(){

  money = 500;

  System.out.println("-------这是类son2----------");

 }

 public void show(){

  System.out.println(this.money);

  System.out.println(super.money);

 }

}

public class SuperExample {

 public static void main(String args[]){

  Son son = new Son();

  son.show();

  Son2 son2 = new Son2();

  son2.show();

/*

   * 结果如下：

   * -------这是类son----------

   500

   100

   -------这是类son2----------

   500

   500

   * */

 }

}

/*

 * 添加 private int money，输出:

 * this.money = 500 //子类自定义变量money，隐藏了父类的同名变量money（这两个money不是同一个变量）

 * super.money = 100 //构造方法设置子类的money=4，super调用父类的变量money=3

 * ----------------------------------------------------------------------------------------------------------------

 * 不添加private int money，输出:

 * this.money = 500//子类直接继承了父类的变量money（父类和子类使用同一个money）

 * super.money = 500

    //构造方法设置money=500，相当于修改父类的money=500，super调用父类的变量得money=500

 * */

---

package com.lesson8.test;

/* 

 * 简单了解super的用法：super调用父类构造方法

 * */

/*

 * 【super】

 * 1.super可以访问被子类重写的父类同名方法和被子类隐藏的父类的成员变量，super只能在子类中（内部）使用

 * 2.可使用super关键字调用父类构造方法

 * */

/*

 * 【新技能get！】

 * 1.调用父类的构造方法必须使用super，不能使用父类的类名调用

 * 2.super调用父类构造函数的方法：

 * （1）显式或隐含地调用super()，前提是父类必须有无参的构造函数（没有的话会报错）

 * （2）显式地调用super(实参)，前提是父类必须有带参的构造函数（没有的话会报错）

 * 3.对super的调用必须是构造函数中的第一个语句（不能调用多个super语句）

 * */

class A{

 int i;

 int j;

 

 /*自定义类中，如果不写构造方法，java系统会默认添加一个无参的构造方法。

      如果写了一个有参的构造方法，还使用无参的构造方法，就必须手动给出无参构造方法。*/

 public A(){}//父类无参构造函数 

 

 public A(int i, int j){//父类带参构造函数 

  this.i = i;

  this.j = j;

 }

}

class B extends A{

 int x; 
 int y; 

       //子类继承父类的非私有成员变量，如果对所有变量重新进行初始化，最好调用父类构造函数，直接传入值进行初始化 
         //子类无法直接继承父类的构造函数，必须使用super进行访问（super隐式或者显式调用） 

 public B(int i, int j, int x, int y){

//隐式调用父类的无参的构造方法 

  //super();//显式调用父类的无参的构造方法 

  super(i, j);//显式调用父类的含参构造方法，对继承的变量进行初始化 

  this.x = x; 

  this.y = y; 

  /* 

  * 调用父类的构造方法就是省略了子类对父类变量的初始化过程: 

  * super(i, j)相当于 

  * this.i = i; 

  * this.j = j; 

  * */

         }

    

 public void f(){

//super();//报错，普通方法中不能调用父类的构造方法

  //因为要想调用构造方法，表示正在构造该方法，但是调用普通方法时，构造方法早已构造完成，不能再进行构造

 }

}

class C extends A{

 int m;

 public C(int i, int j, int m){

 /*super(i, j);

   super(i, j);

 //报错，不能同时调用多个构造函数

 */

 this.m = m;

 //super(i, j);//报错，super必须是构造函数第一个语句

 }

}

public class SuperExample2 {

 public static void main(String[] args){

  B b = new B(1, 2, 3, 4);

  b.f();

  C c = new C(1, 2, 3);

 }

}