旅游网站设计与实现论文/长沙seo免费诊断

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 -- 重写的注解//注解：给程序员和系统解释代码信息@Overridepublic 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;}@Overridepublic 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.重写