Java 基础 20 super关键字以及继承中的方法重写

1.1 super 关键字的概述和使用

1.1.1super 关键字的概述

• super的用法和this很像
  • this代表本类对象的引用
  • super代表父类存储空间的标识（可以理解为父类对象引用）
• 用法（this和super均可如下使用）
  • 访问成员变量
    • this.成员变量 super.成员变量
    • 访问构造方法
    • this(…) super(…)
    • 访问成员方法
    • this.成员方法() super.成员方法()

1.1.2示例代码

package com.itheima_02;

public class Father {
    public int age = 45;
}

package com.itheima_02;
/*
 * super和this的用法很像：
 *      this:代表本类对象的引用
 *      super:代表父类的存储空间(可以理解为代表父类对象的引用)
 * 
 * 用法：
 *      访问成员变量：
 *          this.成员变量
 *          super.成员变量
 *      访问构造方法：
 *          this(...)
 *          super(...)
 *      访问成员方法：
 *          this.成员方法()
 *          super.成员方法()
 */
public class Son extends Father {
    public int age = 20;
    
    public void printAge() {
        int age = 10;
        System.out.println(age);
        //我要访问成员范围的age?
        System.out.println(this.age);
        //我要访问父类成员范围的age?
        System.out.println(super.age);
    }
}
package com.itheima_02;

public class ExtendsTest {
    public static void main(String[] args) {
        Son s = new Son();
        s.printAge();
    }
}

2.2 Java 继承中构造方法的特点

• 子类中所有的构造方法默认都会访问父类中空参数的构造方法
• 为什么呢？
  • 因为子类会继承父类中的数据，可能还会使用父类的数据，所以，子类初始化之前，一定要先完成父类数据的初始化
  • 每一个构造方法的第一条默认语句都是super
• 如果父类中没有构造方法，该怎么办呢？
  • 在父类中加一个无参的构造方法
  • 通过使用super关键字去显示的调用父类的带参构造方法
  • 通过这里我们发现第一种解决方案最简单，所以，建议我们自定义类的时候永远自己给出无参构造方法

1.2.1 示例代码

package com.itheima_03;

public class Father {
    /*
    public Father() {
        System.out.println("Father无参构造方法");
    }
    */
    
    public Father(String name) {
        System.out.println("Father带参构造方法");
        System.out.println(name);
    }
}
package com.itheima_03;
/*
 * Java继承中构造方法的访问特点：
 *      A:子类构造方法执行前都会先执行父类无参构造方法
 *      B:为什么呢?
 *          因为子类继承父类，会继承父类的非私有成员。
 *          而子类在初始化的时候，可能会使用父类的数据，如果父类数据没有先初始化，
 *          子类就不能使用这些数据，所以，在子类初始化之前，一定要先完成父类数据的初始化。
 * 
 *      注意：在子类的构造方法中，默认第一行有一条语句：super()
 * 
 * 问题：假如父类中没有无参构造方法，怎么办呢?
 *      A:在父类中添加一个无参构造方法。
 *      B:可以通过super去访问父类的带参构造方法。
 * 建议使用第一种解决方案，其实就是要求我们写代码的时候，每次都手动的给出无参构造方法。
 */
public class Son extends Father {
    public Son() {
        //super();
        super("林青霞");
        System.out.println("Son无参构造方法");
    }
    
    public Son(String name) {
        //super();
        super("林青霞");
        System.out.println("Son带参构造方法");
        System.out.println(name);
    }
}
package com.itheima_03;

public class ExtendsTest {
    public static void main(String[] args) {
        Son s = new Son();
        System.out.println("---------");
        Son s2 = new Son("林青霞");
    }
}

1.3 Java继承中成员方法的特点

1.3.1 Java继承中成员方法的特点

• 通过子类对象去访问一个方法
  • 首先在子类中找
  • 然后在父类中找
  • 如果还是没有就会报错

1.3.2 示例代码

package com.itheima_04;

public class Father {
    public void show() {
        System.out.println("Father show");
    }
}
package com.itheima_04;
/*
 * Java继承中成员方法的访问特点：
 *      A:子类中方法和父类中方法的声明不一样，这个太简单
 *      B:子类中方法和父类中方法的声明一样，调用的到底是谁的呢?
 *          执行的是子类中的方法。
 * 
 * 通过子类对象调用方法：
 *      a:在子类中找，有就使用
 *      b:在父类中找，有就使用
 *      c:如果没有就报错
 */
public class Son extends Father {
    public void method() {
        System.out.println("Son method");
    }
    
    public void show() {
        System.out.println("Son show");
    }
}
package com.itheima_04;

public class ExtendsTest {
    public static void main(String[] args) {
        Son s = new Son();
        s.method();
        s.show();
        //s.function();
    }
}

1.4 方法重写的概述和使用

1.4.1 方法重写的概述

• 方法重写：子类中出现了和父类中一摸一样的方法声明

1.4.2 方法重写的应用

• 当子类需要父类的功能，而功能主体子类有自己特有的内容时，可以重写中的方法，这样重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

1.4.3方法重写的注意事项

注解

• @Override
  • 表明该方法的重写父类的方法
• 方法重写的注意事项
  • 父类中私有方法不能被重写
  • 子类重写父类方法时，访问权限不能更低
  • 子类重写父类方法时，建议访问权限一摸一样

1.4.4 示例代码

package com.itheima_01;

public class Phone {
    public void call(String name) {
        System.out.println("给"+name+"打电话");
    }
}
package com.itheima_01;

public class NewPhone extends Phone {
    
    public void call(String name) {
        System.out.println("开启视频功能");
        //System.out.println("给"+name+"打电话");
        super.call(name);
    }
}
package com.itheima_01;
/*
 * 方法重写：子类中出现了和父类中一模一样的方法声明的情况。
 * 
 * 方法重写的应用：
 *      当子类需要父类的功能，而功能主体子类又有自己的特有内容的时候，就考虑使用方法重写，
 *      这样即保证了父类的功能，还添加了子类的特有内容。
 */
public class PhoneTest {
    public static void main(String[] args) {
        Phone p = new Phone();
        p.call("林青霞");
        System.out.println("-----------");
        NewPhone np = new NewPhone();
        np.call("林青霞");
    }
}