Chp9-继承

目录

概念

语法

规则

子类内存结构

父类封装

使用

方法重写

概念

规则

使用

访问修饰符

使用

有继承关系的对象创建过程

super关键字

super()

super.

 

---

概念

将子类的共性进行抽取，生成父类

在继承关系下，子类可以拥有父类中可被继承的内容

语法

访问修饰符 class 子类类名 extends 父类类名{
   
}

规则

1. 一个子类只能有一个直接父类（单继承）

2. 一个父类能拥有多个直接子类

3. 一个子类同时可以身为其他类的父类

4. 子类可以拥有独有内容

5. 子类独有内容父类无法拥有和访问

6. 子类可以继承拥有所有父类中可被继承的所有内容

7. 父类的私有内容子类无法继承访问

8. 父类的构造子类无法继承

子类内存结构

• 子类对象结构由父类内容和独有内容构成

• 当使用子类对象访问内容时，优先从独有内容中查找，若独有内容中没有，再去往父类结构中查找

父类封装

父类也是类，为了确保数据的安全性，若父类中存在属性，也应对属性进行封装

使用

父类属性封装之后，子类无法直接访问使用，仍然需要借助对应的getter|setter方法

package com.by.entity;
​
public class Animal {
    private String name;
    private String color;
    private int age;
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public String getColor() {
        return color;
    }
​
    public void setColor(String color) {
        this.color = color;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
​
    private void method(){
        System.out.println("父类Animal中的私有方法");
    }
}

package com.by.test;
​
import com.by.entity.Animal;
import com.by.entity.Dog;
​
public class Test2 {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.setAge(2);
        System.out.println(animal.getAge());
​
        //子类对象
        Dog dog = new Dog();
        //dog.name = "小黑";
        dog.setName("小黑");
        System.out.println(dog.getName());
    }
}

方法重写

• 又名方法覆盖

概念

子类对从父类中继承的方法的方法体进行重新书写，简称方法重写

规则

1. 建立在继承关系之上

2. 返回值类型、方法名、参数列表必须与父类保持一致

3. 访问修饰符必须与父类相同或者更宽

4. 不允许抛出比父类更大或更多的异常

使用

方法重写之后，优先使用子类重写内容

父类的作用：

1. 解决子类之间的代码冗余问题

2. 约束子类必须拥有某些内容

访问修饰符

• 作用为控制内容可被访问的范围

	本类	同包	非同包子类	非同包非子类
private (私有的)	√
default（默认的）	√	√
protected（受保护的）	√	√	√
public（公开的）	√	√	√	√

使用

1. 都可以修饰属性、方法、构造

2. 都不可修饰局部变量

3. 只有public和default可以修饰类

4. default作为访问修饰符不可显式声明

有继承关系的对象创建过程

1. 给父子类属性分配空间，赋默认值

2. 给父类属性赋初始值（属性声明处）

3. 执行父类构造给属性再次赋值

4. 给子类属性赋初始值（属性声明处）

5. 执行子类构造给属性再次赋值

先构建父类内容，再构建子类内容

super关键字

• 代表父类对象

super()

可以调用父类构造内容

super(实参列表);

• 子类有参构造的书写：

  public 子类类名(父类声明的属性,子类声明的属性){
     //利用super()给父类声明属性赋值
     super(父类声明的属性名);
     //利用this.给自己声明属性赋值
     this.自己声明的属性名=自己声明的属性名;
  }

  package com.by.entity;
  ​
  public class Cat extends Animal{
      private String sex;//Cat类的独有属性
  ​
      //无参构造
      public Cat(){}
      //有参构造: 给父类中声明的属性赋值+给自己声明的属性赋值
      public Cat(String name, int age, String color,String sex){
          //利用super给父类声明属性赋值
          super(name, age, color);
          //利用this给自己声明的属性赋值
          this.sex = sex;
      }
  ​
      public String getSex() {
          return sex;
      }
  ​
      public void setSex(String sex) {
          this.sex = sex;
      }
  ​
      //重写父类的吃饭方法
      public void eat(){
          System.out.println("猫吃小鱼干");
      }
  }
  ​

• 使用：

  1. 位置：子类构造有效代码第一行

  2. 当子类未显式通过super调用父类构造时，默认使用super()调用父类无参构造

  3. this()和super()无法同时出现

  4. 执行子类构造内容之前必定先执行父类构造

super.

作用为指明调用父类的属性或方法

super.属性名
super.方法名(实参列表)