Java面向对象编程：类与对象、继承、多态及final关键字详解

最新推荐文章于 2025-11-23 13:27:25 发布

原创最新推荐文章于 2025-11-23 13:27:25 发布 · 731 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

java 专栏收录该内容

13 篇文章

订阅专栏

面向对象编程（OOP）是现代编程语言的核心范式之一，Java作为一门纯面向对象的语言，其类与对象、继承、多态等特性是每个Java开发者必须掌握的基础。本文将结合代码示例，系统讲解这些核心概念，并深入分析final关键字的作用。

一、类与对象：Java世界的基石

1.1 类与对象的关系

类是创建对象的模板，它定义了对象的属性和行为。对象是类的实例，是类的具体实现。简单来说，类中有什么，对象中就有什么。

1.2 类的定义与对象创建

package com.gcbv.hhh;

public class Animal {
    // 属性/字段
    public String name;
    public int age;
    public String sex;
    public String color;
    
    // 方法/行为
    public void run(){
        System.out.println("咿");
    }
    
    public void eat(){
        System.out.println("吃");
    }
}

创建Animal对象：

Animal animal = new Animal();
animal.eat();  // 输出：吃
animal.run();  // 输出：咿

1.3 链表实现：类与对象的实际应用

在数据结构中，链表是类与对象关系的完美体现。每个节点都是一个对象，通过引用连接形成链式结构。

Node节点类：

package com.qcby.hhh;

public class Node {
    public int data;        // 节点数据
    public Node next;       // 指向下一个节点的引用
    
    // 构造方法
    public Node(int data){
        this.data = data;
        this.next = null;   // 默认指向null
    }
}

链表创建与使用：

package com.qcby.hhh;

public class Test {
    public static void main(String[] args) {
        // 创建节点对象
        Node node1 = new Node(1);  // 正确写法，无需参数名前缀
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        
        // 构建链表关系
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        // node4.next 默认为 null，表示链表结束
    }
}

1.4 内存模型解析

Java内存分为栈内存、堆内存和方法区：

栈内存：存储局部变量和对象引用
堆内存：存储对象实例
方法区：存储类信息、常量、静态变量

链表内存示意图：

栈内存(引用) 堆内存(对象)

node1 0x100 → data=1, next=0x200

node2 0x200 → data=2, next=0x300

node3 0x300 → data=3, next=0x400

node4 0x400 → data=4, next=null

二、继承：代码复用的艺术

2.1 继承的基本概念

继承是面向对象的重要特性，允许子类获得父类的属性和方法，实现代码复用。

继承的本质：子类对象可以调用父类中的属性和方法。

2.2 继承的实现

// 父类 Animal
public class Animal {
    public void run() { 
        System.out.println("动物奔跑"); 
    }
    
    public void eat() { 
        System.out.println("动物进食"); 
    }
}

// 子类 Cat 继承 Animal
public class Cat extends Animal {
    // 子类构造方法
    Cat(){
        System.out.println("子类无参构造方法");
    }
    
    // 重写父类方法
    @Override
    public void run(){
        System.out.println("子类重写父类方法 - 猫在跑");
    }
}

2.3 对象创建顺序

创建子类对象时，Java按照以下顺序执行：

父类静态代码块和静态变量初始化
子类静态代码块和静态变量初始化
父类实例变量初始化和构造代码块
父类构造方法
子类实例变量初始化和构造代码块
子类构造方法

三、多态：灵活性的源泉

3.1 多态的概念

多态是指父类引用指向子类对象，同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。

public class Test {
    public static void main(String[] args) {
        // 普通对象创建
        Animal animal = new Animal();
        Cat cat = new Cat();
        cat.run();  // 输出：子类重写父类方法 - 猫在跑
        
        // 多态：父类的引用指向子类的对象
        Animal animalCat = new Cat();
        animalCat.run();  // 输出：子类重写父类方法 - 猫在跑
    }
}

3.2 多态的实现条件

继承关系：存在父子类关系
方法重写：子类重写父类的方法
向上转型：父类引用指向子类对象

3.3 多态的优势

提高代码扩展性：新增子类不影响现有代码
增强代码灵活性：同一接口不同实现
简化代码逻辑：统一处理不同类型的对象

四、final关键字：不可变的保证

4.1 final修饰变量

final修饰的变量称为常量，一旦赋值就不能修改。

public class FinalExample {
    // final修饰的常量
    private final String CONSTANT_VALUE = "初始值";
    private final String nullValue = null;        // 允许赋值为null
    // private final String uninitialized;        // 错误：必须初始化
    
    public void testFinal() {
        // CONSTANT_VALUE = "新值";  // 错误：不能修改final变量
    }
}

重要理解：final固定的是引用地址，而不是对象内容。对于引用类型，final保证引用不变，但对象内部状态可能改变。

4.2 final修饰方法

final修饰的方法不能被子类重写。

public class Parent {
    // final方法，子类不能重写
    public final void cannotOverride() {
        System.out.println("这是最终方法");
    }
}

public class Child extends Parent {
    // 以下代码会编译错误
    // @Override
    // public void cannotOverride() { 
    //     System.out.println("尝试重写");
    // }
}

4.3 final修饰类

final修饰的类不能被继承。

// final类，不能被继承
public final class FinalClass {
    public void show() {
        System.out.println("这是最终类");
    }
}

// 以下代码会编译错误
// public class ExtendedClass extends FinalClass { }

实际应用：Java中的String类就是用final修饰的，保证了字符串的不可变性和安全性。

五、综合应用与实践建议

5.1 设计原则

优先使用组合而非继承：降低耦合度
合理使用final：确保关键组件的不变性
善用多态：提高代码的灵活性和可扩展性

5.2 最佳实践

// 良好的面向对象设计示例
public abstract class Animal {
    protected final String species;  // final确保物种不变
    
    public Animal(String species) {
        this.species = species;
    }
    
    // 抽象方法，强制子类实现
    public abstract void makeSound();
    
    // final方法，所有动物共同的不可变行为
    public final void breathe() {
        System.out.println("呼吸中...");
    }
}

public class Cat extends Animal {
    public Cat() {
        super("猫科");
    }
    
    @Override
    public void makeSound() {
        System.out.println("喵喵喵");
    }
}