一、继承的概念以及优势:
1.概念:
1)继承是面向对象三大特征(封装,继承,多态)之一,可让类与类之间产生子父的关系。
2)封装:对象代表什么,就封装对应的数据,并提供数据对应的行为。
2.继承的格式:
Java中提供一个关键字extends,让一个类与另一个类建立起继承关系。
public class Student extends Person{}
Student称为子类(派生类),Person称为父类(基类或超类)。
3.使用继承的优势:
1)减少代码冗余,提高代码的复用性,将多个子类中重复的代码抽取到父类中,子类可直接使用。
2)使子类更强大,子类可在父类基础上,增加其他的功能。
4.继承后子类的特点:
1)子类可以得到父类的属性和行为,子类可以使用。
2)子类可以在父类的基础上新增其他功能,子类更强大。
5.继承需要学习的点:自己设计;用别人的。
6.什么时候用继承优化代码:
当类与类之间,存在相同(共性)的内容,并满足子类是父类中的一种。
二、继承的特点
1.Java只支持单继承:
一个类只能继承一个直接父类。
2.不支持多继承:
子类不能同时继承多个父类。
3.但支持多层继承:
1)子类A继承父类B,父类B可以继承父类C。
2)对于A来说,B是直接父类,C是间接父类。
4.Java中每一个类都直接或者间接继承于Object类。
5.子类只能访问父类中非私有的成员。
6.继承的练习(自己设计一个继承体系)
现在有四种动物:布偶猫、狸花猫、哈士奇、泰迪。
暂时不考虑属性,只要考虑行为。
请按照继承的思想特点进行继承体系的设计。
四种动物分别有以下的行为:
布偶猫:吃饭、喝水、抓老鼠
狸花猫:吃饭、喝水、抓老鼠
哈士奇:吃饭、喝水、看家、拆家
泰迪:吃饭、喝水、看家、烫卷毛
1)画图法:
从下往上画;
下面:子类;
上面:父类;
需要把子类中的共性内容抽取到父类中。
2)核心:
共性内容抽取;子类是父类中的一种
3)书写代码:
从上往下写。
4)代码:
public class Animal {
//权限修饰符
//private:子类无法访问
//私有只能在本类中访问
//★★★子类只能访问父类中非私有的成员
public void eat() {
System.out.println("吃饭");
}
public void drink() {
System.out.println("喝水");
}
}
public class Cat extends Animal {
public void catchMouse() {
System.out.println("猫在抓老鼠");
}
}
public class Dog extends Animal {
public void housekeeping() {
System.out.println("狗看家");
}
}
public class Husky extends Dog {
public void ruinRoom() {
System.out.println("哈士奇在拆家");
}
}
public class Lihua extends Cat {
}
public class Ragdoll extends Cat {
}
public class Teddy extends Dog {
public void curls() {
System.out.println("泰迪烫卷毛");
}
}
public class Test {
public static void main(String[] args) {
//创建对象并调用方法
//1.创建布偶猫的对象
Ragdoll rd = new Ragdoll();
rd.eat();
rd.catchMouse();
rd.drink();
System.out.println("----------");
//2.创建哈士奇的对象
Husky h = new Husky();
h.eat();
h.ruinRoom();
h.drink();
h.housekeeping();
}
}
三、子类能继承父类中的哪些内容(内存图/内存分析工具)
1.误区:
1)父类私有的东西,子类无法继承。
2)父类中非私有的成员,就被子类继承下来了。
2.构造方法:非私有不能;private不能。
父类的构造方法不能被子类继承。
3.成员变量:非私有能;private能(私有的虽然能继承但不能使用,可以使用GetSet)。
4.成员方法:虚方法表能;非虚方法表不能。
1)只有父类中的虚方法才能被子类继承。
2)虚方法:非private,非static,非final。
3)Object类有5个虚方法。
4)虚方法表图:
四、继承中:成员变量的访问特点:就近原则。
1.先在局部位置找,本类成员位置找,父类成员位置找,逐级往上。
2.如果出现了重名的成员变量:
1)System.out.println(name);//从局部位置开始往上找
2)System.out.println(this.name);//从本类成员位置开始往上找
3)System.out.println(super.name);//从父类成员位置开始往上找
五、继承中:成员方法的访问特点
1.直接调用和this调用满足就近原则。
2.super调用,直接访问父类。
3.方法的重写
1)当父类的方法不能满足子类现在的需求时,需要进行方法重写。
2)书写格式:在继承体系中,子类出现了和父类一模一样的方法声明,称子类这个方法是重写的方法。
3)@Override重写注解
@Override是放在重写后的方法上,校验子类重写时语法是否正确。
加上注解后如果有红色波浪线,表示语法错误。
建议重写方法都加@Override注解,代码安全优雅,可读性好。
4)方法重写的本质:子类的方法覆盖了从父类继承来的虚方法表里的方法。
5)方法重写注意事项和要求:
1、重写方法的名称、形参列表必须与父类中的一致。
2、子类重写父类方法时,访问权限子类必须大于等于父类(空着不写<protected<public)。
3、子类重写父类方法时,返回值类型子类必须小于等于父类。
4、建议:子类重写的方法尽量和父类中的方法保持一致。
5、只有被添加到虚方法表中的方法才能被重写。
4.利用方法的重写设计继承结构
现在有三种动物:哈士奇、沙皮狗、中华田园犬
暂时不考虑属性,只要考虑行为。
请按照继承的思想特点进行继承体系的设计。
三种动物分别有以下的行为:
哈士奇:吃饭(吃狗粮)、喝水、看家、拆家
沙皮狗:吃饭(吃狗粮、吃骨头)、喝水、看家
中华田园犬:吃饭(吃剩饭)、喝水、看家
代码:
public class Dog {
public void eat() {
System.out.println("狗在吃狗粮");
}
public void drink() {
System.out.println("狗在喝水");
}
public void housekeeping() {
System.out.println("狗在看家");
}
}
public class Husky extends Dog {
//哈士奇有一个额外方法拆家
public void ruinRoom() {
System.out.println("哈士奇又在拆家了");
}
}
public class Sharpei extends Dog {
//沙皮狗吃狗粮和骨头
//父类中的方法不能满足需求,需要进行重写
@Override
public void eat() {
super.eat();//吃狗粮
System.out.println("狗啃骨头");
}
}
public class ChineseDog extends Dog {
//父类中的方法不能满足需求,需要进行重写
//中华田园犬不用父类中的代码,所以不需要super进行调用
@Override
public void eat() {
System.out.println("吃剩饭");
}
}
public class DogTest {
public static void main(String[] args) {
//创建对象并调用
Husky h = new Husky();
h.eat();
h.drink();
h.housekeeping();
h.ruinRoom();
ChineseDog cd = new ChineseDog();
cd.eat();
cd.drink();
cd.housekeeping();
}
}
六、继承中:构造方法的访问特点
1.父类中的构造方法不会被子类继承(类名不同)。但可以通过super调用。
2.子类中所有的构造方法默认先访问父类中的无参构造,再执行自己。
1)原因:
1、子类在初始化的时候,有可能会使用到父类中的数据。
如果父类没有完成初始化,子类将无法使用父类的数据。
2、子类初始化之前,一定要调用父类构造方法先完成父类数据空间的初始化。
2)如何调用父类构造方法:
1、子类构造方法的第一行语句默认都是:super(),不写也存在,且必须在第一行。
2、如果想调用父类有参构造,必须手动写super进行调用。
七、this、super使用总结
1.this:理解为一个变量,表示当前方法调用者的地址值。
2.super:代表父类存储空间。
3.★★★this(…)调用本类其他构造方法。
虚拟机不会再添加super()。写在第一行。一般用于设置默认值。
4.练习:带有继承结构的标准Javabean类
1)经理
成员变量:工号,姓名,工资,管理奖金
成员方法:工作(管理其他人),吃饭(吃米饭)
2)厨师
成员变量:工号,姓名,工资
成员方法:工作(炒菜),吃饭(吃米饭)
public class Employee {
//1.类名见名知意
//2.所有的成员变量都需要私有
//3.构造方法(空参 带全部参数的构造)
//4.get/set
private String id;
private String name;
private double salary;
public Employee() {
}
public Employee(String id, String name, double salary) {
this.id = id;
this.name = name;
this.salary = salary;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
//工作
public void work() {
System.out.println("员工在工作");
}
//吃饭
public void eat() {
System.out.println("吃米饭");
}
}
public class Manager extends Employee {
private double bonus;
//空参构造
public Manager() {
}
//带全部参数的构造
//父类+子类
public Manager(String id, String name, double salary, double bonus) {
super(id, name, salary);
this.bonus = bonus;
}
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
@Override
public void work() {
System.out.println("管理其他人");
}
}
public class Cook extends Employee {
public Cook() {
}
public Cook(String id, String name, double salary) {
super(id, name, salary);
}
@Override
public void work() {
System.out.println("炒菜");
}
}
public class Test {
public static void main(String[] args) {
//创建对象并赋值调用
Manager m = new Manager("01", "王总", 20000, 8000);
System.out.println(m.getId() + "," + m.getName() + "," + m.getSalary() + "," + m.getBonus());
m.work();
m.eat();
Cook c = new Cook();
c.setId("02");
c.setName("大董");
c.setSalary(8000);
System.out.println(c.getId() + "," + c.getName() + "," + c.getSalary());
c.work();
c.eat();
}
}