首页 > 技术文章 > Java面向对象

z1174299705 2018-04-01 20:35 原文

一、Java继承

 

继 的 特 性 
子 类 有 父 类 p 「 “ te 的 压 性 , 方 法 。 
子 类 可 以 有 自 已 的 压 性 和 方 法 即 子 类 可 以 父 类 进 行 扩 层 。 
子 类 可 以 甲 自 已 的 方 实 现 父 类 的 方 法 : 
妇 的 继 承 是 望 继 承 但 是 可 以 多 重 继 承 望 继 承 就 是 一 个 子 只 苤 承 一 个 父 类 多 重 继 承 就 是 口 A 类 继 承 日 
类 , 日 类 继 承 C 类 所 以 按 迢 关 系 就 是 C 类 是 日 类 的 父 类 日 类 是 A 类 的 父 类 汶 是 闰 继 承 区 引 于 C “ 继 承 一 个 荐 性 。 
高 了 类 之 间 的 台 性 ( 继 承 生 合 度 高 就 会 适 代 码 之 间 的 联 系 }

 

super 5 this 
class Animal { 
void eat() { 
System. out. : 
class Dog extends Animal { 
void eat() { 
eat"); 
System.out. : eat"); 
void eatTest() { 
// this 
this . eat(); 
// super 
super. eat(); 
public class Test { 
public static void main (StringC) args) { 
Animal a = 
new Animal(); 
a.eat(); 
Dog d = new Dog(); 
d . eatTest();

 

絎 na 《 关 键 字 
关 鼕 字 声 明 类 可 以 把 类 义 为 不 苤 承 的 
即 獒 
或 者 用 于 修 慌 方 法 
该 方 法 不 能 發 子 类 重 写 
声 明 类 : 
final 匚 I 55 ; 名 
声 明 方 法 : 
/ 类 体 
1 彦 i 7 p 凵 bli 匚 / p 「 iV t 已 / 0 巴 f 凵 It / p 「 Ot 已 匚 t 巴 0 〕 final i 回 1 直 ; 型 方 法 名 
方 法 体 
注 实 例 壹 量 也 可 以 褊 义 为 丽 乩 褊 义 为 丽 的 壹 量 不 能 發 修 改 。 褫 声 明 为 丽 类 的 方 法 自 动 地 声 明 为 丽 乩 但 是 窭 例 壹 
量 卉 不 是

 

构 造 器 
子 类 不 苤 承 父 类 的 构 适 器 ( 构 适 方 法 或 者 构 适 数 } 但 是 父 类 的 构 适 器 带 有 的 则 它 须 在 子 类 的 构 适 器 中 显 地 通 过 
supe 「 关 鼕 字 满 用 父 类 的 构 适 器 卉 配 以 适 当 的 列 表 : 
如 果 父 类 有 无 0 构 适 器 , 则 在 子 类 的 构 适 器 中 用 supe 用 父 类 构 适 器 不 疋 它 须 的 , 如 岩 殳 有 使 甲 supe 「 关 鼕 字 系 统 会 自 动 满 用 
父 的 无 构 适 器 :

 

class SuperCIass 
private int n; 
SuperCIass( 
System. out. println ("SuperCIass ( ) " ) ; 
SuperCIass(int n) { 
this.n — 
class Subclass extends SuperCIass{ 
private int n; 
Subclass( 
super ; 
System. out. println ("Subclass" ) • 
public Subclass (int n){ 
this.n — 
public class TestSuperSub{ 
public static void main (String 
Subclass sc = 
new Subclass() 
Subclass sc2 = new Subclass 2%);

 

SuperCIass(int n) 
SubCIass 
SuperCIass( ) 
SubCIass(int n) : 2ee

 

注 蹿 s 凵 些 r 语 笥 必 须 是 子 类 构 方 法 的 第 一 条 语 笥 . 不 能 在 子 类 中 使 甲 父 类 构 方 法 名 来 诓 用 父 类 
构 i ; 方 法 . 父 类 的 构 方 法 不 被 子 类 继 承 . 诓 用 父 类 的 构 方 法 的 唯 一 滏 径 是 甲 s 凵 些 r 关 字 , 如 
果 子 类 中 没 显 诓 用 。 则 编 译 器 目 动 将 s 凵 些 r() ; 作 为 子 类 构 方 法 的 第 一 条 语 笥 . 这 窨 形 成 一 个 构 
酵 态 方 法 中 不 能 甲 s 凵 些 r 关 字 . 
诓 用 父 类 的 方 法 语 法 
5 叩 “ . 方 法 名 ( 訕 列 表 
如 果 是 继 承 的 方 法 是 氵 殳 有 必 要 甲 s 凵 些 r 来 诓 用 , 直 接 即 可 诓 用 . 1 旦 如 果 子 类 盖 或 重 写 了 父 类 的 
方 法 则 只 有 甲 些 r 才 能 在 子 类 中 诓 用 父 类 中 的 被 写 的 方 法 .

 

1 、 a 目 0 类 中 的 , 蕊 性 或 者 变 量 
无 论 压 性 是 基 本 类 型 还 是 引 用 类 型 。 所 起 的 亻 乍 用 都 是 变 量 圭 面 存 放 的 , 值 》 , 不 能 变 . 
这 个 值 对 于 基 本 类 型 来 说 变 量 圭 面 放 的 就 是 实 在 在 的 值 。 如 10 , a " 等 . 
而 引 用 类 型 变 量 圭 面 放 的 是 个 址 。 所 以 甲 a 目 0 引 用 类 型 变 量 指 的 是 它 里 面 的 地 址 不 能 变 并 不 
是 说 这 个 地 址 祈 指 向 的 对 象 或 数 组 的 丙 容 不 可 。 这 个 一 定 要 注 意 . 
1 歹 二 : 类 中 有 一 个 性 是 na 《 Person p=newperson("name"); 那 么 你 不 能 灯 p 进 行 重 新 蹂 值 
但 是 可 以 改 p 里 面 压 性 的 值 p.setName('newName'); 
a 目 0 压 性 。 声 明 变 量 时 可 以 不 值 。 而 且 一 旦 值 就 不 能 發 修 改 了 . 对 压 性 可 以 在 三 个 地 方 
蹂 值 . 声 明 时 、 初 始 化 块 中 、 构 方 法 中 。 之 一 定 要 蹂 值 . 
2 、 酣 0 类 中 的 方 法 
作 用 . 可 以 被 麩 承 但 继 承 后 不 能 被 写 . 
3 、 na 0 《 市 类 
作 用 . 类 不 可 以 被 麩 承 .

 

旧 va 文 亻 牛 被 编 译 成 class 文 件 时 。 在 子 类 的 所 有 构 丞 数 中 的 第 一 行 ( 第 一 个 语 笥 ) 窨 默 认 目 动 添 加 
些 r() 语 笥 。 在 执 行 子 类 的 构 丞 数 前 。 , 茜 窨 先 执 行 父 类 中 的 构 丞 数 .

 

在 缩 写 代 码 要 注 意 
. 1 如 果 父 类 中 不 含 默 认 构 丞 数 ( 就 是 类 名 0 ) , 那 么 子 类 中 的 s 凵 些 r() 语 笥 就 窨 执 行 荚 。 系 统 
就 窨 报 . 一 般 默 认 构 丞 数 编 译 时 窨 目 动 添 加 。 1 旦 如 果 类 中 已 经 有 一 个 构 丞 数 时 就 不 窨 添 加 . 
. 2 执 行 父 类 构 丞 数 的 语 笥 只 能 放 在 丞 数 丙 语 笥 的 首 旬 , 不 然 窨 报 . 
在 继 承 关 系 中 。 在 用 丞 数 ( 方 法 ) 或 者 类 中 的 成 量 时 JVM ( 」 AVA 虚 拟 机 ) 窨 先 陆 测 当 前 的 类 
( 也 就 是 子 类 ) 是 古 : 有 该 丞 数 或 者 成 变 量 如 果 有 就 执 行 子 类 中 的 。 如 果 氵 殳 有 才 窨 执 行 父 类 中 
的 . 如 下

二、Java重写(Override)与重载(Overload

重 S(Override) 
重 写 是 子 类 父 类 的 允 许 访 河 的 方 法 的 实 现 过 程 进 行 重 新 写 返 回 值 和 形 都 不 能 改 壹 : 即 外 壳 不 变 , 核 心 重 写 ! 
重 写 的 好 处 在 于 子 类 可 以 罨 需 要 定 义 荐 定 于 自 已 的 行 为 。 也 就 是 说 子 类 能 罨 需 要 实 现 父 类 的 方 法 。 
重 写 方 法 不 能 抛 土 新 的 查 异 喲 或 者 比 褊 写 方 法 丰 明 苤 乏 的 异 喲 。 口 : 父 类 的 一 个 方 法 丰 明 了 一 个 查 异 喲 
IOExcaption, 但 是 在 重 写 这 个 方 法 的 时 候 不 能 抛 土 Exceptions-X 因 *ExceptionEIOExcaptionäQ* 只 能 抛 土 
IOException 的 子 类 异 喲 :

 

方 法 的 重 写 规 则 
列 表 它 须 完 全 与 褊 写 方 法 的 同 
. 返 回 类 型 它 须 完 全 与 褊 写 方 法 的 返 回 类 型 同 
. 访 河 枚 不 能 比 父 类 中 褊 写 的 方 法 的 访 河 叹 低 : 口 : 如 果 父 类 的 一 个 方 法 褫 蒂 明 为 public , 那 么 在 子 类 中 重 写 该 方 
法 就 不 能 声 明 为 protect : 
父 类 的 民 方 氵 只 能 發 它 的 子 类 重 写 : 
声 明 为 a 方 法 不 00 写 : 
声 明 为 static 的 方 法 不 00 写 但 是 能 被 再 次 声 明 。 
子 类 和 父 类 在 同 一 个 包 中 , 那 么 子 类 可 以 写 父 类 祈 有 方 法 
涂 了 声 明 为 p 「 “ te 和 丽 的 方 法 。 
子 类 和 父 类 不 在 同 一 个 包 中 , 那 么 子 只 能 重 写 父 类 的 声 明 为 public 和 protact 的 《 丽 a 方 法 。 
重 写 的 方 法 能 抛 土 任 回 《 到 虽 老 异 喲 , 无 论 褊 写 的 方 法 是 古 抛 土 异 喲 。 但 是 重 写 的 方 法 不 能 抛 土 新 的 强 老 1 生 异 喲 
者 比 褊 写 方 法 蒂 明 的 苤 广 泛 的 强 制 1 生 异 喲 , 反 之 则 可 以 : 
构 适 方 法 不 00 写 。 
. 如 果 不 苤 承 一 个 方 法 
则 不 能 重 写 这 个 方 法 :

 

重 ä(Overload) 
重 载 〔 “ oading } 是 在 一 个 类 圭 面 , 方 法 名 字 同 , 而 不 同 。 返 回 类 型 可 以 同 可 以 不 同 。 
每 个 重 载 的 方 法 ( 或 者 构 适 数 } 都 它 须 有 一 个 独 一 无 二 的 类 型 列 表 : 
最 喲 用 的 地 方 就 是 构 适 器 的 重 载 : 
褊 载 的 方 法 它 须 改 壹 爻 列 表 〔 爻 或 类 型 或 顺 孛 不 一 棰 
褊 载 的 方 法 可 以 改 亪 返 回 类 型 
褊 载 的 方 法 可 以 改 壹 访 河 修 符 . 
褊 载 的 方 法 可 以 声 明 新 的 或 苤 广 的 查 异 喲 
方 法 能 在 同 一 个 类 中 或 者 在 一 个 子 类 中 褊 载 : 
无 法 以 返 回 值 类 型 作 为 重 载 数 的 区 分 际 ; 邕

 

重 写 与 重 载 之 间 的 区 别 
列 表 
返 回 类 型 
访 河 
它 须 修 改 
可 以 修 改 
可 以 修 改 
可 以 修 改 
一 定 不 能 嗲 改 
一 定 不 能 嗲 改 
可 以 ; 少 或 册 」 涂 , 一 定 不 能 抛 土 新 的 或 者 苤 广 的 异 喲 
一 定 不 能 甘 更 格 的 老 ( 可 以 0 氏 老 }

 

忘 、 纟 吉 
方 法 的 重 写 ( 0 旧 rrlding 重 载 〔 0 旧 ading } 是 闰 “ 多 态 性 的 不 同 表 现 重 写 是 父 类 与 子 类 之 间 多 态 性 的 一 种 表 现 重 载 可 以 解 
多 态 的 具 现 形 : 
( 月 方 法 重 载 是 一 个 类 中 定 义 了 多 个 方 法 名 同 而 他 们 的 的 数 量 不 同 数 量 同 而 类 型 和 次 孛 不 同 , 则 称 为 方 法 的 重 载 
( 0 丽 ing 龙 
罔 方 法 重 写 是 在 子 类 存 在 方 法 与 父 类 的 方 法 的 名 字 同 而 且 的 个 数 与 类 型 一 棰 返 回 值 一 棰 的 方 法 就 称 为 重 写 孓 № 「 
riding). 
. ( 3 } 方 法 重 载 是 一 个 类 的 多 态 性 表 现 而 方 法 重 写 是 子 类 与 父 类 的 一 种 多 态 性 表 现 :

三、Java多态

多 态 是 同 一 ^ 行 为 旱 有 多 个 不 同 表 现 形 或 形 态 的 能 力 : 
多 态 就 是 同 一 个 接 二 , 使 甲 不 同 的 实 例 而 树 行 不 同 臣 作 , 如 玺 所 示 : 
打 印 机 
打 印 
黑 白 打 印 机 
印 效 果 : 黑 白 
打 印 效 果 彩 色

 

如 果 当 前 在 Flash 界 面 下 彈 土 的 就 是 AS 3 的 帮 助 艾 档 . 
如 果 当 前 在 Word 下 彈 土 的 就 是 Word 帮 助 ; 
在 Wi 丽 “ s 下 彈 土 的 就 是 Wi 丽 “ s 帮 助 和 支 持 : 
》 0 一 一 介 孬 件 发 在 00 上 艹 生 不 的 榘 。 
多 态 的 优 点 
1 消 涂 类 型 之 间 的 合 关 系 
2 · 可 替 性 
3 · 可 扩 充 性 
4 接 二 性 
6 · 简 化 性

 

多 态 存 在 的 三 个 要 条 件 
父 类 引 用 1 旨 苘 子 类 对 象 
Parent p 
n 巴 Ch 1 Id 
兰 使 甲 多 态 方 满 用 方 法 时 首 先 查 父 类 中 是 古 有 该 方 法 , 如 岩 殳 有 , 则 译 宿 誤 
多 态 的 好 处 : 可 以 使 程 苒 良 好 的 扩 层 , 卉 可 以 对 所 苒 类 的 象 彳 亍 湮 甲 处 理 : 
如 果 有 
再 去 满 用 子 类 的 同 名 方 法 :

 

多 态 的 实 现 方 式 
艿 式 一 : 重 写 : 
满 个 丙 容 已 还 在 上 一 过 节 详 继 过 , 就 不 再 丕 , 详 继 可 访 河 : 」 3 写 〔 0 祀 rrld 引 与 载 〔 0 祀 003 嗾 
1 生 适 中 的 接 二 亻 表 性 的 就 是 后 座 口 一 个 三 接 头 的 还 头 都 妄 在 三 孔 后 座 中 
因 为 这 个 是 每 个 王 家 都 苒 各 自 
规 定 的 接 二 规 则 , 有 可 能 到 王 外 就 不 行 那 是 因 为 王 外 自 已 定 义 的 接 二 类 型 : 
2 · ja “ 中 的 接 二 类 似 于 生 适 中 的 接 二 , 就 是 一 些 方 法 征 的 合 , 没 有 方 法 的 实 现 。 具 恤 可 以 看 ] 接 口 这 一 
的 内 容 : 
艿 式 三 : 抽 象 类 和 抽 象 方 法 
佯 宿 后 看 年 旦 假

 

对 于 多 态 , 可 以 总 结 以 下 几 点 : 
使 甲 父 类 类 型 的 引 用 指 向 子 类 的 对 象 
该 引 用 只 能 用 父 类 中 过 叟 的 方 氵 和 变 量 
、 如 果 子 类 中 重 写 了 父 类 中 的 一 个 方 法 那 么 在 诓 用 这 个 方 法 的 时 候 。 将 窨 诓 用 子 类 中 的 这 个 方 
法 ; ( 动 态 连 、 动 态 用 ) 
些 、 变 量 不 能 被 写 ( 覆 盖 
在 缤 悻 时 窨 报 宿 。 
] 写 , 的 就 念 只 针 对 方 法 如 果 在 子 类 中 ] 写 ] 了 父 类 中 的 变 量 那 么

 

四、Java抽象类

Java 抽 象 类 
在 面 苘 象 的 念 中 , 所 有 的 象 都 是 通 过 类 来 描 绘 的 但 是 过 来 
包 含 足 够 的 信 孬 某 描 绘 一 个 具 恤 的 象 , 这 棰 的 类 就 是 榧 类 。 
榧 类 涂 了 不 能 实 例 化 象 之 外 , 类 的 其 它 功 能 然 存 在 成 民 量 
卉 不 是 祈 苒 的 类 都 是 甲 来 茧 绘 象 的 如 果 一 个 类 中 没 有 
成 民 方 法 和 构 适 方 法 的 访 河 方 和 晋 涯 类 一 棰 : 
由 于 类 不 能 实 例 化 象 , 所 以 捂 类 须 褊 承 才 《 使 甲 : 是 因 为 这 个 原 因 , 通 喲 在 谩 叶 渝 决 定 不 谩 叶 象 
类 。 
父 类 包 含 了 子 类 合 的 常 见 的 方 法 , 但 是 由 于 父 类 事 身 是 榧 象 的 , 所 以 不 能 底 甲 这 些 方 法 。 
在 妇 “ 中 类 过 亍 的 是 一 种 继 承 关 系 一 个 只 能 继 承 一 个 类 而 一 个 类 却 可 以 窭 现 多 个 接 二 :

 

public abstract class Employee 
private String name; 
private String address; 
private int number; 
public abstract double computepay();

 

Salary.java 
: Salay.java * / 
public class Salamy' extends Employee 
private double salay; // Annual salary 
public double computePay() 
System.out. salary pay for " 
return salay/52; 
+ getName());

 

抽 象 类 总 结 规 定 
1 类 不 00 篓 例 化 〔 初 字 者 很 容 易 犯 的 宿 ), 如 果 褊 篓 例 化 , 就 会 报 宿 
以 创 过 象 : 
2 · 榧 类 中 不 一 包 方 法 但 是 有 方 法 的 类 犭 定 是 榧 类 。 
译 无 法 通 过 : 只 有 类 的 象 子 类 可 
3 · 类 中 的 方 氵 是 蒂 明 , 不 包 含 方 法 , 就 是 不 土 方 法 的 具 窭 现 也 就 是 方 法 的 具 恤 功 能 : 
4 构 适 方 法 类 方 法 ( 用 static 修 慌 的 方 氵 却 不 能 声 明 为 方 法 。 
& 类 的 子 类 须 洁 土 类 中 的 方 法 的 具 窭 现 涂 该 子 类 是 榧 类 :

 

abstract class Animal{ 
private int age; 
public Animal (int 
this.age - 
age; 
System. out . println( 
public void 
System. out . println 
"*niåtAnimaI " ) ; 
• "+this.age 
abstract class Dog extends Animal{ 
public Dog(int 
super( age) ; / 
System. out . ntln ( ) ;

五、Java封装

在 面 苘 象 程 谩 叶 方 法 中 , 封 装 ( 英 语 : Encapsulation) 是 1 旨 一 种 将 象 性 接 二 的 实 现 细 节 部 分 装 
封 装 可 以 被 认 为 是 一 个 俣 护 屏 嶂 防 止 该 类 的 代 码 和 数 据 被 外 部 类 义 的 代 码 随 机 访 河 : 
访 河 该 类 的 代 码 和 数 据 它 篌 通 过 严 格 的 接 二 控 老 : 
封 装 主 的 功 能 在 于 我 们 能 嗲 改 自 已 的 实 现 代 码 , 而 不 用 修 改 那 芸 满 用 我 们 代 码 的 程 孛 片 : 
适 当 的 封 装 可 以 让 程 码 更 容 易 解 与 進 护 强 了 程 码 的 安 全 。 
封 装 的 优 点 
1 良 蔚 的 封 装 能 0 少 合 : 
2 · 类 内 部 的 结 构 可 以 自 由 修 改 。 
3 · 可 以 民 量 过 行 更 谁 的 控 老 : 
4 0 唐 , 实 现 细 节 。 
0 来 的 方

 

public class Person { 
private String name; 
private int age; 
public class Person{ 
private String name; 
private int age; 
public int 
return age; 
public String 
return name; 
this . age 
this . name 
public 
public 
void setAge(int age) { 
age; 
void setName(String name) { 
— name;

 

this (prwata string name) (satNama(String

六、Java接口

接 二 ( 艾 :Int 巳 “ } 在 JAVA} 程 语 言 中 是 一 个 榧 类 型 是 榧 方 法 的 合 , 接 二 通 喲 以 int 巳 毹 来 声 明 。 一 个 类 通 过 继 
承 接 二 的 方 从 而 来 继 承 接 二 的 方 法 : 
接 二 卉 不 是 类 写 接 二 的 方 和 类 很 似 , 但 是 它 们 压 于 不 同 的 念 。 类 描 述 象 的 压 性 和 方 法 。 接 二 则 包 实 现 的 方 
涂 实 坝 接 二 的 类 是 榧 类 古 则 该 类 定 二 中 的 所 有 方 法 。 
接 二 无 法 褊 篓 例 化 , 但 是 可 以 褊 篓 现 。 一 个 实 现 接 二 的 类 , 它 须 窭 现 接 二 内 所 描 述 的 所 有 方 法 古 则 就 必 须 声 明 为 类 。 另 
外 , 在 妇 “ 中 , 接 二 类 型 可 用 来 声 明 一 个 壹 量 他 们 可 以 为 一 个 空 幅 针 或 是 褊 定 在 一 个 以 此 接 二 实 现 的 象 :

 

接 囗 与 类 相 似 点 : 
一 ^ 接 二 可 以 有 多 个 方 法 : 
接 二 艾 件 保 存 在 ja “ 结 昆 的 艾 件 中 , 艾 件 名 使 甲 接 二 名 : 
接 二 的 字 节 码 艾 件 保 存 在 class 结 昆 的 艾 件 中 : 
. 接 二 西 的 字 节 码 艾 件 它 须 在 与 包 名 称 匹 酐 目 录 结 构 中 : 
接 囗 与 类 的 区 别 : 
接 二 不 能 用 于 实 例 化 象 : 
接 二 没 有 构 适 方 法 : 
. 接 二 中 所 有 的 方 法 它 《 页 是 榧 方 法 : 
接 二 不 能 包 含 民 量 涂 了 
. 接 二 不 是 褊 继 承 了 , 而 是 要 褊 窭 现 : 
. 接 二 支 持 多 继 承 :

 

接 囗 特 性 
接 二 中 每 一 个 方 法 是 象 的 接 二 中 的 方 法 会 被 的 1 旨 定 为 pub 《 icabstract ( 只 *publicabstract, 其 他 修 符 
都 会 报 宿 
接 二 中 可 以 有 壹 量 但 是 接 二 中 的 壹 量 会 被 的 幅 定 为 pub 《 ics 怡 tic 《 ina 《 壹 量 ( 卉 且 只 能 是 pu 剂 0 用 p 「 “ t 巳 修 慌 
接 二 中 的 方 法 是 不 能 在 接 二 中 实 现 的 只 能 由 实 现 接 二 的 类 来 实 现 接 二 中 的 方 法 : 
抽 象 类 和 接 囗 的 区 别 
1 榧 类 中 的 方 法 可 以 有 方 法 , 就 是 能 实 现 方 法 的 具 恤 功 能 , 但 是 接 二 中 的 方 法 不 行 。 
2 · 类 中 的 民 量 可 以 是 § 种 类 型 的 而 接 二 中 的 民 跹 只 能 是 pub 《 ics 怡 tic 《 ina 《 类 型 的 : 
3 · 接 二 中 不 有 静 态 代 炔 以 及 静 态 方 法 〔 甲 static(StEä3Æ), 而 类 是 可 以 有 静 态 代 炔 和 静 态 方 法 : 
4 一 个 只 苤 承 一 个 榧 类 而 一 个 类 却 可 以 窭 现 多 个 接 二 。

 

貊 te 毹 关 鼕 字 用 来 声 明 一 ^ 接 二 : 下 面 是 接 二 声 明 的 一 个 简 望 例 子 : 
Nameotlntertace.java 文 亻牛嗡t码: 
件 名 : Nameoflnterface.java 家 / 
import java.lang 
/ / 引 入 包 
public nt 已 「 f [ 已 NameOfInterface 
任 何 类 型 f 1, st 让 享 段 
/ 油 象 方 法 
二 有 以 下 存 性 : 
接 二 是 象 的 兰 声 明 一 ^ 接 二 的 时 候 , 不 L*abstract 关 鼕字: 
接 二 中 每 一 个 方 法 是 象 的 声 明 时 同 棰 不 需 abstract 关 鼕 字 : 
. 接 二 中 的 方 法 都 是 公 有 的 :

 

Animal.java 
interface 
public 
public 
• Animal. java 
Animal { 
void eat(); 
void travel();

 

接 口 的 实 现 
兰 类 窭 现 接 二 的 时 候 , 类 实 现 接 二 中 所 苒 的 方 法 。 古 则 , 类 须 声 明 为 象 的 类 。 
类 底 甲 im ments 关 鼕 字 实 坝 接 二 : 在 类 蒂 明 中 
《 mp 尾 ment 关 字 々 在 引 ass 声 明 后 面 : 
实 现 一 个 接 二 的 语 法 可 以 使 甲 这 个 公 : 
Animal.java 文 件嗡t码: 
一 新 叩 艹 nts 接 囗 名 称 [ , 其 他 接 囗 名 称 , 其 他 接 囗 名 称

 

Mammallnt.java 
: Mammallnt.java * / 
public class Mammallnt implements Animal{ 
public void 
System.out. eats"); 
public void 
System.out. travels"); 
public int 
return a; 
public static void main (String 
Mammallnt m = 
new Mammallnt(); 
m.eat(); 
m. travel ( ) ; 
mammal 
mammal 
eats 
travels

 

重 写 接 二 中 声 明 的 方 法 时 需 意 以 下 规 则 : 
类 在 窭 坝 接 二 的 方 法 时 不 能 抛 土 强 老 1 生 异 喲 只 能 在 接 二 中 , 或 者 继 承 接 二 的 类 中 抛 土 该 强 老 1 生 异 喲 。 
类 在 重 写 方 法 时 要 佞 持 一 致 的 方 法 名 , 卉 且 西 该 佞 持 同 或 者 蒹 容 的 返 回 值 类 型 。 
如 果 实 坝 接 二 的 类 是 榧 类 那 幺 就 沿 堊 实 现 该 接 二 的 方 法 : 
在 窭 现 接 二 的 时 候 , 要 意 = 些 规 则 : 
一 个 类 可 以 同 时 实 现 多 个 接 二 : 
一 个 只 苤 承 一 个 类 但 是 能 实 现 多 个 接 二 。 
一 ^ 接 二 苤 承 另 一 ^ 接 二 , 这 和 类 之 间 的 继 承 杰 似

 

r # e : Sports. java 
public interface Sports 
public void setHoneTeam(String name); 
public void setVisitingTeam(String name); 
. Football. java 
public interface Football extends Sports 
public void honeTeamScored (int points); 
public void visitingTeamScored(int points); 
public void endOfQuarter(int quarter); 
Hockey. java 
public interface Hockey extends Sports 
public 
public 
public 
public 
void 
void 
void 
void 
honeGoaIScored ( ) ; 
visitingGoaIScored ( ) ; 
endOfPeriod(int period); 
overtimeperiod(int of);

 

H k 吖 接 二 自 已 声 明 了 」 个 方 法 从 Sp s 接 二 继 承 了 两 个 方 法 这 棰 实 现 H k 吖 接 二 的 类 需 实 现 六 个 方 法 : 
0 , 实 现 Footb 訓 接 二 的 类 需 实 现 五 个 方 法 其 中 两 个 来 自 于 Sp s 接 二 :

 

接 口 的 多 继 
在 妇 “ 中 , 类 的 多 继 承 是 不 合 法 , 但 接 二 允 许 多 继 承 
在 接 二 的 多 继 承 中 exte 丽 s 关 鼕 字 只 需 使 甲 一 次 , 在 其 舌 跟 苷 继 承 接 二 : 如 下 所 示 : 
public nt 已 「 f [ 已 Hockey extends Sports, Event 
以 上 的 程 孛 片 酚 晃 合 法 定 义 的 子 接 二 , 与 类 不 同 的 是 接 二 允 许 多 继 承 
而 Sp s 及 E nt 可 能 定 义 或 是 继 承 同 的 方 法

 

标 记 接 口 
最 喲 用 的 承 接 二 殳 有 包 含 亻 可 方 法 的 接 二 : 
际 记 接 二 殳 有 亻 可 方 法 和 压 性 的 接 二 它 仅 仅 表 明 它 的 类 于 一 个 荐 定 的 类 型 供 其 他 代 码 来 测 讠 过 允 许 做 = 些 事 宿 : 
际 记 接 二 作 用 : 简 望 形 象 的 说 就 是 洁 个 象 0 个 际 ( 盖 个 } 思 对 有 个 或 鬯 叹 
口 : java-awt-event@*ä MouseListener** 二 继 承 3java-util EventListener** 二 乏曼象口 下 : 
package j 引 . util; 
public nt 已 「 f [ 已 
没 有 任 回 方 法 的 接 二 被 称 为 际 记 接 二 : 际 记 接 二 芏 用 于 以 下 两 种 目 的 : 
建 立 一 个 公 共 的 父 接 囗 
EfiEvantListanar** 二 , 汶 是 由 几 十 个 其 他 接 二 扩 层 的 妇 “ API, 你 可 以 使 甲 一 个 际 记 接 二 来 过 一 接 二 的 父 接 二 。 
口 : 兰 一 ^ 接 二 继 承 了 E ntListe 「 接 二 , 妇 拟 机 〔 JVM } 就 知 洹 该 接 二 将 被 甲 于 一 个 事 件 的 代 理 方 : 
向 一 个 类 添 糠 数 据 类 型 . 
这 种 只 是 际 记 接 二 最 初 的 目 的 , 实 现 际 记 接 二 的 类 不 需 要 定 义 亻 可 接 二 方 法 〔 因 为 际 记 接 二 事 就 没 有 方 法 ), 但 是 该 
类 通 过 多 态 性 变 一 个 接 二 类 型 :

 

1 接 囗 可 以 多 继 承 
2 囗 的 方 法 声 明 必 须 是 些 0 abstr t 即 便 不 写 默 认 也 是 
3 囗 里 面 不 能 包 含 方 法 昼 体 窭 现 
4 类 实 继 承 接 囗 必 须 实 现 囗 里 丰 明 的 金 部 方 法 除 韭 该 类 是 抽 类 
5 类 圭 面 可 声 明 些 ℃ static a 目 0 的 变 量 
6 囗 不 能 篓 1 列 化 。 但 是 可 以 被 篓 现 类 创 建

七、Java

为 了 苤 好 地 组 织 类 
妇 “ 供 了 包 机 斋 l, 用 于 区 引 类 名 的 命 名 空 间 : 
包 的 作 用 
1 、 把 功 能 0 0 关 的 类 接 二 组 织 在 同 一 个 包 中 , 方 的 查 膏 二 使 甲 。 
2 、 如 同 艾 件 荚 一 棰 , 包 懺 采 用 了 树 形 目 录 的 存 储 方 。 同 一 个 包 中 的 类 名 字 是 不 同 的 , 不 同 的 包 中 的 类 的 名 字 是 可 以 
同 的 , 兰 同 时 用 两 个 不 同 包 中 同 类 名 的 类 时 应 该 上 包 名 以 区 引 。 因 此 , 包 可 以 避 茫 名 字 冲 突 。 
3 、 包 定 了 访 河 枚 , 有 包 访 河 枚 的 类 才 厉 河 个 包 中 的 类 。 
妇 “ 使 甲 包 〔 p k 四 的 这 种 机 老 是 为 了 防 止 命 名 冲 突 , 访 河 控 老 瞍 索 和 定 0 类 ( c 到 
接 二 、 枚 举 
(enumerations) 主 》 圣 (annotation) 等 。 
包 语 的 语 法 格 为 : 
package pkg1C . pkg2C . pkg3•„) ] ; 
口 一 个 Something-java 艾 件 它 的 内 容 
package net• j 引 . util; 
public [ 1 55 Something{

 

那 么 ZäEéüænet/java/util/Something.javaE*-±fRFE5. p k 四 豇 包 } 的 作 用 是 吧 不 同 的 ja “ 程 孛 分 类 厚 存 更 方 便 
的 褊 他 闰 “ 程 孛 满 用 : 
一 个 包 〔 p k 四 的 可 以 定 义 为 一 互 联 系 的 类 型 ( 类 、 接 二 、 枚 举 和 注 } 为 这 些 类 型 憷 供 访 河 俣 护 和 命 名 空 间 管 理 的 功 
以 下 是 一 妇 “ 中 的 包 : 
java 」 ang 包 基 0 」 的 类 
java.i 伊 包 含 入 土 功 能 的 数 
开 发 者 可 以 自 已 吧 一 类 和 接 二 等 0 包 , 卉 定 义 自 已 的 包 。 而 且 在 窭 际 开 发 中 这 棰 做 是 值 得 的 , 兰 你 自 已 完 發 类 的 实 现 之 
后 , 0 关 的 类 分 可 以 让 其 他 的 程 者 更 容 易 地 谁 定 哪 些 类 、 接 二 、 枚 举 和 注 等 是 0 关 的 : 
由 于 包 创 过 了 新 的 命 名 空 间 (namespace) , 所 以 不 会 距 其 他 包 中 的 任 回 名 字 产 生 命 名 中 突 : 使 甲 包 这 种 机 斋 l, 更 容 易 实 现 访 河 
控 老 卉 且 让 它 00 关 电 简 望 :

 

创 建 包 
创 过 包 的 时 候 , 你 需 要 为 这 个 包 取 一 个 自 适 的 名 字 。 之 舌 如 果 其 他 的 一 个 泪 艾 件 包 含 了 这 个 包 供 的 类 、 接 二 、 枚 举 或 者 注 
类 型 的 时 候 , 都 它 须 将 这 个 包 的 声 明 放 在 这 个 泪 艾 亻 牛 的 开 头 。 
包 声 明 应 该 在 泪 艾 件 的 第 一 行 , 每 个 泪 艾 件 只 能 有 一 个 包 声 明 , 这 个 艾 件 中 的 每 个 类 型 都 应 甲 于 它 : 
如 果 一 个 泪 艾 亻 牛 中 没 有 使 甲 包 声 明 , 那 幺 其 中 的 类 , 数 , 枚 举 注 等 褊 在 一 个 无 的 包 (unnamadpackaga) 中 。 
例 子 
让 我 们 来 看 一 个 例 子 , 这 个 例 子 创 过 了 一 个 做 anim s 的 包 。 通 喲 使 甲 小 写 的 字 母 来 命 名 避 茫 与 类 
在 anim s 包 中 入 一 ' 「 二 (Intefface) 
Animal.java 文 件嗡t码: 
件 名 : 如 新 “ 1. 艹 
package n 土 m Is 
已 「 f [ 已 Animal { 
public void 已 t() ; 
public void travel(); 
接 下 来 , 在 同 一 个 包 中 入 该 接 二 的 实 现 : 
接 二 名 字 的 冲 突 :

 

import 关 钅 建 字 
为 了 能 使 甲 一 个 包 的 员 , 我 们 需 要 在 妇 “ 程 孛 中 明 谁 导 入 该 包 。 F"import' 语 可 完 此 功 能 。 
在 闰 “ 泪 艾 件 中 imp 语 应 位 于 p k 四 e 语 之 舌 所 有 类 的 定 义 之 前 , 可 殳 有 , 可 以 有 多 条 其 语 法 格 为 : 
import p Ck g 已 1 [ . p Ck g 已 2 . “ ] . ( cl 55n m 到 * ) ; 
如 果 在 一 个 包 中 , 一 个 类 想 要 使 甲 本 包 中 的 另 一 个 类 那 幺 该 包 名 可 以 省 。

 

payroll Employee 
payroll äÜ*, aoss*EÄ51JåpF, 
Boss.java : 
package payroll; 
public class doss 
public void payEmpIoyee(EmpIoyee e) 
e. mailCheck(); 
payroll 
•FIJåp: 
payroll. Employee 
import payroll. * ; 
import Employee 
import payroll. Employee;

 

类 艾 亻 牛 中 可 以 包 含 亻 意 数 量 的 import 声 明。 imp 声 明 它 须 在 包 声 明 之 舌 类 声 明 之 前 。

 

推荐阅读