# Java OOP 概念 – 面向对象的原则

> 原文： [https://howtodoinjava.com/oops/object-oriented-principles/](https://howtodoinjava.com/oops/object-oriented-principles/)

在本 **Java OOP 概念**教程中，我们将学习四个主要的**面向对象原理** – **抽象**，**封装**，**继承**和**多态**。 它们也被称为**面向对象编程范式**的四个支柱。

> 1.  ***抽象***是公开实体基本细节的过程，同时忽略了无关紧要的细节，从而为用户降低了复杂性。
> 2.  ***封装***是将数据和对数据的操作捆绑在一起的过程。
> 3.  ***继承***用于从现有类型派生新类型，从而建立父子关系。
> 4.  ***多态***使实体在不同的上下文中具有不同的含义。

```java
Table of Contents

1\. Abstraction
2\. Encapsulation
3\. Inheritance
4\. Polymorphism
```

## 1\. 抽象

将 OOP 中的与实时示例相关联时，很容易理解。例如，当您开车时，您不必担心汽车的内部运行情况。 您所关心的是通过方向盘，制动踏板，油门踏板等接口与汽车交互。在这里，您对汽车的了解是[抽象](https://howtodoinjava.com/oops/understanding-abstraction-in-java/)的。

在计算机科学中，抽象是这样的过程，在该过程中，数据和程序以其形式（*语义*）的形式类似于其含义的形式定义，同时隐藏了实现细节。

用更简单的术语来说，抽象是**隐藏与上下文**不相关的信息，或者仅显示相关信息，并通过将其与现实世界中的相似内容进行比较来简化该信息。

抽象仅捕获与当前视角相关的对象的那些细节。

通常，可以通过两种方式查看抽象：

1.  #### 数据抽象

    数据抽象是从多个较小的数据类型中创建复杂的数据类型的方法，该类型更接近于现实生活中的实体。 例如 `Employee`类可能是具有各种小型关联的复杂对象。

    ```java
    public class Employee 
    {
        private Department department;
        private Address address;
        private Education education;
        //So on...
    }

    ```

    因此，如果您想获取某个员工的信息，则可以从`Employee`对象中询问该信息 – 就像您在现实生活中一样，请询问此人本身。

2.  #### 控制抽象

    通过将复杂任务的动作序列隐藏在一个简单的方法调用中，可以实现控制抽象，因此可以从客户端隐藏执行任务的逻辑，并且将来可以更改该逻辑而不会影响客户端代码。

    ```java
    public class EmployeeManager
    {
        public Address getPrefferedAddress(Employee e)
        {
            //Get all addresses from database 
            //Apply logic to determine which address is preferred
            //Return address
        }
    }

    ```

    在上面的示例中，明天如果您要更改逻辑，以使每次本地地址始终都是首选地址，则将更改`getPrefferedAddress()`方法内部的逻辑，并且客户端将不受影响。

> **阅读更多：[了解 Java 中的抽象](//howtodoinjava.com/object-oriented/understanding-abstraction-in-java/)**

## 2\. 封装

**将类**中的数据和方法与实现隐藏（通过访问控制）结合起来通常称为 OOP 中的[封装](https://howtodoinjava.com/oops/encapsulation-in-java-and-its-relation-with-abstraction/)。 结果是具有特征和行为的数据类型。 封装本质上既具有信息隐藏又具有实现隐藏。

> “ **不管有什么变化，都将其封装**” – 著名的设计原理

**信息隐藏**是通过使用[访问控制修饰符](https://howtodoinjava.com/oops/java-access-modifiers/)（公共，私有，受保护的）完成的，而实现隐藏是通过创建类的接口来实现的。

**实现隐藏**使设计人员可以自由修改对象如何履行职责。 这在设计（甚至需求）可能会发生变化的点上特别有价值。

让我们以一个例子来使它更清楚。

#### 2.1 信息隐藏

```java
class InformationHiding 
{
    //Restrict direct access to inward data
    private ArrayList items = new ArrayList();

    //Provide a way to access data - internal logic can safely be changed in future
    public ArrayList getItems(){
        return items;
    }
}

```

#### 2.2 实现隐藏

```java
interface ImplemenatationHiding {
    Integer sumAllItems(ArrayList items);
}
class InformationHiding implements ImplemenatationHiding
{
    //Restrict direct access to inward data
    private ArrayList items = new ArrayList();

    //Provide a way to access data - internal logic can safely be changed in future
    public ArrayList getItems(){
        return items;
    }

    public Integer sumAllItems(ArrayList items) {
        //Here you may do N number of things in any sequence
        //Which you do not want your clients to know
        //You can change the sequence or even whole logic
        //without affecting the client
    }
}

```

> 阅读更多：Java 中的[封装](//howtodoinjava.com/object-oriented/encapsulation-in-java-and-its-relation-with-abstraction/)

## 3\. 继承

[继承](https://howtodoinjava.com/oops/java-inheritance/)是面向对象编程中的另一个重要概念。 Java 中的**继承**是一种机制，通过该机制，一个对象可以获取父对象的属性和行为。 本质上是在类之间创建父子关系。 在 Java 中，主要将继承用于代码的可重用性和可维护性。

关键字`extends`用于**继承 Java** 中的类。 关键字`extends`表示您正在制作一个新类，该新类是从现有类中派生的。 在 Java 术语中，被继承的类称为**超类**。 新类称为**子类**。

子类从其超类继承所有非私有成员（字段，方法和嵌套类）。 构造器不是成员，因此它们不会被子类继承，但是可以从子类调用超类的[构造器](https://howtodoinjava.com/oops/java-constructors/)。

例如

```java
class Employee 
{
    private Department department;
    private Address address;
    private Education education;
    //So on...
}
class Manager extends Employee {
    private List<Employee> reportees;
}

```

在上面的示例中，`Manager`是`Employee`的专用版本，可重用`Employee`类别中的部门，地址和教育，并定义其自己的报告人列表。

## 4\. 多态

[**多态**](https://howtodoinjava.com/oops/what-is-polymorphism-in-java/)是一种能力，通过这种能力，我们可以创建在不同程序环境下表现不同的函数或参考变量。

在 Java 语言中，多态本质上被认为是两个版本：

*   编译时多态（静态绑定或**方法重载**）
*   运行时多态（动态绑定或**方法覆盖**）

> 阅读更多：Java 中的[**多态**](//howtodoinjava.com/object-oriented/what-is-polymorphism-in-java/)

上面是四个 Java OOP 概念，我建议您对每个概念都有一个很好的了解。

学习愉快！

参考文献：

[https://docs.oracle.com/javase/tutorial/java/concepts/](https://docs.oracle.com/javase/tutorial/java/concepts/)

[http://c2.com/cgi/wiki?InformationHiding](http://c2.com/cgi/wiki?InformationHiding)