目录
1，概述
1.1继承的含义
1.2什么时候用继承
1.3继承的好处
1.4继承的特点
2，继承的格式
3，可以继承哪些内容
4，成员方法和成员变量的访问特点
5，构造方法的访问特点
6，this，super使用总结
7，小结
8，练习
1，概述
1.1继承的含义
继承：就是子类继承父类的属性和行为，使得子类对象可以直接具有与父类相同的属性、相同的行为（行为可重写）。子类可以直接访问父类中的非私有的属性和行为。
继承描述的是事物之间的所属关系，这种关系是：is-a 的关系。例如，兔子属于食草动物，食草动物属于动物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。
- Java提供一个关键字extends，用这个关键字，我们可以让一个类与另一个类建立联系
public class Cat extends Animal{}- Cat称为子类（派生类），Animal称为父类（基类或超类）
1.2什么时候用继承
当类与类之间，存在相同（共性）的内容，并满足子类是父类的一种，就可以考虑用继承来优化代码
图一：
图二
图一设计的继承结构正确，图二错误，因为Coder是人，Goods是物品，Coder不是Goods里面的一种
1.3继承的好处
- 可以把多个子类中重复的代码抽取到父类中，提高代码的复用性（减少代码冗余，相同代码重复利用）。
- 子类可以在父类的基础上，增加其他的功能，使子类更强大
- 使类与类之间产生了关系
1.4继承的特点
- Java只支持单继承：一个类只能继承一个直接父类
- 不支持多继承，但支持多层继承
多层继承：子类A继承父类B，父类B可以继承父类C
2，继承的格式
通过extends关键字，可以声明一个子类继承一个父类，定义格式如下：
class 父类{
.....
}
class 子类 extends 父类{
.....
}需要注意：Java是单继承的，一个类只能继承一个直接父类，跟现实世界很像，相当于一个儿子只能有一个父亲，但是Java中的子类是更加强大的。
例子
package extendsKey;
public class Test {
public static void main(String[] args) {
//创建对象
Ragdoll rd=new Ragdoll();
rd.eat();
rd.drink();//间接继承
rd.mouse();//直接继承
System.out.println("-----------------");
Huskey hs=new Huskey();
hs.eat();
hs.drink();//间接继承
hs.lookHome();//直接继承
hs.catchHome();//本类中的行为
//子类只能访问父类中非私有的成员
}
}
class Animal {
public void eat(){
System.out.println("动物在吃饭");
}
public void drink(){
System.out.println("动物在喝水");
}
}
class Cat extends Animal{
public void mouse (){
System.out.println("猫在抓老鼠");
}
}
class Dog extends Animal{
public void lookHome(){
System.out.println("狗在看家");
}
}
class Huskey extends Dog{
public void catchHome(){
System.out.println("哈士奇在拆家");
}
}
class Ragdoll extends Cat{
}结果
3，可以继承哪些内容
- 构造方法不能被继承
- 成员变量都能被继承，但私有的不能使用
- 成员方法非私有能，私有不能
4，成员方法和成员变量的访问特点
就近原则：谁离我近，我就用谁
- 重名怎么办
System.out.println(name); 从局部位置开始往上找
System.out.println(this.name);从本类成员位置开始往上找，如果本类中没有，就找从父类继承下来的
System.out.println(super.name);从父类成员位置开始往上找
package extendsKey;
public class Fu {
String name="Fu";
}
class Zi extends Fu{
String name="Zi";
public void Zishow(){
String name="zishow";
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
}
class Tester{
public static void main(String[] args) {
Zi per=new Zi();
per.Zishow();
}
}结果
4.1成员方法的重写
（1）重写是什么？
- 子类可以继承父类方法，但有时从父类继承的方法在子类中必须进行修改以适应新类的需要，这种对父类方法进行改写或改造的现象称为方法重写或方法覆盖。父类方法在子类中重写使继承更加灵活。
（2）语法规则：
- 在子类中定义；
-
方法名、参数类型、顺序、个数（不包括参数名，对参数名没有要求）都要与父类继承的方法相同；
-
当子类重写父类方法后，子类对象调用的是重写后的方法。
-
Java中用@Override标注重写后的方法，如果重写不成功，标注会报错
5，构造方法的访问特点
- 父类中的构造方法不会被子类继承
- 子类中所有的构造方法默认先访问父类中的无参构造，再执行自己
为什么？
- 子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据
- 子类在初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化
- 父类中的属性都是共性的内容，而且都是可以被子类继承下来的，而父类中的空参构造就是给父类中的属性一个默认初始化，如果没有这一步，子类在使用父类的属性是就没有值了
怎么调用父类构造方法的？
- 子类构造方法的第一行默认语句都是：super（），不写也存在，且必须在第一行
- 如果想要调用父类的有参构造，必须手动写super进行调用，因为默认的只能调用空参
代码实现
6，this，super使用总结
- this：理解为一个变量，表示当前方法调用者的地址值
- super：代表父类存储空间
| 关键字 | 访问成员变量 | 访问成员方法 | 访问构造方法 |
| this | this.成员变量 访问本类成员变量 | this.成员方法（...) 访问本类成员方法 | this（...) 访问本类其他构造方法 |
| super | super.成员变量 访问父类成员变量 | super.成员方法（...) 访问父类成员方法 | super（...) 访问父类构造方法 |
this（...)访问本类其他构造方法：
- 什么时候用到：给一些数据做默认值的时候就会用到
结果
7，小结
- 继承实际上是子类相同的属性和行为可以定义在父类中，子类特有的属性和行为由自己定义，这样就实现了相同属性和行为的重复利用，从而提高了代码复用。
- 子类继承父类，就可以直接得到父类的成员变量和方法
8，练习
- 带有继承结构的标准javabean类（成员变量私有化，用set，get方法获取）
1，经理
成员变量：工号，姓名，工资，管理奖金
成员方法：工作（管理其他人），吃饭（吃米饭）
2，厨师
成员变量：工号，姓名，工资
成员方法：工作（炒菜），吃饭（吃米饭）
- 父类
package extendsKey;
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("在吃米饭");
}
}- 子类
package extendsKey;
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("管理其他人");
}
}
package extendsKey;
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("厨师正在炒菜");
}
}- 测试类
package extendsKey;
public class Test3 {
public static void main(String[] args) {
Manager s=new Manager("001","管理小行家",99999.1,8000);
System.out.println(s.getId()+","+s.getName()+","+s.getSalary()+","+s.getBonus());
Cook c=new Cook();
c.setId("002");
c.setName("厨师高手");
c.setSalary(9999.9);
System.out.println(c.getId()+","+c.getName()+","+c.getSalary());
}
}- 结果
![蓝桥杯(4):python动态规划DF[1]](https://img-blog.csdnimg.cn/direct/0c6768dd0acd471daa755f1852ddd22b.png)
