OOP概念梳理：Java中面向对象编程的核心特征

Java
196
0
0
2023-10-20
JVM 源码分析：深入理解 CAS
上一篇
MyBatis的SQL执行流程不清楚？看完这一篇就够了
下一篇

面向对象编程（ OOP -Object-oriented programming）是一种开发方法和组织模式，它力图将结构化编程的最佳特性与新概念相结合来消除传统编程方法中存在的某些缺陷。OOP涉及组织和开发程序的新方法，与使用某一特定语言无关，更多的是一种思想，或说其为解决问题的实现模式。支持 OOP 功能特性的语言包括 Smalltalk、 Objective C 、C++、Ada、 Pascal 和 java 等等。

本文主要目的是简要梳理下OOP核心概念，总体性构建一个面向对象编程的思想范式，并掌握其所支撑的关键概念要素。

OOP概念梳理：Java中面向对象编程的核心特征 OOP概念特性

1、Java中OOP定义

在Java中可将 OOP 编程定义为：

“面向对象的编程是一种通过为功能函数和相关数据创建一个分区的内存区域来模块化程序的方法，这些函数和数据可以用作模板来按需创建此类模块的副本。” 简单点说，就是Java程序最小的可运行构成模块是类，类中包括了方法（函数）和数据。这些类可以看做是模版，在需要的时候根据相应的模版来创建程序的可运行载体——对象，他们在内存中的生成、存放、销毁等管理则由 虚拟机 按统一按规则调度。

记住：Java中的面向对象编程的一切，最终都是立足于类上而实现的——所以Java编程时要有个“一切皆对象”(通过实例化类构建程序运行载体，即对象)的意识。

2、OOPS 范式

面向对象方法的主要目标是消除过程方法中存在的一些缺陷。 OOP 将数据视为程序中的一个元素，不允许它在系统中自由流动。它将数据与对其进行操作的函数紧密联系起来，并保护它免受其他现有函数的无意修改。 OOPS 允许将问题分解为多个称为对象的实体，然后从这些实体构建数据和函数。数据与方法的组合构成了一个对象。如下图所示：

OOP概念梳理：Java中面向对象编程的核心特征 O = M + D

对象=方法+数据 （Object = Method + Data ）

通常一个对象的数据由与该对象关联的方法访问。但是，一个对象的方法也可以访问其他对象的方法。

3、面向对象的特点

java面向对象编程的一些特点是：

  • l 数据重要性超过过程的重要性
  • l 程序被划分为很多对象；
  • l 数据结构旨在表征对象；
  • l 对对象数据进行操作的方法捆绑在数据结构中；
  • l 数据是隐藏的，外部函数/方法无法直接访问它；
  • l 对象通过方法相互通信；
  • l 必要时可以轻松添加新方法和数据；
  • l 在程序设计中遵循自下而上的方法。

注： 程序设计 中的 自下而上 的方法，与 自上而下 是相对的，或说完全相反。 在这种方法中，我们从解决问题的最基本层面开始，然后逐步扩展解决方案的多个部分，以实现所需的结果。 最基本的单元、模块和子模块是单独设计和解决的，然后将这些单元集成在一起，可以为解决问题提供更具体的基础。而 自上向下 方法的基本思想是将复杂的算法或问题分解为称为模块的较小段，此过程也称为模块化。 模块将进一步分解，直到没有剩余空间可以折断模块而又不影响其独创性。

4、Java中OOP认知

Java 中常规OOP 概念有：

1）对象和类（Object和Class）

对象是面向对象系统中的运行时实体。一个对象可以代表一个人、一个银行账户、一个地方、一张数据表。它还可以表示用户定义的数据类型，如列表和向量。任何编程问题都基于对象以及它们之间如何通信进行分析和实现。当程序执行时，对象通过相互发送消息来相互交互。例如，“customer”（客户）和“account”（账户）是两个对象，客户可以向账户对象发送消息获知余额。每个对象都包含用于操作数据的代码和数据。对象甚至可以在不知道彼此的代码或数据的详细信息的情况下进行交互。

使用类的概念可以使对象的整个代码和数据集成为用户定义的数据类型。某个类就是“数据类型”，而对象是该类型的“变量”。创建一个类后，通常可以创建任意数量的对象（单例除外）。

概括而言，对相似类型的对象集合的抽象称为类。例如，apple、orange 和 mango 是 Fruit 类的对象。类-class（的行为）类似于 编程语言 的内置数据类型（如int、float等），但自己创建的类类型则属于用户定义的数据类型。例如下面自定义类型Person类，其表示如下图所示：

Person类的一个实例对象，就是由此类按照“模版”化的数据和方法来生成构造的。

2）数据抽象和封装

将数据和方法包装到单个单元中称为封装。数据只能被封装在类中的那些方法访问，而不能被外部世界访问。这种将数据与程序的直接访问隔离开来的过程称为数据隐藏。对象的封装使得对象可以被视为执行特定任务的“黑匣子”，而无需考虑内部实现。如下图示：

抽象是通过表示基本特征而不包括背景解释或细节而来降低编程复杂性的行为。类是抽象的概念，可被定义为类抽象属性的如：size、weight、cost以及对这些属性进行操作的方法等。类通常包装或封装了要创建的对象的所有基本属性。

（1）抽象类和抽象方法：

  • l 抽象类 是带有 abstract 关键字的类。
  • l 抽象方法是在没有方法体的情况下声明的方法。
  • l 抽象类可能不是所有的方法都是抽象方法。即有些方法可以是具体的。
  • l 定义为抽象方法必须在派生类中实现它，从而强制覆盖此方法。
  • l 包含抽象方法的类必须用 abstract 关键字声明。
  • l 抽象类的对象不能用 new 运算符实例化。
  • l 抽象类可以有参数化的构造函数。

（2）实现抽象的方法：

  • l 使用abstract关键字；
  • l 使用接口。

示例代码：

通过下面的代码示例来演示抽象，如下所示：

 package com.learning;

/**
* 抽象演示示例
*
* @author Administrator
*/public class AbstractDemo {

    public  static   void  main(String args[]) {
        Car obj = new Tesla();
        obj.drive();
        obj.gearChange();
    }
}

abstract class Car {

    Car() {
        System.out.println("Car is built. ");
    }

    abstract void drive();

    void gearChange() {
        System.out.println("Gearchanged!!");
    }
}

class  Tesla  extends Car {

    void drive() {
        System.out.println("Drive Safely");
    }
}

3）继承

继承是一个类的对象获取另一类对象的某些属性的过程。继承支持分层分类的概念。例如，知更鸟是Robin类的一种，但不是哺乳动物，后者又属于Animal类的一种。这种划分背后的原则是每个子类都具有来自其父类的类的共同特征。

属性的继承

在 OOP 中，继承的思想提供了可重用性的概念。这意味着我们可以不修改父类而添加额外的特性——通过从父类派生一个新类来实现。新类由两个类的组合特征组成。在 Java 中，派生类也称为子类。

继承的类型有：

  • l 单一继承（自定义了默认基础Object类）；
  • l 多类继承（如抽象类/实体类+接口模式）；
  • l 多层次继承（如A->B->C+接口模式）；
  • l 混合继承（如类+接口）。

通过如下示例来进一步理解继承：

 package com.learning;
/**
* 继承示例演示
*
* @author Solo Cui
*/public class InheritanceDemo {

    public static void main(String args[]) {
        Dog d = new Dog();
        d.eat();
        d.nature();
        d.sound();
    }
}

class Animal {

    void eat() {
        System.out.println("我是杂食性动物!! ");
    }
}

class Mammal extends Animal {

    void nature() {
        System.out.println("我是哺乳动物!! ");
    }
}

class Dog extends Mammal {

    void sound() {
        System.out.println("I bark!! ");
    }
}

4）多态性

多态是一个重要的 OOP 概念；这意味着采取多种形式的能力。例如，一个操作在不同情况下表现出不同的行为。行为取决于操作中使用的数据类型。例如，在加法运算中，该运算生成两个数的和。如果操作数是 字符串 ，则通过连接操作产生第三个字符串。

下图演示了可以使用单个函数名称来处理不同的数字和不同类型的参数的情况。

OOP概念梳理：Java中面向对象编程的核心特征

在多态中，具有不同内部结构的对象可以共享相同的外部接口；这意味着即使每个操作的动作可能不同，也可以以相同的方式访问一类操作。在继承中广泛使用了 多态 的概念。

多态可以通过两种方式实现：

1） 方法重载

可以创建具有相同名称但不同参数列表和不同定义的方法。这称为方法重载。当需要对象执行相似的任务但使用不同的输入参数时，需要方法重载。当我们调用对象中的方法时，Java首先匹配方法名称，然后匹配参数的数量和类型来决定执行哪个定义。

方法重载通过三种方式实现：

基于

示例

参数数量

times ( int , int )

times ( int , int , int )

参数数据类型

times ( int , int )

times ( int , float)

参数的数据类型顺序

times (int, float )

times ( float , int)

下面的代码演示了方法重载的概念。

 package com.learning;

/**
* 重载示例
* @author Solo Cui
*/public class OverloadingDemo {

    public static void main(String args[]) {
        CircleArea ca = new CircleArea();
        SquareArea sa = new SquareArea();
        RectangleArea ra = new RectangleArea();
        TriangleArea ta = new TriangleArea();

        System.out.println(" 圆面积  = " + ca.area(1));
        System.out.println("正方形面积 = " + sa.area());
        System.out.println("矩形面积 = " + ra.area(, 4));
        System.out.println("三角形面积= " + ta.area(, 3));
    }
}

class CircleArea {

    double area(double x) {
        return.14 * x;
    }
}

class SquareArea {

    int area(int x) {
        return x * x;
    }
}

class  Rectangle Area {

    int area(int x, int y) {
        return x * y;
    }
}

class TriangleArea {

    int area(int y, int x) {
        return (y * x) /;
    }
}

2）方法覆盖

超类中定义的方法由其子类继承，并由子类创建的对象使用。然而，有时一个对象应该响应相同的方法，但在调用该方法时表现不同，这意味着超类中定义的方法被覆盖。覆盖是通过在子类中定义一个与超类中的方法具有相同名称、相同参数和相同返回类型的方法来实现的。因此，当调用该方法时，将调用并执行子类中定义的方法，而不是超类中的方法。

示例代码。下面的代码演示了方法覆盖的概念。

 package com.learning;
/**
*  方法覆盖 
*
* @author Solo Cui
*/public class  Overriding Demo {

    public static void main(String args[]) {
        Circle c = new Circle();
        c.draw();
        c. number OfSides();

        Box b = new Box();
        b.draw();
        b.numberOfSides();

        Triangle t = new Triangle();
        t.draw();
        t.numberOfSides();
    }
}

class Shape {

    void draw() {
        System.out.println("Mention shape here");
    }

    void numberOfSides() {
        System.out.println("side =");
    }
}

class Circle extends Shape {

    void draw() {
        System.out.println("CIRCLE ");
    }

    void numberOfSides() {
        System.out.println("side = ");
    }
}

class Box extends Shape {

    void draw() {
        System.out.println("BOX ");
    }

    void numberOfSides() {
        System.out.println("side=");
    }
}

class Triangle extends Shape {

    void draw() {
        System.out.println("TRIANGLE ");
    }

    void numberOfSides() {
        System.out.println("side = ");
    }
}

3）动态绑定

绑定是将过程调用链接到要响应调用而执行的代码的过程。这意味着给定过程调用相关联的代码直到运行时调用时才知道。它与继承和多态有关。

消息通讯

对象在 OOP 中相互通信的编程过程包括以下内容：

  • l 创建定义对象及其行为的类；
  • l 创建对象；
  • l 建立对象之间的通信；
  • l 相互通信的对象网络。

对象间相互通信的对象网络示例如图所示：

指定对象名称、方法名称和要发送的信息涉及消息传递。如下代码语句所示：

对象可以被创建或销毁，因为它们有 生命周期 。在对象处于活动状态期间，它允许对象之间的通信。

Java OOP 概念的好处：

  • l 继承消除了冗余代码并实现了可重用性。
  • l 由于消息传递允许与对象进行通信，因此每次都需要从头开始编写代码。因此，它节省了开发时间并提高了生产力。
  • l 项目的区块化见效于类和对象。
  • l 系统升级很容易。

OOPs概念在Java中的应用场景，包括而不限于：

  • l 实时系统；
  • l 仿真和建模；
  • l 面向对象的数据库；
  • l 超文本和超媒体；
  • l 人工智能 和专家系统；
  • l 神经网络和并行编程；
  • l 自动化系统等等。

5、总结

Java 是一种健壮且可扩展的面向对象编程语言，它基于对象和类的概念。它提供了继承、抽象、封装和多态等特性，用于开发高效可靠的代码。

JVM 源码分析：深入理解 CAS
上一篇
MyBatis的SQL执行流程不清楚？看完这一篇就够了
下一篇