Java 核心知识点整理：final、static、多态

原创已于 2025-11-24 20:57:35 修改 · 910 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#java #算法 #学习 #笔记

于 2025-11-21 13:51:54 首次发布

一、final 关键字

1. 核心作用

final 译为 "最终的"，用于修饰类、属性、方法，限制其可变性。

2. 详细说明

修饰对象	核心特点	简洁示例代码
类	不能被继承，自身功能不受影响	`java final class FinalClass {} // 正确 // class Sub extends FinalClass {} // 错误：无法继承`
属性 / 成员变量	必须初始化，赋值后不可修改（常量）	`java class Demo { final int MAX = 100; // 声明时初始化 // MAX = 200; // 错误：不可修改 }`
局部变量	可延迟初始化，赋值后不可修改	`java void test() { final int num; num = 5; // 正确 // num = 6; // 错误：不可修改 }`
方法	子类不能重写该方法	`java class Parent { final void print() {} } class Child extends Parent { // void print() {} // 错误：无法重写 }`
对象引用	引用地址固定，对象内部数据可修改	`java final List<String> list = new ArrayList<>(); list.add("a"); // 正确 // list = new ArrayList<>(); // 错误：地址不可变`

说明：

常量命名规范：被 final 修饰的常量通常用全大写字母，如 MAX_VALUE
对象引用特性：final 修饰的是 "引用" 而非对象本身，因此对象的属性和内容可以正常修改
初始化要求：成员变量必须在声明时或构造方法中初始化；局部变量需在使用前完成初始化

二、static 关键字

1. 核心作用

static 译为 "静态的"，用于修饰属性和方法，实现数据共享和方便调用。

2. 内存特性

加载时机：随类加载而加载（早于对象创建）
存储位置：方法区（非堆内存）
共享性：被该类所有对象共享，只有一份拷贝

3. 使用场景

（1）共享数据

class TicketWindow {
    static int tickets = 100; // 所有窗口共享票数
    
    void sell() {
        if (tickets > 0) {
            System.out.println("卖出1张，剩余：" + --tickets);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        TicketWindow w1 = new TicketWindow();
        TicketWindow w2 = new TicketWindow();
        w1.sell(); // 剩余99
        w2.sell(); // 剩余98
    }
}

（2）静态常量（static + final）

class Constants {
    // 常量命名规范：全大写，下划线分隔
    public static final double PI = 3.1415926;
    public static final int MAX_SIZE = 100;
}

// 调用：直接通过类名访问，无需创建对象
System.out.println(Constants.PI);

（3）工具方法

class ArrayUtil {
    // 静态工具方法，方便调用
    public static void printArray(int[] arr) {
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

// 调用示例
int[] nums = {1,2,3};
ArrayUtil.printArray(nums); // 无需创建ArrayUtil对象

4. 注意事项

静态成员只能直接访问静态成员（静态方法不能用 this）
非静态成员可以访问静态和非静态成员
静态方法不能被重写（即使子类有同名静态方法，也不是重写）

三、多态

1. 核心概念

多态指同一方法表现出不同状态，即 "一个接口，多种实现"。

2. 实现条件

继承关系（或实现接口）
子类重写父类方法
父类引用指向子类对象（向上转型）

3. 代码示例

// 1. 父类
class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}

// 2. 子类重写
class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    
    // 子类特有方法
    public void watchHouse() {
        System.out.println("狗看家");
    }
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

// 3. 多态实现
public class Test {
    public static void main(String[] args) {
        // 父类引用指向子类对象（向上转型）
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
        
        animal1.eat(); // 输出"狗吃骨头"（运行看子类）
        animal2.eat(); // 输出"猫吃鱼"（运行看子类）
        
        // 注意：父类引用不能直接调用子类特有方法
        // animal1.watchHouse(); // 编译报错
    }
}

4. 多态的好处

降低耦合度：例如统一的喂养方法可以接收任何动物

class Person {
    // 一个方法适配所有动物，无需为每个动物写单独方法
    public void feed(Animal animal) {
        animal.eat();
    }
}

// 使用
Person person = new Person();
person.feed(new Dog()); // 喂狗
person.feed(new Cat()); // 喂猫

四、类型转换（向上 / 向下转型）

1. 向上转型（自动转换）

语法：父类类型变量名 = new 子类类型();
特点：小类型转大类型，自动完成
限制：只能调用父类中定义的方法

2. 向下转型（强制转换）

语法：子类类型变量名 = (子类类型) 父类引用;
前提：必须先完成向上转型（父类引用实际指向子类对象）
作用：调用子类特有方法

public class Test {
    public static void main(String[] args) {
        // 1. 先向上转型
        Animal animal = new Dog();
        
        // 2. 再向下转型（安全转换）
        Dog dog = (Dog) animal;
        dog.watchHouse(); // 调用子类特有方法
        
        // 错误示例：转型为非实际类型
        // Cat cat = (Cat) animal; // 运行时抛出ClassCastException
    }
}

3. instanceof 关键字

用于判断对象实际类型，避免转型错误：

public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
        
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            // ...
        }
    }
}

五、多态应用场景

方法参数多态：方法参数定义为父类类型，实际传入子类对象
方法返回值多态：返回值定义为父类类型，实际返回子类对象

public Animal getAnimal(String type) {
    if ("dog".equals(type)) {
        return new Dog(); // 返回子类对象
    } else {
        return new Cat(); // 返回子类对象
    }
}

数组多态：数组定义为父类类型，存储子类对象

Animal[] zoo = new Animal[3];
zoo[0] = new Dog();
zoo[1] = new Cat();
zoo[2] = new Dog();

六、重点总结

final：修饰后不可变（类不可继承、方法不可重写、变量不可修改）
static：共享数据、类名直接访问、静态只能访问静态
多态三要素：继承、重写、向上转型
多态核心表现：编译看父类，运行看子类
转型原则：向上自动转，向下强制转（需用 instanceof 判断）

通过这些特性，可以写出更灵活、可扩展的代码，这也是面向对象编程的核心优势。