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面向對象程序設計的基本概念是什么這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！