Java核心技术【十四】深入讲解Java的三大特性：封装、继承与多态

原创已于 2024-07-02 18:02:41 修改 · 810 阅读

25 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言 #封装 #继承 #多态 #java三大特性 #可扩展性

于 2024-06-25 12:28:28 首次发布

JAVA-核心技术专栏收录该内容

27 篇文章

订阅专栏

引言

所有文章均为原创验证，您随手的关注、点赞、收藏是我创作最大的动力。
示例代码地址：https://gitee.com/code-in-java/csdn-blog.git

在面向对象编程（OOP）中，封装、继承和多态是三大核心概念。这些概念在Java编程语言中得到了充分的体现和应用。本文将通过理论结合示例代码的方式，深入讲解这三个概念在Java中的实现和应用。

一、封装（Encapsulation）

封装是面向对象编程的基础，它隐藏对象的属性和实现细节，仅对外提供公共的访问方式。在Java中，封装性是通过访问修饰符来实现的，如 private、protected 和 public 等。

1. 封装的作用

数据隐藏：用户只需要知道对象提供哪些方法，而不需要了解内部细节。
提高安全性：防止用户随意修改对象的内部状态，只能通过对象提供的方法来操作。
提高复用性：封装好的类可以在多个地方重复使用，提高代码复用率。
便于修改和维护：由于内部实现被隐藏，因此可以在不改变接口的情况下修改内部实现。

2. 如何在Java中实现封装

1）私有属性：将类的属性设置为 private，这样它们就不能被类的外部直接访问。


public class Person {  
    private String name; // 私有属性  
    private int age; // 私有属性  
}

2）提供公共方法：为了访问和修改私有属性，需要提供公共的 getter 和 setter 方法。


public class Person {  
    private String name;  
    private int age;  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public int getAge() {  
        return age;  
    }  
  
    public void setAge(int age) {  
        this.age = age;  
    }  
}

3）数据验证：在 setter 方法中加入验证逻辑，确保数据的有效性和一致性。


public void setAge(int age) {  
    if (age < 0 || age > 100) {  
        throw new IllegalArgumentException("Invalid age!");  
    }  
    this.age = age;  
}

在上述示例中，name 和 age 属性被声明为私有（private），这意味着它们不能在类的外部直接访问。相反，我们提供了公共的 getter 和 setter 方法来获取和设置这些属性的值。这样做的好处是可以对数据进行校验和格式化，确保数据的完整性和安全性。

二、继承（Inheritance）

Java的继承是面向对象编程中的一个核心概念，它允许我们创建一个分等级层次的类结构。通过继承，我们可以定义一个通用的类（父类或基类），然后创建更具体的类（子类或派生类）来继承父类的属性和方法。下面是对Java继承的详细解释：

1. 继承的概念

定义：继承是从已有的类（父类）派生出新的类（子类）的过程。
目的：实现代码复用和扩展。

2. 继承的特点

子类拥有父类的属性和方法：子类会继承父类的所有 public 和 protected 成员。
子类可以添加新的属性和方法：以扩展其功能。
子类可以重写父类的方法：以实现不同的行为。

3. Java如何实现继承

使用 extends 关键字：在 Java 中，通过 extends 关键字来声明一个类是从另一个类继承的。


public class SubClass extends SuperClass {  
    // 子类的内容  
}

4. 继承中的关键概念和特性

单继承：Java只支持单继承，即一个类只能直接继承自一个父类。
方法重写（Override）：子类可以提供与父类相同方法签名的方法来重写父类的方法。
super关键字：子类可以使用 super 关键字来引用父类的成员或调用父类的方法。
访问权限：子类可以访问父类的 public 和 protected 成员，但不能直接访问 private 成员。

5. 继承的层次结构

继承可以形成层次结构，子类可以成为另一个类的父类，形成类之间的层次关系。

6. 抽象类和接口在继承中的角色

抽象类：包含抽象方法和非抽象方法的类，不能直接实例化，只能被继承。
接口：只包含抽象方法的纯抽象类型，用于定义行为的规范，一个类可以实现多个接口（从而实现多继承的效果）。

7. 继承的应用场景

当多个类共享相同的属性和行为时，可以使用继承来减少代码冗余。
通过继承和多态性，可以实现更加灵活和可扩展的程序设计。

8. 注意事项

过度使用继承可能导致代码的复杂性增加，应谨慎使用。
在设计类结构时，应考虑到类的职责和单一职责原则。

总的来说，Java的继承是一种强大的代码复用和组织机制，它允许我们创建分层次的类结构，促进代码的重用和扩展。通过合理使用继承，我们可以构建出更加灵活、可维护和可扩展的软件系统。

三、多态（Polymorphism）

Java中的多态性是面向对象编程的三大特性之一，其他两个是封装和继承。多态性允许我们使用父类类型的变量来引用子类对象，并能够在运行时确定实际调用哪个子类的方法。这种特性使得我们的代码更加灵活和可扩展。

1. 多态性的定义

多态性（Polymorphism）是指允许一个接口（引用变量）被多种实际类型所实现，或者说一个接口可以有多种不同的实现方式。

2. 多态性的实现方式

Java中的多态性主要通过以下两种方式实现：

方法重载（Overloading）：在同一类中，方法名相同但参数列表不同（参数类型、数量、顺序），这称为方法的重载。重载的方法在编译时就能确定调用哪个方法，因此也称为 编译时多态。
方法重写（Overriding）与对象上转型：子类继承父类并重写父类中的方法，然后通过父类引用指向子类对象来调用被重写的方法。这种多态性在运行时才能确定调用哪个子类的方法，因此也称为 运行时多态。

3. 多态性的应用

多态性在Java编程中有着广泛的应用，主要体现在以下几个方面：

提高代码的可扩展性：通过多态性，我们可以编写与特定类无关的代码，使得代码更加通用和灵活。当需要添加新的子类时，无需修改原有的代码。
简化代码结构：使用多态性可以减少大量的条件判断语句，使代码更加简洁明了。
增强代码的可读性和可维护性：多态性使得代码更加模块化，提高了代码的可读性和可维护性。

4. 示例

下面是一个简单的Java多态性示例：


class Animal {  
    void eat() {  
        System.out.println("Animal is eating.");  
    }  
}  
  
class Dog extends Animal {  
    @Override  
    void eat() {  
        System.out.println("Dog is eating.");  
    }  
}  
  
class Cat extends Animal {  
    @Override  
    void eat() {  
        System.out.println("Cat is eating.");  
    }  
}  
  
public class PolymorphismDemo {  
    public static void main(String[] args) {  
        Animal animal1 = new Dog(); // 上转型对象  
        Animal animal2 = new Cat(); // 上转型对象  
          
        animal1.eat(); // 输出 "Dog is eating."  
        animal2.eat(); // 输出 "Cat is eating."  
    }  
}

在这个示例中，我们定义了一个 Animal 类和两个继承自 Animal 的子类 Dog 和 Cat。在 main 方法中，我们通过父类 Animal 的引用来引用 Dog 和 Cat 的对象，并调用它们的 eat 方法。由于多态性，程序会在运行时确定实际调用哪个子类的 eat 方法。