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

前言
1. 三大特性概述
2. 封装
3. 继承
4. 多态
结语

在这里插入图片描述

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

前言

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

1. 三大特性概述

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

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

2. 封装

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

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

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

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

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

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;}
}

方法公开化：将类的属性的设置和获取方法设置为公开，以供外部使用。

构造方法：在类中定义构造方法，用于在创建对象时初始化对象的属性。

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;}
}

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

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

3. 继承

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

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

声明继承关系：在子类中使用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 方法以提供特定的实现。

继承属性和方法：子类可以继承父类的属性和方法，包括私有属性和方法。
重写父类方法：子类可以覆盖（override）父类的方法，以提供新的实现。覆盖的方法必须具有相同的名称、返回类型和参数列表。
```
public class Animal {void makeSound() {System.out.println("Animal makes a sound");}
}
public class Dog extends Animal {@Overridevoid makeSound() {System.out.println("Dog barks");}
}
```
在这个例子中，Dog 类覆盖了 Animal 类的 makeSound 方法。

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

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。

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

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

4. 多态

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

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

接口（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"}
}

继承（Inheritance）：

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

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