JAVA继承、封装和多态性

最新推荐文章于 2025-05-14 17:38:00 发布

程序员爱学习

最新推荐文章于 2025-05-14 17:38:00 发布

阅读量815

点赞数 6

CC 4.0 BY-SA版权

分类专栏： Java基础知识体系文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/guanglihuan/article/details/136949406

Java基础知识体系专栏收录该内容

40 篇文章

订阅专栏

本文详细介绍了Java中继承、封装和多态的概念，展示了如何通过这些机制实现代码重用、类结构组织和运行时灵活性。通过实例说明了继承、封装的实现以及多态性在方法重载和重写中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在Java中，继承、封装和多态是面向对象编程(OOP)的三个核心概念。以下是每个概念的详细介绍和示例：

继承（Inheritance）

继承是一种使得一个类能够获得另一个类的属性和方法的机制。在Java中，继承通过使用extends关键字实现。

为什么使用继承？

代码重用：允许重用现有类的字段和方法，而不需要重新编写代码。
创建类的层次结构：通过创建类的层次化模型，你可以组织和标准化结构化的代码。

示例

// 父类
class Animal {
    void eat() {
        System.out.println("Eating...");
    }
}

// 子类
class Dog extends Animal {
    void bark() {
        System.out.println("Barking...");
    }
}

public class TestInheritance {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.bark();
        d.eat(); // Dog 类继承了 Animal 类的方法
    }
}

在这个例子中，Dog类继承了Animal类，因此Dog的对象可以使用eat()方法。

封装（Encapsulation）

封装是将数据(字段)和代码(方法)捆绑在一起并对数据的直接访问进行限制的过程。在Java中，通常通过将字段声明为私有private并提供公共public的getter和setter方法来实现封装。

为什么使用封装？

控制数据的访问：通过提供方法（getter和setter），可以控制外部代码对字段的访问和更新，并可以添加检查逻辑。
增加代码的维护性：将实现细节隐藏起来，使得可以在不影响外部代码的情况下修改代码。

示例

public class EncapsulatedDog {
    private String name; // 私有字段

    // 公共 getter 方法
    public String getName() {
        return name;
    }

    // 公共 setter 方法
    public void setName(String name) {
        this.name = name;
    }
}

public class TestEncapsulation {
    public static void main(String[] args) {
        EncapsulatedDog d = new EncapsulatedDog();
        d.setName("Buddy");
        System.out.println(d.getName());
    }
}

在这个例子中，EncapsulatedDog类通过private关键字封装了name字段，并提供了public的getter和setter方法。

多态性（Polymorphism）

多态性是指同一个行为具有多个不同表现形式或能够以多种形式发生作用的能力。在Java中，多态性主要有两种形式：编译时多态性（通过方法重载实现），和运行时多态性（通过方法重写实现）。

为什么使用多态性？

接口的统一：允许程序使用通用的接口来引用具有多种实现的对象。
可替代性和易扩展性：可以很容易地用新的实现替换或扩展现有的代码，而不需要修改使用它的代码。

示例

class A {
    void show() {
        System.out.println("Show from A");
    }
}

class B extends A {
    @Override
    void show() {
        System.out.println("Show from B");
    }
}

public class TestPolymorphism {
    public static void main(String[] args) {
        A a = new A(); // A类对象
        a.show();
        
        A b = new B(); // A的引用但是B的对象
        b.show(); // 运行时多态性
    }
}

在这个例子中，B类重写了A类的show()方法。尽管b的静态类型是A，但是它的运行时类型是B，所以调用b.show()时，执行的是B类中的show()方法，这就是运行时多态性的一个示例。

方法重载（Method Overloading）与方法重写（Method Overriding）

为了深入理解多态性，我们需要区分方法重载和方法重写。

方法重载（Method Overloading）

方法重载发生在同一个类中，当有多个方法共享同一名称但具有不同的参数列表（类型或数量）时。它是编译时多态性的一种形式，因为编译器知道要调用哪个方法。

class DisplayOverloading {
    void display() {
        System.out.println("无参数方法");
    }
    
    void display(String data) {
        System.out.println("带有一个字符串参数的方法: " + data);
    }

    void display(int data) {
        System.out.println("带有一个整型参数的方法: " + data);
    }
}

public class TestOverloading {
    public static void main(String[] args) {
        DisplayOverloading obj = new DisplayOverloading();
        obj.display();
        obj.display("重载");
        obj.display(10);
    }
}

在这个例子中，display方法被重载三次，分别接受不同的参数。

方法重写（Method Overriding）

方法重写发生在父类和子类之间，当子类有一个与父类签名完全相同（名称、参数列表）的方法时。它是运行时多态性的一种形式，因为具体调用哪个方法（父类的还是子类的）取决于对象的运行时类型。

class Parent {
    void show() {
        System.out.println("父类的show方法");
    }
}

class Child extends Parent {
    @Override
    void show() {
        System.out.println("子类重写父类的show方法");
    }
}

public class TestOverriding {
    public static void main(String[] args) {
        Parent p = new Parent();
        p.show(); // 调用Parent类的show方法
        
        Parent cp = new Child();
        cp.show(); // 调用Child类重写的show方法
    }
}