【Java笔记】第8章：面向对象的三大特性（封装、继承、多态）

#include<GUIQU.h>
int main {
上期回顾:【Java笔记】第7章：面向对象
个人主页：C_GUIQU
归属专栏：【Java学习】
return 一键三连;
}

前言

各位小伙伴大家好！上期小编给大家讲解了Java中的面向对象，接下来讲讲Java中面向对象的三大特性！

1. 三大特性概述

Java中面向对象的三大特性是封装（Encapsulation）、继承（Inheritance）和多态（Polymorphism）。这些特性是Java编程语言中实现面向对象编程（OOP）的核心概念。

1. 封装（Encapsulation）：
   • 封装是指将数据（属性）和操作数据的方法（行为）封装在一起，形成一个不可分割的整体。
   • 在Java中，封装通过访问修饰符（如public、private、protected和default）来实现，用于控制类成员（属性和方法）的访问级别。
   • 封装的目的是保护对象的内部状态不被外部直接访问，只能通过公共接口（方法）来访问和修改。
2. 继承（Inheritance）：
   • 继承是指一个类（子类）可以继承另一个类（父类）的属性和方法。
   • 在Java中，继承通过extends关键字来实现，子类可以扩展父类的功能，也可以覆盖父类的方法以提供新的实现。
   • 继承的目的是代码复用和扩展，子类可以重用父类的代码，同时添加新的属性和方法。
3. 多态（Polymorphism）：
   • 多态是指允许不同类的对象对同一消息做出响应，即同一操作作用于不同的对象时可以有不同的解释和行为。
   • 在Java中，多态通常通过接口（interface）和继承来实现。
   • 多态的目的是提高代码的灵活性和可扩展性，允许程序在不修改现有代码的情况下，添加新的功能和行为。
     这三大特性使得Java成为了一个强大的面向对象编程语言，它们允许开发者以更接近现实世界的方式思考和解决问题。通过封装，我们可以隐藏对象的内部实现细节，只暴露必要的接口；通过继承，我们可以重用和扩展已有的代码；通过多态，我们可以编写更灵活、可扩展的代码。

2. 封装

封装是面向对象编程中的一个核心概念，它将数据（属性）和操作数据的方法（行为）组合在一起，形成一个不可分割的整体。封装的目的是保护对象的内部状态不被外部直接访问，只能通过公共接口（方法）来访问和修改。在Java中，封装通过访问修饰符（如public、private、protected和default）来实现。

【访问修饰符】
在Java中，有四种访问修饰符：

1. public：公共的，可以被任何类访问。
2. private：私有的，只能被同一个类的其他方法访问。
3. protected：受保护的，可以被同一个包中的类访问，或者被子类访问。
4. default（不写）：默认的，可以被同一个包中的类访问。

【封装的实现】
封装的实现主要通过以下几种方式：

1. 属性私有化：将类的属性设置为私有，只允许类内部的方法访问和修改。

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

2. 方法公开化：将类的属性的设置和获取方法设置为公开，以供外部使用。
3. 构造方法：在类中定义构造方法，用于在创建对象时初始化对象的属性。

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

【封装的好处】
封装有以下几个好处：

1. 保护对象的状态：通过将属性设置为私有，可以防止外部直接修改对象的内部状态，从而保护对象的一致性和完整性。
2. 提高代码的可读性和可维护性：通过公开的接口（方法）来访问和修改对象的属性，可以使代码更易于理解和维护。
3. 实现代码的复用：通过继承和多态，可以重用已有的代码，并在此基础上添加新的功能和行为。
4. 提高系统的灵活性和可扩展性：通过封装，可以更容易地添加新的功能和行为，而不需要修改现有的代码。
   封装是面向对象编程中非常重要的一个概念，它可以帮助开发者创建更可靠、可维护和可扩展的代码。

3. 继承

继承是面向对象编程中的一个核心概念，它允许一个类（子类）继承另一个类（父类）的属性和方法。继承的目的是代码复用和扩展，子类可以重用父类的代码，同时添加新的属性和方法。在Java中，继承通过extends关键字来实现。

【继承的实现】
在Java中，继承的实现主要通过以下几个步骤：

1. 声明继承关系：在子类中使用extends关键字来声明它继承自父类。

   public class Animal {
       void makeSound() {
           System.out.println("Animal makes a sound");
       }
   }
   public class Dog extends Animal {
       void makeSound() {
           System.out.println("Dog barks");
       }
   }
   

   在这个例子中，Dog 类继承了 Animal 类，并覆盖了 makeSound 方法以提供特定的实现。

2. 继承属性和方法：子类可以继承父类的属性和方法，包括私有属性和方法。

3. 重写父类方法：子类可以覆盖（override）父类的方法，以提供新的实现。覆盖的方法必须具有相同的名称、返回类型和参数列表。

   public class Animal {
       void makeSound() {
           System.out.println("Animal makes a sound");
       }
   }
   public class Dog extends Animal {
       @Override
       void makeSound() {
           System.out.println("Dog barks");
       }
   }
   

   在这个例子中，Dog 类覆盖了 Animal 类的 makeSound 方法。

4. 添加新属性和方法：子类可以添加新的属性和方法，以扩展父类的功能。

   public class Animal {
       void makeSound() {
           System.out.println("Animal makes a sound");
       }
   }
   public class Dog extends Animal {
       void bark() {
           System.out.println("Dog barks");
       }
   }
   

   在这个例子中，Dog 类添加了一个新的方法 bark。

【继承的好处】
继承有以下几个好处：

1. 代码复用：子类可以重用父类的代码，避免重复编写相同的代码。
2. 扩展功能：子类可以扩展父类的功能，添加新的属性和方法。
3. 提高可读性和可维护性：通过继承，可以创建一个层次化的类结构，使得代码更易于理解和维护。
4. 实现多态：继承是实现多态的基础，通过继承，可以创建具有相同接口的类，从而实现多态。继承是面向对象编程中非常重要的一个概念，它可以帮助开发者创建更可靠、可维护和可扩展的代码。

4. 多态

多态是面向对象编程中的一个核心概念，它允许不同类的对象对同一消息做出响应，即同一操作作用于不同的对象时可以有不同的解释和行为。在Java中，多态通常通过接口（interface）和继承来实现。多态的目的是提高代码的灵活性和可扩展性，允许程序在不修改现有代码的情况下，添加新的功能和行为。

【多态的实现】
多态的实现主要通过以下几种方式：

1. 接口（interface）：
   • 接口是一组抽象方法的集合，用于定义一组行为。
   • 类可以通过实现接口来继承接口的方法。
   • 接口中的方法都是抽象的，没有具体的实现。
   • 实现接口的类必须提供接口中所有方法的实现。

   public interface Flyable {
       void fly();
   }
   public class Bird implements Flyable {
       public void fly() {
           System.out.println("Bird flies");
       }
   }
   public class Plane implements Flyable {
       public void fly() {
           System.out.println("Plane flies");
       }
   }
   public class PolyTest {
       public static void main(String[] args) {
           Flyable flyer1 = new Bird();
           Flyable flyer2 = new Plane();
           flyer1.fly(); // 输出 "Bird flies"
           flyer2.fly(); // 输出 "Plane flies"
       }
   }
   

2. 继承（Inheritance）：
   • 子类可以覆盖（override）父类的方法，以提供新的实现。
   • 覆盖的方法必须具有相同的名称、返回类型和参数列表。
   • 子类对象可以作为父类类型的引用，从而实现多态。

   public class Animal {
       void makeSound() {
           System.out.println("Animal makes a sound");
       }
   }
   public class Dog extends Animal {
       @Override
       void makeSound() {
           System.out.println("Dog barks");
       }
   }
   public class PolyTest {
       public static void main(String[] args) {
           Animal animal = new Dog();
           animal.makeSound(); // 输出 "Dog barks"
       }
   }
   

【多态的实现】
多态有以下几个好处：

1. 提高代码的灵活性和可扩展性：通过多态，可以创建一个灵活的代码结构，使得程序在不修改现有代码的情况下，添加新的功能和行为。
2. 实现代码复用：通过继承和接口，可以重用已有的代码，并在此基础上添加新的功能和行为。
3. 提高代码的可读性和可维护性：通过多态，可以创建一个层次化的类结构，使得代码更易于理解和维护。

多态是面向对象编程中非常重要的一个概念，它可以帮助开发者创建更可靠、可维护和可扩展的代码。

结语

至此，Java面向对象的三大特性讲解完毕。
感谢您的观看！互三必回！持续更新中~！