学习JavaEE的日子 day14 继承，super()，this()，重写
Day14
1.继承的使用
理解：子类继承父类所有的属性和方法
使用场景：多个类似的类，有相同的属性和方法，就可以把相同属性和方法抽取到父类
优点：减少代码的冗余； 使类与类之间产生了关系(多态的前提)
缺点：继承会增加类与类之间的关系，会增加代码的维护难度
需求：编写中国人和日本人的类，创建各自的对象
分析：
人类： 属性：姓名、性别、年龄 方法：吃饭饭、睡觉觉 中国人的类 继承 人类 ： 属性：身份证 方法：打太极 日本人的类 继承 人类： 属性：年号 方法：拍电影
//父类
public class Person {
String name;
char sex;
int age;
public void eat(){
System.out.println(this.name + "吃饭饭");
}
public void sleep(){
System.out.println(this.name + "睡觉觉");
}
}
// 子类 继承 父类
public class Chinese extends Person{
String id;
public void playTaiJi(){
System.out.println("中国人打太极");
}
}
// 子类 继承 父类
public class Japanese extends Person{
String yearNum;
public void playVideo(){
System.out.println("日本人拍电影");
}
}
//测试类
public class Test01 {
public static void main(String[] args) {
//创建对象
Chinese c = new Chinese();
//操作父类属性
c.name = "小彭";
c.sex = '男';
c.age = 21;
//操作子类属性
c.id = "1234567890";
//调用父类方法
c.eat();
c.sleep();
//调用子类方法
c.playTaiJi();
System.out.println("-----------------------------");
//创建对象
Japanese j = new Japanese();
//操作父类属性
j.name = "波多野结衣";
j.sex = '女';
j.age = 18;
//操作子类属性
j.yearNum = "令和";
//调用父类方法
j.eat();
j.sleep();
//调用子类方法
j.playVideo();
}
}
继承内存图：
父类空间优先于子类对象产生
在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法
小结
1.继承实际上是子类相同的属性和行为可以定义在父类中，子类特有的属性和行为由自己定义，这样就实现了相同属性和行为的重复利用，从而提高了代码复用。
2.继承是在多个类中之间的，使用关键字extends，在父类的非私有属性和方法可以被子类继承
3.java是单继承的
2.继承的深入
面试题
1.创建子类对象，会调用父类的构造方法吗？
会
2.创建子类对象，为什么会调用父类构造方法？
因为会在子类对象中开辟空间，用于存储父类的成员属性
3.创建子类对象，先调用父类构造方法还是子类构造方法？
先调用子类的构造方法
4.创建子类对象，先完成父类构造方法还是子类构造方法？
先完成父类的构造方法
5.子类对象是否能继承父类所有的属性和方法？
Java官网上，明确表示子类不能继承父类私有化的属性和方法，这是站在使用的角度
实际上，子类能继承父类私有化的属性方法，但是不能直接使用，可以在父类中编写公有方法去调用私有的属性和方法
*值得注意的是子类可以继承父类的私有成员（成员变量，方法），只是子类无法直接访问而已，可以通过在父类中设置get/set方法访问父类的private成员变量。*
public class Father {
private String fatherAttr = "父类私有化属性";
public Father() {
System.out.println("调用父类的构造方法");
}
public String getFatherAttr() {
return fatherAttr;
}
public void setFatherAttr(String fatherAttr) {
this.fatherAttr = fatherAttr;
}
private void method01(){
System.out.println("父类私有化方法");
}
public void method02(){
method01();
}
}
public class Son extends Father{
public Son() {
//super();//默认实现：调用父类的构造方法,所以首先完成父类构造方法，再执行下一句
System.out.println("调用子类的构造方法");
}
}
//测试类
public class Test01 {
public static void main(String[] args) {
Son son = new Son();
System.out.println(son.getFatherAttr());
son.method02();
}
}
3.super
理解：super表示父类
super代表的是父类对象的引用，this代表的是当前对象的引用。*
作用：
1.super.属性：在子类中，调用父类的非私有化的成员属性（不常用，因为属性已经私有化了）
2.super.方法：在子类中，调用父类的非私有化的成员方法
3.super()：在子类构造方法中的第一句调用父类的非私有化的构造方法
需求：编写中国人和日本人的类，创建各自的对象
public class Person {
private String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void eat(){
System.out.println(this.name + "吃饭饭");//name这个属性是本类的，所以使用this，而不是super
}
}
public class Chinese extends Person{
private String id;
public Chinese() {
}
public Chinese(String name,String id) {
super(name);//子类中把父类的成员变量一起有参构造出来，方便使用
this.id = id;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public void playTaiJi(){
System.out.println(super.getName() + "打太极");//super.属性：用的是分类的成员变量，子类中没有名字这个属性
}
}
public class Japanese extends Person{
private String yearNum;
public Japanese() {
}
public Japanese(String name,String yearNum) {
super(name);
this.yearNum = yearNum;
}
public String getYearNum() {
return yearNum;
}
public void setYearNum(String yearNum) {
this.yearNum = yearNum;
}
public void playVideo(){
System.out.println(super.getName() + "拍电影");//super.属性：用的是分类的成员变量，子类中没有名字这个属性
}
}
public class Test01 {
public static void main(String[] args) {
//创建对象
Chinese c = new Chinese("小彭", "1234567890");
//调用父类方法
c.eat();
//调用子类方法
c.playTaiJi();
System.out.println("-----------------------------");
//创建对象
Japanese j = new Japanese("波多野结衣", "令和");
//调用父类方法
j.eat();
//调用子类方法
j.playVideo();
}
}
小结 - 编写一个类的步骤：
1.属性
2.私有化属性
3.无参构造
4.有参构造
5.get/set方法
6.其他的方法
3.1 继承后的特点——构造方法
构造方法的名字是与类名一致的。
构造方法的作用是初始化对象成员变量数据的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。（*先有爸爸，才能有儿子*）
*继承后子类构方法器特点:子类所有构造方法的第一行都会默认先调用父类的无参构造方法*****
子类构造方法的第一行都隐含了一个super()调用父类无参数构造方法，super()可以省略不写。
3.2 super和this的用法格式
this.成员变量 – 本类的
this.成员方法名() – 本类的
super.成员变量 – 父类的
super.成员方法名() – 父类的
接下来我们使用调用构造方法格式：
this(…) – 调用本类的其他构造方法，根据参数匹配确认
super(…) – 调用父类的构造方法，根据参数匹配确认
注意：
*子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。*
*super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。*
4.重写/复写
理解：在子类中，将父类的方法重新写一遍
子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。*声明不变，重新实现*
应用场景：父类方法不能被改动时，在子类中重新写一遍
条件：
1.在子类中重写父类的方法
2.返回值、方法名、参数列表必须跟父类重写的方法一致
3.访问修饰符不能比父类更严格
面试题：重写(overriding)与重载(overloading)的区别？
重写是发生在子父类继承关系中方法名相同，参数列表相同，返回值相同，子类访问修饰符要大于等于父类的修饰符，子类的异常声明必须小于等于父类的异常声明；
方法重载发生在同一个类中,方法名相同，参数列表不同，返回值无关。
需求：编写中国人和日本人的类，创建各自的对象
public class Test01 {
public static void main(String[] args) {
//创建对象
Chinese c = new Chinese("小彭", "1234567890");
c.eat();//调用子类重写后的方法
System.out.println("-----------------------------");
//创建对象
Japanese j = new Japanese("波多野结衣","令和");
j.eat();//调用子类重写后的方法
}
}
public class Person {
private String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void eat(){
System.out.println(this.name + "吃饭饭");
}
}
public class Chinese extends Person{
private String id;
public Chinese() {
}
public Chinese(String name, String id) {
super(name);
this.id = id;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
//@Override -- 重写的注解
//注解：给程序员和系统解释代码信息
@Override
public void eat(){
System.out.println(super.getName() + "吃山珍海味");
}
}
public class Japanese extends Person{
private String yearNum;
public Japanese() {
}
public Japanese(String name,String yearNum) {
super(name);
this.yearNum = yearNum;
}
public String getYearNum() {
return yearNum;
}
public void setYearNum(String yearNum) {
this.yearNum = yearNum;
}
@Override
public void eat() {
System.out.println(super.getName() + "吃生鱼片");
}
}
4.1 @Override重写注解
@Override:注解，重写注解校验！
这个注解标记的方法，就说明这个方法必须是重写父类的方法，否则编译阶段报错。
建议重写都加上这个注解，一方面可以提高代码的可读性，一方面可以防止重写出错！
4.2 注意事项
1.方法重写是发生在子父类之间的关系。
2.子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
3.子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。
4.父类中的方法使用private，static，final任意修饰符，那么，不能被子类重写。
5.总结
1.继承的使用
2.继承的深入 — 重要
3.super
4.重写