OOP篇（JavaSE - OOA/OOD/OOT/OOP）（持续更新迭代）

本文链接：https://blog.csdn.net/qq_51226710/article/details/141291862

2. 什么是多态机制？Java语言是如何实现多态的？

OOA

一、简介

Object-Oriented Analysis：面向对象分析方法

是在一个系统的开发过程中进行了系统业务调查以后，按照面向对象的思想来分析问题。

OOA与结构化分析有较大的区别。

OOA所强调的是在系统调查资料的基础上，针对OO方法所需要的素材进行的归类分析和整理，而不是对管理业务

现状和方法的分析。

OOA（面向对象的分析）模型由5个层次（主题层、对象类层、结构层、属性层和服务层）和5个活动（标识对象

类、标识结构、定义主题、定义属性和定义服务）组成。

在这种方法中定义了两种对象类之间的结构，一种称为分类结构，一种称为组装结构。

分类结构就是所谓的一般与特殊的关系。
组装结构则反映了对象之间的整体与部分的关系。

OOA在定义属性的同时，要识别实例连接。

实例连接是一个实例与另一个实例的映射关系。

OOA在定义服务的同时要识别消息连接。

当一个对象需要向另一对象发送消息时，它们之间就存在消息连接。

OOA 中的5个层次和5个活动继续贯穿在OOD（画向对象的设计）过程中。

OOD模型由4个部分组成。

它们分别是设计问题域部分、设计人机交互部分、设计任务管理部分和设计数据管理部分。

二、主要原则

1. 抽象

抽象：从许多事物中舍弃个别的、非本质的特征，抽取共同的、本质性的特征，就叫作抽象。

抽象是形成概念的必须手段。

抽象原则有两方面的意义：

第一，尽管问题域中的事物是很复杂的，但是分析员并不需要了解和描述它们的一切，只需要分析研究其中与

系统目标有关的事物及其本质性特征。

第二，通过舍弃个体事物在细节上的差异，抽取其共同特征而得到一批事物的抽象概念。

抽象是面向对象方法中使用最为广泛的原则。

抽象原则包括过程抽象和数据抽象两个方面。

过程抽象是指，任何一个完成确定功能的操作序列，其使用者都可以把它看作一个单一的实体，尽管实际上它可

能是由一系列更低级的操作完成的。

数据抽象是根据施加于数据之上的操作来定义数据类型，并限定数据的值只能由这些操作来修改和观察。

数据抽象是OOA的核心原则。

它强调把数据（属性）和操作（服务）结合为一个不可分的系统单位（即对象），对象的外部只需要知道它做什

么，而不必知道它如何做。

2. 封装

封装就是把对象的属性和服务结合为一个不可分的系统单位，并尽可能隐蔽对象的内部细节。

3. 继承

继承：特殊类的对象拥有的其一般类的全部属性与服务，称作特殊类对一般类的继承。

在OOA中运用继承原则，就是在每个由一般类和特殊类形成的一般—特殊结构中，把一般类的对象实例和所有特

殊类的对象实例都共同具有的属性和服务，一次性地在一般类中进行显式的定义。

在特殊类中不再重复地定义一般类中已定义的东西，但是在语义上，特殊类却自动地、隐含地拥有它的一般类

（以及所有更上层的一般类）中定义的全部属性和服务。

继承原则的好处是：使系统模型比较简练也比较清晰。

4. 分类

分类：就是把具有相同属性和服务的对象划分为一类，用类作为这些对象的抽象描述。

分类原则实际上是抽象原则运用于对象描述时的一种表现形式。

5. 聚合

聚合：又称组装，

其原则是：把一个复杂的事物看成若干比较简单的事物的组装体，从而简化对复杂事物的描述。

6. 关联

关联：是人类思考问题时经常运用的思想方法：通过一个事物联想到另外的事物。能使人发生联想的原因是事物

之间确实存在着某些联系。

7. 消息通信

消息通信：这一原则要求对象之间只能通过消息进行通信，而不允许在对象之外直接地存取对象内部的属性。

通过消息进行通信是由于封装原则而引起的。在OOA中要求用消息连接表示出对象之间的动态联系。

8. 粒度控制

粒度控制：一般来讲，人在面对一个复杂的问题域时，不可能在同一时刻既能纵观全局，又能洞察秋毫。

因此需要控制自己的视野：考虑全局时，注意其大的组成部分，暂时不详察每一部分的具体的细节；

考虑某部分的细节时则暂时撇开其余的部分。这就是粒度控制原则。

9. 行为分析

行为分析：现实世界中事物的行为是复杂的。

由大量的事物所构成的问题域中各种行为往往相互依赖、相互交织。

三、三种分析模型

1. 对象模型

对象模型：对用例模型进行分析,把系统分解成互相协作的分析类,通过类图/对象图描述对象/对象的属性/对象间的

关系,是系统的静态模型

2. 动态模型

动态模型：描述系统的动态行为,通过时序图/协作图描述对象的交互,以揭示对象间如何协作来完成每个具体的用

例,单个对象的状态变化/动态行为可以通过状态图来表达

3. 功能模型

功能模型(即用例模型à作为输入)。

四、主要优点

（1）加强了对问题域和系统责任的理解；

（2）改进与分析有关的各类人员之间的交流；

（3）对需求的变化具有较强的适应性；

（4）支持软件复用。

（5）贯穿软件生命周期全过程的一致性。

（6）实用性；

（7）有利于用户参与。

五、基本步骤

在用OOA具体地分析一个事物时，大致上遵循如下五个基本步骤：

第一步，确定对象和类。这里所说的对象是对数据及其处理方式的抽象，它反映了系统保存和处理现实世界中某

些事物的信息的能力。类是多个对象的共同属性和方法集合的描述，它包括如何在一个类中建立一个新对象的描

述。

第二步，确定结构（structure）。结构是指问题域的复杂性和连接关系。类成员结构反映了泛化-特化关系，整

体-部分结构反映整体和局部之间的关系。

第三步，确定主题（subject）。主题是指事物的总体概貌和总体分析模型。

第四步，确定属性（attribute）。属性就是数据元素，可用来描述对象或分类结构的实例，可在图中给出，并在

对象的存储中指定。

第五步，确定方法（method）。方法是在收到消息后必须进行的一些处理方法：方法要在图中定义，并在对象的

存储中指定。对于每个对象和结构来说，那些用来增加、修改、删除和选择一个方法本身都是隐含的（虽然它们

是要在对象的存储中定义的，但并不在图上给出），而有些则是显示的。

六、模型和需求

1. 模型

需求模型：

- 用况图：捕获与描述用户的要求

基本模型（类图）：

- 对象层：给出所有与问题域和系统责任有挂你的对象，用对象类表示
- 特征层：定义每个对象类的属性与服务
- 关系层：通过已定义的关系描述对象类之间的关系

辅助模型

- 交互图：完成某项特定功能的一组对象之间的详细交互
- 状态图：一个对象的状态变迁
- 活动图：一个服务的流程或业务流程
- 包图：对关系密切的元素打包，帮助理解系统模型

模型规约：对模型中的所有元素进行详细说明

2. 过程

建立需求模型：定义用况，用用况对用户需求进行规范化描述
建立类图:

- 发现对象、定义对象类
- 识别对象的内部特征
- 识别对象的外部关系

原型开发：结合其他活动反复进行

OOD

一、简介

面向对象设计（Object-Oriented Design，OOD）方法是OO方法中一个中间过渡环节。

其主要作用是对OOA分析的结果作进一步的规范化整理，以便能够被OOP直接接受。

面向对象设计（OOD）是一种软件设计方法，是一种工程化规范。这是毫无疑问的。

按照Bjarne Stroustrup的说法，面向对象的编程范式（paradigm）是[Stroustrup, 97]：

决定你要的类；
给每个类提供完整的一组操作；
明确地使用继承来表现共同点。

由这个定义，我们可以看出：OOD就是“根据需求决定所需的类、类的操作以及类之间关联的过程”。

OOD的目标是管理程序内部各部分的相互依赖。

为了达到这个目标，OOD要求将程序分成块，每个块的规模应该小到可以管理的程度，

然后分别将各个块隐藏在接口（interface）的后面，让它们只通过接口相互交流。

比如说，如果用OOD的方法来设计一个服务器-客户端（client-server）应用，那么服务器和客户端之间不

应该有直接的依赖，而是应该让服务器的接口和客户端的接口相互依赖。

这种依赖关系的转换使得系统的各部分具有了可复用性。

还是拿上面那个例子来说，客户端就不必依赖于特定的服务器，所以就可以复用到其他的环境下。

如果要复用某一个程序块，只要实现必须的接口就行了。

OOD是一种解决软件问题的设计范式（paradigm），一种抽象的范式。

使用OOD这种设计范式，我们可以用对象（object）来表现问题领域（problem domain）的实体，每个

对象都有相应的状态和行为。

我们刚才说到：OOD是一种抽象的范式。

抽象可以分成很多层次，从非常概括的到非常特殊的都有，而对象可能处于任何一个抽象层次上。

另外，彼此不同但又互有关联的对象可以共同构成抽象：只要这些对象之间有相似性，就可以把它们当成

同一类的对象来处理。

二、背景知识

计算机硬件技术却在飞速发展。从几十年前神秘的庞然大物，到现在随身携带的移动芯片；

从每秒数千次运算到每秒上百亿次运算。

当软件开发者们还在寻找能让软件开发生产力提高一个数量级的“银弹”[Brooks, 95]时，硬件开发的生产

力早已提升了百倍千倍。硬件工程师们能够如此高效，是因为他们都很懒惰。他们永远恪守“不要去重新

发明轮子”的古训。Grady Booch把这些黑箱称为类属（class category），现在我们则通常把它们称

为“组件（component）”。

类属是由被称为类（class）的实体组成的，类与类之间通过关联（relationship）结合在一起。一个类可以

把大量的细节隐藏起来，只露出一个简单的接口，这正好符合人们喜欢抽象的心理。

所以，这是一个非常伟大的概念，因为它给我们提供了封装和复用的基础，让我们可以从问题的角度来看

问题，而不是从机器的角度来看问题。

软件的复用最初是从函数库和类库开始的，这两种复用形式实际上都是白箱复用。到90年代，开始有人开

发并出售真正的黑箱软件模块：框架（framework）和控件（control）。框架和控件往往还受平台和语言

的限制，现在软件技术的新潮流是用SOAP作为传输介质的Web Service，它可以使软件模块脱离平台和语

言的束缚，实现更高程度的复用。

但是想一想，其实Web Service也是面向对象，只不过是把类与类之间的关联用XML来描述而已[Li, 02]。

在过去的十多年里，面向对象技术对软件行业起到了极大的推动作用。

在可以预测的将来，它仍将是软件设计的主要技术——至少我看不到有什么技术可以取代它的。

三、到底从哪儿来？

有很多人都认为：OOD是对结构化设计（Structured Design，SD）的扩展，其实这是不对的。

OOD的软件设计观念和SD完全不同。SD注重的是数据结构和处理数据结构的过程。

而在OOD中，过程和数据结构都被对象隐藏起来，两者几乎是互不相关的。

不过，追根溯源，OOD和SD有着非常深的渊源。

1967年前后，OOD和SD 的概念几乎同时诞生，它们分别以不同的方式来表现数据结构和算法。

当时，围绕着这两个概念，很多科学家写了大量的论文。

其中，由Dijkstra和 Hoare两人所写的一些论文讲到了“恰当的程序控制结构”这个话题，声称goto语句

是有害的，应该用顺序、循环、分支这三种控制结构来构成整个程序流程。

这些概念发展构成了结构化程序设计方法；而由Ole-Johan Dahl所写的另一些论文则主要讨论编程语言中

的单位划分，其中的一种程序单位就是类，它已经拥有了面向对象程序设计的主要特征。

这两种概念立刻就分道扬镳了。

在结构化这边的历史大家都很熟悉：NATO会议采纳了Dijkstra的思想，整个软件产业都同意goto语句的

确是有害的，结构化方法、瀑布模型从70年代开始大行其道。同时，无数的科学家和软件工程师也帮助结

构化方法不断发展完善，其中有很多今天足以使我们振聋发聩的名字，例如Constantine、Yourdon、

DeMarco和Dijkstra。

有很长一段时间，整个世界都相信：结构化方法就是拯救软件工业的 “银弹”。

当然，时间最后证明了一切。

而此时，面向对象则在研究和教育领域缓慢发展。

结构化程序设计几乎可以应用于任何编程语言之上，而面向对象程序设计则需要语言的支持[1]，这也妨碍

了面向对象技术的发展。实际上，在60年代后期，支持面向对象特性的语言只有Simula-67这一种。

到70年代，施乐帕洛阿尔托研究中心（PARC）的 Alan Key等人又发明了另一种基于面向对象方法的语

言，那就是大名鼎鼎的Smalltalk。

但是，直到80年代中期，Smalltalk和另外几种面向对象语言仍然只停留在实验室里。

到90年代，OOD突然就风靡了整个软件行业，这绝对是软件开发史上的一次革命。

不过，登高才能望远，新事物总是站在旧事物的基础之上的。

70年代和80年代的设计方法揭示出许多有价值的概念，谁都不能也不敢忽视它们，OOD也一样。

四、和传统方法有什么区别？

还记得结构化设计方法吗？程序被划分成许多个模块，这些模块被组织成一个树型结构。

这棵树的根就是主模块，叶子就是工具模块和最低级的功能模块。

同时，这棵树也表示调用结构：每个模块都调用自己的直接下级模块，并被自己的直接上级模块调用。

那么，哪个模块负责收集应用程序最重要的那些策略？当然是最顶端的那些。

在底下的那些模块只管实现最小的细节，最顶端的模块关心规模最大的问题。

所以，在这个体系结构中越靠上，概念的抽象层次就越高，也越接近问题领域；

体系结构中位置越低，概念就越接近细节，与问题领域的关系就越少，而与解决方案领域的关系就越多。

但是，由于上方的模块需要调用下方的模块，所以这些上方的模块就依赖于下方的细节。

换句话说，与问题领域相关的抽象要依赖于与问题领域无关的细节！

这也就是说，当实现细节发生变化时，抽象也会受到影响。

而且，如果我们想复用某一个抽象的话，就必须把它依赖的细节都一起拖过去。

而在OOD中，我们希望倒转这种依赖关系：我们创建的抽象不依赖于任何细节，

而细节则高度依赖于上面的抽象。

这种依赖关系的倒转正是OOD和传统技术之间根本的差异，也正是OOD思想的精华所在。

五、基本步骤

细化重组类

细化和实现类间关系,明确其可见性

增加属性,指定属性的类型与可见性

分配职责,定义执行每个职责的方法

对消息驱动的系统,明确消息传递方式

利用设计模式进行局部设计

画出详细的类图与时序图

六、设计过程中要展开的主要几项工作

1. 对象定义规格的求精过程

对于OOA所抽象出来的对象-＆-类以及汇集的分析文档，OOD需要有一个根据设计要求整理和求

精的过程，使之更能符合OOP的需要。

这个整理和求精过程主要有两个方面：

一是要根据面向对象的概念模型整理分析所确定的对象结构、属性、方法等内容，改正错误的内

容，删去不必要和重复的内容等。

二是进行分类整理，以便于下一步数据库设计和程序处理模块设计的需要。

整理的方法主要是进行归类，对类一＆一对象、属性、方法和结构、主题进行归类。

2. 数据模型和数据库设计

数据模型的设计需要确定类-＆-对象属性的内容、消息连接的方式、系统访问、数据模型的方法

等。最后每个对象实例的数据都必须落实到面向对象的库结构模型中。

3. 优化

OOD的优化设计过程是从另一个角度对分析结果和处理业务过程的整理归纳，优化包括对象和结构的优

化、抽象、集成。

对象和结构的模块化表示OOD提供了一种范式，这种范式支持对类和结构的模块化。

这种模块符合一般模块化所要求的所有特点，如信息隐蔽性好，内部聚合度强和模块之间耦合度弱等。

集成化使得单个构件有机地结合在一起，相互支持。

七、能给我带来什么？

问这个问题的人，脑子里通常是在想“OOD能解决所有的设计问题吗？”

没有银弹。

OOD也不是解决一切设计问题、避免软件危机、捍卫世界和平……的银弹。

OOD只是一种技术。

但是，它是一种优秀的技术，它可以很好地解决目前的大多数软件设计问题——当然，这要求

设计者有足够的能力。

OOD可能会让你头疼，因为要学会它、掌握它是很困难的；OOD甚至会让你失望，因为它也并不成熟、并

不完美。OOD也会给你带来欣喜，它让你可以专注于设计，而不必操心那些细枝末节；OOD也会使你成为

一个更好的设计师，它能提供给你很好的工具，让你能开发出更坚固、更可维护、更可复用的软件。

OOT（doing）

doing . . .

OOP

一、前言

面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）

是一种计算机编程架构。

OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。

OOP 达到了软件工程的三个主要目标：重用性、灵活性和扩展性。

为了实现整体运算，每个对象都能够接收信息、处理数据和向其它对象发送信息。

OOP 主要有以下的概念和组件：

组件

数据和功能一起在运行着的计算机程序中形成的单元，

组件在 OOP 计算机程序中是模块和结构化的基础。

抽象性

程序有能力忽略正在处理中信息的某些方面，即对信息主要方面关注的能力。

封装

也叫做信息封装：确保组件不会以不可预期的方式改变其它组件的内部状态；只有在那些提供了内部

状态改变方法的组件中，才可以访问其内部状态。每类组件都提供了一个与其它组件联系的接口，并

规定了其它组件进行调用的方法。

多态性

组件的引用和类集会涉及到其它许多不同类型的组件，

而且引用组件所产生的结果得依据实际调用的类型。

继承性

允许在现存的组件基础上创建子类组件，这统一并增强了多态性和封装性。典型地来说就是用类来对

组件进行分组，而且还可以定义新类为现存的类的扩展，这样就可以将类组织成树形或网状结构，这

体现了动作的通用性。

由于抽象性、封装性、重用性以及便于使用等方面的原因，以组件为基础的编程在脚本语言中已经变得特

别流行。；例如，Python 和 Ruby 等语言，在开发时完全采用了 OOP 的思想，而流行的 Perl 脚本

语言从版本5开始也慢慢地加入了新的面向对象的功能组件。用组件代替“现实”上的实体成为 JavaScript

（ECMAScript）得以流行的原因，有论证表明对组件进行适当的组合就可以在英特网上代替 HTML 和

XML 的文档对象模型（DOM）。

设计模式、技术和直觉构成严峻的挑战。

这是选择编程语言之前必须认识到的，尽管不同语言的设计特性可能促进或者阻碍这一转化。

在网络应用的增长中，一个很重要的部分是小型移动设备和特殊Internet设备的爆炸性增长。

这些设备各有各的操作系统，或者只在某种特定的设备领域内有共同的操作系统。

我们现在还可以一一列举出这些设备——家庭接入设备、蜂窝电话、电子报纸、PDA、自动网络设

备等等。但是这些设备领域的数量和深入程度将会很快变得难以估量。我们都知道这个市场大得惊人，PC

的兴起与之相比不过小菜一碟。

因此在这些设备的应用程序市场上，竞争将会相当残酷。获胜的重要手段之一，就是尽快进入市场。

开发人员需要优秀的工具，迅速高效地撰写和调试他们的软件。平台无关性也是制胜秘诀之一，它使得程

序员能够开发出支持多种设备平台的软件。

我预期的另一个变化是，我们对于代码(Java)和数据(XML)协同型应用程序的开发能力将会不断提高。

这种协同是开发强大应用程序的核心目标之一。

我们从XML的迅速流行和ebXML规范的进展中，已经看到了这个趋势。

ebXML是一个针对电子商务和国际贸易的，基于XML的开放式基础构架，由联合国贸易促进和电子商务中

心(UN/CEFACT)与结构性信息标准推进组织(OASIS)共同开发。

我们能否期望出现一个真正的面向组件(component-oriented)的语言？它的创造者会是谁呢？

Stroustrup: 我怀疑，这个领域中之所以缺乏成果，正是因为人们——主要是那些非程序员们——对“组件”这个意义含糊的字眼寄予了太

多的期望。这些人士梦想，有朝一日，组件会以某种方式把程序员赶出历史舞台。

以后那些称职的“设计员”只需利用预先调整好的组件，把鼠标拖一拖放一放，就把系统组合出来。

对于软件工具厂商来说，这种想法还有另一层意义，他们认为，到时候只有他们才保留有必要的技术，有

能力编写这样的组件。

这种想法有一个最基本的谬误：这种组件很难获得广泛欢迎。一个单独的组件或框架(framework)，如果能

够满足一个应用程序或者一个产业领域对所提出的大部分要求的话，对于其制造者来说就是划算的产品，

而且技术上也不是很困难。可是该产业内的几个竞争者很快就会发现，如果所有人都采用这些组件，那么

彼此之间的产品就会变得天下大同，没什么区别，他们将沦为简单的办事员，主要利润都将钻进那些组件/

框架供应商的腰包里！

小“组件”很有用，不过产生不了预期的杠杆效应。

中型的、更通用的组件非常有用，但是构造时需要非同寻常的弹性。

二、什么是面向对象编程

首先面向对象不是一种技术, 而是一种编程思想。

面向对象编程(Object Oriented Programming)就是把现实世界的具体事物全部看成一个一个的对象来解决问题

三、为什么要用面向对象编程？

让程序更符合人类的思维习惯

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

面向过程和面向对象都是编程范式，它们在程序设计的思想和实现方式上有很大的不同。

1. 面向过程

面向过程（Procedure Oriented Programming，POP）是一种基于函数、模块、线性结构的编程范

式。其主要特点是把问题分解为一个个可重用的函数或过程，并通过算法来描述控制流程。

通常情况下，面向过程的程序逻辑是由顺序执行的一系列函数调用组成的。

优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、

嵌入式开发、Linux/Unix 等一般采用面向过程开发，性能是最重要的因素。

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

2. 面向对象

面向对象（Object Oriented Programming，OOP）是一种基于对象、类、继承、多态等概念的编程范式。其主

要特点是将数据和行为封装在一个对象中，并通过消息传递机制来描述对象之间的交互。通常情况下，面向对象

的程序逻辑是由一些相对独立的对象组成的。

可以简单理解为：面向过程强调的是函数、接口和步骤，而面向对象强调的是对象、类和继承。

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

统更加灵活、更加易于维护

缺点：性能比面向过程低

3. 区别

面向过程是具体化的，流程化的，解决一个问题，你需要一步一步的分析，一步一步的实现。

面向对象是模型化的，你只需抽象出一个类，这是一个封闭的盒子，在这里你拥有数据也拥有解决问题的方法。

需要什么功能直接使用就可以了，不必去一步一步的实现，至于这个功能是如何实现的，管我们什么事？我们会

用就可以了。

面向对象的底层其实还是面向过程，把面向过程抽象成类，然后封装，方便我们使用的就是面向对象了。

五、面向对象三大特性

1. 面向对象的特征有哪些方面

面向对象的特征主要有以下几个方面：

抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。

抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。

封装 : 封装把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法，如果属性不想被外界访问，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。
继承 : 继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，
但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码。
关于继承如下 3 点请记住：

1. 子类拥有父类非 private 的属性和方法。
2. 子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
3. 子类可以用自己的方式实现父类的方法。

多态 : 所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。在Java中有两种形式可以实现多态：继承（多个子类对同一方法的重写）和接口（实现接口并覆盖接口中同一方法）。

其中Java 面向对象编程三大特性：封装继承多态

封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式，将变化隔离，便于使用，提高复用性和安全性。

继承：继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可

以用父类的功能，但不能选择性地继承父类。通过使用继承可以提高代码复用性。继承是多态的前提。

关于继承如下 3 点请记住：

子类拥有父类非 private 的属性和方法。
子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。

多态性：父类或接口定义的引用变量可以指向子类或具体实现类的实例对象。提高了程序的拓展性。

在Java中有两种形式可以实现多态：

继承（多个子类对同一方法的重写）和接口（实现接口并覆盖接口中同一方法）。

方法重载（overload）实现的是编译时的多态性（也称为前绑定），

而方法重写（override）实现的是运行时的多态性（也称为后绑定）。

一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，

必须在由程序运行期间才能决定。运行时的多态是面向对象精髓的东西，要实现多态需要做两件事：

方法重写（子类继承父类并重写父类中已有的或抽象的方法）；
对象造型（用父类型引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）。

2. 什么是多态机制？Java语言是如何实现多态的？

所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编

程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该

引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。

因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种

不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序

运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

多态分为编译时多态和运行时多态：

其中编辑时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的函数，

通过编辑之后会变成两个不同的函数，在运行时谈不上多态。而运行时多态是动态的，它是通过

动态绑定来实现的，也就是我们所说的多态性多态的实现 Java实现多态有三个必要条件：继承、

重写、向上转型。

继承：在多态中必须存在有继承关系的子类和父类。

重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。

向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类

的方法和子类的方法。

只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的

对象，从而达到执行不同的行为。

对于Java而言，它多态的实现机制遵循一个原则：

当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的

成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。

六、6大原则

OOP基本上有6大原则，而实际上都是互补的，也就是说一些原则需要利用另一些原则来实现自

己。6大原则如下：

Open-Close Principle（OCP），开闭原则，讲的是设计要对扩展有好的支持，而对修改要严格限制。这是最重要也是最为抽象的原则，基本上我们所说的Reusable Software既是基于此原则而开发的。其他的原则也是对它的实现提供了路径。
Liskov Substituition Principle（LSP），里氏代换原则，很严格的原则，规则是“子类必须能够替换基类，否则不应当设计为其子类。”也就是说，子类只能去扩展基类，而不是隐藏或覆盖基类。
Dependence Inversion Principle（DIP），依赖倒换原则，“设计要依赖于抽象而不是具体化”。换句话说就是设计的时候我们要用抽象来思考，而不是一上来就开始划分我需要哪些哪些类，因为这些是具体。这样做有什么好处呢？人的思维本身实际上就是很抽象的，我们分析问题的时候不是一下子就考虑到细节，而是很抽象的将整个问题都构思出来，所以面向抽象设计是符合人的思维的。另外这个原则会很好的支持OCP，面向抽象的设计使我们能够不必太多依赖于实现，这样扩展就成为了可能，这个原则也是另一篇文章《Design by Contract》的基石。
Interface Segregation Principle（ISP），接口隔离原则，“将大的接口打散成多个小接口”，这样做的好处很明显，我不知道有没有必要再继续描述了，为了节省篇幅，实际上我对这些原则只是做了一个小总结，如果有需要更深入了解的话推荐看《Java与模式》，MS MVP的一：本巨作！_
单一职责：一个类的功能尽量单一，降低耦合
Law of Demeter or Least Knowlegde Principle（LoD or LKP），迪米特法则或最少知识原则，这个原则首次在Demeter系统中得到正式运用，所以定义为迪米特法则。它讲的是“一个对象应当尽可能少的去了解其他对象”。也就是又一个关于如何松耦合（Loosely-Coupled）的法则。

还有一个继承复用原则（这儿就不体现了）

七、面向对象的程序设计

1. 简介

面向对象的程序设计是一种编程范式，

它将程序分解为对象的集合，这些对象通过相互之间的交互来实现系统的功能。

在面向对象的程序设计中，每个对象都有自己的属性和方法，可以封装数据和行为。

通过继承和多态等机制，可以实现代码的重用性和扩展性。

面向对象的程序设计可以提高代码的可读性和可维护性，使得程序的结构更清晰。

它强调对象之间的关系和交互，更符合现实世界的抽象和模型化。

以下是一个面向对象的程序设计示例代码，以Java语言为例：

// 定义一个动物类 Animal
class Animal {
    private String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void eat() {
        System.out.println(name + " 正在吃东西");
    }
}
 
// 定义一个狗类 Dog，继承自Animal类
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    
    public void bark() {
        System.out.println("汪汪汪！");
    }
}
 
// 主程序
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("旺财");
        dog.eat(); // 调用继承自Animal类的eat()方法
        dog.bark(); // 调用自身的bark()方法
    }
}

这个示例中，我们定义了一个Animal类和一个继承自Animal类的Dog类。

Animal类有一个表示名称的属性和一个eat()方法，Dog类新增了一个bark()方法。

在主程序中，我们创建了一个名为"旺财"的Dog对象，通过调用eat()和bark()方法展示了代码的运

行结果。