目录
一. 继承
二. 多态
三. 引用类型的转换 检查
向上转型（Upcasting）
向下转型（Downcasting）
四. final关键字
一. 继承
在 Java 中，继承（Inheritance）是面向对象编程的一个重要特性，它允许一个类（子类）继承另一个类（父类）的属性和方法。
优点
代码复用：子类可以直接使用父类中定义的属性和方法，无需重新编写相同的代码，提高了代码的可重用性。
层次结构：有助于建立清晰的类层次结构，反映现实世界中的对象关系。
易于扩展：通过继承，可以在不修改父类代码的情况下，为子类添加新的属性和方法，扩展功能。
语法
使用 extends 关键字来表示继承关系。
class Parent {
// 父类的属性和方法
}
class Child extends Parent {
// 子类的属性和方法
}
访问控制
子类可以访问父类的
public和protected成员。如果子类和父类在同一个包中，子类还可以访问父类的默认访问权限（没有明确修饰符）的成员。
方法重写（Override）
子类可以重写父类的方法，方法名、参数列表和返回类型必须与父类被重写的方法相同。重写的方法体可以根据子类的需求进行修改。
class Parent {
public void method() {
System.out.println("Parent's method");
}
}
class Child extends Parent {
@Override
public void method() {
System.out.println("Child's method");
}
}
构造方法
子类的构造方法在创建对象时会首先调用父类的无参构造方法（如果父类没有定义无参构造方法，必须在子类的构造方法中显式地调用父类的有参构造方法）。
可以在子类的构造方法中通过
super关键字调用父类的构造方法。
示例
class Animal {
protected String name;
public void eat() {
System.out.println(name + " is eating.");
}
}
class Dog extends Animal {
public Dog(String name) {
this.name = name;
}
public void bark() {
System.out.println(name + " is barking.");
}
public static void main(String[] args) {
Dog dog = new Dog("Buddy");
dog.eat();
dog.bark();
}
}
继承使得代码更加简洁、可维护和可扩展，但也要注意合理使用，避免过度复杂的继承层次和不必要的继承。
二. 多态
在 Java 中，多态（Polymorphism）是面向对象编程的重要特性之一，它允许不同的对象对同一消息或操作做出不同的响应。
多态的类型
-
编译时多态（方法重载 - Overloading）：在同一个类中，存在多个方法具有相同的名称，但参数的数量、类型或顺序不同。在编译时，根据传递的参数类型和数量来决定调用哪个具体的方法。
例如：
class Calculator {
public int add(int a, int b) {
return a + b;
}
public double add(double a, double b) {
return a + b;
}
}
-
运行时多态（方法重写 - Overriding）：子类继承父类的方法，并对其进行重新定义。在运行时，根据对象的实际类型来决定调用子类还是父类中被重写的方法。
例如：
class Animal {
public void makeSound() {
System.out.println("The animal makes a sound");
}
}
class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("The dog barks");
}
}
实现多态的条件
-
继承：子类继承父类。
-
方法重写：子类重写父类的方法。
-
父类引用指向子类对象：通过父类类型的引用变量来引用子类对象。
例如：
Animal animal = new Dog();
animal.makeSound(); // 实际调用的是 Dog 类中重写的 makeSound 方法
多态的优点
增强了代码的灵活性和可扩展性，使得代码更易于维护和修改。
提高了代码的复用性，不同的对象可以通过相同的方法调用实现不同的功能。
使得程序的设计更加符合现实世界的逻辑，能够更好地模拟不同类型对象的行为差异。
总之，多态是 Java 中非常强大的特性，合理运用多态可以使程序更加简洁、高效和易于理解。
三. 引用类型的转换 检查
在 Java 中，当涉及多态和引用类型的转换时，需要特别注意类型的兼容性和转换的安全性。
向上转型（Upcasting）
将子类对象的引用赋值给父类类型的变量，这是自动进行的，因为子类对象总是可以被当作父类对象来处理。
例如：
class Animal {
public void eat() {
System.out.println("Animal is eating");
}
}
class Dog extends Animal {
@Override
public void eat() {
System.out.println("Dog is eating");
}
public void bark() {
System.out.println("Dog is barking");
}
}
public class PolymorphismExample {
public static void main(String[] args) {
Animal animal = new Dog(); // 向上转型，自动完成
animal.eat(); // 调用的是 Dog 类重写的 eat 方法
}
}
向下转型（Downcasting）
将父类对象的引用转换为子类类型的变量。这是不安全的，除非确定引用实际指向的是子类对象，否则可能会导致运行时错误 ClassCastException 。
在进行向下转型之前，需要使用 instanceof 运算符进行类型检查，以确保转换的安全性。
例如：
public class PolymorphismExample {
public static void main(String[] args) {
Animal animal = new Dog(); // 向上转型
if (animal instanceof Dog) { // 类型检查
Dog dog = (Dog) animal; // 向下转型
dog.bark();
}
}
}
instanceof 运算符用于判断一个对象是否是某个类或其子类的实例，如果是则返回 true ，否则返回 false 。
总之，在处理多态中的引用类型转换时，要谨慎进行，充分利用 instanceof 进行类型检查，以避免运行时错误。
四. final关键字
在 Java 中，final 关键字有多种用途：
-
修饰变量：
- 当
final修饰基本数据类型的变量时，该变量的值一旦被初始化就不能再被修改。 - 当
final修饰引用数据类型的变量时，该变量所引用的对象不能再被重新赋值，但对象的属性值可以修改。
例如：
- 当
final int num = 10; // 不能再修改 num 的值
final String str = "Hello"; // 不能再修改 str 的值
final List<String> list = new ArrayList<>(); // 不能将 list 重新指向其他对象，但可以修改 list 中的元素
-
修饰方法：被
final修饰的方法不能被子类重写。例如：
class Parent {
final void finalMethod() {
// 方法实现
}
}
class Child extends Parent {
// 不能重写 finalMethod 方法
}
-
修饰类：被
final修饰的类不能被继承。例如：
final class FinalClass {
// 类的实现
}
// 以下代码会报错，因为不能继承 final 类
// class SubClass extends FinalClass {}
使用 final 关键字可以提高代码的安全性和可读性，防止意外的修改和不必要的继承重写。
