JAVA面向对象程序设计的基本概念是什么

这篇文章主要讲解了“JAVA面向对象程序设计的基本概念是什么”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“JAVA面向对象程序设计的基本概念是什么”吧！

§ 6.1 面 向 对 象 的 程 序 设 计

面 向 过 程 的 程 序 设 计 方 法 从 解 决 问 题 的 每 一 个 步 骤 入 手 ,它 适 合 于 解 决 比 较 小 的 简 单
问 题 。 C语 言 采 用 面 向 过 程 的 程 序 设 计 模 型 ,但 是 由 于 C本 身 几 乎 没 有 支 持 代 码 重 用 的 语 言
结 构 ,并 且 缺 乏 统 一 的 接 口 ,使 得 当 程 序 的 规 模 达 到 一 定 程 度 时 ,程 序 员 很 难 控 制 其 复 杂 性。

面 向 对 象 的 程 序 设 计 方 法 则 按 照 现 实 世 界 的 特 点 来 管 理 复 杂 的 事 物 ,把 它 们 抽 象 为 对
象 ,具 有 自 己 的 状 态 和 行 为 ,通 过 对 消 息 的 反 应 来 完 成 一 定 的 任 务 。

6.1.1 对 象 、 类 和 消 息

一 个 对 象 就 是 变 量 和 相 关 的 方 法 的 集 合 ,其 中 变 量 表 明 对 象 的 状 态 ,方 法 表 明 对 象 所
具 有 的 行 为 ,下 图 表 示 了 一 个 对 象 的 特 征 :

从 图 中 可 以 看 出 ,一 个 对 象 的 变 量 构 成 这 个 对 象 的 核 心 ,包 围 在 它 外 面 的 方 法 使 这 个
对 象 和 其 它 对 象 分 离 开 来 。 例 如 :我 们 可 以 把 汽 车 抽 象 为 一 个 对 象 ,用 变 量 来 表 示 它 当 前 的
状 态 ,如 速 度 、 油 量 、 型 号 、 所 处 的 位 置 等 ,它 的 行 为 则 可 以 有 加 速 、 刹 车 、 换 挡 等 。 我
们 操 纵 汽 车 时 ,不 用 去 考 虑 汽 车 内 部 各 个 零 件 如 何 运 作 的 细 节 ,而 只 需 根 据 汽 车 可 能 的 行
为 使 用 相 应 的 方 法 即 可 。 实 际 上 ,面 向 对 象 的 程 序 设 计 实 现 了 对 对 象 的 封 装 ,使 我 们 不 必
关 心 对 象 的 行 为 是 如 何 实 现 的 这 样 一 些 细 节 。 通 过 对 对 象 的 封 装 ,实 现 了 模 块 化 和 信 息 隐
藏 ,有 利 于 程 序 的 可 移 植 性 和 安 全 性 ,同 时 也 利 于 对 复 杂 对 象 的 管 理 。

对 象 之 间 必 须 要 进 行 交 互 来 实 现 复 杂 的 行 为 。 例 如 ,要 使 汽 车 加 速 ,必 须 发 给 它 一 个
消 息 ,告 诉 它 进 行 何 种 动 作 (这 里 是 加 速 )以 及 实 现 这 种 动 作 所 需 的 参 数 (这 里 是 需 要 达 到 的
速 度 等 )。 下 图 表 示 了 对 象 A与 对 象 B间 的 消 息 传 递 过 程 。

从 图 中 可 以 看 出 ,一 个 消 息 包 含 三 个 方 面 的 内 容 :

● 　 消 息 的 接 收 者

● 　 接 收 对 象 应 采 用 的 方 法

● 　 方 法 所 需 要 的 参 数 。

同 时 ,接 收 消 息 的 对 象 在 执 行 相 应 的 方 法 后 ,可 能 会 给 发 送 消 息 的 对 象 返 回 一 些 信 息
(如 上 例 中 ,汽 车 的 仪 表 上 会 出 现 已 经 达 到 的 速 度 等 )。

由 于 任 何 一 个 对 象 的 所 有 行 为 都 可 以 用 方 法 来 描 述 ,通 过 消 息 机 制 就 可 以 完 全 实 现 对
象 之 间 的 交 互 ,同 时 ,处 于 不 同 处 理 过 程 甚 至 不 同 主 机 的 对 象 间 也 可 以 通 过 消 息 实 现 交 互
。

上 面 所 说 的 对 象 是 一 个 具 体 的 事 物 ,例 如 每 辆 汽 车 都 是 一 个 不 同 的 对 象 。 但 是 多 个 对
象 常 常 具 有 一 些 共 性 ,如 所 有 的 汽 车 都 有 轮 子 、 方 向 盘 、 常 具 有 一 些 共 性 ,如 所 有 的 汽 车
都 有 轮 子 、 方 向 盘 、 刹 车 装 置 等 。 于 是 我 们 抽 象 出 一 类 对 象 的 共 性 ,这 就 是 类 。 类 中 定 义
一 类 对 象 共 有 的 变 量 和 方 法 。 把 一 个 类 实 例 化 即 生 成 该 类 的 一 个 对 象 。 比 如 我 们 可 以 定
义 一 个 汽 车 类 来 描 述 所 有 汽 车 的 共 性 。 通 过 类 的 定 义 人 们 可 以 实 现 代 码 的 复 用 。 我 们 不
用 去 描 述 每 一 个 对 象 (如 某 辆 汽 车 ),而 是 通 过 创 建 类 (如 汽 车 类 )的 一 个 实 例 来 创 建 该 类 的 一
个 对 象 ,这 大 大 减 化 了 软 件 的 设 计 。

6.1.2 继 承

通 过 对 象 、 类 ,我 们 实 现 了 封 装 ,通 过 子 类 我 们 可 以 实 现 继 承 。

对 于 上 例 来 说 ,公 共 汽 车 、 出 租 车 、 货 车 等 都 是 汽 车 ,但 它 们 是 不 同 的 汽 车 ,除 了 具 有
汽 车 的 共 性 外 ,它 们 还 具 有 自 己 的 特 点 (如 不 同 的 操 作 方 法 ,不 同 的 用 途 等 )。 这 时 我 们 可 以
把 它 们 作 为 汽 车 的 子 类 来 实 现 ,它 们 继 承 父 类 (汽 车 )的 所 有 状 态 和 行 为 ,同 时 增 加 自 己 的 状
态 和 行 为 。 通 过 父 类 和 子 类 ,我 们 实 现 了 类 的 的 层 次 ,可 以 从 最 一 般 的 类 开 始 ,逐 步 特 殊 化
,定 义 一 系 列 的 子 类 。 同 时 ,通 过 继 承 也 实 现 了 代 码 的 复 用 , 使 程 序 的 复 杂 性 线 性 地 增 长 ,而
不 是 呈 几 何 级 数 增 长 。

在 c++中 支 持 多 重 继 承 ,即 一 个 类 可 以 继 承 多 个 父 类 ,这 使 得 对 象 的 实 现 变 得 非 常 复 杂
且 不 可 预 料 (设 想 多 个 父 类 拥 有 某 些 相 同 的 变 量 和 方 法 )。 Java则 只 支 持 单 一 继 承 ,大 大 降 低
了 复 杂 度 。 在 Java中 通 过 接 口 可 以 实 现 多 重 继 承 ,但 接 口 的 概 念 更 简 单 ,使 用 更 方 便 ,而 且 不
仅 仅 限 于 继 承 ,它 使 多 个 不 相 关 的 类 可 以 具 有 相 同 的 方 法 。

6.1.3 多 态

Java通 过 方 法 重 写 和 方 法 重 载 来 实 现 多 态 。

通 过 方 法 重 写 ,一 个 类 中 可 以 有 多 个 具 有 相 同 名 字 的 方 法 , 由 传 递 给 它 们 的 不 同 个 数
和 类 型 的 参 数 来 决 定 使 用 哪 种 方 法 ,这 就 是 多 态 。 例 如 ,对 于 一 个 作 图 的 类 ,它 有 一 个
draw()方 法 用 来 画 图 或 输 出 文 字 ,我 们 可 以 传 递 给 它 一 个 字 符 串 、 一 个 矩 形 、 一 个 圆 形 ,甚
至 还 可 以 再 指 定 作 图 的 初 始 位 置 、 图 形 的 颜 色 等 ,对 于 每 一 种 实 现 ,只 需 实 现 一 个 新 的
draw()方 法 即 可 ,而 不 需 要 新 起 一 个 名 字 , 这 样 大 大 简 化 了 方 法 的 实 现 和 调 用 ,程 序 员 和 用 户
都 不 需 要 记 住 很 多 的 方 法 名 ,只 需 要 传 入 相 应 的 参 数 即 可 。

通 过 方 法 重 载 ,子 类 可 以 重 新 实 现 父 类 的 某 些 方 法 ,使 其 具 有 自 己 的 特 征 。 例 如 对 于
汽 车 类 的 加 速 方 法 ,其 子 类 (如 赛 车 )中 可 能 增 加 了 一 些 新 的 部 件 来 改 善 提 高 加 速 性 能 ,这 时
可 以 在 赛 车 类 中 重 载 父 类 的 加 速 方 法 。 重 载 隐 藏 了 父 类 的 方 法 ,使 子 类 拥 有 自 己 具 体 实 现
,更 进 一 步 表 明 了 与 父 类 相 比 ,子 类 所 具 有 的 特 殊 性 。

本 节 中 ,我 们 对 面 向 对 象 程 序 设 计 的 一 些 基 本 内 容 作 了 讲 解 ,下 面 我 们 就 分 别 讲 述
Java是 如 何 实 现 这 些 内 容 的 。

§ 6.2 类

类 是 组 成 Java程 序 的 基 本 要 素 。 它 封 装 了 一 类 对 象 的 状 态 和 方 法 ,是 这 一 类 对 象 的 原
型 。 在 前 几 章 的 例 子 中 ,我 们 已 经 定 义 了 一 些 简 单 的 类 ,如 Hellowo rldApp类 。

public class HelloWorldApp{
public static void main( String args[ ] ){
System.out.println("Hello World !");
}
}
可以看出,一个类的实现包含两部分的内容:
classDeclaration {
classBody
}

下 面 我 们 分 别 对 每 一 部 分 详 细 讲 述 。

6.2.1 类 声 明

一 个 最 简 单 的 类 声 明 如 下 :

class className {
……
}
例如:
class Point{
……
}

同 时 ,在 类 声 明 中 还 可 以 包 含 类 的 父 类 ,类 所 实 现 的 接 口 以 及 修 饰 符 public、 abstract或
final。 　 我 们 将 分 别 在 后 面 的 几 节 中 介 绍 。

6.2.2 类 体

类 体 中 定 义 了 该 类 所 有 的 变 量 和 该 类 所 支 持 的 方 法 。 通 常 变 量 在 方 法 前 定 义 (并 不 一
定 要 求 ),如 下 所 示 :

class className {
memberVariableDeclarations
methodDeclarations
}

下 例 定 义 了 一 个 Point类 ,并 且 声 明 了 它 的 两 个 变 量 x、 y坐 标 ,同 时 实 现 init()方 法 对 x、 y赋
初 值 。

例 6.1

class Ponit {
int x,y;
void init(int ix, int iy){
x=ix;
y=iy;
}
}

类 中 所 定 义 的 变 量 和 方 法 都 是 类 的 成 员 。 对 类 的 成 员 可 以 设 定 访 问 权 限 ,来 限 定 其 它
对 象 对 它 的 访 问 ,访 问 权 限 所 以 有 以 下 几 种 :private, protected, publi c, friendly。 我 们 将 在 § 6.6中 详 细
讨 论 。

同 时 ,对 类 的 成 员 来 说 ,又 可 以 分 为 实 例 成 员 和 类 成 员 两 种 。 我 们 在 § 6.8中 详 细 讨 论 。

6.2.3 成 员 变 量

最 简 单 的 成 员 变 量 的 声 明 为 :

type variableName;

如 在 例 6.1中 所 声 明 的 变 量 ,int x,y;

成 员 变 量 的 类 型 可 以 是 Java中 的 任 意 数 据 类 型 包 括 简 单 类 型 、 数 组 、 类 和 接 口 。 在 一
个 类 中 ,成 员 变 量 应 该 是 唯 一 的 ,但 是 成 员 变 量 的 名 字 可 以 和 类 中 某 个 方 法 的 名 字 相 同 ,例
如 :

class Point{
int x,y;
int x(){
return x;
}
}

其 中 ,方 法 x()和 变 量 x具 有 相 同 的 名 字 。

类 的 成 员 变 量 和 在 方 法 中 所 声 明 的 局 部 变 量 是 不 同 的 ,成 员 变 量 的 作 用 域 是 整 个 类
,而 局 部 变 量 的 作 用 域 只 是 方 法 内 部 。

对 一 个 成 员 变 量 ,我 们 还 可 以 限 定 它 的 访 问 权 限 (见 § 6.6),用 static限 定 它 为 类 变 量 (见 §
6.7),或 者 用 以 下 的 修 饰 符 限 定 :

final:用 来 声 明 一 个 常 量 ,如 :

class FinalVar{
final int CONSTANT = 50;
……
}

例 中 声 明 了 常 量 CONSTANT, 并 赋 值 为 50。 对 于 用 final限 定 的 常 量 ,在 程 序 中 不 能 改 变 它
的 值 。 通 常 常 量 名 用 大 写 字 母 。

? (未 完 待 续 )6.2.6 构 造 方 法

构 造 方 法 是 一 种 特 殊 的 方 法 。 Java中 的 每 个 类 都 有 构 造 方 法 ,用 来 初 始 化 该 类 的 一 个
新 的 对 象 。 构 造 方 法 具 有 和 类 名 相 同 的 名 称 ,而 且 不 返 回 任 何 数 据 类 型 ,在 构 造 方 法 的 实
现 中 ,也 可 以 进 行 方 法 重 写 。

例6.5
class point {
int x,y;
point (){
x=0; y=0;
}
point (int x, int y){
this.x=x; this.y=y;
}
}

上 例 中 ,我 们 对 类 Point实 现 了 两 个 构 造 方 法 ,方 法 名 均 为 Poin t,与 类 名 相 同 。 而 且 我 们 使
用 了 方 法 重 写 ,根 据 不 同 的 参 数 分 别 对 点 的 x、 y坐 标 赋 与 不 同 的 初 值 。

回 忆 在 例 6.2中 ,我 们 曾 用 init()方 法 对 点 的 x、 y坐 标 进 行 初 始 化 。 二 者 完 成 相 同 的 功 能
,那 么 用 构 造 方 法 的 好 处 在 哪 里 呢 ?

当 用 运 算 符 new为 一 个 对 象 分 配 内 存 时 ,要 调 用 对 象 的 构 造 方 法 ,而 当 创 建 一 个 对 象 时
,必 须 用 new为 它 分 配 内 存 。 因 此 用 构 造 方 法 进 行 初 始 化 避 免 了 在 生 成 对 象 后 每 次 都 要 调
用 对 象 的 初 始 化 方 法 。 如 果 没 有 实 现 类 的 构 造 方 法 ,则 Java运 行 时 系 统 会 自 动 提 供 缺 省 的
构 造 方 法 ,它 没 有 任 何 参 数 。

另 外 ,构 造 方 法 只 能 由 new运 算 符 调 用 。 我 们 将 在 § 6.3中 进 行 详 细 介 绍 。 对 构 造 方 法 同
样 也 有 访 问 权 限 的 限 制 (见 § 6.6)。

6.2.7 finalize()方 法

在 对 对 象 进 行 垃 圾 收 集 前 ,Java运 行 时 系 统 回 自 动 调 用 对 象 的 finalize()方 法 来 释 放 系 统 资
源 ,如 打 开 的 文 件 或 Socket。 该 方 法 的 声 明 必 须 如 下 所 示 :

protected void finalize() throws throwable

finalize()方 法 在 类 java.lang.Object中 实 现 。 如 果 要 在 一 个 所 定 义 的 类 中 实 现 该 方 法 以 释 放
该 类 所 占 用 的 资 源 (即 要 重 载 父 类 的 finalize()方 法 ),则 在 对 该 类 所 使 用 的 资 源 进 行 翻 译 后 ,一
般 要 调 用 父 类 的 finalize()方 法 以 清 除 对 象 使 用 的 所 有 资 源 ,包 括 由 于 继 承 关 系 而 获 得 的 资 源
。 通 常 的 格 式 应 为 :

protected void finalize () throws throwable{
…… // clean up code for this class
super. finalize();
}

该 例 中 ,通 过 super来 调 用 其 父 类 的 finalize()方 法 ,有 关 super我 们 将 在 § 6.4中 讲 述 ,对 类
java.lang.Ob-ject,我 们 也 将 在 § 6.4中 讲 述 。

§ 6.3 对 象

把 类 实 例 化 ,我 们 可 以 生 成 多 个 对 象 ,这 些 对 象 通 过 消 息 传 递 来 进 行 交 互 (消 息 传 递 即
激 活 指 定 的 某 个 对 象 的 方 法 以 改 变 其 状 态 或 让 它 产 生 一 定 的 行 为 ),最 终 完 成 复 杂 的 任 务
。

一 个 对 象 的 生 命 期 包 括 三 个 阶 段 :生 成 、 使 用 和 清 除 。 下 面 我 们 分 别 讲 述 :

6.3.1 对 象 的 生 成

对 象 的 生 成 包 括 声 明 、 实 例 化 和 初 始 化 三 方 面 的 内 容 。 通 常 的 格 式 为 :

type objectName = new type ( [paramlist] );

1. type objectName; 声 明 了 一 个 类 型 为 type的 对 象 。 其 中 type是 组 合 类 型 (包 括 类 和 接 口 )。
对 象 的 声 明 并 不 为 对 象 分 配 内 存 空 间 。

2. 运 算 符 new为 对 象 分 配 内 存 空 间 ,实 例 化 一 个 对 象 。 new调 用 对 象 的 构 造 方 法 ,返 回 对
该 对 象 的 一 个 引 用 (即 该 对 象 所 在 的 内 存 地 址 )。 用 new可 以 为 一 个 类 实 例 化 多 个 不 同 的 对
象 。 这 些 对 象 分 别 占 用 不 同 的 内 存 空 间 ,因 此 改 变 其 中 一 个 对 象 的 状 态 不 会 影 响 其 它 对 象
的 状 态 。

3. 生 成 对 象 的 最 后 一 步 是 执 行 构 造 方 法 ,进 行 初 始 化 。 由 于 对 构 造 方 法 可 以 进 行 重 写
,所 以 通 过 给 出 不 同 个 数 或 类 型 的 参 数 会 分 别 调 用 不 同 的 构 造 方 法 。

以 例 6.5中 所 定 义 的 类 Point 为 例 ,我 们 生 成 类 Point的 对 象 :

Point p1 = new Point();

Point p2 = new Point(5,10);

这 里 ,我 们 为 类 Point生 成 了 两 个 对 象 p1、 p2,它 们 分 别 调 用 不 同 的 构 造 方 法 ,p1调 用 缺 省
的 构 造 方 法 (即 没 有 参 数 ),p2则 调 用 带 参 数 的 构 造 方 法 。 p1、 p2 分 别 对 应 于 不 同 的 内 存 空 间
, 它 们 的 值 是 不 同 的 ,可 以 完 全 独 立 地 分 别 对 它 们 进 行 操 作 。

虽 然 new运 算 符 返 回 对 一 个 对 象 的 引 用 ,但 与 C、 C++中 的 指 针 不 同 ,对 象 的 引 用 是 指 向
一 个 中 间 的 数 据 结 构 ,它 存 储 有 关 数 据 类 型 的 信 息 以 及 当 前 对 象 所 在 的 堆 的 地 址 ,而 对 于
对 象 所 在 的 实 际 的 内 存 地 址 是 不 可 操 作 的 ,这 就 保 证 了 安 全 性 。

6.3.2 对 象 的 使 用

对 象 的 使 用 包 括 引 用 对 象 的 成 员 变 量 和 方 法 ,通 过 运 算 符 ? 可 以 实 现 对 变 量 的 访 问 和
方 法 的 调 用 ,变 量 和 方 法 可 以 通 过 设 定 一 定 的 访 问 权 限 (见 § 6.6) 来 允 许 或 禁 止 其 它 对 象 对
它 的 访 问 。

我 们 先 定 义 一 个 类 Point,它 在 例 6.5的 定 义 中 添 加 了 一 些 内 容 。

例6.6
class Point{
int x,y;
String name = "a point";
Point(){
x = 0;
y = 0;
}
Point( int x, int y, String name ){
this.x = x;
this.y = y;
this.name = name;
}
int getX(){
return x;
}
int getY(){
return y;
}
void move( int newX, int newY ){
x = newX;
y = newY;
}
Point newPoint( String name ){
Point newP = new Point( -x, -y, name );
return newP;
}
boolean equal( int x, int y ){
if( this.x==x && this.y==y )
return true;
else
return false;
}
void print(){
System.out.println(name+" : x = "+x+" y = "+y);
}
}
public class UsinGobject{
public static void main( String args[] ){
Point p = new Point();
p.print(); //call method of an object
p.move( 50, 50 );
System.out.println("** after moving **");
System.out.println("Get x and y directly");
System.out.println("x = "+p.x+" y = "+p.y); //access variabl

es of an object
System.out.println("or Get x and y by calling method");
System.out.println("x = "+p.getY()+" y = "+p.getY());
if( p.equal(50,50) )
System.out.println("I like this point!!!! ");
else
System.out.println("I hate it!!!!! ");
p.newPoint( "a new point" ).print();
new Point( 10, 15, "another new point" ).print();
}
}
运行结果为:
C:java UsingObject
a point : x = 0 y = 0
**** after moving *****
Get x and y directly
x = 50 y = 50
or Get x and y by calling method
x = 50 y = 50
I like this point!!!!
a new point : x = -50 y = -50
another new point : x = 10 y = 15

1. 引 用 对 象 的 变 量

要 访 问 对 象 的 某 个 变 量 ,其 格 式 为 :

objectReference.variable

其 中 objectReference是 对 象 的 一 个 引 用 ,它 可 以 是 一 个 已 生 成 的 对 象 ,也 可 以 是 能 够 生 成 对
象 引 用 的 表 达 式 。

例 如 :我 们 用 Point p=new Point();生 成 了 类 Point的 对 象 p后 ,可 以 用 p.x,p.y来 访 问 该 点 的 x、 y坐
标 ,如

p.x = 10; p.y = 20;

或 者 用 new生 成 对 象 的 引 用 ,然 后 直 接 访 问 ,如 :

tx = new point().x;

2. 调 用 对 象 的 方 法

要 调 用 对 象 的 某 个 方 法 ,其 格 式 为 :

objectReference.methodName ( [paramlist] );

例 如 我 们 要 移 动 类 Point的 对 象 p,可 以 用

p.move(30,20);

虽 然 我 们 可 以 直 接 访 问 对 象 的 变 量 p.x、 p.y来 改 变 点 p的 坐 标 ,但 是 通 过 方 法 调 用 的 方
式 来 实 现 能 更 好 地 体 现 面 向 对 象 的 特 点 ,建 议 在 可 能 的 情 况 下 尽 可 能 使 用 方 法 调 用 。

同 样 ,也 可 以 用 new生 成 对 象 的 引 用 ,然 后 直 接 调 用 它 的 方 法 ,如

new point(). move (30,20);

前 面 已 经 讲 过 ,在 对 象 的 方 法 执 行 完 后 ,通 常 会 返 回 指 定 类 型 的 值 ,我 们 可 以 合 法 地 使
用 这 个 值 ,如 :例 6.6中 类 Point的 方 法 equal返 回 布 尔 值 ,我 们 可 以 用 它 来 作 为 判 断 条 件 分 别 执 行
不 同 的 分 支 。 如 :

if (p.equal (20,30)){
…… //statements when equal
}else {
…… //statements when unequal
}

另 外 ,类 Point的 方 法 newPoint返 回 该 点 关 于 原 点 的 对 称 点 ,返 回 值 也 是 一 个 Point类 型 , 我 们
可 以 访 问 它 的 变 量 或 调 用 它 的 方 法 ,如 :

px = p.newPoint().x 或
px = p.newPoint(). getX(); 

感谢各位的阅读，以上就是“JAVA面向对象程序设计的基本概念是什么”的内容了，经过本文的学习后，相信大家对JAVA面向对象程序设计的基本概念是什么这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是编程网，小编将为大家推送更多相关知识点的文章，欢迎关注！