Python异常处理：三种不同方法的探索与最佳实践

文章目录

• 前言
• 继承
• • 继承语法
  • 继承总结
  • super指定访问父级
  • 子类构造方法
  • super和this
  • 再谈初始化(执行顺序)
  • protected 关键字
  • 继承方式
  • final 关键字
  • 继承与组合
• 多态
• • 动态绑定与静态绑定
  • 多态实现条件
  • 重写

前言

适合复习看

继承

继承语法

修饰符 class 子类 extends 父类 {
// ...
}

继承总结

在子类方法中 或者 通过子类对象访问成员时：

成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找

子类中访问父类的成员方法时:

super指定访问父级

注意

子类构造方法

注意：

super和this

【相同点】

【不同点】

再谈初始化(执行顺序)

protected 关键字

子类 就是 基类(父类)的派生类(子类)

注意：父类中private成员变量虽然在子类中不能直接访问，但是也继承到子类中了

继承方式

Java中只支持以下几种继承方式：

注意：Java中不支持多继承。

final 关键字

final关键可以用来修饰变量、成员方法以及类。

final int a = 10;
a = 20; // 编译出错

final public class Animal {
...
}
public class Cat extends Animal {
...
} 
// 编译出错
//Error:(3, 27) java: 无法从最终com.bit.Animal进行继承

我们平时是用的 String 字符串类, 就是用 final 修饰的, 不能被继承

继承与组合

class Student2 {

}
class Teacher {

}

class School {

    public Student2[] student2s = new Student2[10];
    public Teacher[] teachers = new Teacher[5];
    //不用继承就能使用"父类"

}

多态

动态绑定与静态绑定

多态的本质就是利用动态绑定,不同对象执行的效果也不一样

多态实现条件

在java中要实现多态，必须要满足如下几个条件，缺一不可：

1. 必须在继承体系下
2. 子类必须要对父类中方法进行重写
3. 通过父类的引用调用重写的方法

多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法

父类:

class Animal {
    private String name;
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
    public void eat() {
        System.out.println("eat");
    }
}

两个子类:

class Cat extends Animal {
    Cat(String name) {
        super.setName(name);
    }
    @Override//对父类的eat进行重写
    public void eat() {
        System.out.println(super.getName() + "吃猫粮");
    }
}
class Dog extends Animal {
    Dog(String name) {
        super.setName(name);
    }
    @Override//对父类的eat进行重写
    public void eat() {
        System.out.println(super.getName() + "吃狗粮");
    }
}

测试:

class test {
    public static void main(String[] args) {
        Animal animal = new Cat("猫猫");//向上转型,把子类传给父类的类型
        animal.eat();

        animal = new Dog("狗子");
        animal.eat();
        //打印为:
        //猫猫吃猫粮
        //狗子吃狗粮
    }
}

重写

重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法

方法重写规则: