面向对象和面向过程的区别

C是面向过程

C++、 JAVA是面向对象

面向对象和面向过程的区别

一个博大,一个精深.

总体而言,面向对象简单,面向过程对人员要求素质过高

面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

艾兰.库伯的《软件创新之路》中提到：

面向过程和面向对象的区别并不像人们想象得那么大

面向对象的大部分思想在面向过程中也能体现

但面向过程最大的问题（也许是唯一先天的缺陷）在于随着系统的膨胀，面向过程将无法应付，最终导致系统的崩溃

面向对象的提出正是试图解决这一软件危机

目前看来，似乎有一定成效

但仍任重道远

---------------------------------------------------------------

做一些对比来说吧：

分析 基本构件 方法 工具

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

面向过程 基于算法 函数／过程 数据流图、伪代码... ...

面向对象 基于对象 类 UML建模... Rose，viso等

---------------------------------------------------------------

其实我始终认为，不管是面向对象，还是面向过程，都体现了一种软件重用的思想！

只不过面向过程中重用的是过程和函数，但是面向对象重用的是类，一种将数据和处理数据的过程及函数封装在一起的实体，其实面向对象中的过程和函数和面向过程中的分别不是很大，所以数据流图和伪代码还是有用的。

面向对象一个很大的好处就是数据 和方法的封装，由此面向对象的三大特性得到发挥

什么是面向对象 面向过程 面向事件

2010-06-05 11:26

      面向过程是在面向对象出现之前，以及之后，甚至至今都应用于程序开发中的程序设计思想。

      面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

      如：

      一辆汽车

      用面向过程的思想去考虑它应该是这样的：如何启动汽车、如何起步、加速、刹车、熄火等一个个操作。而汽车在这里并不是我们所关心的。

      而面向对象则以汽车为对象，一切由汽车开始，以上的可用操作，即功能是汽车这个对象本身所具有的，做任何操作只要告诉汽车就可以了。

     C语言是面向过程的编程，它的最重要特点是函数，通过主函数来调用一个个子函数。程序运行的顺序都是程序员决定好了的。

      C++是面向对象的编程，类是它的主要特点，程序执行过程中，先由主函数进入，定义一些类，根据需要，执行类的成员函数，过程的概念被淡化了（实际上过程还是有的，就是主函数的那些语句），类就是对象，所以我们称之为面向对象程序设计。

      Visual C++，它是面向事件的编程，程序执行时，不断检测有没有事件（消息）发生，如果有，那么就看有没有对应于事件的函数，如果有就执行这个函数。相比之下，它过程式的味道几乎没有了，但是实际上也是面向过程的，这个过程就是检验有没有事件，只不过这个过程被隐藏了起来。

      面向过程是把所有的功能全部在一个大的类里定义出来，当系统庞大时，功能多了，各种操作之间的调用关系也很复杂，当需要修改一个功能时就可能引发一连串的改动，使修改和维护成本很昂贵。

而面向对象，对把功能以对象为基本单位进行分类：这就是我们在面向对象程序设计中所常说的类了。我们知道在管理中有一种方法叫“授权”，意思是管理者把不同的任务交给相应的人去处理，这样就把责任分发到相应的负责人，管理者只需要记录谁负责什么就可以，哪里出了问题或是没有完成任务，就找相应的负责人，只要修改相应的类以及极小部份的其他改动。

      面向对象的思想需要大家在实际工作中去慢慢体会，通过和面向过程的对比，我们就能发现它的优越性，进而更好地掌握运用。

对于类的理解

    面向对象是在分析和解决问题的时候，将涉及的数据和对数据的操作封装在类中。通过类可以创建对象。比方：可以构建一个Circle类，一个表示圆的类，它是半径不同的所有的圆的一个抽象的描述。通过类可以创建任意多个对象，这些对象之间是相互独立的。可以由圆类Circle创建圆c1和圆c2。而c1和c2是彼此独立的对象。

这样，对于事物的观控粒度，由某个具体的对象扩大到一个类。这样符合人们认识事物的习惯。

public class Circle

{

       private double R;                      // 圆的泛权——半径

       public void getR(double r)             //设置圆的半径

   {

         R=r;

   }

   public double getArea()                //求圆的面积

   {

          return 3.14*R*R;

   }

}

面向对象和面向过程

   1.面向过程程序设计方法的实质上是从计算机处理问题的观点来进行程序设计工作：输入——运算——输出。面向过程程序设计者需要变更习惯的思维方法以贴近计算机的内部工作机理。面向过程程序设计所具有的流的工作性质，试图通过信息流及其转换来认识系统，不仅加大了程序设计的难度，同时亦使得程序的可理解性比较差。

面向对象程序设计方法中，一种普遍采用的优化方法是使用结构化的程序设计方法。

面向过程程序设计方法一般适宜采用自上而下的设计方法。

面向过程程序设计方法需要在一开始就全面的，自上而下的设计整个应用程序的架构，因此要求程序设计者对问题域有全面的了解。

面向过程程序设计方法很难复用以前已经设计完成的软件。

2.面向对象程序设计是一种自下而上的程序设计方法，往往从问题的一部分着手，一点一点地构建出整个程序。面向对象设计一数据为中心，类作为表现数据的工具，成为划分程序的基本单位。

面向对象有以下几个重要特点：

   （1）客观世界有对象组成

   （2）对象抽象为类

   （3）类与类之间存在继承关系

   （4）对象之间通过传递消息而彼此联系

关于面向过程及面向对象编程

2010-06-10 10:00

　　 从事软件开发的人可能同时用过面向过程及面向对象的编码，例如JAVA、C++、C#均是面向对象的语言、C语言是面向过程的语言、PHP既支持面向过程也支持面向对象的功能，面向过程及面向对象均有自己的优缺点，也均有自己的适用范围。

　　面向过程

　　优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。

　　缺点：没有面向对象易维护、易复用、易扩展

　　面向对象

　　优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护

　　缺点：性能比面向过程低

　　面向对象程序设计的一些显著的特性包括：

　　.程序设计的重点在于数据而不是过程；

　　.程序被划分为所谓的对象；

　　.数据结构为表现对象的特性而设计；

　　.函数作为对某个对象数据的操作，与数据结构紧密的结合在一起；

　　.数据被隐藏起来，不能为外部函数访问；

　　.对象之间可以通过函数沟通；

　　.新的数据和函数可以在需要的时候轻而易举的添加进来；

　　.在程序设计过程中遵循由下至上（bottom-up）的设计方法。

　　面向对象程序设计在程序设计模式中是一个新的概念，对于不同的人可能意味着不同的内容。我们对面向对象程序设计的定义是"面向对象程序设计是一种方法，这种方法为数据和函数提供共同的独立内存空间，这些数据和函数可以作为模板以便在需要时创建类似模块的拷贝。这样的程序设计方法称为面向对象程序设计。"

　　从以上定义可以看到，一个对象被认为是计算机内存中的一个独立区间，在这个区间中保存着数据和能够访问数据的一组操作。因为内存区间是相互独立的，所以对象可以不经修改就应用于多个不同的程序中。

　　什么是面向对象程序设计？

　　面向对象程序设计（OOP）技术汲取了结构化程序设计中好的思想，并将这些思想与一些新的、强大的理念相结合，从而给你的程序设计工作提供了一种全新的方法。通常，在面向对象的程序设计风格中，你会将一个问题分解为一些相互关联的子集，每个子集内部都包含了相关的数据和函数。同时，你会以某种方式将这些子集分为不同等级，而一个对象就是已定义的某个类型的变量。当你定义了一个对象，你就隐含的创建了一个新的数据类型。

　　对象

　　在一个面向对象的系统中，对象是运行期的基本实体。它可以用来表示一个人或者说一个银行帐户，一张数据表格，或者其它什么需要被程序处理的东西。它也可以用来表示用户定义的数据，例如一个向量，时间或者列表。在面向对象程序设计中，问题的分析一般以对象及对象间的自然联系为依据。如前所述，对象在内存中占有一定空间，并且具有一个与之关联的地址，就像Pascal中的record和 C中的结构一样。

　　当一个程序运行时，对象之间通过互发消息来相互作用。例如，程序中包含一个"customer"对象和一个 "account"对象，而customer对象可能会向account对象发送一个消息，查询其银行帐目。每个对象都包含数据以及操作这些数据的代码。即使不了解彼此的数据和代码的细节，对象之间依然可以相互作用，所要了解的只是对象能够接受的消息的类型，以及对象返回的响应的类型，虽然不同的人会以不同的方法实现它们。

　　类

　　我们刚才提到，对象包含数据以及操作这些数据的代码。一个对象所包含的所有数据和代码可以通过类来构成一个用户定义的数据类型。事实上，对象就是类类型（class type）的变量。一旦定义了一个类，我们就可以创建这个类的多个对象，每个对象与一组数据相关，而这组数据的类型在类中定义。因此，一个类就是具有相同类型的对象的抽象。例如，芒果、苹果和桔子都是fruit类的对象。类是用户定义的数据类型，但在一个程序设计语言中，它和内建的数据类型行为相同。比如创建一个类对象的语法和创建一个整数对象的语法一模一样。

　　数据抽象和封装

　　把数据和函数包装在一个单独的单元（称为类）的行为称为封装。数据封装是类的最典型特点。数据不能被外界访问，只能被封装在同一个类中的函数访问。这些函数提供了对象数据和程序之间的接口。避免数据被程序直接访问的概念被称为"数据隐藏"。

　　抽象指仅表现核心的特性而不描述背景细节的行为。类使用了抽象的概念，并且被定义为一系列抽象的属性如尺寸、重量和价格，以及操作这些属性的函数。类封装了将要被创建的对象的所有核心属性。因为类使用了数据抽象的概念，所以它们被称为抽象数据类型（ADT）。

　　封装

　　封装机制将数据和代码捆绑到一起，避免了外界的干扰和不确定性。它同样允许创建对象。简单的说，一个对象就是一个封装了数据和操作这些数据的代码的逻辑实体。

　　在一个对象内部，某些代码和（或）某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。

　　继承

　　继承是可以让某个类型的对象获得另一个类型的对象的属性的方法。它支持按级分类的概念。例如，知更鸟属于飞鸟类，也属于鸟类。这种分类的原则是，每一个子类都具有父类的公共特性。

　　在 OOP中，继承的概念很好的支持了代码的重用性（reusability），也就是说，我们可以向一个已经存在的类中添加新的特性，而不必改变这个类。这可以通过从这个已存在的类派生一个新类来实现。这个新的类将具有原来那个类的特性，以及新的特性。而继承机制的魅力和强大就在于它允许程序员利用已经存在的类（接近需要，而不是完全符合需要的类），并且可以以某种方式修改这个类，而不会影响其它的东西。

　　注意，每个子类只定义那些这个类所特有的特性。而如果没有按级分类，每类都必须显式的定义它所有的特性。

　　多态

　　多态是OOP的另一个重要概念。多态的意思是事物具有不同形式的能力。举个例子，对于不同的实例，某个操作可能会有不同的行为。这个行为依赖于所要操作数据的类型。比如说加法操作，如果操作的数据是数，它对两个数求和。如果操作的数据是字符串，则它将连接两个字符串。

　　多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。多态在实现继承的过程中被广泛应用。

　　面向对象程序设计语言支持多态，术语称之为"one interface multiple method（一个接口，多个实现）"。简单来说，多态机制允许通过相同的接口引发一组相关但不相同的动作，通过这种方式，可以减少代码的复杂度。在某个特定的情况下应该作出怎样的动作，这由编译器决定，而不需要程序员手工干预。

　　在多函数程序中，许多重要的数据被声明为全局变量，这样它们才可以被所有的函数访问。每个函数又可以具有它自己的局部变量。全局变量很容易被某个函数不经意之间改变。而在一个大程序中，很难分辨每个函数都使用了哪些变量。如果我们需要修改某个外部数据的结构，我们就要修改所有访问这个数据的函数。这很容易导致bug的产生。

　　在结构化程序设计中，另一个严重的缺陷是不能很好的模拟真实世界的问题。这是因为函数都是面向过程的，而不是真正的对应于问题中的各个元素。

　　面向过程的程序设计的一些特点如下：

　　.强调做（算法）；

　　.大程序被分隔为许多小程序，这些小程序称为函数；

　　.大多数函数共享全局数据；

　　.数据开放的由一个函数流向另一个函数。函数把数据从一种形式转换为另一种形式。

　　采用由上至下的程序设计方法。

　　动态绑定

　　绑定指的是将一个过程调用与相应代码链接起来的行为。动态绑定的意思是，与给定的过程调用相关联的代码只有在运行期才可知。它与多态和继承的联系极为紧密。一个多态引用的函数调用决定于这个引用的动态类型。

　　消息传递

　　一个面向对象的程序由许多对象组成，这些对象之间需要相互沟通。因此，在面向对象程序设计语言中，程序设计的主要步骤如下：

　　1、创建类，这些类定义了对象及其行为；

　　2、由类定义创建对象；

　　3、建立对象之间的通讯。

　　对象之间通过收发信息相互沟通，这一点类似于人与人之间的信息传递。信息传递的概念使得真实世界的直接模拟更易于和建立系统交流。

　　对于某个特定对象来说，消息就是请求执行某个过程，因此，消息的接收对象会调用一个函数（过程），以产生预期的结果。传递的消息的内容包括接收消息的对象的名字，需要调用的函数的名字，以及必要的信息。

　　对象就有一个生命周期。它们可以被创建和销毁。只要对象正处于其生存期，就可以与其进行通讯。

　　OOP的优点

　　OOP具有许多优点，无论是对于程序设计者或者用户来说都是如此。面向对象为软件产品扩展和质量保证中的许多问题提供了解决办法。这项技术能够大大提高程序员的生产力，并可提高软件的质量以及降低其维护费用。其主要的优点陈列于下：

　　1、通过继承，我们可以大幅减少多余的代码，并扩展现有代码的用途；

　　2、我们可以在标准的模块上（这里所谓的"标准"指程序员之间彼此达成的协议）构建我们的程序，而不必一切从头开始。这可以减少软件开发时间并提高生产效率；

　　3、数据隐藏的概念帮助程序员们保护程序免受外部代码的侵袭；

　　4、允许一个对象的多个实例同时存在，而且彼此之间不会相互干扰；

　　5、允许将问题空间中的对象直接映射到程序中；

　　6、基于对象的工程可以很容易的分割为独立的部分；

　　7、以数据为中心的设计方法允许我们抓住可实现模型的更多细节；

　　8、面向对象的系统很容易从小到大逐步升级；

　　9、对象间通讯所使用的消息传递技术与外部系统接口部分的描述更简单；

　　10、更便于控制软件复杂度。

　　当需要将以上所说的所有特性有机的结合于一个面向对象系统中，它们之间的相对重要性就取决于工程的类型和程序员的喜好。为了获得上述的某些优势，必须考虑很多事情。例如，对象库必须可以被重用。技术还在不停的发展，现有的产品也会很快的更新换代。如果重用没有能够实现，那么就需要进行严格的控制和管理。

　　易于使用的开发软件往往难以编写。面向对象程序设计工具有望解决这个问题。

　　面向对象程序设计语言

　　面向对象技术并不是某个特定语言的特权。如同结构化程序设计一样，OOP概念可以在很多语言比如C和Pascal中实现。但是，当程序越来越大时，程序设计工作会变得拙劣而混乱。而一个支持OOP概念的程序设计语言则可以让一切变得简单。

　　一个语言必须支持几个主要的OOP概念才能称其是面向对象的。根据所支持的OOP特性，语言可以分为以下两类：

　　1、基于对象的程序设计语言；

　　2、面向对象的程序设计语言。

　　基于对象的程序设计语言仅支持封装和对象辨识。

　　一个面向对象的程序设计语言所要支持的重要特性如下：

　　.数据封装

　　.数据隐藏和访问机制

　　.对象的自动初始化和清除

　　.操作符重载

　　支持对象风格程序设计的语言称为基于对象的程序设计语言。它们不支持继承和动态绑定。

　　Ada就是一个典型的基于对象的程序设计语言。

　　面向对象的程序设计不仅仅包含基于对象程序设计的特性，还支持继承和动态绑定。

　　OOP的应用

　　OOP最有前途的应用领域如下：

　　1、实时系统；

　　2、仿真和建模；

　　3、面相对象数据库；

　　4、超文本、超媒体和扩展文本；

　　5、AI和专家系统；

　　6、神经网络和并行程序设计；

　　7、决策支持和办公自动化系统；

　　8、CIM/CAM/CAD系统。

　　Via

　　业务逻辑比较简单的适合用面向过程，例如统计当前在线用户数，一条SQL语句就可以搞定的没有多大必要用面向对象，也没有必要用什么设计模式，那样就是简单问题复杂化了。

　　业务逻辑比较复杂的适合用面向对象，这样当需求有变化时，维护起来会比较方便。

　　面向对象的局部是面向过程的，比如某个类里面某个方法里面实际就是面向过程的，而面向过程会借用面向对象的一些优点来进行优化。

　　网上发现了一篇文章，说了一下OP与OO的不同，并且打了一个比喻，通俗易懂。

　　有人这么形容OP和OO的不同：用面向过程的方法写出来的程序是一份蛋炒饭，而用面向对象写出来的程序是一份盖浇饭。所谓盖浇饭，北京叫盖饭，东北叫烩饭，广东叫碟头饭，就是在一碗白米饭上面浇上一份盖菜，你喜欢什么菜，你就浇上什么菜。我觉得这个比喻还是比较贴切的。

　　蛋炒饭制作的细节，我不太清楚，因为我没当过厨师，也不会做饭，但最后的一道工序肯定是把米饭和鸡蛋混在一起炒匀。盖浇饭呢，则是把米饭和盖菜分别做好，你如果要一份红烧肉盖饭呢，就给你浇一份红烧肉；如果要一份青椒土豆盖浇饭，就给浇一份青椒土豆丝。

　　蛋炒饭的好处就是入味均匀，吃起来香。如果恰巧你不爱吃鸡蛋，只爱吃青菜的话，那么唯一的办法就是全部倒掉，重新做一份青菜炒饭了。盖浇饭就没这么多麻烦，你只需要把上面的盖菜拨掉，更换一份盖菜就可以了。盖浇饭的缺点是入味不均，可能没有蛋炒饭那么香。

　　到底是蛋炒饭好还是盖浇饭好呢？其实这类问题都很难回答，非要比个上下高低的话，就必须设定一个场景，否则只能说是各有所长。如果大家都不是美食家，没那么多讲究，那么从饭馆角度来讲的话，做盖浇饭显然比蛋炒饭更有优势，他可以组合出来任意多的组合，而且不会浪费。

　　盖浇饭的好处就是"菜""饭"分离，从而提高了制作盖浇饭的灵活性。饭不满意就换饭，菜不满意换菜。用软件工程的专业术语就是"可维护性"比较好，"饭" 和"菜"的耦合度比较低。蛋炒饭将"蛋""饭"搅和在一起，想换"蛋""饭"中任何一种都很困难，耦合度很高，以至于"可维护性"比较差。软件工程追求的目标之一就是可维护性，可维护性主要表现在3个方面：可理解性、可测试性和可修改性。面向对象的好处之一就是显著的改善了软件系统的可维护性。

最近打算给开发和QA的同学介绍一下面向对象和UML相关的内容。这是第一篇，介绍主要面向对象的基础概念和UML类图的绘制。

类

概念：类似对象的一种软件抽象，创建对象的模板。

UML图：属性和操作之前可附加一个可见性修饰符。加号（+）表示具有公共可见性。减号（-）表示私有可见性。#号表示受保护的可见性。省略这些修饰符表示具有package（包）级别的可见性。如果属性或操作具有下划线，表明它是静态的。在操作中，可同时列出它接受的参数，以及返回类型。

接口

概念：定义了一套内聚行为的一个或多个操作特性标记的集合。接口是确保送耦合的一种强大的方法。它们允许类参与一套共同的功能集，除了支持接口意外，不需要别的类知道任何有关他的事情。接口的设计要遵循“接口分离原则”，参见什么是面相对象设计的SOLID原则(s)

UML图：接口的UML图展现的样式会有几种变化，但内容都是一样的。

注：在StarUML中可以通过选择Interface元素的Format->【Stereotype Display】、【Suppress Attributes】、【Suppress Operations】来调整。

联系（Association）

概念：实体之间的一个结构化关系表明对象是相互连接的。箭头是可选的，它用于指定导航能力。如果没有箭头，暗示是一种双向的导航能力。

UML图：

方向性。开口箭头指出关联的方向。只有一个开口箭头的关联是单向的：它仅可以在一个方向（箭头的方向）上移动。没有箭头时，表示关联是可以在两个方向上移动。

标签。标签是可选的，一般有一到两个词组成，用来描述关联。

多重性（Multiplicity)。关联的多重性在线的两端标出，每个方向有一个多重性指示器。

聚合（Aggregation）

概念：有时对象会有其他对象组成。例如，飞机由机身、机翼、引擎、起落架等组成。这些全部都是聚合这个概念的例子，它表示“is part of”关系。

UML图：

class Node { private: vector<Node*> itsNodes; };

上述代码只有当子节点不会成为父节点的父节点时（即，必须是树结构，不能是图结构），才能称之

为聚合。

组合（Composition）

概念：组合是更强形式的聚合，其中“整体”负责部分，每个“部分”对象也仅与一个整体对象联系。例如，

在任何给定时间，引擎是且仅是飞机的一部分。而且，除了飞机以外，其他对象都不能直接与引擎对象发

生交互。

UML图：

class Car { public: virtual ~Car() {delete itsCarb;} private: Carburetor* itsCarb };

依赖（Dependency）

概念：对象之间存在临时关系，只有一个原因，它们可能会相互协作。一个对象与另一个对象进行协作，它需要了解这个对象。这意味着两个对象之间必须存在对象关系或part-of关系。当两个对象之间不存在持久关联的时候，我们需要在两个类之间建立依赖。

UML图：

泛化(Generalization)

概念：表示一个更泛化的元素和一个更具体的元素之间的关系。

UML图：

AbstractKmsTheme被标记为抽象的（名字是斜体）。

实现（Realization）

概念：指定两个实体之间的一个合同。换言之，一个实体定义一个合同，而另一个实体保证履行该合同。

UML图

总结面向对象的概念和术语汇总表

术语 描述

Abstract Class抽象类 不能实例化的类

Abstraction抽象 一个项目（可能是类或者操作）的本质特征

Aggregation聚合 两个类或者组件之间的关系，定义为“is part of”

Association关联 两个类或者对象之间的关系

Attribute属性 类了解的东西（数据/信息)

Cardinality基数 表示“有多少”的概念

Class类 类似对象的一种软件抽象，创建对象的模板

Cohesion内聚 封装单元（如组件或者类）的相关程度

Component组件 一种内聚功能单元，可以独立开发、发布、由其他组件编辑组成更大的单元。

Composition组合 强类型的聚合，其中“整体”完全负责各个组成部分，每个部分对象仅与一个“整体”对象相关联

Concrete Class具体类 可以从中实例化对象的类

Coupling耦合 两个项目之间的依赖程度

Generalization泛化 表示一个更泛化的元素和一个更具体的元素之间的关系。

Inheritance继承 定义为“is a”或者“is like”的关系

Instance实例 一个对象，它是某个类的一个示例

Instantiate实例化 从类定义中创建对象

Interface接口 定义了一套内聚行为的一个或多个操作特性标记的集合

Message消息 请求星系或者执行任务

Messaging消息传递 对象之间通过发送消息相互协作的过程

Method方法 有执行值操作的类实现的一个过程（与结构化编程中的函数相似）

Multiple Inheritance多重继承 直接继承自一个以上的类

Object对象 基于类定义的人物、地点、事件、事物等等

Optionality选择性 概念“你需要它吗？”

Override 在子类中重新定义属性和/或方法，以使它们与父类中的定义有区别

Pattern 在考虑相关因素的情况下，通用问题的一个可行性解决方案

Polymorphism多态 不同的对象可以以不同的方式响应同一消息，使对象可以交互而不需要知道确切的类型

Property 在UML2中，是一个命名的值，例如，属性和关联，包括组合，指定元素（例如类或者组件）的一个特征。在Java中，属性的组合包括Getter和Setter

Single Inheritance多重继承 仅从一个类直接继承

Stereotype构造型 建模元素的一种通用用法

Subclass子类 继承自另一个类的类

Superclass父类 另一个类从中继承的类