Java面向对象三大特性详解：封装、继承、多态与接口

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

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

18 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

java 专栏收录该内容

13 篇文章

订阅专栏

引言

在Java编程世界中，面向对象编程（OOP）是其核心灵魂。今天我们将深入探讨Java面向对象的四大支柱：封装、继承、多态和接口，通过生动的代码示例和内存分析，带你彻底理解这些核心概念。

一、封装（Encapsulation）

1.1 封装的基本概念

封装是面向对象编程的基础，它将数据和行为包装在一个类中，并控制对数据的访问权限。

public class Animal {
    // 使用public修饰符，暂时放宽封装限制
    public String name;
    public String color;
    public int age;
    public String sex;
    
    // 封装的行为方法
    public void run() {
        System.out.println("所有动物都会跑");
    }
    
    public void eat() {
        System.out.println("所有动物都会吃");
    }
}

1.2 封装的实际意义

数据保护：防止外部代码直接访问内部数据
接口统一：提供统一的访问方法
维护性：内部实现修改不影响外部调用

二、继承（Inheritance）

2.1 继承的本质

package com.gcby.hhh;

public class Cat extends Animal {
    // 子类可以添加特有方法
    public void fly() {
        System.out.println("猫不会飞，但这是子类特有方法");
    }
}

继承的本质：代码的复用，子类对象可以使用父类的方法和变量（public修饰的）

2.2 继承的优势

代码复用：避免重复编写相同代码
层次结构：建立清晰的类层次关系
扩展性：易于扩展和维护

三、多态（Polymorphism）

3.1 多态的核心概念

多态的前提：一定要有继承关系，通常子类会重写父类的方法。

public class Test {
    public static void main(String[] args) {
        // 普通对象创建
        Cat cat = new Cat();
        cat.run();  // 调用子类重写后的方法
        cat.name = "小猫";
        cat.eat();
        cat.fly();
        
        // 多态的体现：父类的引用指向子类对象
        Animal animalCat = new Cat(); // 多态
        animalCat.run();  // 实际调用子类重写的方法
        animalCat.eat();  // 实际调用子类重写的方法
        // animalCat.fly(); // 编译错误：父类引用不能调用子类特有方法
    }
}

3.2 方法重写（Override）

public class Cat extends Animal {
    // 方法重写：子类与父类方法名相同，参数相同，返回值相同
    @Override
    public void run() {
        System.out.println("猫会轻盈地跑");
    }
    
    // 子类特有方法
    public void fly() {
        System.out.println("猫不会飞，但这是子类特有方法");
    }
}

重写规则：

方法名、参数列表、返回值类型必须相同
访问权限不能比父类更严格
当子类对象调用方法时，默认调用重写后的方法

四、深入多态：方法调用的奥秘

4.1 复杂多态场景分析

package com.gcby.hhh;

public class A {
    public String show(B obj) {
        return "A and B";
    }
    
    public String show(A obj) {
        return "A and A";
    }
}

public class B extends A {
    public String show(Object obj) {
        return "B and B";
    }
    
    @Override
    public String show(A obj) {
        return "B and A";
    }
}

public class C extends B {}
public class D extends B {}

4.2 多态方法调用测试

public class Test {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B(); // 多态：父类引用指向子类对象
        B b = new B();
        C c = new C();
        D d = new D();
        
        // 测试用例分析
        System.out.println("1---" + a1.show(b)); // A and B
        System.out.println("2---" + a1.show(c)); // A and B  
        System.out.println("3---" + a1.show(d)); // A and B
        
        System.out.println("4---" + a2.show(b)); // B and A
        System.out.println("5---" + a2.show(c)); // B and A
        System.out.println("6---" + a2.show(d)); // A and B
        
        System.out.println("7---" + b.show(b));  // B and A
        System.out.println("8---" + b.show(c));  // B and A
        System.out.println("9---" + b.show(d));  // B and B
    }
}

4.3 多态方法调用解析

调用规则总结：

创建对象看前面：决定可用方法范围
方法匹配看参数：寻找最匹配的方法签名
向上转型机制：当找不到完全匹配时，向父类转型寻找

详细解析：

第7行 b.show(b)：
- 入参类型为B，当前对象b（类型为B）的可用方法：show(Object)、show(A)、show(B)
- 没有完全匹配的show(B)，考虑向上转型：B的父类是A
- 匹配到show(A obj)，输出"B and A"
第8行 b.show(c)：
- 入参类型为C，可用方法中没有show(C)
- 向上转型：C→B→A，匹配到show(A obj)，输出"B and A"
第9行 b.show(d)：
- 入参类型为D，可用方法中有show(Object obj)（因为D继承自B，而B继承自A，最终继承Object）
- 直接匹配show(Object obj)，输出"B and B"

五、内存模型深度解析

5.1 对象内存布局

Animal对象内存布局：

name color age sex

0x2 0x3 0x4 0x5

Cat对象内存布局（继承Animal）：

name color age sex [特有字段]

0x2 0x3 0x4 0x5

方法表：

Animal: run0() eat0()

Cat: run0() eat0() fly0()