Java基础之继承和多态

目录

继承

继承的定义

父类和子类（基类和派生类）

super类

多态

多态的定义：

静多态（静态绑定/编译期多态）

动多态（动态绑定/运行期多态）

---

继承

继承的定义

两个类如果是has a（car has a wheel） 的关系，则称之为组合关系，如果是is a （people is a animal）的关系，则称之为继承关系。

继承是在已有类基础上生成新的类的过程。已有类是一般类，新类是特殊类。通过继承，特殊类拥有一般类的属性和行为，特殊类中不必再重新定义已在一般类中定义过的属性和行为。一个特殊类既有自己新定义的属性和行为，又有继承下来的属性和行为。

继承的作用是避免代码的大量重复。

父类和子类（基类和派生类）

继承是在已有类基础上生成新的类的过程。已有类是一般类，新类是特殊类。继承又可以称为派生，一般类又可以称为基类或父类，特殊类又可以称为派生类或子类。

public class Cat extends Animal{
···       // 使用extends关键字体现继承关系
// Cat 继承了类 Animal
}

创建People 、Teacher、Student 类并演示他们的关系

 定义一个people类作为父类；

package test.inheritant;

public abstract class People{
    private String name;
    private int age;
    private String gender;

    public People(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public abstract void work();

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getGender() {
        return gender;
    }
}

 定义Teacher 类继承People类

package test.inheritant;

public class Teacher extends People{
    private float salary;
    private String department;

    public Teacher(String name, int age, String gender, float salary, String department) {
        super(name, age, gender);
        this.salary = salary;
        this.department = department;
    }

    @Override
    public void work() {
        System.out.println(getName()+"学习,这位老师是"+getGender()+"所属单位"+department);
    }
}

定义Student类继承People类

package test.inheritant;

public class Student extends People {
    private int score;
    private String grade;

    public Student(String name, int age , String gender, int score, String grade){
        super(name, age, gender);  // 调用基类的构造方法
        this.score = score;
        this.grade = grade;
    }

    @Override
    public void work() {
        System.out.println(getName()+"学习,这位学生是"+getGender()+"成绩是"+score);
    }
}

在测试类中将结果打印出来

package test.inheritant;

public class course1 {
    public static void work(Object obj){
        if(obj instanceof Student){
            Student student = (Student) obj;
            student.work();
        }
        if(obj instanceof Teacher){
            Teacher teacher = (Teacher) obj;
            teacher.work();
        }
    }
    public static void main(String[] args){
        Student s1 = new Student("zs",19,"男生",89,"一班");
        work(s1);
        Teacher T1 = new Teacher("LS",30,"男生",10000,"西安");
        work(T1);
    }
}

 打印结果如下：

super类

super（）在当前类构造函数中，主要有两个用途：1.调用基类的构造方法 (在上述代码中已经体现）2.访问基类的属性和方法

构造函数不能被继承。

public class people{
    ·····
    public void print(){
        System.out.println("name"+name);
        System.out.println("age"+age);
    }
}
public class Student extends People{
    ······
    public void print(){
        super.print();  //使用super.print();调用父类的print方法；
    }
}

多态

多态的定义：

不同物体对同一消息做出不同的反应。

多态的实现条件：

1. 继承
2. 方法重写 （重写是Java多态性的一种体现）
3. 向上造型（基类的引用，引用 派生类的对象  ； 基接口的引用  引用实现该接口的类对象）

多态的实现原理：

静多态（静态绑定/编译期多态）

核心围绕方法重载，方法重载条件是作用域相同，同一个类，同一个函数名，但参数列表不同

发生静多态的条件与方法重载一样。

动多态（动态绑定/运行期多态）

核心围绕方法重写，（方法重写（在子类中重写父类中的方法，其函数名相同，方法名、参数列表相同，子类的访问限定符权限>=父类的访问限定符权限））；

发生动多态的条件是：1.继承 2.方法重写 （重写是Java多态性的一种体现）3.向上造型（基类的引用，引用 派生类的对象；基接口的引用 引用 实现该接口的类对象）

方法区，方法表，栈（内存的开辟，栈帧的开辟（Java虚拟机  JVM专项）），堆，Class类 （方法重写的实现原理==动态绑定）

----->基于向上造型拓展向下造型：

instanceof   在运行期判断对象类型

Animal animal = new Animal();
Dog dog = (Dog) animal;

这种写法是错误的 

正确写法为：

Animal animal = new Animal();
if(animal intanceof Dog){
    Dog dog = (Dog) animal;
}