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("林青霞");
}
}
