(JAVA学习笔记) 类的继承，super，方法的重写，多态

类的继承，super，方法的重写，多态

1.类的继承

• 继承的本质是对某一批类的抽象，从而实现对世界更好的建模
• extends的意思是“扩展”。子类是父类的扩展
• JAVA中类只有单继承，没有多继承！（一个儿子只有一个爸爸，但爸爸可以有多个儿子）
• 继承是类和类之间的一种关系。除此之外，类和类的关系还有依赖，组合，聚合等。
• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
• 子类和父类之间，从意义上讲应该具有“is a”的关系

代码演示：

父类Person：

//Person 人：父类
//在java中，所有的类都间接或直接继承Object类
public class Person /*extends Object*/{
    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    //public可被继承，private则不能
    private int money = 10_0000_0000;
    public void say(){
        System.out.println("说了一句话");
    }
}

子类Student：

//学生 is 人 ：子类
//子类继承了父类就会拥有父类的全部方法
public class Student extends Person{
//ctrl + h 显示继承关系
}

main方法：

 public static void main(String[] args) {
        Student student = new Student();
        student.say();
        System.out.println(student.getMoney());
    }

结果：

2.super和this

super注意点：

1. super调用父类的构造方法，必须在构造方法中的第一个
2. super必须只能出现在子类的方法或者构造方法中！
3. super和this不能同时调用构造方法

super 和 this 的区别：

1. 代表的对象不同：this：本身调用这个对象。super：代表父类对象的引用
2. 前提：this：没有继承也可以使用。super：只有继承条件才可以使用
3. 构造方法：this() 本类的构造。super()：父类的构造。

代码演示：

父类：Father类：

public class Father {
    protected String name = "爸爸";
    public void print(){
        System.out.println("打印爸爸");
    }
}

子类：Son类：

public class Son extends Father{
    private String name = "儿子";
    public void print(){
        System.out.println("打印儿子");
    }
    //方法的调用
    public void test1(){
        this.print();
        super.print();
    }
    //对象的调用
    public void test2(){
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

main方法：

public static void main(String[] args) {
        Son son = new Son();
        son.test1();
        son.test2();
    }

输出结果：

3.方法的重写

重写：需要有继承关系，子类重写父类的方法！

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大但不能缩小； public>prtected>private
4. 抛出的异常范围可以被缩小，但不能扩大；ClassNotFoundException -->Exception(大)
5. 重写，子类的方法和父类必须一致，方法体不同

为什么需要重写？

• 父类的功能，子类不一定需要，或者不一定满足
  快捷键 ：alt+inert ->override；

代码演示：

父类B：

public class B {
    public void test(){
        System.out.println("Hello，B");
    }
}

子类A：

public class A extends B{
    @Override
    public void test() {
        System.out.println("Hello,A");
    }
}

main方法：

  public static void main(String[] args) {
        A a = new A();
        a.test();
    }

4.多态

即同一方法可以根据发送对象的不同而采用不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用类型有很多（父类，有关系的类）。

多态存在的条件:

• 有继承关系
• 子类重写父类方法
• 父类引用指向子类对象
  

注意：多态是方法的多态，属性没有多态。

代码演示：

父类Person：

public class Person {

    public void run(){
        System.out.println("run");
    }
}

子类Student：

public class Student extends Person{
    public void run(){
        System.out.println("son");
    }
}

main方法：

    public static void main(String[] args) {
        //一个对象的实例类型是确定的
        //但是可以指向的引用类型就不确定了：父类的引用指向子类

        //Student 能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 =new Person();
        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
        s1.run();//如果子类重写了父类的方法，执行子类的方法
        s2.run();
    }