我的书签
添加书签
移除书签
返
回 总 目 录
目 录
CO M 注 册 错 误 ( V isu a l J + + ) 2 1 4
W ind ow s E X E /C O M D L L 打 包 错 误 ( V isu a l J + + ) 2 1 7
#
if #e l if #e l if #e lse 和 #e nd if 条 件 伪 指 令 2 2
3
#unde f 条 件 伪 指 令 2 2 6
# e rro r 条 件 伪 指 令 2 2 7
#w a rn ing 条 件 伪 指 令 2 2 8
条 件 方 法 2 2 9
条 件 伪 指 令 2 3 0
附
录 C 保 留 字 关 键 字
.............................................................................
2 3 3
a b s t ra c t 2 3 3
boo le a n 235
b re a k 2 3 5
b yte 2 3 6
c a s e 2 3 7
c a tc h 2 3 7
c h a r 2 3 8
c la s s 2 3 9
c o n t in u e 2 3 9
d e fa u l t 2 4 1
d e le g a te 2 4 1
d o 2 4 2
doub le 243
e ls e 2 4 3
e x te n d s 2 4 4
fa lse 2 4 5
f in a l 2 4 5
f in a l ly 2 4 6
f lo a t 2 4 7
fo r 2 4 7
i f 2 4 8
im p le m e n ts 2 4 9
im p o r t 2 4 9
in s ta n c e o f 2 5 0
in t 2 5 0
in te r fa c e 2 5 1
lo n g 2 5 1
m u l t ic a s t 2 5 2
n a t iv e 2 5 2
n e w 2 5 3
n u l l 2 5 3
p a c k a g e 2 5 4
p r iv a te 2 5 4
p ro te c te d 2 5 4
p u b l ic 2 5 5
re tu rn 2 5 5
sh o r t 2 5 5
s ta t ic 2 5 6
su p e r 2 5 6
sw i tc h 2 5 7
syn c h ro n iz e d 2 5 8
th is 2 5 9
th ro w 2 6 0
th ro w s 2 6 1
t ra n s ie n t 2 6 2
t ru e 2 6 2
t ry 2 6 2
v o id 2 6 4
v o la tile 2 6 5
w h i le 2 6 5
附 录 A 错 误 和 警 告
编 译 器 错 误 J0 0 0 1
IN TER N A L C O M P I LER ER R O R 内 部 编 译 器 错 误 
编
译 器 在 检 测 出 错 误 之 后 不 能 恢 复 请 参 阅 He lp 帮 助
菜 单 中 可 用 的技 术 支 持 帮 助 文 件 查 找 M ic rosoft K now le dg e
B a se 中 关 于 该 问 题 的 最 新信 息 还 有 试 着 简 化 编 译 器 报 告
出 现 该 错 误 的 代 码 并 重 新 编 译
编 译 器 错 误 J0 0 0 2
O u t o f m e m o r y 内 存 溢 出
编
译 器 试 图 在 处 理 过 程 中 分 配 一 些 附 加 的 内 存 但 是 却 做 不
到 这 一 点检 查 系 统 交 换 文 件 的 位 置 大 小 和 有 效 性 同 时 确
保 在 交 换 文 件 所 在的 驱 动 器 上 有 足 够 的 空 间 可 以 使 用
编 译 器 错 误 J0 0 0 4
C a n n o t o p en cla ss f i le ' f i len a m e' fo r rea d in g 不 能 打 开 要 读 的 类 文 件
file
n a m e
编
译 器 不 能 打 开 要 读 入 的 程 序 源 文 件 通 常 在 其 他 程 序 已 经
独 占 锁 定该 源 文 件 时 会 发 生 此 错 误 关 闭 其 他 可 能 会 访 问
到 该 源 文 件 的 其 他 进程 并 重 新 编 译
编 译 器 错 误 J0 0 0 5
C a n n o t o p e n c la ss file 'file n a m e ' fo r w r itin g 不 能 打 开 要 写 入 的 类 文 件
file
n a m e
编
译 器 在 生 成 输 出 .c la ss 文 件 时 失 败 编 译 器 没 有 写 入 或 创
建 该 文 件 的 权限 时 通 常 会 发 生 该 错 误 要 确 认 该 文 件 没 有
被 设 置 为 只 读 属 性 并 且没 有 被 其 他 进 程 使 用 在 用 户 正 在
运 行 或 调 试 包 含 指 定 .c la ss 文 件 的 程 序时 也 会 出 现 此 错
误 关 闭 所 有 的 程 序 实 例 并 重 新 编 译
编 译 器 错 误 J0 0 0 6
C a n n o t r e a d c la s s f ile 'file n a m e ' 不 能 读 类 文 件 file n a m e
编
译 器 读 取 某 个 指 定 的 类 文 件 时 失 败 当 编 译 器 读 取 指 定 的
存 储 设 备 遇到 错 误 时 或 编 译 器 不 能 得 到 读 取 该 文 件 的 权
限 时 通 常 发 生 该 错 误要 确 定 该 文 件 没 有 被 其 他 进 程 使 用
另 外 使 用 磁 盘 扫 描 程 序 来 确 定 所要 使 用 的 存 储 设 备 是 有
效 的
编 译 器 错 误 J0 0 0 7
C a n n o t w r ite c la ss f ile 'file n a m e ' 类 文 件 file n a m e 不 能 写
编
译 器 在 试 图 将 缓 冲 区 的 内 容 写 入 到 指 定 的 类 文 件 时 失 败
当 目 标 存 储设 备 上 的 空 间 不 够 时 通 常 会 发 生 此 错 误 从 该
存 储 设 备 中 释 放 一 些 可用 空 间 并 重 新 编 译
编 译 器 错 误 J0 0 1 0
S y n ta x erro r 句 法 错 误
编
译 器 不 能 确 定 在 源 程 序 中 表 达 式 或 语 句 的 意 义 当 错 误 信
息 中 指 定 行的 句 法 无 效 时 通 常 发 生 该 错 误 通 常 这 类 错 误
还 带 有 更 多 的 说 明 信息 修 改 所 有 相 关 的 错 误 并 重 新 编 译
下 面 举
例 说 明 该 错 误
Pu b lic c la s s S im p le {
p u b lic v o id m e th o d 1 ( ) {
in t i= : / / erro r : m iss ing assign m ent valu e
}
}
编 译 器 错 误 J0 0 1 1
E x p ected ' : ' 缺 少
在
ca s e 标 签 后 或 在 条 件 表 达 式 中 应 当 有 一 个 冒 号 以 便 使 用
三 重 运算 符 在 偶 然 丢 掉 了 冒 号 时 通 常 发 生 该 错 误 通 常 情
况 下 该 错 误 是由 编 译 器 报 告 错 误 所 在 行 的 前 一 行 引 起 的
确 保 需 要 冒 号 的 行 是 正 确的 并 重 新 编 译
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le {
p r iv a te in t i;
p riv a te s ta tic in t x = i;
pub lic v o id m e thod1( in t a rg 1 ) {
s w itch ( a rg 1 ) {
ca s e 1 / / erro r : ': ' o m it ted a f ter 'c a s e 1 '
}
i = ( a rg 1 < x ) ? a rg 1 x ; // e r ro r : ': ' o m itte d a f te r 'a rg 1 '
}
}
编 译 器 错 误 J0 0 1 2
E x p ected ' ; ' 缺 少
编
译 器 期 望 在 错 误 信 息 所 指 出 的 位 置 找 到 一 个 分 号 在 语 句
的 结 尾 偶 然遗 漏 了 分 号 时 通 常 会 发 生 此 错 误 当 条 件 表 达
式 的 语 法 不 正 确 时 也会 发 生 此 类 错 误 该 错 误 经 常 是 由 编
译 器 报 告 错 误 所 在 行 的 前 一 行 引 起的 确 保 分 号 的 正 确 使
用 并 重 新 编 译
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le {
p riv a te s ta tic in t x = 1 0 / / erro r : '; ' o m it ted
pub lic v o id m e thod1( in t a rg 1 ) {
fo r ( in t i = 1 ; i < x i+ + ) {
/ / erro r : ; o m it ted
}
}
}
编 译 器 错 误 J0 0 1 3
E x p ected ' ( ' 缺 少
编
译 器 期 望 在 错 误 信 息 所 指 出 的 位 置 找 到 一 个 左 括 号 在 下
列 任 何 一 种情 况 下 丢 失 左 括 号 时 通 常 会 发 生 此 错 误
-
类 型 初 始 化
-
ca tc h 语 句
-
带 有 括 号 的 表 达 式
-
w h ile 循 环
-
fo r 循 环
-
if/e lse 语 句
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le { p r iv a te in t i ;
pub lic v o id m e thod1( in t a rg 1 , in t a rg 2 ) ;
if a rg 1 < a rg 2 ) / / erro r : ' (' o m itted i = a rg 1 ;
e ls e
i = a rg 2 ;
}
}
编 译 器 错 误 J0 0 1 4
E
x p ected ' ) ' 缺 少
编
译 器 期 望 在 错 误 信 息 所 指 出 的 位 置 找 到 一 个 右 括 号 在 下
列 任 何 一 种情 况 下 丢 失 右 括 号 时 通 常 会 发 生 此 错 误
-
类 型 初 始 化
-
类 型 转 换
-
ca tc h 语 句
-
带 有 括 号 的 表 达 式
-
w h ile 循 环
-
fo r 循 环
-
if/e lse 语 句
下 面 举
例 说 明 该 错 误
p u b lic c la s s S im p le {
p r iv a te in t i ;
p u b lic vo id m e thod 1 ( in t arg1 , in t arg2 ) {
i = ( a rg 1 < a rg 2 ? a rg 1 : a rg 2 ;
/ / erro r : ) o m it ted
}
}
编 译 器 错 误 J0 0 1 5
E x p ect ' ] ' 缺 少 ]
编
译 器 期 望 在 错 误 信 息 所 指 出 的 位 置 找 到 一 个 右 方 括 号 当
从 数 组 声 明中 意 外 地 丢 失 右 方 括 号 时 通 常 会 发 生 此 错 误
该 错 误 经 常 是 由 编 译 器报 告 错 误 所 在 行 的 前 一 行 引 起 的
确 保 所 有 的 方 括 号 匹 配 并 重 新 编 译下 面 举 例 说 明 该 错 误
p u b lic c la s s S im p le {
p r iv a te in t x [ = n ew in t [ 5 0 0 ]; //erro r : '] ' o m itted
}
编 译 器 错 误 J0 0 1 6
E x p ected '{ ' 缺 少 {
编
译 器 期 望 在 错 误 信 息 所 指 出 的 位 置 找 到 一 个 左 大 括 号 当
在 类 声 明 或方 法 代 码 块 的 开 始 位 置 丢 失 左 大 括 号 时 通 常
出 现 该 错 误 该 错 误 经 常是 由 编 译 器 报 告 错 误 所 在 行 的 前
一 行 引 起 的 确 保 所 有 的 大 括 号 是 匹 配的 并 重 新 编 译
下 面 举
例 说 明 该 错 误
p u b lic c la s s S im p le / / erro r :'{ ' o m it ted
p u b lic v o id m e th o d 1 ( ) {
/ / do som e th ing m eanin g ful
}
}
编 译 器 错 误 J0 0 1 7
E x p ected '} ' 缺 少 }
编
译 器 期 望 在 错 误 信 息 所 指 出 的 位 置 找 到 一 个 右 大 括 号 当
找 不 到 类 声明 或 方 法 的 结 束 大 括 号 时 通 常 发 生 此 错 误 该
错 误 经 常 是 由 编 译 器 报告 错 误 所 在 行 的 前 一 行 引 起 的 确
保 所 有 的 大 括 号 匹 配 并 重 新 编 译 下 面 举 例 说 明 该 错 误
p u b lic c la s s S im p le {
{
in t x , y ;
/ / erro r : no m a tchin g b race fo und fo r c lass
编 译 器 错 误 J0 0 1 8
E x p ect ' w h i le ' 缺 少 w h i le
编
译 器 在 错 误 信 息 所 指 出 的 位 置 需 要 找 到 关 键 字 w h ile 当
do /w h i le 循 环的 句 法 不 正 确 时 通 常 出 现 该 错 误
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ) { d o {
/ / do so m e th ing u s eful h ere
} ; / / erro r : m is s in g w h ile s ta tem en t
}
下 面 的
代 码 说 明 了 正 确 的 do /w h i le 格 式
p u b lic c la s s S im p le{
p u b lic static void m e thod1 ( ){ in t x = 1 0 ;
d o {
S ys tem .o u t .p r in t in ( x ) ; x - - ;
} w hile( x != 0 ) ; / / th is is co r rect fo rm fo r do / w hile loop
}
p u b lic static void m a in ( S t r ing args[]) { S im p le .m e thod1 ( ) ;}
}
编 译 器 错 误 J0 0 1 9
E x p ect id en t i f ier 缺 少 标 识 符
编
译 器 需 要 在 类 名 接 口 变 量 或 方 法 声 明 之 前 找 到 标 识 符 当
在 声 明中 偶 然 丢 失 类 型 时 通 常 出 现 该 错 误
下 面 举
例 声 明 该 错 误
p u b lic c la s s S im p le {
p r iv a te i; / / erro r :typ e o m it ted
}
编 译 器 错 误 J0 0 2 0
E x p ect ' c la ss' o r ' in te r fa ce' 
缺 少 c la ss 或 in terfa c e
编
译 器 期 望 在 相 应 的 声 明 中 找 到 c las s 或 in te r fa c e 关 键
字 当 在 c las s 和in te r fa c e 声 明 中 关 键 字 偶 然 丢 失 时 通 常
出 现 该 错 误 另 外 一 种 导 致 该错 误 的 原 因 就 是 作 用 域 括 号
不 匹 配
下 面 举
例 声 明 该 错 误
p u b lic S im p le { / / erro r : m is s in g th e 'cla s s ' k eyw o rd
// D o s o m eth in g h ere
}
下 面
的 例 子 说 明 了 由 于 范 围 括 号 不 匹 配 导 致 的 错 误
Pu b lic c la s s S im p le {
/ / D o som e th in g m ean ingful
} } / / erro r : addition al '} ' not need ed
编 译 器 错 误 J0 0 2 1
E x p ected ty p e sp e c i f ie r 缺 少 类 型 指 定
编
译 器 期 望 在 错 误 信 息 所 指 出 的 位 置 找 到 类 型 指 定 当 在 对
象 实 例 和 或变 量 声 明 中 存 在 输 入 错 误 时 通 常 会 发 生 此 错
误
下 面 举
例 说 明 该 错 误
p u b lic c la s s S im p le {
p u b lic O b ject o = n ew ; / / erro r : m is s in g 'O b ject' ty p e s p ecifier
}
编 译 器 错 误 J0 0 2 2
E x p ected en d o f f i le 缺 少 文 件 尾
编
译 器 找 不 到 所 期 望 的 文 件 结 束 字 符 当 源 文 件 在 某 些 地 方
损 坏 时 通常 出 现 该 错 误 实 际 检 查 一 下 来 源 文 件 中 明 显 的
错 误 保 存 所 做 的 改 变
并 重 新
编 译
编 译 器 错 误 J0 0 2 3
E x p e c te d 'c a tc h ' o r 'fin a lly ' 缺 少 ca tc h 或 f in a lly
在
相 应 的 try 块 后 面 缺 少 ca tc h 或 fin a l ly 块下 面 举 例 说 明 该
错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ){ t ry {
/ / do so m e th ing m eanin g ful
}
} / / erro r : ca tch o r f inally no t found
}
下 面 的
例 子 说 明 了 使 用 t ry / catc h 块 的 正 确 句 法
p u b lic c la s s S im p le{
p u b lic v o id m e th o d 1 ( ){ t ry{
// D o s o m eth in g h ere. P o s s ib ly th ro w a n ex cep tio n typ e
}
ca tch ( E x cep t io n e){
/* H a n d le a n y erro rs h ere a n d u s e th e 'E x cep t io n ' o b ject to d e term in e th e typ e o f erro r th a t o ccu rred */
}
}
}
编 译 器 错 误 J0 0 2 4
E x p ected m e th o d b o dy 缺 少 方 法 主 体
在
方 法 声 明 后 面 缺 少 方 法 主 体 当 缺 少 大 括 号 所 包 围 的 方 法
主 体 时 通常 会 发 生 此 错 误 当 方 法 打 算 进 行 ab s t ra c t 或 na
t iv e 操 作 但 ab s t ra c t 或na t iv e 关 键 字 在 方 法 声 明 中 丢
失 时 也 会 产 生 该 错 误
下 面 举
例 说 明 该 错 误
p u b lic ab stra c t c lass S im p le {
p u b lic vo id m e thod 1 ( ) ;
// erro r: ′ab stra c t ′ om it ted
/ / T h is erro r w o u ld a ls o ex is t if th e cla s s is n o t d ecla red ′ab stra c t ′
}
编 译 器 错 误 J0 0 2 5
E x p ected s ta tem en t 缺 少 语 句
在
当 前 作 用 域 的 结 尾 之 前 缺 少 一 个 语 句 当 缺 少 指 定 当 前 作
用 域 开 始 的左 大 括 号 或 缺 少 左 右 两 个 大 括 号 时 通 常 出 现
该 错 误 确 认 当 前 作 用域 的 大 括 号 是 匹 配 的
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le {
v o id m e thod1( in t a rg 1 ) {
if ( a rg 1 = = 1 )
/ / erro r: m is s in g th e left b ra ce fo r th e if s ta tem en t
}
}
编 译 器 错 误 J0 0 2 6
E x p ected U n ic o d e esca p e s e qu en ce 缺 少 Un ic o d e 换 码 序 列
缺
少 有 效 的 U n ic ode 换 码 序 列 当 反 斜 线 后 面 没 有 跟 随 用 来
表 示 U n ic ode 换 码 序 列 的 字 母 u 时 通 常 会 发 生 此 错 误 检 查
U n ic ode 换 码 序 列 的句 法 并 重 新 编 译
下 面 举
例 说 明 该 错 误
p u b lic c la s s S im p le {
in t i = \\u 0 0 3 2 ;
/ / erro r: '\\' n o t v a lid
}
编 译 器 错 误 J0 0 2 7
Id e n tifie r to o lo n g 标 识 符 太 长
编
译 器 检 测 出 某 个 标 识 符 的 名 称 长 于 1024 个 字 符 缩 短 标 识
符 名 称 并重 新 编 译
编 译 器 错 误 J0 0 2 8
In va lid n u m b e r 无 效 数 字
编
译 器 检 测 出 某 个 Ja va 语 言 所 不 能 支 持 的 数 字 值 当 指 定 的
数 字 值 超 出任 何 Ja va 的 原 始 数 据 类 型 的 作 用 域 时 通 常 出
现 该 错 误 当 数 字 值 远 远大 于 在 指 定 数 据 类 型 中 存 储 的 值
时 也 会 出 现 该 错 误
下 面 举
例 说 明 该 错 误
p u b lic c la s s S im p le {
lo n g i = 123 456 789 012 34 567 890 ;
/ / erro r : valu e o u t of ra nge fo r 'long'
}
编 译 器 错 误 J0 0 2 9
In va lid c h ar ac te r 无 效 字 符
编
译 器 检 测 出 不 能 用 来 作 为 标 识 符 的 AS C II 字 符 当 类 接 口
方 法 或变 量 标 识 符 中 包 含 无 效 字 符 时 通 常 会 发 生 此 错 误
下 面 举
例 说 明 该 错 误
p u b lic c la s s S im p le {
p r iv a te in t c# :
// erro r : '# ' n o t s u p p o rted
}
编 译 器 错 误 J0 0 3 0
In va lid c h ar ac te r c o n s ta n t 无 效 字 符 常 量
编
译 器 检 测 出 对 类 型 为 ch ar 的 变 量 试 图 指 定 的 字 符 或 字 符
换 码 序 列无 效
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le {
ch a r c = '\';
/ / erro r : in v a lid es ca p e ch a ra c ter
ch a r x = '\\'; \* co rrect a s s ig n m en t o f th e b a ck s la s h to th e ch a r v a r ia b le */
}
编 译 器 错 误 J0 0 3 1
In va lid e sc a p e c h ar ac te r 无 效 换 码 字 符
编
译 器 检 测 出 使 用 了 某 个 无 效 换 码 字 符 当 在 U n ic ode 换 码
序 列 中 找 到句 法 结 构 错 误 时 通 常 会 发 生 此 错 误 如 果 在 字
符 串 赋 值 中 使 用 一 个 \ 字 符 也 会 出 现 该 错 误
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le {
in t i = \u 0 3 2 ;
/ / erro r : U n icod e uses 4 hex digits in t x = \u 0 032 ;
/ / co rrect a s s ig n m en t o f a U n ico d e es ca p e s eq u en ce
}
下
例 说 明 了 由 于 使 用 不 适 当 的 字 符 \ 对 字 符 串 赋 值 所 产 生
的 错 误
p u b lic c la ss S im p le {
p u b lic S t r ing str = c :\W indow s\deskto p ;
/ / erro r : invalid assignm en t of th e '\' ch aracter to a s t r in g
/ / T o a s s ig n it co rrectly u s e th e '\\' ch a ra c ter a s s ig n m en t
}
编 译 器 错 误 J0 0 3 2
U n te r m in a ted s trin g c o n s ta n t 字 符 串 常 量 未 终 止
编
译 器 在 字 符 串 常 量 的 结 尾 检 测 不 到 使 之 终 止 的 双 引 号 字
符 当 字 符 串结 束 符 丢 失 或 当 字 符 串 常 量 被 错 误 地 分 成 多
行 时 通 常 出 现 该 错 误
下 面 举
例 说 明 该 错 误
p u b lic c la s s S im p le {
S t r in g s t r = " h e llo ;
/ / erro r : closing q uote om it ted
}
编 译 器 错 误 J0 0 3 3
U n te r m in a ted co m m en t 注 释 未 终 止
编
译 器 检 测 到 注 释 块 的 开 始 但 检 测 不 到 有 效 的 结 尾 当 注 释
块 的 结 尾字 符 意 外 丢 失 时 通 常 会 发 生 此 错 误
下 面 举
例 说 明 该 错 误
p u b lic c la s s S im p le {
/* T h is co m m en t b lo ck
-
d o es not have a v a lid
-
term in a to r
}
编 译 器 错 误 J0 0 3 5
In it ia l iz e r b lo c k c a n n o t h a v e m o d ifie r s e x c e p t ' s ta tic ' 除 了 sta t ic 之外 初 始 化 程 序 块 不 能 有 修 饰 符
编
译 器 检 测 到 与 初 始 化 程 序 块 关 联 的 修 饰 符 不 是 sta t ic 只
能 使 用 sta t ic 关 键 字 来 指 定 初 始 化 程 序 为 sta t ic 的 或 者
不 使 用 修 饰 符 表 示 为 实 例初 始 化 程 序 从 错 误 信 息 指 定 的
初 始 化 程 序 中 删 除 该 修 饰 符 或 者 将sta t ic 修 饰 符 加 入 到
初 始 化 程 序 中 然 后 重 新 编 译
下 面 举
例 说 明 该 错 误
p u b lic c la s s S im p le {
p ro tected { / / erro r: ′p ro tected ′ is invalid here
/ / do som e th ing here
}
}
编 译 器 错 误 J0 0 3 6
A d a ta m e m b e r c a n n o t b e ' n a t iv e ' , ' a b s tr a c t ' , o r ' s y n c h r o n iz e d ' 数 据 成员 不 能 为 na t iv e ab s tr a c t 或 sy n c h r o n iz e d
编
译 器 在 变 量 声 明 中 检 测 到 上 述 修 饰 符 之 一 修 饰 符 sync hron
iz e d 和na t iv e 只 能 应 用 于 方 法 声 明 ab s t ra c t 修 饰 符 可
以 应 用 在 方 法 类 和 接 口中
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le {
native in t m yv a r 1 ;
a b s t ra c t in t m yv a r 2 ;
synchronized in t m yvar 3 ;
/ / erro r : th e vars ab o v e have invalid m o difiers
}
编 译 器 错 误 J0 0 3 7
A m e th od c a n n ot b e ' tr a n s ie n t ' or ' v ola t i le ' 方 法 不 能 为 tr a n s ie n t 或
vo la t i le
编 译 器
在 方 法 声 明 中 检 测 到 上 述 修 饰 符 之 一 修 饰 符 tra n s ie n t
和 v o la tile
只
能 应 用 在 字 段 声 明 中下 面 举 例 说 明 该 错 误
p u b lic c la ss S im p le {
tra n s ien t v o id M eth o d 1 ( ) { } ; volatile vo id M e thod2 ( ) { } ;
/ / erro r : th e m e thod s ab ove h a ve in v a lid m odifiers
}
编 译 器 错 误 J0 0 3 8
'fin a l ' m e m b e r 'id e n t if ie r ' m u s t b e in itia liz e d w h e n d e c la r e d in a n in terfa c e 当 在 接 口 中 声 明 时 fin a l 成 员 id e n t i f ie r 必 须 进 行 初 始 化
编
译 器 在 接 口 定 义 中 检 测 到 未 初 始 化 的 fin a l 变 量 在 接 口
定 义 中 的 变 量声 明 如 fin a l 必 须 在 声 明 中 设 置 值 一 旦 设 置
该 值 就 不 能 在 程 序 中
改 变
下 面 举
例 说 明 该 错 误
in terfa ce IS im p le {
f in a l in t C O O L _ R A D ;
/ / erro r : m u st have valu e set
}
编 译 器 错 误 J0 0 4 0
C a n n o t d e fin e a m e th o d b o d y fo r a b s tr a c t / n a t iv e m e th o d s 不 能 为
ab s tr a c t / n ativ e 方 法 定 义 方 法 主 体
编
译 器 在 相 应 的 ab s t ra c t 或 na t iv e 方 法 声 明 的 后 面 检 测
到 方 法 主 体 定义 ab s t ra c t 方 法 必 须 在 子 类 中 定 义 实 现 代
码 na t iv e 方 法 是 使 用 本 机 语言 中 的 代 码 实 现 的 如 C+ +
下 面 举
例 说 明 该 错 误
p u b l ic a b stra c t c la ss S im p le {
ab stra c t vo id m e thod 1 ( ){
/ / D o s o m e th in g h ere
} / / erro r : a b s tra ct m e th o d s a re im p lem en ted in s u b c la s s es
}
在
接 口 中 声 明 的 代 码 是 隐 含 的 ab s t ra c t 同 样 当 用 户 试 图
在 接 口 中 定 义
方
法 主 体 时 也 会 出 现 该 错 误 下 面 的 代 码 说 明 了 这 种 情 况
p u b lic in te r fa c e S im p le {
p u b lic v o id m e th o d 1 ( ) {
/ / erro r : m u st define th is m e thod b o d y
/ / in a c la s s th a t im p lem en ts th e
/ / 'S im p le ' in terfa ce
}
}
编 译 器 错 误 J0 0 4 1
D u p l ic a te m o d if ier 修 饰 符 重 复
编
译 器 在 声 明 中 检 测 到 一 个 修 饰 符 使 用 了 两 次 在 一 个 声 明
中 同 样 的修 饰 符 多 次 使 用 时 就 会 出 现 该 错 误
下 面 举
例 说 明 该 错 误
Pu b lic c la s s S im p le {
p u b lic p u b lic void m e th od1 ( ) { / / erro r : 'p ub lic ' used tw ice
/ / do som e th ing m eanin gfu l
}
}
编 译 器 错 误 J0 0 4 2
O n ly c la ss c a n im p le m e n t in te r fa c e 只 有 类 才 能 实 现 接 口
编
译 器 检 测 到 接 口 声 明 使 用 im p lem en ts 关 键 字 接 口 不 能 实
现 其 他 接口 接 口 只 能 由 类 实 现 当 接 口 实 现 错 误 而 不 是 使
用 e x te nds 关 键 字 扩展 其 他 接 口 时 会 出 现 该 错 误
p u b lic in te r fa c e S im p le im p le m e n ts c o lo r{
/ / erro r : 'S im p le' ca n n o t im p lem en t th e
// 'co lo r ' in terfa ce
}
in terfa ce co lo r {
/ / d o som e th in g m ean ingful
}
in te r face p a t tern e x te n d s co lo r{
/ / ex tending an in terface is O K hee
}
编 译 错 误 J0 0 4 3
R e d ecla r a t io n o f m e m b er ' id en t i f ie r ' 成 员 id e n tifie r 再 次 声 明
编
译 器 检 测 到 在 相 同 作 用 域 中 相 同 的 标 识 符 名 多 次 声 明 当
一 个 变 量或 方 法 多 次 声 明 时 会 出 现 该 错 误 确 认 在 同 一 类
中 没 有 多 次 定 义 同 一个 方 法 或 变 量 名 方 法 可 以 使 用 相 同
的 名 称 但 为 了 区 别 方 法 参 数 必须 有 所 不 同
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le {
p r iv a te in t i;
p u b lic v o id m e th o d 1 ( ) {
/ / do som e th ing here
}
// O th e r d ecla ratio n s fo r th e class g o h e re
p r iv a te in t I; / / erro r: I d ecla red tw ice p u b lic v o id m e th o d 1 ( ){
/ / erro r: m e th o d d ecla red tw ice
}
}
编 译 错 误 J0 0 4 4
C a n n o t fin d d e fin itio n fo r c la ss ' id e n t i f ie r ' 找 不 到 类 id e n tifie r 定 义
编
译 器 找 不 到 指 定 类 的 定 义 该 错 误 通 常 是 由 于 输 入 错 误 而
引 起 的 当找 不 到 包 含 指 定 类 的 软 件 包 时 也 会 出 现 该 错 误
下 面 举
例 说 明 该 错 误
c las s N o t S im p le{
// d o s o m eth in g h ere
}
p u b lic c la ss S im p le {
N o t S im p le s m p = n ew N o t S m p le();
/ / erro r : 'N ot S m p le ' no t a valid c lass nam e
}
编 译 器 错 误 J0 0 4 5
'id
e n tifie r ' is n o t a c la ss n a m e id e n tifie r 不 是 一 个 类
名
编
译 器 检 测 到 下 列 几 种 情 况 时 出 现 此 错 误
-
找 不
到 作 为 im port 语 句 的 一 部 分 的 类 名
-
导 入
语 句 语 法 无 效
-
类
试 图 展 开 一 个 接 口 只 有 类 能 够 与 e x te nds 语 句 一 起 使
用
-
确
保 这 个 软 件 包 都 存 在 并 且 导 入 的 所 有 类 都 要 在 im port
语 句 中 指定 的 软 件 包 中 存 在 然 后 重 新 编 译
下 面 举
例 说 明 该 错 误
p a ck a g e n o n .ex is ten t ;
im p o r t no n.ex is tent; /* erro r : th e p a ck ag e is not ex is ten t and ca nnot b e im p o r ted */
p u b lic c la ss S im p le {
/ / d o som e th in g m ean ingful
}
编 译 器 错 误 J0 0 4 6
'id e n tifie r ' is n o t a n in te r fa c e n a m e id e n tifie r 不 是 接 口 名
编
译 器 检 测 到 im p lem en ts 关 键 字 引 用 的 标 识 符 不 是 接 口 在
im p lem en ts
语
句 中 使 用 类 来 替 代 接 口 时 通 常 出 现 该 错 误下 面 举 例 说 明
该 错 误
c las s S im p le 2 {
/ / d o som e th in g m ean ingful
}
p u b lic c la s s S im p le im p lem en ts S im p le 2 {
// erro r : ca n n o t im p lem e n t c lass 'S im p le 2 '
}
编 译 器 错 误 J0 0 4 8
C a n n o t e x te n d fin a l c la s s ' id e n tifie r ' 不 能 扩 展 fin a l 类 id e n t i f ie r
编
译 器 检 测 到 试 图 细 分 使 用 fin a l 关 键 字 声 明 的 类 使 用 fin
a l 声 明 的 类不 能 细 分 子 类
下 面 举
例 说 明 该 错 误
f in a l c lass S im p le 2 {
/ / d o som e th in g m ean ingful
}
p u b lic c la s s S im p le ex ten d s S im p le 2 {
// e r ro r : c a nno t e x te nd 'S im p le 2 '
}
编 译 错 误 J0 0 4 9
U n d e f ine d na m e ' id e n tif ie r ' id e n tifie r 名 未 定 义
编
译 器 检 测 到 类 方 法 或 变 量 的 引 用 不 存 在 发 生 该 错 误 的 例
子 包 括
-
引 用
的 变 量 不 存 在 或 类 型 错 误
-
与 方
法 一 起 使 用 的 对 象 不 存 在 或 类 型 错 误
-
导 入
的 类 在 指 定 的 软 件 包 中 不 存 在 或 类 型 错 误
确
保 在 错 误 信 息 中 显 示 的 类 方 法 或 变 量 的 引 用 是 正 确 的 并
重 新 编 译
im port ja v a . io .bog us; // e r ro r : unkn ow n c la ss na m e
p u b lic c la s s S im p le {
pub lic in t m e thod1 ( ){
retu rn n o v a r1 ;
/ / erro r: 'n o v a r 1 ' d o es n o t ex is t
}
p u b lic v o id m e th o d 2 ( ){
N o t S im p le n t = n ew N o t S im p le ( ) ; n p .m e th o d x ( ) ;
/ / erro r: th e o b ject referen ce 'n p ' s h o u ld b e 'n t '
}
c lass N o t S im p le{
p u b lic v o id m e th o d x ( ){
/ / do som e th ing m eanin gfu l here
}
}
编 译 器 错 误 J0 0 5 1
U n d e f in d ed p a ck a g e ' id en t i f ie r ' 软 件 包 id e n t i f ie r 未 定 义
编
译 器 检 测 到 软 件 包 名 称 声 明 但 找 不 到 该 软 件 包 的 定 义 当
在 im port 语 句 中 存 在 句 法 错 误 时 通 常 出 现 该 错 误 当 不 能
找 到 该 软 件 包 或 软 件包 不 存 在 时 也 会 出 现 该 错 误
下 面 举
例 说 明 该 错 误
im port ja v a . la n g . bog us.* ;
/ / erro r : 'b o gus ' no t a valid p a ck age nam e
p u b lic c la ss S im p le {
/ / d o som e th in g m ean ingful
}
编 译 器 错 误 J0 0 5 3
A m b ig u o u s n a m e :'id e n t i f ie r ' a n d ' id e n t ifie r ' 不 明 确 的 名 称
id
e n tifie r 和 id e n tifie r
在
显 示 的 两 个 标 识 符 之 间 有 二 义 性 编 译 器 不 能 确 定 当 相 同
的 类 名 出现 在 两 个 软 件 包 中 并 且 这 两 个 软 件 包 都 使 用 类
导 入 指 定 符 * 导 入到 一 个 源 文 件 中 时 通 常 会 出 现 该 错 误
确 保 正 在 导 入 到 源 文 件 中 的 软
件
包 中 没 有 两 个 类 是 同 名 的 并 重 新 编 译
编 译 器 错 误 J0 0 5 6
M issin g r e tu r n ty p e sp e c ific a tio n 没 有 指 定 返 回 类 型
编
译 器 检 测 到 方 法 声 明 没 有 指 定 返 回 类 型 所 有 方 法 声 明 都
必 须 指 定 一个 返 回 类 型 如 果 方 法 不 需 要 返 回 值 则 使 用 vo
id 关 键 字
下 面 举
例 说 明 该 错 误
Pu b lic c la s s S im p le {
p u b lic m eth o d 1 ( ) { / / erro r : n o retu rn typ e
/ / do som e th ing m eanin gfu l
}
}
编 译 器 错 误 J0 0 5 7
C la ss file 'id e n t i f ie r ' sh o u ld n o t c o n ta in c la ss 'id e n tifie r ' 类 文 件
id
e n tifie r 应 该 不 包 含 类 id e n tifie r
在
指 定 的 类 文 件 中 编 译 器 检 测 不 到 指 定 的 类 当 类 被 编 译 到
类 文 件 而 这 个 类 文 件 以 后 又 改 名 时 通 常 会 出 现 该 错 误 因
为 类 文 件 与 类 中 所包 含 的 名 称 不 同 所 以 试 图 使 用 类 文 件
名 作 为 类 时 将 会 失 败 要 避
免
这 种 情 况 可 以 将 类 定 义 改 变 为 正 确 的 名 称 或 将 该 文 件 名
改 回 到 原来 的 文 件 名
编 译 器 错 误 J0 0 5 8
C a n n o t h ave a var ia b le o f ty p e ' v o id ' 不 能 有 vo id 类 型 的 变 量
编
译 器 检 测 到 一 个 变 量 声 明 为 vo id 类 型 关 键 字 vo id 不 允 许
在 变 量 声 明中 使 用 更 确 切 地 说 vo id 只 能 作 为 方 法 返 回 类
型 使 用 这 种 方 法 实 际上 不 返 回 值
下 面 举
例 说 明 该 错 误
p u b lic in terfa ce S im p le {
p u b lic f in a l s ta tic v o id i = 1 ;
// erro r : 'v o id ' n o t v a lid
}
编 译 错 误 J0 0 5 9
C a n n o t re feren ce m e m b er ' id en t i f ie r ' w i th o u t a n o b je c t 不 能 引 用 无 对象 的 成 员 id e n t i f ie r
编
译 器 检 测 到 试 图 引 用 没 有 已 知 对 象 与 之 关 联 的 变 量 当 一
个 实 例 字 段或 方 法 没 有 被 关 键 字 sta t ic 声 明 的 字 段 或 方
法
从 没 有 有 效 实 例 的 sta t ic 方 法 中 引 用 时 通 常 会 发 生 此 错
误 S ta t ic 方 法 不 能 使 用 没 有 有 效 的 类 实例 的 实 例 字 段 和
方 法
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le {
p r iv a te in t x ;
p u b lic v o id m e th o d 1 ( ){
/ / D o s o m e th in g h ere
}
p u b lic static void m a in ( S t r ing args[]) {
x = 0 ; /* erro r: 'x ' m u s t b e s ta t ic o r referen ced u s in g cla s s in s ta n ce */
m e th o d 1 ( ) ; /* erro r : 'm e thod1 ' m u st b e static or referenced w ith a c lass in s tance */
}
}
下 面 的
例 子 说 明 了 引 用 非 静 态 成 员 字 段 或 方 法 的 正 确 方 法
p u b lic c la ss S im p le {
p r iv a te in t x ; / / a cces s lev e l o f m em b er d o es n o t m a t ter p u b lic v o id m e th o d 1 ( ){
/ / D o s o m e th in g h ere
}
p u b lic static void m a in ( S t r ing args[]) {
/ / C rea te a n in s ta n ce o f th e 'S im p le ' cla s s S im p le s m p = n ew S im p le ( ) ;
s m p .x = 0 ; // v a lid referen ce to field
sm p .m e thod 1 ( ) ; / / valid ca ll to m e th o d
}
}
编 译 器 错 误 J0 0 6 0
In v a l id fo rw a r d refer en ce to m e m b er ' id en t i f ier ' 前 面 对 成 员
id
e n tifie r 的 引 用 无 效
编
译 器 检 测 到 程 序 试 图 使 用 其 他 还 未 定 义 的 变 量 来 初 始 化
某 个 变 量 要避 免 这 种 情 况 的 发 生 应 该 改 变 字 段 声 明 的 顺
序 首 先 定 义 要 引 用 的 变量
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le {
p riv a te s ta tic in t i = j;
// erro r: 'j' n o t yet d efin ed p riv a te s ta tic in t j = 0 ;
}
下
面 的 例 子 显 示 了 正 确 的 方 法 来 使 用 在 同 一 个 类 中 的 其 他
字 段 初 始 化一 个 字 段
p u b lic c la s s S im p le {
p riv a te s ta tic in t j = 0 ; / / f ie ld is in s ta n t ia ted a n d p o p u la ted p r iv a te s ta t ic in t i = j; // w ith 'j' p ro p erly s e t , 'i' ca n b e s e t
}
编 译 器 错 误 J0 0 6 1
T h e m e m b ers ' ide n t if ier' a n d ' id en t i f ier' d i f fer in re tu r n ty p e o n ly 成 员
id
e n tifie r 与 id e n tifie r 的 返 回 类 型 不 同
编
译 器 检 测 到 一 个 子 类 方 法 试 图 重 载 一 个 基 类 方 法 但 是 这
些 方 法的 返 回 类 型 不 同 在 Ja va 中 重 载 的 方 法 必 须 通 过 唯
一 的 签 名 来 区 别唯 一 的 签 名 由 方 法 名 数 字 和 它 的 参 数 位
置 和 返 回 类 型 组 成
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le e x te n d s S im p le 2 {
p u b lic v o id m e th o d 1 ( ) {
// erro r: o n ly retu rn ty p e d iffers
}
}
c las s S im p le 2 {
p u b lic in t m e thod1 ( ) {
re tu rn 1 ;
}
}
编 译 器 错 误 J0 0 6 2
A t te m p t to red u ce a c cess le v e l o f m e m b er ' id en t i f ie r ' 试 图 还 原 成 员
id
e n tifie r 的 访 问 级 别
编
译 器 在 被 编 译 的 类 中 检 测 到 一 个 重 载 的 方 法 它 降 低 了 基
类 方 法 的 访问 级 别 方 法 的 基 类 访 问 修 饰 符 必 须 由 想 要 重
载 该 方 法 的 所 有 派 生 类 进行 维 护
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ){
/ / D o s o m e th in g h ere
}
}
c las s S im p le 2 ex te n d s S im p le {
p riv a te v o id m e th o d 1 ( ){
/* erro r: ca n n o t ch a n g e a cces s lev e l o f a m e th o d w h en ov erriding a b a se c lass’ s m e thod. */
}
}
编 译 器 错 误 J0 0 6 3
D ecla r e th e cla ss a b s tr a c t , o r im p le m en t a b s tr a ct m e m b e r ' id e n t i f ie r ' 声明 类 ab s tr a c t 或 实 现 ab s tr a c t 成 员 id e n tifie r
编
译 器 检 测 到 一 个 ab s t ra c t 方 法 在 类 超 类 或 实 现 接 口 中
定 义 但 是 该方 法 从 不 实 现 当 类 实 现 一 个 接 口 或 展 开 包 含
ab s t ra c t 方 法 定 义 的 类
但
该 类 从 不 实 现 ab s t ra c t 方 法 时 通 常 出 现 该 错 误 当 类 定
义 一 个 ab s t ra c t 方 法 但 类 没 有 定 义 的 ab s t ra c t 修 改 符
时 也 会 出 现 该 错 误 确 保 类 已经 实 现 了 任 何 ab s t ra c t 方 法
并 且 再 次 编 译
下 面 举
例 说 明 该 错 误
in te r face IT est{
p u b lic ab stra c t void m e th od1 ( ) ;
}
p u b lic c la s s S im p le im p lem en ts IT es t{
/ / D o som e th in g m ean ingful h ere
/ / erro r : th e ab s t ra c t m e th od defined in 'IT est' is n ev er im p lem en ted
}
编 译 器 错 误 J0 0 6 5
C a n n o t a ssig n to th is e x p r e ss io n 不 能 赋 值 到 该 表 达 式
编
辑 器 在 lv a lu e 赋 值 的 通 常 位 置 上 检 测 到 一 个 表 达 式 当 给
表 达 式 指 定一 个 值 但 是 该 表 达 式 不 可 能 赋 这 个 值 时 通 常
发 生 该 错 误
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ) {
in t x = 0 ;
in t y = 0 ;
x + + = y; // e r ro r : '+ + ' n o t v a l id
}
}
编 译 器 错 误 J0 0 6 6
'th is ' c a n o n ly b e u se d in n o n - s ta t ic m e th o d s th is 不 能 用 在 非 静 态 方 法中
编
译 器 在 类 或 静 态
方 法 中 检 测 到 关 键 字 th is 的 使 用 类 方 法 不 传 递隐 含 的 th
is 引 用 同 样 它 们 不 能 引 用 实 例 非 静 态
变 量 或 方 法
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le {
in t x ;
pub lic s ta t ic v o id m e thod1() {
th is .x = 1 2 ; / / erro r: th is in s ta n ce s p ecific
}
}
编 译 器 错 误 J0 0 6 7
C o n n o t co n v er t ' ty p e ' to ' ty p e' 不 能 从 类 型 转 换 到 类 型
编
译 器 检 测 到 变 量 类 型 的 使 用 超 出 当 前 上 下 文 同 样 编 译 器
不 能 隐 式将 该 结 果 转 换 为 任 何 有 意 义 的 数 值 将 试 图 使 用
的 值 转 换 为 方 法 或 字 段所 需 要 的 数 值 然 后 再 编 译
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ) {
in t i = 1 0 ;
if (i--) {
/ / erro r : condition al need s ex p ression
/ / or b oolea n f ie ld
}
}
}
编 译 器 错 误 J0 0 6 8
C a n n o t im p l ic itly c o n v e r t 'ty p e ' to 'ty p e ' 不 能 隐 式 地 从 类 型 转 换到 类 型
编
译 器 由 于 没 有 明 确 的 类 型 转 换 typ e cast
而 不 能 转 换 指 定 的 变 量当 将 数 字 字 段 赋 予 非 数 字 的 数 据
类 型 时 通 常 出 现 该 错 误 使 用 类 型 转换 将 数 据 类 型 转 换 到
适 当 的 数 据 类 型 然 后 再 次 编 译
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le {
in t i = 1 0 ;
pub lic v o id m e thod1() {
ch a r c = i; / / erro r : ex p ected typ e ch a r
ch a r c = ( ch a r ) i; / / th is is th e co r rect a s s ig n m en t s ta tem en t
}
}
编 译 器 错 误 J0 0 6 9
C o n n o t a pply ' .' o p e r a to r to a n o p er a n d o f ty pe ' ide n t i f ie r'
编
译 器 检 测 到 . 运 算 符 应 用 到 无 效 的 类 型 当 无 效 的 方 法 调
用 是 由 固有 的 数 据 类 型 生 成 时 通 常 出 现 该 错 误 要 确 保 方
法 调 用 是 使 用 正 确 的对 象 然 后 再 次 编 译
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le { in t i = 1 2 3 ;
in t j = i.len g th ; //erro r : 'i' n o t a n a r ra y
}
编 译 器 错 误 J0 0 7 2
' ide n t i f ier' is n o t a m e m b er o f cla ss ' id en t i f ier'
编
译 器 检 测 到 一 个 方 法 调 用 但 是 该 方 法 未 被 定 义 当 方 法 名
拼 写 错 或是 在 适 当 的 作 用 域 中 找 不 到 时 通 常 出 现 该 错 误
当 方 法 不 存 在 时 也会 出 现 该 错 误 确 保 尝 试 引 用 的 方 法 在
指 定 的 类 中 存 在 并 且 再 次 编 译下 面 举 例 说 明 该 错 误
p u b lic c la ss S im p le {
p u b lic static void m a in ( S t r ing args[]) { S y s tem .o u t.p r in tlin e(" H e llo ")
/ / erro r : 'p r intline' shoule b e 'p r intln '
}
}
编 译 器 错 误 J0 0 7 4
O p e r a to r c a n n o t be a p plie d to ' id e n t i f ier ' a n d ' ide n t i f ie r ' v a lu e s
编
译 器 检 测 到 不 能 被 正 确 地 应 用 于 在 错 误 信 息 中 表 示 标 识
符 的 运 算 符当 两 个 字 段 为 非 数 字 时 以 及 运 算 符 应 用 于 适
用 于 字 段 中 的 数 字 时 通常 出 现 该 错 误
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ) {
S tr in g s 1 = " o n e ";
S t r in g s 2 = " tw o " ; S t r in g res u lt ;
re su l t = s 1 * s 2 ; // e rro r: in v a l id o p e ra n d s
}
}
编 译 器 错 误 J0 0 7 5
In va lid c a l l 无 效 调 用
编
译 器 检 测 到 方 法 调 用 的 句 法 但 标 识 符 表 示 了 一 个 无 效 的
方 法 名 当方 法 名 拼 写 错 误 或 包 含 有 Ja va 语 言 命 名 约 定 中
不 认 识 的 字 符 时 通 常 发生 该 错 误
下 面 举
例 说 明 该 错 误
c lass S im p le { in t x = l();
/ / erro r : 'i( ) ' is not a valid m e th od nam e
}
编 译 错 误 J0 0 7 6
T o o m a n y a r g u m e n ts fo r m e th o d ' id e n t i f ie r '
编
译 器 检 测 一 个 已 知 的 方 法 调 用 但 该 调 用 包 含 的 参 数 比 需
要 的 要 多检 查 用 于 试 图 调 用 方 法 的 参 数 数 量 并 且 从 调 用
中 删 除 额 外 的 参 数下 面 举 例 说 明 该 错 误
p u b lic c la ss S im p le {
p u b lic vo id m e thod 1 ( in t arg1 ) {
// d o so m e th in g m e a n in g fu l
}
pub lic v o id m e thod2() {
m e th od 1 ( 1 ,2 ) ; / / erro r : T o o m a n y a rgu m en t s
}
}
编 译 错 误 J0 0 7 7
N o t e n o u g h a r g u m e n ts fo r m e th o d ' id e n tifie r '
编
译 器 检 测 一 个 已 知 的 方 法 调 用 但 该 调 用 包 含 的 参 数 比 需
要 的 要 少
当
一 个 或 多 个 参 数 从 调 用 中 意 外 丢 失 时 通 常 会 出 现 该 错
误下 面 举 例 说 明 该 错 误
p u b lic c la ss S im p le {
p u b lic vo id m e thod 1 ( in t arg1 ) {
/ / do som e th ing m eanin gfu l
}
pub lic v o id m e thod2() {
m eth o d 1 (); // erro r: T o o few a rg u m en t s
}
}
编 译 器 错 误 J0 0 7 8
C la ss ' id e n tifie r ' d o e s n ' t h a v e a m e th o d th a t m a tc h e s ' id e n tifie r '
编
译 器 检 测 到 在 一 类 中 到 已 知 重 载 方 法 的 调 用 但 是 使 用 正
确 的 参 数 数量 不 能 检 测 到 匹 配 的 方 法 确 保 该 重 载 方 法 调
用 有 正 确 的 参 数 数 量 和 类型 并 且 再 次 编 译
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ) {
/ / do som e th ing m eanin gfu l
}
pub lic v o id m e thod1( in t a rg 1 ) {
/ / do som e th ing m eanin gfu l
}
}
c las s S im p le 2 {
p u b lic v o id m e th o d 1 ( ) {
S im p le s = n e w S im p le ( ) ;
s .m e th o d 1( 1 ,2 ,3);, / / erro r : to o m a n y a rg u m en t s
}
}
编 译 器 错 误 J0 0 7 9
A m b ig u ity b e tw e e n ' id e n tifie r ' a n d ' id e n tifie r '
编
译 器 不 能 确 定 要 实 现 的 正 确 方 法 当 两 个 重 载 方 法 具 有 相
关 的 参 数 列表 并 且 方 法 调 用 不 能 区 分 这 两 个 方 法 时 通 常
出 现 该 错 误 确 保 方 法调 用 没 有 使 用 与 其 他 重 载 方 法 有 冲
突 的 参 数 避 免 该 错 误 的 另 外 一 种 方法 就 是 改 变 这 两 个 重
载 方 法 的 参 数 列 表 这 样 它 们 就 有 不 同 的 参 数 数 量
和
唯 一 定 义 的 参 数 类 型下 面 举 例 说 明 该 错 误
p u b lic c la ss S im p le {
s ta tic v o id m e th o d 1 ( S im p le 2 s 2 , S im p le 3 s 3 ) {
/ / do som e th ing m eanin gfu l
}
s ta tic v o id m e th o d 1 ( S im p le 3 s 3 , S im p le 2 s 2 ) {
/ / do som e th ing m eanin gfu l
}
p u b l ic s ta t ic v o id m a in (S tr in g a rg s []) {
S im p le 2 s 2 = n ew S im p le 2 ( ) ; m e th o d 1 ( s 2 , s 2 ) ;
/ / erro r : A m b iguity b e tw een S im p le 2 and S im p le 3
}
}
c la s s S im p le 2 e x te nds S im p le 3 {
/ / d o som eghing m eaningful
}
c las s S im p le 3 {
/ / d o som e th in g m ean ingful
}
编 译 器 错 误 J0 0 8 0
V a lu e fo r a r g u m e n t ' id e n t if ier' ca n n o t b e co n v erte d fr o m ' id e n t if ier' in c a l l to ' id e n tifie r '
编
译 器 检 测 到 与 方 法 声 明 中 所 指 定 的 参 数 不 匹 配 的 方 法 参
数 当 数 字 字段 作 为 一 个 参 数 传 递 到 方 法 中 但 该 方 法 需 要
不 同 的 数 字 类 型 时 通 常出 现 该 错 误 要 传 递 不 同 的 数 字 类
型 到 方 法 的 参 数 将 传 递 到 方 法 的 字段 进 行 类 型 转 换
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le {
p u b lic vo id m e thod 1 ( in t arg1 ) {
/ / do som e th ing m eanin gfu l
}
pub lic v o id m e thod2(){
f lo a t f = 1 .0 f ;
m eth o d 1 ( f); / / ero r : ,m is m a tch ed ca ll typ es
}
}
下 面 举
例 说 明 如 何 避 免 该 错 误
p u b lic c la s s S im p le{
p u b lic vo id m e thod 1 ( in t arg1 ) {
/ / do som e th ing m eanin gfu l
}
pub lic v o id m e thod2(){
f lo a t f = 1 .0 f ;
m eth o d 1 ( in t) f ) ; // typ eca s t th e 'f lo a t ' to b e t rea ted a s a n 'in t '
}
}
编 译 器 错 误 J0 0 8 1
V a lu e fo r a r g u m e n t ' id e n t if ier' ca n n o t b e co n v erte d fr o m ' id e n t if ier' in c a l l to ' id e n tifie r '
编
译 器 检 测 到 调 用 到 位 于 不 同 类 文 件 中 的 类 的 方 法 但 是 不
能 将 所 提 供的 某 个 参 数 类 型 转 换 到 在 方 法 声 明 中 显 示 的
类 型 当 方 法 使 用 错 误 的 参
数
顺 序 调 用 方 法 或 调 用 错 误 的 方 法 时 通 常 发 生 该 错 误 检 查
在 错 误 信息 中 导 致 错 误 的 参 数 数 量 并 且 确 保 传 递 了 正 确
的 参 数 类 型
编 译 器 错 误 J0 0 8 2
C la ss ' id e n tifie r ' d o e s n ' t h a v e a c o n str u c to r th a t m a tc h e s ' id e n t if ie r '
编
译 器 检 测 不 到 与 调 用 标 识 符 匹 配 的 构 造 器 当 使 用 错 误 的
参 数 数 量 调用 构 造 器 时 通 常 发 生 该 错 误 确 保 含 有 构 造 器
的 类 与 所 试 图 调 用 的 类相 匹 配 然 后 再 次 编 译
下 面 举
例 说 明 该 错 误
p u b lic c la ss S im p le {
S im p le(in t a rg 1 ) {
/ / do som e th ing m eanin gfu l
}
p u b l ic s ta t ic v o id m a in (S t r in g a rg s[]) {
S im p le s = n ew S im p le ( 1 2 ,1 3 ) ;
/ / erro r : too m a ny argum en ts
}
}
编 译 器 错 误 J0 0 8 3
' su p e r ()' o r ' th is()' m a y o n ly b e c a l le d w ith in a c o n str u c to r
编
译 器 检 测 到 在 构 造 器 之 外 使 用 supe r ( ) 或 th is() 关 键 字 关
键 字 supe r ( ) 用 于 调 用 一 个 超 类 构 造 器 而 关 键 字 th is() 用
于 从 其 他 构 造 器 中 调 用 构 造器 在 基 类 中 引 用 方 法 用 户 必
须 使 用 关 键 字 supe r .
下 面 举
例 说 明 该 错 误
p u b lic c la s s S im p le {
p u b lic void m e thod1 ( ) {
sup er(); / / erro r : 's up er ' ca nnot b e ca lled
}
}
下 面 举
例 说 明 使 用 关 键 字 supe r . 在 基 类 中 引 用 方 法
c lass N o t S im p le{
pu b lic c la s s m eth o d 1(){
/ / do som e th ing here
}
}
p u b lic c la ss S im p le {
pu b lic m e th o d 2(){
s u p er.m eth o d 1 (); // co rrect w a y to ca ll a m eth o d o f a s u p ercla s s
}
}
编 译 器 错 误 J0 0 8 4
C a n n ot r e tu r n a v a lu e fr om a ' v oid ' m e th od
编
译 器 检 测 到 试 图 从 使 用 vo id 的 返 回 类 型 定 义 方 法 中 返 回
值下 面 举 例 说 明 该 错 误
p u b lic c la s s S im p le {
p u b lic v o id m e th o d 1 ( ) {
retu rn 1 ; / / erro r : ca n n o t retu rn a v a lu e
}
}
编 译 器 错 误 J0 0 8 5
E x p ected retu r n v a lu e o f ty p e ' id en t i f ier '
编 译 器
检 测 到 关 键 字 re tu rn 在 声 明 返 回 特 定 类 型 的 方 法 主 体 中
但 是
re
tu rn 没 有 关 联 的 值 没 有 关 联 值 的 re tu rn 语 句 将 不 会 返 回
默 认 值 并 且
因
此 必 须 指 定 一 个 有 效 的 返 回 值下 面 举 例 说 明 该 错 误
p u b lic c la s s s im p le {
p u b lic in t m e thod1 ( ) {
retu rn ; / / erro r : m u s t retu rn in t v a lu e
}
}
编 译 器 错 误 J0 0 8 6
'[]' c a n n o t b e a p p l ie d to a v a lu e o f ty p e ' id e n t if ie r '
编
译 器 检 测 使 用 非 数 组 类 型 使 用 数 组 括 号 如 果 想 要 使 用 某
字 段 作 为 数组 则 将 字 段 改 变 为 有 效 的 数 组 声 明 并 且 重 新
编 译
下 面 举
例 说 明 该 错 误
p u b lic c la s s S im p le {
p u b lic v o id m e th o d 1 ( ) { in t i = 0 ;
in t j, x ;
x = j[ i] ; / / erro r: 'j' n o t d ecla red a s a r ra y
}
}
编 译 器 错 误 J0 0 8 7
' g o to ' s tate m e n t is n o t c u r r e n t ly s u p p o r te d b y Java
关
键 字 go to 作 为 关 键 字 定 义 时 在 Ja va 语 言 中 不 能 实 现
编 译 器 错 误 J0 0 8 9
Th e c a s e ' id e n tifie r ' h a s a lrea d y b e e n d e f in e d in s w i tch s ta tem en t
编
译 器 发 现 在 同 一 个 sw i tc h 语 句 中 两 个 或 更 多 的 ca s e 语
句 使 用 相 同 的标 识 符 或 值
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic in t m e thod1 ( int arg1 ) {
s w i tc h ( a rg 1 ) {
ca s e 1 :
retu rn ( in t ) 1 ; ca s e 2 :
retu rn ( in t ) 2 :
ca s e 2 : / / erro r : d u p lica te o f a b o v e retu rn ( in t ) 3 :;
d efa u lt :
retu rn ( in t ) 0 ;
}
}
}
编 译 器 错 误 J0 0 9 0
' de fa u l t ' h a s a lrea d y b e e n d e f in e d in s w i tch s ta tem en t
编 译 器
发 现 在 同 一 个 sw i tc h 语 句 中 出 现 两 个 或 更 多 的 关 键 字 de
fa u lt
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic in t m e thod1 ( int arg1 ) {
s w i tc h ( a rg 1 ) {
ca s e 1 :
retu rn ( in t ) 1 ; ca s e 2 :
retu rn ( in t ) 2 ; d efa u lt :
retu rn ( in t ) 3 ;
defa ult: / / erro r : dup licate o f ab ove retu rn ( in t ) 0 ;
}
}
}
编 译 器 错 误 J0 0 9 1
' ca se ' o u ts id e o f s w i tch s ta tem en t
编 译 器
发 现 在 一 个 sw i tc h 语 句 作 用 域 外 使 用 关 键 字 ca s e
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
pub lic in t m e thod1 ( ) {
ca
s e 1 / / erro r:n o s w itch s ta tem en t retu rn 1
}
}
编 译 器 错 误 J0 0 9 2
C o n s ta n t ex p r e s s io n e x pe cted
编
译 器 发 现 需 要 一 个 常 数 值 的 表 达 式 使 用 了 非 常 数 值 通 常
在 一 个 ca s e 语 句 中 使 用 一 个 变 量 时 就 会 出 现 这 种 错 误 检
查 这 个 表 达 式 确 保 它使 用 了 一 个 常 数 值 然 后 再 次 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
in t v a r 1 = 10; in t v a r 2 = 20;
p u b lic v o id m e th o d 1 ( ){ s w itch ( v a r 1 ){
ca s e v a r 2 :
/ / erro r : ca nnot use variab le w ith ca s e
}
}
}
编 译 器 错 误 J0 0 9 3
' b rea k ' o n ly a llo w e d in lo o p s a n d sw itc h s ta te m e n ts
编
译 器 检 测 到 关 键 字 b reak 出 现 在 loop 或 sw i tc h 语 句 的 作 用
域 之 外下 面 举 例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ){ if ( t ru e)
b rea k ;
/ / erro r : b rea k allo w ed in loop s only
}
}
编 译 器 错 误 J0 0 9 4
la b e l ' id e n tifie r ' n o t fo u n d
编
译 器 检 测 到 与 关 键 字 c on tinue 或 b reak 有 关 的 标 号 名 存 在
但 是 没 有发 现 标 号 通 常 当 标 号 不 存 在 而 它 却 被 b reak 和 c
on tinue 语 句 引 用时 会 出 现 这 种 错 误 如 果 标 号 放 在 b reak 和
c on tinue 语 句 作 用 域 之 外这 种 错 误 也 可 能 出 现 b reak 和 c on
tinue 语 句 必 须 引 用 位 于 一 个 循 环 或 块之 前 的 标 号 确 保 b
reak 和 c on tinue 语 句 能 引 用 一 个 合 法 的 标 号 然 后再 次 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic in t m e thod1 ( ){ in t y;
fo r ( in t x = 0; x < 10 ; x+ + ){ y = x * 2 ;
if ( x = = 5 )
b rea k tes t ; / / erro r 't es t ' is n o t d efin ed a s a la b e l
}
retu rn y;
}
}
下
面 举 例 说 明 当 应 用 b reak 和 c on tinue 语 句 时 标 号 的 正 确 使
用
p u b lic c la s s S im p le{
p u b lic in t m e thod1 ( int arg1 ){ in t x ,y = 0 ;
tes t : / / la b el p reced es th e lo o p . if ( a rg 1 = 0 )
retu rn y;
fo r ( x = 1 ; x < 1 0 ; x + + ){ y = x * a rg 1 ;
if ( y < = a rg 1 ){ y = - 1 ;
b ra d k tes t ;
}
}
retu rn y;
}
}
编 译 器 错 误 J0 0 9 5
' co n t in u e ' o n ly a llo w e d in lo o p
编
译 器 检 测 到 试 图 在 一 个 循 环 之 外 的 作 用 域 内 应 用 关 键 字
c on tinue 通常 当 删 除 一 个 循 环 而 把 c on tinue 语 句 留 在 代 码
中 时 会 出 现 这 种 错 误删 除 循 环 之 外 的 所 有 c on tinue 语 句 再
次 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic vo id m e thod 1 ( in t arg1 ){ if ( a rg 1 = = 1 )
co n t in u e;
/ / erro r : continue o n ly allo w ed in lo op s. R em ove 'continue; '.
}
}
编 译 器 错 误 J0 0 9 6
C lass va lu e e x p e c te d
编
译 器 检 测 到 一 个 同 步 块 但 是 sync hron iz e d 语 句 应 用 到 一
个 非 法 类 型里 通 常 当 用 sync hron iz e d 语 句 使 用 一 个 除 了 类
对 象 实 例 以 外 的 标 识符 时 会 出 现 这 种 错 误
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ) { in t i;
s yn ch ro n iz ed (I){ / / erro r I m u s t res o lv e to a n o b ject referen ce
/ / D o s o m e th in g h ere
}
}
}
编 译 器 错 误 J0 0 9 7
' in s ta n c e o f ' o p era to r ex p e c ted c la ss o r a r r a y
编
译 器 检 测 到 in s ta n c e o f 运 算 符 应 用 的 类 型 不 是 类 或 数
组 in s ta n c e o f 运算 符 用 于 确 保 标 识 符 是 否 是 一 个 特 定
的 类 或 数 组 的 实 例 确 保 和
in s ta n
c e o f 运 算 符 一 起 使 用 的 in v a lu e 引 用 了 一 个 类 实 例 或
数 组 并 且
rv
a lu e 引 用 了 合 法 的 类 名 或 数 组 再 次 进 行 编 译下 面 举 例 说
明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ) {
S im p le 2 obj = ne w S im p le 2();
if ( o b j in s ta n ceo f in t) // erro r: 'in t ' is n o t a c la s s n a m e
/ / do som e th in g m ea n ingful
}
}
c las s S im p le 2 {
/ / d o som e th in g m ean ingful
}
编 译 器 错 误 J0 0 9 8
A tte m p to a c c e ss n o n - e x iste n t m e m b e r o f ' id e n t i f ie r '
编
译 器 检 测 到 指 定 的 一 个 数 组 成 员 但 是 不 能 标 识 它 通 常 当
试 图 引用 一 个 没 标 类 型 的 数 组 方 法 le n g th 时 会 出 现 这 种
错 误 当 在 一 个 对 象数 组 中 试 图 调 用 一 个 方 法 但 是 这 个 调
用 没 有 引 用 数 组 元 素 时 也 会 出
现 这 种
错 误
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ) {
S t r ing j [ ] = new S t r ing[ 1 0 ] ;
/ / in t ia liz e th e a r ra y elem en t s h ere S t r in g s t r = j.to U p p erC a s e();
// erro r: m is s in g a rra y b ra ck e ts ' []'
}
}
编 译 器 错 误 J0 1 0 0
ca n n o t th ro w ' id e n tifie r ' th e ty p e d o e s n o t in h e r i t fr o m ' Th r o w a b le '
编
译 器 在 th ro w 语 句 里 检 测 到 一 个 对 象 不 是 从 Th ro w a b le
类 里 继 承 的 当 一 个 th ro w 语 句 使 用 不 是 从 Th ro w a b le 类
里 继 承 的 类 时 往 往 会 出 现这 种 错 误 确 保 正 在 发 出 的 异 常
类 是 一 个 合 法 的 异 常 类
下 面 举
例 说 明 这 种 错 误
c las s B o g u s E x c ep t io n {
/ / D o som e th in g usefu l here
}
p u b lic c la ss S im p le {
p u b lic vo id m e thod 1 ( in t arg1 ) {
/ / D o s o m e th in g m ea n in g fu l if ( a rg 1 = = 0 ){
th ro w n ew B o g u s E x cep t io n ( ) ;
/ / erro r : B ogu s E x cep t ion is not a valid ex cep t ion c lass
}
}
}
编 译 器 错 误 J0 1 0 1
th e ty p e ' id e n tife r ' d o s n o t in h e r i t fr o m ' Th r o w a b le '
编
译 器 检 测 到 在 一 个 ca tc h 语 句 里 使 用 了 一 个 非 法 的 类 参
数 当 使 用 一个 ca tc h 语 句 处 理 异 常 时 必 须 用 从 Th ro w a b le
里 作 为 参 数 派 生 的 类 来 定义 它 确 保 为 ca tc h 语 句 定 义 的 类
是 从 Th ro w a b le 里 派 生 的 并 且 再 次 编译 它
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ) {
t ry {
/ / do som e th in g m ea n ingful
} ca tch ( S t r in g s ) {
/ / erro r : S t r in g n o t a s u b c la s s
/ / o f 'T h ro w a b le '
}
}
}
下 面 举
例 说 明 使 用 ca tc h 语 句 捕 获 异 常 的 正 确 方 式
p u b lic c la s s S im p le{
p u b lic vo id m e thod 1 ( in t arg1 ){ t ry{
/ / do som e th in g here if ( a rg 1 = = 0 )
th ro w new m y E x cep t ion ( ) ; / / th ro w a valid ex cep t ion ob ject
}
ca tch ( m y E x cep t io n c) { / / th is is a v a lid ex cep t io n o b ject to ca tch
/ / hand le ex cep t ion here
}
}
}
cla s s m y E x cep t io n ex ten d s T h ro w a b le{
/ / c la s s defin it ion g o es here
}
编 译 器 错 误 J0 1 0 2
ha n d le r fo r ' id e n tifie r ' h id d e n b y ea r lier h a n d le r fo r ' id e n t i f ie r '
编
译 器 检 测 到 一 个 永 远 不 能 实 现 的 异 常 处 理 程 序 因 为 较 早
的 处 理 程 序已 经 捕 获 到 这 个 异 常 当 用 错 误 的 顺 序 书 写 ca
tc h 语 句 时 往 往 会 出 现这 种 错 误
下 面 举
例 说 明 这 种 错 误
c las s S im p le {
s ta t ic
{
t ry
{
}
ca tch ( E x cep t io n e)
{
}
ca tch (A r ith m eticE x cep t io n e)
{
}
/ / erro r: a n y ex cep t io n s th is b lo ck
/ / co u ld hav e ca ught are already ca ught
/ / b y th e firs t ca tch s ta tem en t
}
}
编 译 器 错 误 J0 1 0 3
ca n n o t o v err id e f in a l m e th o d ' id e n tifie r '
编
译 器 检 测 到 一 个 类 方 法 试 图 超 越 它 的 一 个 基 类 方 法 而 这
个 基 类 方 法是 用 关 键 字 fin a l 声 明 的 用 fin a l 修 饰 符 定 义
的 方 法 不 能 被 派 生 类 取代
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le e x te n d s S im p le 2 {
p u b lic v o id m e th o d 1 ( ){
/ / erro r : 'm e thod1 ' f inal in sup ercla ss
}
}
c las s S im p le 2 {
p u b lic f in a l v o id m e th o d 1 ( ) {
/ / do som e th ing m eanin gfu l
}
}
编 译 器 错 误 J0 1 0 4
编
译 器 检 测 到 一 个 在 任 何 情 况 下 都 不 能 到 达 的 语 句 或 声 明
当 从 一 个 方法 里 调 用 一 个 re tu rn 语 句 而 代 码 放 在 re tu rn
语 句 后 面 时 往 往 会 出 现这 种 错 误 如 果 在 循 环 里 使 用 一 个 b
reak 语 句 而 循 环 里 没 有 任 何 流 控制 允 许 它 下 面 的 代 码 运 行
时 也 会 出 现 这 种 错 误
下 面 举
例 说 明 这 种 错 误
c las s S im p le {
p u b lic in t m e thod1 ( int arg1 ) { fo r ( in t y= 1 0 ; y < 1 0 ; y+ + ){
b rea k ;
in t z = y + 1 0 ; / / erro r :b rea k ca u s es th is lin e to n ev er b e ru n
}
/ / do som e th ing here retu rn a rg 1 ;
in t x = a rg 1 / 2 ;
/* erro r : th is lin e o f co d e ca nnot b e reached b eca u s e of retu rn sta tem en t */
}
}
编 译 器 错 误 J0 1 0 5
M e th o d ' id e n tifie r ' m u s t r e tur n a v a lue
编
译 器 检 测 到 包 含 除 了 vo id 以 外 返 回 类 型 的 方 法 声 明 但 是
在 方 法 主 体里 没 有 发 现 关 键 字 re tu rn 当 返 回 一 个 值 的 方
法 缺 少 合 法 的 re tu rn 语 句时 往 往 会 出 现 这 种 错 误 如 果 在
流 控 制 块 里 调 用 一 个 re tu rn 语 句 但是 由 于 方 法 逻 辑 而 总
是 不 能 访 问 这 个 re tu rn 语 句 时 也 可 能 会 出 现 这 种错 误
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic in t m e thod1 ( int arg1 ) { if ( a rg 1 = = 0 )
retu rn a rg 1 + 2 ;
} / / erro r :f low contro l p rohib its a v a lu e f rom alw a y s b e in g retu rn ed
}
编 译 器 错 误 J0 1 0 6
C la ss ' id e n tifie r ' h a s a circ u la r d e p e n d en cy
编
译 器 检 测 到 两 个 或 更 多 的 类 直 接 或 间 接 地 试 图 彼 此 再 分
类 当 两 个 类彼 此 扩 展 时 往 往 会 出 现 这 种 错 误 一 个 类 应 充
当 其 他 类 的 基 类
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le e x te n d s S im p le 2 {
// erro r: ex ten d in g 'S im p le 2 '
}
c las s S im p le 2 ex te n d s S im p le {
/ / erro r : a ls o ex ten d in g 'S im p le'
}
编 译 器 错 误 J0 1 0 7
M issing a r r a y d im e nsio n
编
译 器 检 测 到 一 个 数 组 的 初 始 化 但 是 没 有 检 测 到 一 个 合 法
的 数 组 维数 当 定 义 一 个 数 组 但 是 没 有 定 义 数 组 的 维 数 时
往 往 会 出 现 这 种 错 误为 使 用 一 个 数 组 必 须 定 义 所 有 的 维
数
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ) {
in t [][] I = n e w in t [] [1 2 ] ;
// erro r: m is s in g firs t a r ra y d im en s io n
}
}
编 译 器 错 误 J0 1 0 8
ca n n o t ' ne w ' an in s tan c e o f ty p e ' id e n tifie r '
编
译 器 检 测 到 试 图 声 明 一 个 不 需 要 使 用 关 键 字 ne w 的 数 据
类 型 当 试 图开 始 使 用 带 有 固 有 数 据 类 型 的 关 键 字 ne w 而 声
明 不 是 数 组 时 往 往 会出 现 这 种 错 误 确 保 声 明 的 成 员 没 有
使 用 关 键 字 ne w 除 非 它 是 一 个 类对 象 或 者 是 数 组 声 明
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ) {
S t r ing m y S t r ing = new S t r ing ( ) ; /* usage O K s ince it is a c lass ob ject*/ in t x [ ] = n ew in t [ 1 0 ] ; / / usage of new h ere is O K
in t i = n ew in t ( 5 ) ;
/ / erro r: ca n n o t u s e 'n ew ' o n 'in t ' ty p es
}
}
编 译 器 错 误 J0 1 0 9
C a n n o t ' n e w ' a n in s ta n ce o f a b s tra ct cla ss ' id en t i f ier'
编 译 器
检 测 到 试 图 实 例 化 一 个 声 明 为 ab s t ra c t 的 类 对 象 声 明
为 ab s t ra c t
的
类 不 能 实 例 化 它 只 作 为 其 他 获 取 类 的 基 类 而 存 在下 面 举
例 说 明 这 种 错 误
a b s t ra ct cla ss S im p le 2 {
/ / d o som e th in g m ean ingful
}
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ) {
S im p le 2 s 2 O b je c t = n e w S im p le 2 ( ) ;
/ / erro r: cla s s 'S im p le2 ' d ecla red a s a b s t ra ct
}
}
编 译 器 错 误 J0 1 1 0
C a n n o t ' n e w ' a n in te r fa c e 'id e n tifie r '
编
译 器 检 测 到 试 图 实 例 化 声 明 为 ab s t ra c t 的 接 口 对 象 接
口 只 能 通 过 一个 类 来 实 现 所 以 不 能 用 类 的 方 式 来 实 例 化
注
意 默 认 情 况 下 接 口 是 默 认 的 不 管 在 声 明 里 是 否 使 用 了
关 键字 abstract
下 面 举
例 说 明 这 种 错 误
in te r face S im p le 2 {
/ / d o som e th in g m ean ingful
}
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ) {
S im p le 2 s 2 O b je c t = n e w S im p le 2 ( ) ;
/ / erro r: in terfa ce S im p le 2 is a b s t ra ct
}
}
编 译 器 错 误 J0 1 1 1
In v a l id u s e o f a r r a y in itia liz e r
编
译 器 检 测 到 试 图 初 始 化 一 个 数 组 , 但 是 初 始 化 语 句 句 法
不 正 确 数 组 可以 在 声 明 里 用 初 始 设 定 值 来 初 始 化 当 试 图
用 不 正 确 的 大 括 号 数 和 逗 号数 以 及 不 正 确 的 大 括 号 位 置
和 逗 号 位 置 初 始 化 一 个 数 组 时 往 往 会 出 现这 种 错 误 确 保
初 始 化 数 组 的 语 法 正 确 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ) {
in t [ ] i = { { 1 ,2 ,3 } , { 4 ,5 ,6 ,} } ;
/ / erro r : " i" delcared fo r only one dim ensio n
}
}
下 面 举
例 说 明 数 组 初 始 化 的 正 确 句 法
p u b lic c la s s S im p le{
p u b lic v o id m e th o d 1 ( ){
in t [ ] i = ( 1 ,2 ,3 ,4 ,5 ,6 ) ; / / s in g le d im en s io n in itia liz a t io n
in t [ ] [ ] x = { { 1 ,2 ,3 } ,{ 4 ,5 ,6 } } ; / / m u lti- d im en s io n in itia liz a tio n
}
}
编 译 器 错 误 J0 1 1 2
C a n n o t a ssig n f in a l v a r ia b le 'id e n t i f ie r '
编
译 器 检 测 到 试 图 改 变 声 明 为 fin a l 的 字 段 的 值 一 个 声 明
为 fin a l 的 字段 一 旦 用 声 明 里 的 值 或 一 个 实 例 初 始 值 或 构
造 器 初 始 化 时 这 个 字 段 不能 再 赋 一 个 值
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p riv a te f in a l in t i = 3 ;
pub lic v o id m e thod1( in t a rg 1 ) {
i = a rg 1 ;
/ / erro r: v a r ia b le " i" d ecla red fin a l
}
}
编 译 器 错 误 J0 1 1 3
C a l l to c o n str u c to r m u s t b e fir s t s ta te m e n t in c o n str u c to r
编
译 器 检 测 到 从 第 二 个 构 造 器 主 体 里 调 用 的 构 造 器 但 是 构
造 器 调 用 没有 放 在 第 二 个 构 造 器 主 体 的 开 始 处 在 一 个 构
造 器 里 必 须 在 构 造 器 主体 代 码 的 第 一 行 调 用 另 一 个 构 造
器 确 保 构 造 器 调 用 位 于 构 造 器 主 体 代
码
的 第 一 行 再 次 进 行 编 译下 面 举 例 说 明 这 种 错 误
p u b lic c la ss S im p le {
in t i, j;
S im p le ( ) {
i = 0 ;
}
S im p le (in t a rg 1 ) {
j= a rg 1 ;
th is ( ) ; // erro r: ca ll to S im p le ( ) m u s t b e firs t
}
}
编 译 器 错 误 J0 1 1 4
C a n n o t r e fere n c e ' th is ' in co n s tr u c to r ca l l
编
译 器 检 测 到 在 一 个 构 造 器 里 不 恰 当 地 引 用 了 th is th is 语
句 在 构 造 器 里通 常 用 于 访 问 方 法 和 构 造 器 类 的 字 段 在 一
个 构 造 器 里 使 用 th is( th is ) 或supe r ( th is ) 将 导 致 这 种 错
误 出 现 因 为 类 实 例 还 没 有 创 建 所 以 不 能 传 递到 另 外 一 个
构 造 器
下 面 举
例 说 明 这 种 错 误
c las s S u p e r S im p le {
S u p erS im p le ( ) { }
S u p er S im p le(O b ject o ) { }
}
p u b lic c la ss S im p le e x te n d s S u p e r S im p le {
in t x ;
p u b lic S im p le ( )
{
th is( 1 0 ) ; // th is is O K ; c a lls a n o th e r c o n stru c to r
s u p er( th is ) ;
/ / erro r : ca nn ot p a ss th is to a sup er constructo r th is .x = 1 ; / / th is is O K
th is .m e th o d 1 ( ) ; / / th is is O K to o
}
p u b lic S im p le( in t a rg 1 ) {
th is .x = a rg 1 ; // th is is O K
}
p u b lic v o id m e th o d 1 ( ) { }
}
编 译 器 错 误 J0 1 1 5
C a n n o t c a l l co n s tr u c to r re cu r s iv ely ( d irec t ly o r in d ire ctly )
编
译 器 检 测 到 递 归 的 构 造 器 调 用 当 一 个 构 造 器 调 用 相 同 的
构 造 器 时 往 往 会 出 现 这 种 错 误 如 果 一 个 构 造 器 调 用 第 二
个 构 造 器 而 第 二 个 构造 器 又 返 回 来 调 用 第 一 个 构 造 器 时
也 会 出 现 这 种 错 误
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
S im p le ( in t a rg 1 ) {
th is ( 1 ) ;
/ / erro r : co n s t ru c to r ca llin g its elf
}
}
编 译 器 错 误 J0 1 1 6
V a rib le ' id en t i f ier' m a y b e u sed b e fo r e in it ia l iz a t io n
编
译 器 检 测 到 试 图 在 变 量 正 确 初 始 化 之 前 使 用 这 个 变 量 为
了 在 赋 值 或表 达 式 中 使 用 一 个 变 量 必 须 给 这 个 变 量 指 定
一 个 值 在 构 造 器 里 或 字段 初 始 化 器 里 初 始 化 这 个 变 量 再
次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
s ta t ic
{
in t i;
in t j = i;
/ / erro r : " i" n o t yet in itia liz ed
}
}
编 译 器 错 误 J0 1 1 7
C a n n o t d e c la re a n in terfa c e o r o u ter cla ss to b e ' p riv a te '
编
译 器 检 测 到 在 外 部 类 或 接 口 声 明 中 使 用 了 修 饰 符 priv a te
这 个 修 饰 符只 能 通 过 字 段 方 法 和 内 部 类 声 明 来 使 用
下 面 举
例 说 明 这 种 错 误
p r iv a te c lass S im p le {
/ / erro r: a cla s s ca n n o t b e 'p riv a te '
}
编 译 器 错 误 J0 1 2 0
D iv ide o r m o d by z e r o
编
译 器 检 测 到 被 零 除 的 除 法 错 误下 面 举 例 说 明 这 种 错 误
p u b lic c la ss S im p le { f ina l in t x= 0;
in t y= 1 % x ;
// erro r: x ca n n o t b e 0
}
编 译 器 错 误 J0 1 2 1
U n a b le to r eco v e r fr o m p rev io u s e rro r( s )
编
译 器 遇 到 一 系 列 错 误 不 能 继 续 可 靠 地 处 理 文 件 确 保 所 有
错 误 都 已经 消 除 再 次 进 行 编 译
编 译 器 错 误 J0 1 2 2
E x cep t io n ' id en t i fe r ' n o t c a u g h t o r d ec la red b y ' id e n t i f ie r '
编
译 器 检 测 到 发 出 的 异 常 但 是 在 这 个 异 常 类 里 从 来 都 没 有
捕 捉 到 这 个异 常 当 一 个 方 法 调 用 声 明 为 发 出 异 常 的 另 外
一 个 方 法 时 往 往 会 出 现这 种 错 误 为 了 使 一 个 方 法 能 调 用
发 出 异 常 的 另 外 一 个 方 法 这 个 方 法必 须 声 明 为 发 出 异 常
或 者 使 用 一 个 t ry/ca tch 组 合 处 理 错 误
下 面 举
例 说 明 这 种 错 误
c la s s S im p le E x c e p tion e x te nds E x c e p t ion {
/ / d o som e th in g m ean ingful
}
c las s S im p le {
void m e th od1 ( ) th ro w s S im p le E x cep t ion { } void m e th od2 ( ) { m ethod1 ( ) ; }
/ / erro r : ex cep t io n n o t d ecla red fo r m e th o d 2
}
下 面 举
例 说 明 如 何 调 用 声 明 为 发 出 异 常 的 方 法
/* T h is ex am p le illu stra tes hand lin g b y declarin g th e other m e thod a s th ro w in g a n ex cep t io n d u p lica te to th e m e th o d it is ca llin g .*/
cla s s S im p le E x cep t io n ex ten d s E x cep t io n {
// d o s o m eth in g h ere
}
p u b lic c la ss S im p le {
void m e th od1 ( ) th ro w s S im p le E x cep t ion{
/ / do som e th ing here
}
void m e th od2 ( ) th ro w s S im p le E x cep t ion{
m e th o d 1 ( ) ; / / ca ller o f m e th o d 2 n o w is fo rced to h a n d le ex cep t io n
}
}
/* T h is ex a m p le illu s tra tes h a n d lin g th e ex cep t io n u s in g a t ry/ ca tch co m b in a t io n .* / ca ls s S im p le E x cep t io n ex ten d s E x cep t io n {
// d o s o m eth in g h ere
}
p u b lic c la ss S im p le {
void m e th od1 ( ) th ro w s S im p le E x cep t ion{
/ / do som e th ing here
}
void m e th od2 ( ){ t ry{
m e th o d 1 ( ) ;
}
ca tch ( S im p le E x cep t io n e){
/ / hand le ex cep t ion here
}
}
}
编 译 器 错 误 J0 1 2 3
M u t ip le in h e rita n ce o f c la s se s is n o t su p p o rted
编
译 器 检 测 到 一 个 类 试 图 把 关 键 字 e x te nds 应 用 到 一 个 以
上 的 基 类 中 在 其 他 语 言 中 这 可 以 定 义 成 多 重 继 承 而 Ja va
语 言 不 支 持 类 的 多 重 继承
下 面 举
例 说 明 这 种 错 误
p u b lic lc a ss S im p le e x te n d s B a se C la ss 1 , B a s e C la ss 2 {
/ / erro r : m u lt ip le inherita n ce not su p p o r ted in Java
}
c la s s B a se C la ss1 {
/ / d o som e th in g m ean ingful
}
c la s s B a se C la ss2 {
/ / d o som e th in g m ean ingful
}
编 译 器 错 误 J0 1 2 4
O p e r a to r c a n n o t b e a p p l ie d to ' id e n tifie r ' v a lu e s
编
译 器 检 测 到 一 个 运 算 符 应 用 到 它 不 能 使 用 的 类 型 中 确 保
正 试 图 使 用的 运 算 符 的 变 量 类 型 或 对 象 是 合 法 的 再 次 进
行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
void m e th od1 ( b o o lean b ) {
b + + ;
/* erro r: p o s t in crem en t o p era to r ca n n o t b e a p p lied to b o o lea n v a r ia b les */
}
}
编 译 器 错 误 J0 1 2 5
' fin a lly ' b lo c k u s e d w i th o u t ' tr y ' s ta te m e n t
编
译 器 检 测 到 一 个 fin a l ly 块 但 是 没 有 发 现 相 应 的 try 语 句
一 个 fin a l ly
块
用 于 实 现 一 个 try 语 句 后 面 的 代 码 而 不 管 try 语 句 的 结 果下
面 举 例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ) {
f in a l ly {
/ / erro r : m is s in g co rres p o n d in g t ry s ta tem en t
}
}
}
下 面 举
例 说 明 fin a l ly 块 的 正 确 使 用
p u b lic c la s s S im p le{
pub lic in t m e thod1 ( int a rg 1 ) {
t ry{
a rg 1 / 1 0 ;
}
ca tch ( E x cep t io n e){
/ / hand le ex cep t ion here; m u st co m e b efo re 'f in ally'
}
f in a lly{
/ / do so m e th ing h ere; th is sectio n is run regard less of 't ry '
}
}
}
编 译 器 错 误 J0 1 2 6
' c a tc h ' b lo c k u sed w i th o u t ' try ' s ta tem en t
编
译 器 检 测 到 一 个 ca tc h 语 句 但 是 没 有 发 现 相 应 的 try 语 句
为 了 使 用一 个 ca tc h 语 句 , 必 须 在 它 之 前 有 一 个 try 语 句 确
保 在 ca tc h 语 句 之 前 有一 个 合 法 的 try 语 句 , 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ) {
c a tc h {
/ / erro r: m is s in g co rres p o n d in g t ry s ta tem en t
}
}
}
下 面 举
例 说 明 ca tc h 块 的 正 确 使 用
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ) { t ry{
/ / d o s o m e th in g h ere
}
ca tch ( E x cep t io n e){
/ / h a n d le ex cep t io n s fro m t ry s ta tem en t h ere
}
}
}
编 译 器 错 误 J0 1 2 7
'e ls e ' k e y w o r d u se d w i th o u t 'if' s ta te m e n t
编
译 器 检 测 到 关 键 字 e ls e 但 是 没 有 发 现 相 应 的 if 语 句 当 程
序 中 有 e ls e 语 句 位 置 的 作 用 域 问 题 时 往 往 会 出 现 这 种 错
误 如 果 缺 少 与 e ls e 语 句相 匹 配 的 if 语 句 时 也 会 出 现 这 种
错 误
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic vo id m e thod 1 ( in t arg1 ) { if ( a rg 1 = = 0 ){
/ / D o s o m e th in g h ere e ls e{ }
/ / erro r 'e ls e ' is in side of th e 'if ' b lock in s tea d of outside
}
}
}
编 译 器 错 误 J0 1 2 8
C a n n o t d e c lar e an in te r fac e to b e ' f in a l'
编
译 器 检 测 到 使 用 关 键 字 fin a l 声 明 的 一 个 接 口 接 口 不 能
定 义 为 fin a l 所 以 不 能 使 用 fin a l 修 饰 符 从 接 口 声 明 中 删
除 关 键 字 fin a l 再 次 进 行 编译
下 面 举
例 说 明 这 种 错 误
f in a l in te r fa c e S im p le {
/* erro r : 'fin a l' o n ly a p p lies
to c lasses , m e th ods,o r variab les*/
}
编 译 器 错 误 J0 1 2 9
C a n n o t de cla r e a c la s s to be ' ide n t i f ie r' a n d ' ide n t if ie r '
编
译 器 检 测 到 使 用 修 饰 符 声 明 的 一 个 类 不 能 组 合 确 保 应 用
到 类 里 的 修饰 符 彼 此 没 有 冲 突 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
pub lic a b s t ra c t f ina l c la ss S im p le {
/* erro r : 'a b s t ract' an d 'f in al' ca nno t
b e used to g e th er in a class d eclaration */
}
编 译 器 错 误 J0 1 3 0
C a n n o t d e c la re a n in terfa c e m e th o d to b e ' n a t iv e ' , ' s ta t ic ', ' s y n ch ro n iz e d ' o r 'fin a l '
编 译 器
检 测 到 在 接 口 方 法 声 明 中 使 用 了 错 误 信 息 里 显 示 的 关 键
字 之 一
因 为 一
个 接 口 方 法 没 有 实 现 代 码 它 不 能 声 明 为 n a tiv e ,s ta tic ,
syn c h ro n iz e d
或 fin a
l
下 面 举
例 说 明 这 种 错 误
in te r face S im p le {
pub lic f ina l v o id m e thod 1();
/* erro r : 'm ethod1 ' ca nnot b e declared
as f inal in an in terface*/
}
编 译 器 错 误 J0 1 3 1
C a n n ot d e c la r e a m e th od to b e ' id e n tifie r ' an d ' id e n tifie r '
编
译 器 检 测 到 在 一 个 方 法 声 明 中 使 用 了 两 个 或 更 多 的 不 一
致 的 修 饰 符当 使 用 两 个 访 问 修 饰 符 如 pub lic 和 priv a te 定
义 一 个 方 法 时 往 往 会 出 现这 种 错 误 确 保 这 个 方 法 的 修 饰
符 彼 此 不 冲 突 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la s s S im p le {
p u b lic p r iv ate void m e thod1 ( ) {
/ / erro r : m odifiers 'p ub lic ' and 'p r ivate'
/ / ca n n o t b e co m b in ed in a d ecla ra t io n
}
}
编 译 器 错 误 J0 1 3 2
C a n n o t de cla r e a f ield to b e ' id e n tifie ' an d ' id e n t i f ie r '
编
译 器 检 测 到 在 一 个 变 量 声 明 中 使 用 了 两 个 或 更 多 的 不 一
致 的 修 饰 符当 使 用 两 个 访 问 修 饰 符 如 pub lic 和 priv a te 定
义 一 个 字 段 时 往 往 会 出 现这 种 错 误 确 保 这 个 字 段 的 修 饰
器 彼 此 不 冲 突 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la s s S im p le {
p u b lic p riv a te in t i;
/ / erro r : m odifiers 'p ub lic ' and 'p r iv a te '
/ / ca n n o t b e co m b in ed in a d ecla ra t io n
}
编 译 器 错 误 J0 1 3 3
C o n s tr u c to rs ca n n o t b e de cla r e d ' n a t iv e ', ' s ta t ic ', ' sy n ch ro n iz e d ' o r 'fin a l '
编
译 器 检 测 到 在 一 个 构 造 器 声 明 中 使 用 了 上 面 显 示 的 修 饰
符 之 一 确 保这 个 构 造 器 没 有 使 用 错 误 信 息 中 提 到 的 任 何
一 个 修 饰 符 定 义 再 次 进 行编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
f in a l s im p le() { }
// erro r: co n s tru cto r s ca n n o t b e 'f in a l'
}
编 译 器 错 误 J0 1 3 4
In te rfa ces c a n n o t h a v e co n s tr u c to r s
编
译 器 检 测 到 一 个 包 含 构 造 器 声 明 的 接 口 因 为 一 个 接 口 不
能 实 例 化不 能 为 接 口 定 义 构 造 器 如 果 正 在 使 用 与 一 个 接
口 相 同 的 名 字 定 义 一 个方 法 确 保 它 有 一 个 与 构 造 器 声 明
中 不 同 的 相 应 修 饰 符
下 面 举
例 说 明 这 种 错 误
in terfa ce S im p le {
S im p le ( ) ;
/ / erro r : in terfa ces ca n n o t
/ / d ecla re co n s t ru c to rs
}
编 译 器 错 误 J0 1 3 5
In te rfa ce da ta m e m b er s ca n n o t be d ec la red ' tr a n s ie n t ' ' vo la t i le ' ' p r ivate '
or ' pr o te c te d '
编
译 器 检 测 到 在 一 个 接 口 成 员 变 量 的 声 明 中 使 用 了 上 面 显
示 的 修 饰 符 之一 因 为 接 口 是 公 共 的 并 且 不 能 实 例 化 所 以
这 些 修 饰 符 都 不 能 应 用而 只 应 该 通 过 类 来 使 用
下 面 举
例 说 明 这 种 错 误
in te r face S im p le {
v o la tile in t i= 1 ;
/ / erro r : 'v olatile' ca nnot b e used
}
编 译 器 错 误 J0 1 3 6
P u b lic c la ss ' id e n tifie r ' sh o u d n o t be de f in e d in ' id e n t i f ie r '
编
译 器 检 测 到 在 一 个 源 文 件 中 有 一 个 以 上 的 类 使 用 修 饰 符
pub lic 声 明 从 其 他 类 中 删 除 pub lic 访 问 修 饰 符 并 且 确 保 这
个 将 通 过 类 文 件 来 公 布的 类 声 明 为 pub lic 也 可 以 把 需 要 声
明 为 pub lic 的 类 移 到 它 们 自 己 的 源文 件 中 如 果 一 个 源 文 件
有 一 个 与 在 它 内 部 定 义 的 pub lic 类 不 同 的 名字 或 者 pub lic
类 与 源 文 件 万 一 不 匹 配 时 也 会 出 现 这 种 错 误 给 源 文件 改
名 或 把 源 文 件 内 部 定 义 的 pub lic 类 改 名 以 便 它 们 一 致 再
次 进 行 编译
下 面 举
例 说 明 这 种 错 误
p u b lic c la s s S im p le {
/ / d o som e th in g m eaningful
}
p u b lic c la s s E r ro rcla s s {
/ / erro r : only one c lass m a y b e defined as
// 'p u b lic ' w ith in th e s a m e s o u rce file
}
编 译 器 错 误 J0 1 3 8
In te r fac e c a n n o t h ave s tatic o r in s tan c e in it ia l iz e r
编
译 器 检 测 到 在 一 个 接 口 里 有 一 个 sta t ic 初 始 值 或 实 例 初
始 值 因 为 一个 接 口 没 有 获 得 实 例 化 不 能 在 一 个 接 口 里 定
义 初 始 值 为 设 置 接 口 字段 的 值 应 在 声 明 时 就 初 始 化 它 们
下 面 举
例 说 明 这 种 错 误
in terfa ce S im p le {
in t x = 1 0 ; // T h is is O K
{
/ / erro r : in it ia liz ers ca n n o t
/ / b e u s ed in in terfa ces
}
}
编 译 器 错 误 J0 1 3 9
In va lid la b e l
编
译 器 检 测 到 一 个 非 法 标 号 标 号 必 须 用 一 个 非 数 值 字 符 开
始 修 改 这个 标 号 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic in t m e thod1 ( int arg1 ) { 1 2 3 :
/ /
erro r : la b e l ca nno t b egin w ith a nu m b er. R e tu rn a rg 1
* 2
}
}
编 译 器 错 误 J0 1 4 0
C a n n ot ov e r r id e s ta t ic m e th od ' id e n tifie r ' w ith n o n - s ta t ic m e th o d
' id e n tifie r '
编
译 器 检 测 到 试 图 从 一 个 子 类 里 取 代 一 个 sta t ic 方 法 声 明
为 sta t ic 方 法不 能 被 取 代
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
s ta tic v o id m e th o d 1 ( ) { }
}
c la s s S im p le S u b c la s s e x te n d s S im p le {
void m e th od1 ( ) { }
/ / erro r : ca nnot overrid e
// s ta t ic m eth o d
}
编 译 器 错 误 J0 1 4 1
A r g u m e n t c a nn o t ha ve ty p e ' vo id '
编
译 器 检 测 到 一 个 定 义 为 vo id 类 型 的 方 法 自 变 量 vo id 类 型
只 能 用 于 把返 回 值 声 明 为 无 返 回 值 方 式 的 方 法 修 改 自 变
量 的 数 据 类 型 再 次 进 行编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic vo id m e thod 1 ( void i) {
/ / erro r : ty p e void ca n o n ly
/ / b e u s ed a s a retu rn v a lu e
}
}
编 译 器 错 误 J0 1 4 2
C a n n o t m a k e s ta t ic ca l l to a b s tra ct m e th o d ' id e n t i f ie r '
编
译 器 检 测 到 试 图 直 接 调 用 一 个 抽 象 方 法 定 义 抽 象 方 法 是
为 细 分 子 类实 现 的 方 法 提 供 一 个 定 义 所 以 ab s t ra c t 方 法
没 有 实 现 代 码 由 于 ab s t ra c t 方 法 缺 少 这 种 实 现 过 程 所
以 使 用 supe r 关 键 字 调 用 一 个 抽 象 方 法 是 非法 的
下 面 举
例 说 明 这 种 错 误
p u b l ic a b stra c t c la ss S im p le {
ab stra c t in t m ethod1 ( ) ;
}
c la s s S im p le S u b c la s s e x te n d s S im p le {
in t m eth o d 1 ( ) {
re tu rn s u p e r.m e th o d 1 ();
/ / erro r: ca n n o t ca ll a b s tra ct m eh to d
}
}
编 译 器 错 误 J0 1 4 3
C a n n o t th ro w ex c e p t io n ' id e n tifie r ' fr o m s ta tic in itia l iz e r
编
译 器 检 测 到 试 图 从 一 个 静 态 初 始 值 中 发 出 异 常 当 调 用 一
个 th ro w 语句 或 在 一 个 静 态 初 始 值 作 用 域 中 出 现 静 态 类 实
例 的 初 始 值 时 往 往 会 出现 这 种 错 误 为 了 在 一 个 静 态 初 始
值 中 捕 获 来 自 静 态 类 实 例 的 异 常 可以 联 合 使 用 t ry/ca tch
块
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
s ta t ic {
T h ro w C la s s T C la s s = n ew T h ro w C la s s ( ) ;
/ / erro r: ca n n o t th ro w ex cep t io n s
/ / w ith in s ta tic in it ia liz ers
}
}
c las s T h ro w C la s s {
T h ro w C la s s ( ) th ro w s E x cep t io n { }
}
下 面 举
例 说 明 在 一 个 静 态 初 始 值 中 初 试 化 静 态 类 实 例 时 如 何 联
合 使 用
t ry/ca
tch 块 捕 获 可 能 发 生 的 错 误
p u b lic c la ss S im p le {
s ta tic T h ro w C la s s th r ; s ta t ic{
t ry{
T h ro w C la s s th r = n ew T h ro w C la s s ( ) ;
}
ca tch ( E x cep t io n e){
/ / H a ndle erro rs h ere f rom in it ia lizatio n of 'T hrow C lass'
}
}
}
c las s T h ro w C la s s {
T h ro w C la s s ( ) th ro w s E x cep t io n ( ){
/ / D o s o m e th in g h ere
}
}
编 译 器 错 误 J0 1 4 4
C a n n o t fin d d e fin itio n fo r in te r fa c e ' id e n tifie r '
编
译 器 不 能 为 命 名 的 接 口 找 到 定 义 当 一 个 实 现 的 接 口 丢 失
或 拼 写 错 误时 往 往 会 出 现 这 种 错 误 检 查 正 在 实 现 的 接 口
的 位 置 和 名 字 再 次 进行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le im p le m e n ts B o g u s {
/ / erro r : th e in terfa ce 'B o g u s ' d o es n o t ex is t
}
编 译 器 错 误 J0 1 4 5
O u tp u t d irecto r y o r f i le to o lo n g : ' id e n tifie r '
保
存 的 输 出 目 录 或 源 文 件 的 长 度 超 过 228 个 字 符 缩 短 输 出 目
录 路 径 或源 文 件 的 长 度 再 次 进 行 编 译
编 译 器 错 误 J0 1 4 6
C a n n o t c rea te o u tp u t d ir ecto r y ' id e n tifie r '
不
能 创 建 输 出 目 录 当 不 允 许 在 指 定 的 驱 动 器 上 写 入 时 往 往
会 出 现 这种 错 误
编 译 器 错 误 J0 1 4 7
C a n n o t a cce s s pr iv a te m e m b e r ' id e n tifie r ' in c la ss ' id e n t i f ie r ' fr o m c la s s
' id e n tifie r '
编
译 器 检 测 到 试 图 非 法 访 问 包 含 在 另 一 个 类 里 的 局 部 成 员
局 部 类 成 员只 能 从 这 个 成 员 类 里 访 问 一 个 类 的 局 部 成 员
也 只 能 从 它 的 内 部 类 里 访问
下 面 举
例 说 明 这 种 错 误
c las s A c cess C la ss {
p r iv a te in t i = 0 ;
}
p u b lic c la s s S im p le {
pub lic v o id m e thod1() {
A ccessC la ss ac = new A ccessC la ss();
a c .i = 1 ;
/ / erro r: ca n n o t a cces s 'i'
}
}
编 译 器 错 误 J0 1 4 8
C a n n o t refe ren ce in s ta n ce m e th o d ' id e n t i f ie r ' b e fo re s u p e rc la s s co n s tr u c to r h a s b een ca l led
编
译 器 检 测 到 试 图 在 调 用 超 类 构 造 器 之 前 引 用 一 个 方 法 实
例 当 使 用supe r
语 句 在 一 个 子 类 构 造 器 中 调 用 一 个 基 类 方 法 时 往 往 会 出
现 这种 错 误 如 果 子 类 使 用 supe r
语 句 从 构 造 器 中 调 用 它 自 己 的 方 法 时也 会 出 现 这 种 错 误
这 种 错 误 出 现 的 原 因 是 调 用 构 造 器 的 同 时 子 类 和基 类 的
实 例 没 有 进 行 实 例 化 为 避 免 这 种 情 况 使 用 supe r . 语 句 调
用 一个 基 类 方 法 并 且 使 用 th is . 语 句 调 用 一 个 子 类 方 法
下 面 举
例 说 明 这 种 错 误
a b s t ra ct cla ss S im p le {
S im p le ( in t i) { }
in t m e th o d 1 ( ) {
retu rn 0 ;
}
}
c la s s S im p le S u b c la s s e x te n d s S im p le {
S im p le S u b cla s s ( ) {
s upe r ( m e thod1 ());
/ / erro r: co n s t ru c to r m u s t b e ca lled f irs t
}
}
在
上 面 的 例 子 中 使 用 抽 象 类 下 面 举 例 说 明 如 何 从 构 造 器 里
调 用 基 类 方法
c lass S im p le S u b c la ss ex ten d s S im p le {
S im p le S u b cla s s ( ) {
S u p er.m e th o d 1 ( ) ;
}
}
编 译 器 错 误 J0 1 5 0
C a n n o t h a v e rep ea te d in te rfa ce ' id e n tifie r '
编
译 器 检 测 到 在 一 个 类 声 明 中 重 复 使 用 一 个 接 口 名 字 当 一
个 类 实 现 许多 接 口 而 其 中 的 一 个 接 口 在 im p lem en t 表 里 具
有 双 重 入 口 时 往 往 会
出
现 这 种 错 误 确 保 没 有 双 重 接 口 入 口 再 次 进 行 编 译下 面 举
例 说 明 这 种 错 误
in terfa ce S im p le I {
/ / d o som e th in g m ean ingful
}
cla s s S im p le im p lem en ts S im p le I.Ico lo r .IF o n t .S im p leI {
/ / erro r : 'S im p leI' rep ea ted
}
编 译 器 错 误 J0 1 5 1
V a r ia b le ‘ id e n tifie r ’ is a lr e a d y d e f in e d in th is m e th o d
编
译 器 检 测 到 在 一 个 类 的 相 同 作 用 域 内 有 使 用 相 同 名 字 定
义 两 次 的 两 个变 量 确 保 在 相 同 的 作 用 域 内 变 量 没 有 定 义
两 次 或 没 有 把 变 量 定 义 成与 传 递 到 方 法 的 一 个 自 变 量 有
相 同 的 名 字 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ) {
in t i = 1 ;
in t j = i;
/ / m o re co d e h ere in t i = 0 ;
/ / erro r : 'i' defined tw ice w ith in
/ / th e s a m e s co p e
}
}
编 译 器 错 误 J0 1 5 2
A m b ig u o u s re feren ce to ' id e n tifie r ' in in terfa c e ' id e n tifie r ' an d ' id e n t i f ie r '
编
译 器 检 测 到 标 识 符 的 引 用 具 有 二 义 性 可 能 在 两 个 或 更 多
的 接 口 生 命了 标 识 符 而 编 译 器 不 能 确 保 要 引 用 使 用 哪 一
个 确 保 没 有 使 用 两 个 接口 定 义 相 同 的 字 段
下 面 举
例 说 明 这 种 错 误
in te r face In te r fa ce1 {
f in a l in t i = 0 ;
}
in te r face In te r fa ce2 {
f in a l in t i = 1 ;
}
p u b lic c la ss S im p le im p le m e n ts In te r fa c e 1 , In te r fa c e 2 {
in t m eth o d 1 ( ) {
retu rn i; / / erro r : ca nnot determ in e w h ich in stance o f 'i' to use
}
}
编 译 器 错 误 J0 1 5 8
C la ss ' id e n tifie r ' a lr e a dy de f in e d
编
译 器 检 测 到 使 用 相 同 的 名 字 定 义 了 两 个 或 更 多 的 类 确 保
在 同 一 个 源文 件 或 软 件 包 里 的 类 定 义 次 数 没 有 超 过 一 次
定 义 为 外 部 类
如 果 一个 类 被 一 个 导 入 类 复 制 也 会 出 现 这 种 错 误 重 新 命
名 其 中 的 一 个 类 或删 除 双 重 实 例 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la s s S im p le {
/ / d o som e th in g m ean ingful
}
c lass S im p le {
/ / erro r : class 'S im p le ' already defined
}
编 译 器 错 误 J0 1 5 9
'@ ' m u s t be fo l lo w e d by th e r e spo n se f i le n a m e
编
译 器 检 测 到 在 JV C 命 令 行 里 有 @ 字 符 但 是 没 有 检 测 到 紧 随
其 后 的 合法 响 应 文 件 提 供 响 应 文 件 再 次 进 行 编 译
编 译 器 错 误 J0 1 6 0
R e sp o n se f i le ' id e n tifie r ' co u ld n o t be o p en e d
编
译 器 不 能 打 开 响 应 文 件 当 响 应 文 件 名 拼 写 错 误 或 文 件 不
存 在 时 往往 会 出 现 这 种 错 误 检 查 响 应 文 件 的 位 置 再 次 进
行 编 译
编 译 器 错 误 J0 1 6 1
C a n n o t o p en s o u rce f i le : ' id e n t i f ie r'
不
能 打 开 错 误 信 息 中 指 出 的 源 文 件 当 错 误 信 息 中 指 出 的 源
文 件 名 拼 写错 误 或 文 件 不 存 在 时 往 往 会 出 现 这 种 错 误 检
查 所 指 出 的 文 件 的 位 置再 次 进 行 编 译
编 译 器 错 误 J0 1 6 2
F a ile d to in itia liz e c o m p ile r
初
始 化 失 败 这 种 错 误 经 常 发 生 的 原 因 是 编 译 器 和 或
Ja va 上 的M ic rosoft 虚 拟 机 VM
没 有 正 确 安 装 或 者 是 非 正 确 版 本 确 保 这 个 正确 版 本 和 VM
及 编 译 器 的 安 装
编 译 器 错 误 J0 1 6 3
A r r a y 'id e n t i f ie r ' m iss in g a r r a y in d e x
编
译 器 检 测 到 访 问 一 个 数 组 类 型 但 是 缺 少 下 标 值 为 访 问 一
个 数 组 元素 必 须 为 数 组 提 供 一 个 合 法 的 整 数 型 下 标 确 保
数 组 的 下 标 使 用 了 合法 的 整 数 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la s s S im p le {
in t j[]= { 1 , 2 , 3 } ;
void m
e th od1 ( ) { j[]= 0
/ / erro r : 'j' m issing index v a lu e
}
}
编 译 器 错 误 J0 1 6 4
A m b ig u o u s im po r t o f cla ss ' id e n tifie r ' fr o m m o re th a n o n e pa c k a g e
编
译 器 检 测 到 两 个 或 更 多 的 im port 语 句 试 图 从 不 同 的 软 件
包 里 导 入 相 同的 类 名 当 两 个 软 件 包 包 含 相 同 的 类 而 两 个
软 件 包 都 导 入 到 同 一 个 源文 件 里 时 通 常 会 出 现 这 种 错 误
检 查 与 相 同 类 有 关 的 导 入 到 源 文 件 中软 件 包 从 一 个 软 件
包 里 删 除 相 同 类 或 者 从 原 文 件 中 删 除 一 个 im port 语 句
下 面 举
例 说 明 这 种 错 误
im p o r t B o x .T est; / / T h is p a ck age co n tains a class n a m ed 'T ex t '
im p o r t C a r ton .T es t ; / / T h is p a ck age contains a c lass n a m ed 'T ex t ' a lso
/ / erro r : w h ich 'T ex t ' c lass should b e u s ed b y th e co m p ile r?
p u b lic c la s s S im p le {
// D o s o m eth in g h ere
}
编 译 器 错 误 J0 1 6 5
C
a n n o t th r o w e x c e p tio n ' id e n tifie r ' fr o m m e th o
d ' id e n t i f ie r ' it is n o t a su bc la ss o f a n y ex c e p t
io n s th r o w n fr o m o v er rid d e n m e th o d ' id e n tifie r
' 编 译 器 检 测 到 一 个 被 超 越 的 方 法 试 图 比 超 越 它 的 方
法 发 出 更 多 的 异 常
在
Ja va 中 一 个 超 越 方 法 不 能 声 明 为 发 出 比 被 超 越 方 法 更 多
的 异 常 把基 类 th ro w s 的 异 常 改 为 1 或 把 基 类 声 明 改 为 子
类 需 要 发 出 的 发 出 异 常类 型
下 面 举
例 说 明 这 种 错 误
c las s E x cep t io n A ex te n d s E x cep t io n {
/ / d o som e th in g m ean ingful
}
c a ls s E x c e p t ionB e x te nds E x c e p tion {
/ / d o som e th in g m ean ingful
}
c la s s A no the r C la ss {
p u b lic v o id m e th o d 1 ( ) th ro w s E x cep tio n A {
/ / do som e th ing m eanin gfu l
}
}
p u b lic c la ss S im p le e x te n d s A n o th e r C la ss {
p u b lic vo id m e thod 1 ( ) th ro w s E x cep t io nA , E x cep t ion B {
/ / erro r : ca nn ot th ro w grea ter th an
/ / o n e ex cep t io n h ere
}
}
编 译 器 错 误 J0 1 6 6
C a n n o t a c c e s s m e m b e r ' id e n tifie r ' in c la s s ' id e n t i f ie r ' fr o m ' id e n t i f ie r '
it
is in a d i f fe r e n t p a c k a g e
编
译 器 检 测 到 试 图 非 法 引 用 在 不 同 软 件 包 内 定 义 的 变 量 成
员 或 方 法 当试 图 访 问 定 义 在 另 一 个 软 件 包 里 的 pro te c te d
或 默 认 访 问 成 员 时 通 常会 出 现 这 种 错 误 位 于 不 同 软 件 包
里 一 个 类 的 pro te c te d 或 默 认 访 问 成 员是 不 能 访 问 的 确 保
在 另 一 个 软 件 包 里 正 试 图 访 问 的 成 员 不 是 pro te c te d 或
默 认 访 问 成 员
编 译 器 错 误 J0 1 6 7
C a n n ot ov e r r id e n o n - s ta t ic m e th od ' id e n t i f ie r ' w ith s ta t ic m e th od ' id e n tifie r '
编
译 器 检 测 到 试 图 使 用 修 饰 符 sta t ic 声 明 的 子 类 方 法 超 越
一 个 超 类 方法 当 一 个 方 法 在 一 个 子 类 里 被 超 越 时 这 个 方
法 不 能 提 高 或 降 低 方 法的 访 问 级 别 也 不 能 使 用 sta t ic 修
饰 符 从 超 越 方 法 声 明 中 删 除 sta t ic 修 饰 符 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ) {
/ / do som e th ing m eanin gfu l
}
}
c las s S im p le 2 ex te n d s S im p le {
static p u b lic void m e thod1 ( ) {
/ / erro r : v o erridin g sup ercla ss 'm e thod1 '
/ / w ith a static m e thod is not valid
}
}
编 译 器 错 误 J0 1 6 8
T h e d e c lar atio n o f a n ab s tr a c t m e th o d m u s t ap p e ar w i th in an ab s tr a c t c la ss
编
译 器 检 测 到 在 一 个 没 有 定 义 为 ab s t ra c t 的 类 内 使 用 修
饰 符 ab s t ra c t 声 明的 方 法 当 打 算 把 一 个 类 声 明 为 ab s t
ra c t 但 在 类 声 明 中 丢 失 ab s t ra c t 修饰 符 时 往 往 会 出 现
这 种 错 误 改 变 类 使 它 声 明 为 ab s t ra c t 或 从 类 内 定义 的 方
法 中 删 除 修 饰 符
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
a b s t ra c t v o id m e thod1 ( ) ;
/ / erro r : c lass m u st also b e ab stra c t
}
编 译 器 错 误 J0 1 6 9
C a n n o t a cce s s ' id en t i f ie r ' o n ly p u b l ic cla ss e s a n d in te rfa ces in o th e r p a ck a g e s ca n b e a cce s sed
编
译 器 检 测 到 试 图 访 问 包 含 在 另 一 个 软 件 包 里 的 一 个 非 公
共 类 或 接 口只 有 用 修 饰 符 pub lic 定 义 的 类 或 接 口 才 能 在 其
他 软 件 包 里 访 问 检 查 正在 其 他 软 件 包 里 访 问 的 类 或 接 口
的 访 问 级 别 确 保 它 是 pub lic 再 次 进行 编 译
下 面 举
例 说 明 这 种 错 误
// S o u rce lo ca ted in 'B o x e s . J a v a ' in th e 'B o x ' p a ck ag e
p a ck a g e B o x ;
pu b lic c la s s B o x{
Ta p e Ro ll t r = n ew Ta p e Ro ll ( ) ;
/ / D o m ea n ingful s tuff here
}
c lass T a p e R o ll{
// D efin e th e c la s s h ere
}
// S o u rce lo ca ted in 'S im p le . ja v a '
im po r t B o x .T a pe R o ll; p u b lic c la s s S im p le{
p u b lic static void m a in ( S t r ing args[]){
B o x .T a pe R o ll t r = n ew B o x .T a pe R o ll() ;
/ / erro r: ca n n o t a cces s a 'n o n - p u b lic ' cla s s in a d ifferen t p a ck a g e
}
}
编 译 器 错 误 J0 1 7 0
C a n n o t lo a d p red efin ed c la ss ' id en t i f ie r '
编
译 器 试 图 装 入 一 个 预 先 定 义 的 类 但 是 不 能 找 到 相 应 的 文
件 当 在 系统 上 找 不 到 Ja va A P I 类 文 件 或 Ja va 上 的 M ic
rosoft 虚 拟 机 VM
没 有 安装 适 当 的 版 本 时 往 往 会 出 现 这 种 错 误 确 保 系 统 上
有 Ja va A P I 类 文 件以 及 VM 的 正 确 安 装 再 次 进 行 编 译
编 译 器 错 误 J0 1 7 3
F o u n d cla ss ' id en t i f ie r ' in p a ck a g e ' id en t i f ie r ' ra th er th a n p a ck a g e ' id e n tifie r '
编
译 器 发 现 指 定 的 类 但 是 这 个 类 没 有 定 义 成 正 确 的 软 件 包
成 员 当 从一 个 错 误 的 目 录 导 入 一 个 类 文 件 时 通 常 会 出 现
这 种 错 误 确 保 正 导 入的 类 位 于 正 确 的 软 件 包 目 录 再 次 进
行 编 译
编 译 器 错 误 J0 1 7 5
C a n n ot in v o k e m e th od on ' n u l l ' l i te r a l
编
译 器 检 测 到 试 图 从 nu ll 关 键 字 中 调 用 一 个 方 法 nu ll 不 是
一 个 类 对 象而 且 也 不 提 供 方 法 删 除 试 图 从 nu ll 关 键 字 中
调 用 方 法 的 语 句 再 次 进行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
pu b lic S t r in g m e th o d 1(){
/ / D o s o m e th in g m ea n in g fu l h ere retu rn n u ll.to S t r in g ( ) ;
/ / erro r : ca nn ot invok e a m e th od f ro m nu ll
}
}
编 译 器 错 误 J0 1 7 6
D u p l ic a te la b e l 'id e n t i f ie r ' n e s te d in s id e a n o th e r la b e l w ith s a m e n a m e
编
译 器 检 测 到 一 个 嵌 套 标 记 与 另 一 个 标 记 相 同 给 这 个 标 记
改 成 不 同 的名 字 修 改 引 用 这 个 标 记 的 所 有 b reak 和 c on
tinue 语 句 再 次 进 行 编 译下 面 举 例 说 明 这 种 错 误
p u b lic c la ss S im p le {
void m e th od1 ( ){ o u ts id e L o o p :
fo r ( in t i= 0 ; i< 1 0 ; i+ + )
{
ou ts id e L oop : / / erro r : dup lica te la b e l fo r ( in t x = 0 ; x < 1 0 ; x + + )
{
b rea k o u ts id e L o o p ;
}
b rea k o u ts id e L o o p ;
}
}
}
编 译 器 错 误 J0 1 8 9
'r e tu r n ' n o t a llo w e d in a s ta t ic in itia liz e r o r in s ta n c e in itia liz e r
在
一 个 静 态 或 实 例 初 始 化 里 发 现 一 个 re tu rn 语 句 初 始 化 像
一 个 构 造 器一 样 不 能 返 回 值 删 除 re tu rn 语 句 再 次 进 行 编
译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
s ta t ic in t v a r 1 ;
s ta t ic {
v a r 1 = 0 ; retu rn ;
/ / erro r : retu rn s ta tem en t n o t a llo w ed in s ta tic in itia liz er
}
}
编 译 器 错 误 J0 1 9 1
E x p ected ' . c la ss '
编
译 器 检 测 到 在 一 个 表 达 式 或 赋 值 语 句 中 使 用 了 一 个 内 在
类 型 的 名 字但 是 在 名 字 后 面 没 有 发 现 当 漏 掉 关 键 字 .c la
ss 时 通 常 会 出 现 此 错 误
把
. c la ss 作 用 域 加 到 内 在 类 型 的 后 边 再 次 进 行 编 译下 面 举
例 说 明 这 种 错 误
p u b lic c la s s S im p le {
p u b lic s ta tic v o id m a in ( S t rin g a rg s [ ] ){ C la s s x = in t ; / / erro r : m is s in g '.c la s s '
}
}
编 译 器 错 误 J0 1 9 2
' . c lass' o n in tr in s ic ty p e r e q u ir e s Java 1 .1 c o m p atib le c lass l ib r a r ie s
编
译 器 检 测 到 通 过 一 个 内 在 数 据 类 型 使 用 .c la ss 但 是 Ja va
上 的 M ic rosoft 虚 拟 机 VM
或 Ja va 类 库 是 基 于 Ja va 1 .0 的 确 保 类 库 和 Ja va V M 是Ja va 1
. 1 版 本 再 次 进 行 编 译
编 译 器 错 误 J0 1 9 3
C a n n o t h ave an ar r a y o f ty p e ' v o id '
编
译 器 发 现 试 图 定 义 一 个 类 型 为 vo id 的 数 组 vo id 数 据 类 型
用 在 方 法 上用 来 声 明 这 个 方 法 没 有 返 回 值 不 能 用 于 数 组
Pu b lic c la s s S im p le {
V o id M y A r ra y[]; / / erro r : v o id a rra ys n o t s u p p o rted
}
编 译 器 错 误 J0 1 9 4
C la ss o r in te rfa ce ca n n o t be d ec la red ' v o la t i le' 'n a tiv e ' ' tr a ns ie n t' or ' sy n ch ro n iz e d '
编
译 器 检 测 到 使 用 上 边 提 到 的 修 饰 字 声 明 的 一 个 内 部 类 或
接 口 当 把 一个 方 法 或 字 段 修 饰 字 用 到 内 部 类 或 接 口 定 义
时 往 往 会 出 现 这 种 错 误 内 部 类 和 接 口 可 以 使 用 priv a te
pub lic 和 pro te c te d 访 问 修 饰 字 内 部 类还 可 以 使 用 修 饰 字
例 如 ab s t ra c t sta t ic 和 fin a l
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
// D o s o m eth in g h ere
volatile c lass Inner C la ss{
/* erro r : lik e outer c lass, in ner c las ses ca nn ot b e defined as vo la t ile */
}
}
编 译 器 错 误 J0 1 9 5
C a n n o t d e c la r e 'id e n t i f ie r ' a s 'sta t ic ' in in n e r c la ss ' id e n tifie r '
编
译 器 检 测 到 试 图 在 一 个 内 部 类 中 把 一 个 变 量 或 方 法 声 明
为 sta t ic 和 常规 的 类 声 明 不 同 内 部 类 不 支 持 静 态 成 员 在
另 一 个 类 内 定 义 的 类 声 明为 sta t ic 时 可 以 有 静 态 成 员 但
是 这 个 类 被 认 为 是 外 部 类 如 果 在 一个 内 部 类 中 定 义 一 个
接 口 也 会 出 现 这 种 错 误
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
/ / D o som e th in g m ean ingful h ere
c la s s In n e r C la ss {
static in t v a r 1 ; /* erro r : ca nnot declare s tatic m em b ers in inner c lass*/
}
}
下 面 举
例 说 明 如 何 在 一 个 类 内 定 义 包 含 sta t ic 成 员 的 类
p u b lic c la s s S im p le{
// D o so m e th in g m e a n in g fu l h e re
/* B eca u s e 'In n er C la s s ' cla s s is d ecla red a s s ta t ic it is n o w t rea ted a s a n o u ter cla s s en clo s ed w ith in th e 'S im p le ' cla s s */
static c lass Inner C la ss{
s ta tic in t v a r 1 = 1 0 0 ; / / T h is is O K a s lo n g a s th e c la s s is s ta tic
}
}
编 译 器 错 误 J0 1 9 6
N e s ted cla ss ' id en t i f ie r ' ca n n o t h a v e th e sa m e n a m e a s a n y o f i ts en clo s in g c la ss e s
指
定 内 部 类 与 嵌 套 下 的 一 个 类 有 相 同 的 名 字 确 保 在 嵌 套 的
内 部 类 中 没有 重 复 类 名 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
/ / D o som e th in g m ean ingful h ere c lass In n er C la ss{
/ / D o s o m e th in g m ea n in g fu l h ere c la s s S im p le{
/ / erro r : in n er c la s s h a s s a m e n a m e a s a p a ren t c la s s
}
}
}
编 译 器 错 误 J0 1 9 7
C a n n o t d e c la r e in te r fa c e in in n e r c la s s ' id e n tifie r '
编
译 器 检 测 到 试 图 在 一 个 内 部 类 内 部 声 明 一 个 接 口 内 部 类
定 义 不 支 持在 其 内 部 声 明 一 个 接 口 从 内 部 类 声 明 中 删 除
接 口 声 明 再 次 进 行 编 译下 面 举 例 说 明 这 种 错 误
p u b lic c la ss S im p le {
/ / D o som e th in g m ean ingful h ere c lass In n er C la ss{
/ / D o som e th in g m ean ingful h ere in terfa ce M y In terfa ce{
/* erro r : in terfaces ca nnot b e d eclared in s id e in n er c la s s es */
}
}
}
编 译 器 错 误 J0 1 9 8
A n en clo s in g in s ta n c e o f ty pe ' id e n t i f ie r ' is req u ire d
编 译 器
检 测 到 一 个 内 部 类 定 义 试 图 引 用 它 作 用 域 之 外 的 东 西 出
现 这 种
错 误 的
情 况 有
在
另 外 一 个 类 里 声 明 为 sta t ic 的 类 引 用 它 父 类 中 的 一 个 非
静 态 变 量 或 方法 因 为 这 个 类 声 明 为 sta t ic 如 果 没 有 父 类
定 义 的 实 例 它 不 能 引 用 父类 中 的 任 何 成 员
—
个 内 部 类 试 图 引 用 一 个 不 是 它 外 部 类 的 类 而 这 个 被 引 用
类 使 用 在 它前 面 带 有 类 名 的 关 键 字 th is 因 为 这 个 引 用 类
不 是 内 部 类 的 父 类 所 以不 能 应 用 一 个 实 例
下 面 举
例 说 明 这 种 错 误
// T h is e x a m p le illu s t ra te s th e f i rs t e r ro r situ a tio n
p u b lic c la s s S im p le{ in t x = 10;
static c lass Inner C la ss{
p u b lic void m e thod1 ( ){
in t y = x ; /* erro r: in s ta n ce v a ria b le n eed ed
to referen ce p a ren t v a r ia b les . */
}
}
}
// T h is e x a m p le i l lu s t ra te s th e se c ond e r ro r s i tu a t io n
c lass A {
in t x ;
}
c lass B {
/ / D o som e th in g m ean ingful h ere c lass In n er C la ss{
v o id m e th o d 1 ( ){
in t y = A .th is .x ;
/* erro r : no in stance of A d efin ed . C a nno t use
th e < c la s s n a m e .th is .v a r ia b le> s yn ta x h ere.*/
}
}
}
编 译 器 错 误 J0 1 9 9
C a ll o f 'th is ( ) ' c a n n o t b e q u a lifie d
编
译 器 检 测 到 一 个 内 部 类 构 造 器 试 图 通 过 使 用 带 有 th is
方 法 的 类 名调 用 它 的 外 部 类 构 造 器 内 部 类 不 能 调 用 它 们
的 外 部 类 构 造 器 从 内 部类 构 造 器 删 除 调 用 的 外 部 类 构 造
器 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
in t x ;
S im p le ( in t x ){
th is .x = x ;
}
c lass In n er C la ss{ In n er C la s s ( ){
S im p le .th is ( 1 0 ) ;
/ / erro r: ca n n o t ca ll o u ter cla s s co n s t ru c to r
}
}
}
编 译 器 错 误 J0 2 0 0
' th is ' m u s t be qu a l if ie d w i th a c la ss n a m e
编
译 器 检 测 到 试 图 在 一 个 内 部 类 里 使 用 关 键 字 th is 引 用 外
部 类 成 员 而关 键 字 th is 带 有 的 名 字 不 是 外 部 类 名 为 引 用
外 部 类 成 员 只 能 从 一 个内 部 类 使 用 外 部 类 名
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
in t x ;
c lass In n er C la ss{
v o id m e th o d 1 ( ){ in t j = x .th is ;
/* erro r : o n ly a c la s s n a m e ca n b e u s ed w ith th is to referen ce o u ter c la s s * /
}
}
}
下 面 举
例 说 明 引 用 外 部 类 成 员 正 确 的 方 式
p u b lic c la s s S im p le{
in t x ;
in t m e th od2 ( int arg 1 ){ retu rn a rg 1 *;
}
c lass In n er C la ss{
v o id m e th o d 1 ( ){
in t j = S im p le .th is .x ; / / T h is is O K ! in t z = S im p le .th is .m e th o d 2 ( 1 0 ) ;
}
}
}
编 译 器 错 误 J0 2 0 1
' su p er ' c a n n o t b e q u a l i f ie d ex ce pt a s a su pe rcla ss co n s tr u c to r ca l l
编
译 器 检 测 到 使 用 前 面 带 有 超 类 实 例 的 关 键 字 supe r 来 访 问
超 类 的 字 段或 方 法 应 当 与 关 键 字 supe r 一 起 使 用 超 类 实 例
限 于 在 超 类 内 部 有 一个 定 义 的 内 部 类 时 引 用 一 个 超 类 构
造 器
下 面 举
例 说 明 这 种 错 误
c las s S im p le {
in t x ;
}
c las s N o t S im p le ex te n d s S im p le {
N o t S im p le ( S im p le s m p){ s m p .s u p er.x = 1 00;
/*erro r C a n n o t referen ce f ield w ith s u p ercla s s n a m e*/ s u p er.x = 1 0 0 ; / / T h is is O K !
}
}
编 译 器 错 误 J0 2 0 2
'su p e r ( ) ' c a n n o t b e q u a lifie d ; su p e r c la ss 'id e n t i f ie r ' is n o t a n in n e r c la ss
编
译 器 检 测 到 使 用 超 类 实 例 调 用 超 类 构 造 器 但 是 这 个 超 类
不 是 一 个 内部 类 只 有 一 个 超 类 是 内 部 类 时 超 类 实 例 与 关
键 字 supe r 才 能 一 起 使用
下 面 举
例 说 明 这 种 错 误
c las s S im p le {
/ / D o som e th in g m ean ingful h ere
}
c las s N o t S im p le ex te n d s S im p le
{
N o t S im p le ( S im p le s m p){ s m p .s u p er();
/* erro r: ca n n o t ca ll s u p er w ith in s ta n ce w h en sup ercla ss does no t contain inner c lass es*/
}
}
下 例 给
出 带 有 supe r 关 键 字 的 超 类 实 例 的 正 确 用 法
c lass S im p le{
// D o s o m eth in g h ere c lass In n er C la ss{
in t v a r 1 , v a r 2 ;
}
}
pub lic c la ss N o t S im p le e x te nds S im p le . Inn e r C la ss {
N o t S im p le ( S im p le s m p){ s m p .s u p er();
/ / T h is is O K !
}
}
编 译 器 错 误 J0 2 0 3
C a n n o t a cce s s p r o tec te d m e m b er ' id e n t i f ie r' in c la ss ' id en t i f ie r ' fr o m c la ss ' id e n tifie r '
编
译 器 检 测 到 试 图 从 一 个 类 的 不 同 软 件 包 中 访 问 保 护 成 员
一 个 类 的 保护 成 员 可 以 从 软 件 包 的 外 部 访 问 在 这 个 软 件
包 中 只 通 过 负 责 类 实 现的 代 码 声 明 删 除 到 其 他 软 件 包 的
保 护 成 员 的 调 用 或 者 使 这 个 类 成 为其 他 软 件 包 类 的 一 个
子 类 重 新 编 译
下 面 举
例 说 明 这 种 错 误
/* ( so u rc e lo c a te d in a f i le c a lle d P u b lic C la s s .ja v a in
th e th e B o x es P a ck a g e d irecto ry ) */ p a ck a g e B o x es ;
pub lic c la ss P ub lic C la ss{
p rotected void m e th od1 ( ){
/ / D o s o m e th in g h ere
}
}
// ( so u rce lo ca ted in a f i le ca l le d S im p le .jav a )
im po r t B o xes .Pu b lic C la s s ;
p u b lic c la ss S im p le e x te n d s P u b l ic C la ss{
p u b lic v o id m e th o d 1 ( ){
P u b lic C la s s pu b = n ew P u b lic C la s s ( ) ; p u b .m e th o d 1 ( ) ;
/* erro r : C a nn ot access p rotected m e th od 'm e thod1 ' b eca u s e it is lo ca ted in a d if feren t p a ck a g e .* /
}
}
编 译 器 错 误 J0 2 0 4
C a n n o t a c c e ss p r o te c te d m e m b e r 'id e n t i f ie r ' in c la s s 'id e n t i f ie r ' v ia a q u a lifie r o f ty p e ' id e n tifie r '
编
译 器 检 测 到 一 个 软 件 包 里 的 一 个 类 是 另 一 个 软 件 包 的 扩
展 类 而 这 个类 试 图 使 用 一 个 基 类 实 例 访 问 基 类 的 保 护 成
员 当 一 个 类 试 图 通 过 一 个
实
例 而 不 是 th is , s u p e r 或 派 生 类 的 实 例 访 问 它 基 类 的 成
员 时 通 常 会 出现 这 种 错 误 确 保 被 访 问 它 基 类 的 成 员 使 用
th is 或 supe r 关 键 字 或 一 个派 生 类 的 实 例 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
/* ( so u rc e lo c a te d in a file c a lle d P o in t . ja v a lo c a te d in th e B o x e s p a c k a g e d ire c tory) * /
pa ck a g e B o xes ;
p u b lic c la ss P o in t{
p ro tected in t x , y;
/ / D o other m eanin gfu l code h ere
}
/ / ( s o u rce lo ca ted in a f ile ca lled s im p le.ja v a ) im po r t B o xes .Po in t ;
p u b lic c la ss S im p le e x te n d s P o in t{
p u b lic v o id m e th o d 1 ( P o in t p ){ s u p er.x = 0 ; / / th is is O K !
p .x = 0 ; /* erro r: ca n n o t u s e a p ro tected m em b er fo r usage other th an ex tending it . */
}
}
编 译 器 错 误 J0 2 0 5
C a n n o t u se n o n - f in a l lo ca l v a r ia b le ' id en t i f ie r ' fr o m a d i f feren t m e th o d
编
译 器 检 测 到 在 一 个 方 法 里 引 用 了 一 个 局 部 变 量 而 这 个 局
部 变 量 没 有声 明 为 最 终 变 量 如 果 在 一 个 局 部 块 或 方 法 声
明 中 定 义 一 个 内 部 类 而这 个 内 部 类 试 图 引 用 一 个 在 它 作
用 域 之 外 定 义 的 参 数 或 局 部 变 量 时 可能 会 出 现 这 种 错 误
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
void m e th od1 ( in t var 1 ){ c la s s In n er C la s s {
b o o lea n g e t V a r 1 ( ){
retu rn ( v a r 1 = = 1 ) ;
/* erro r ca n n o t referen ce lo ca l v a r ia b le o f m eth o d f ro m w ith in in n er c la s s . */
}
}
}
}
编 译 器 错 误 J0 2 0 6
C a n n o t assign a se c o n d va lu e to b la n k f in a l var ia b le ' id e n t i f ie r'
编
译 器 检 测 到 试 图 多 次 把 一 个 值 赋 值 到 fin a l 变 量 在 一 个
构 造 器 或 初 始化 中 多 次 初 始 化 一 个 空 的 fin a l 变 量 时 通 常
会 出 现 这 种 错 误 检 查 错 误信 息 中 提 到 的 fin a l 变 量 的 双 重
初 始 化 重 新 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
f in a l in t v a r 1 ;
{
v a r 1 = 1 0 ;
/ / D o o th er in itia liz a tio n s h ere
v a r 1 = 2 0 ; / / erro r: d u p lica te a s s ig n m en t
}
}
编 译 器 错 误 J0 2 0 7
C a n n o t assign b lan k f in a l var ia b le ' id e n t i f ie r ' in a lo o p
编 译 器
检 测 到 在 程 序 控 制 循 环 作 用 域 内 给 一 个 fin a l 变 量 赋 值
一 个 fin a l
变
量 只 能 一 次 赋 值 所 以 在 一 个 循 环 内 不 能 被 初 始 化 删 除 错
误 信 息 中
指
出 的 循 环 外 fin a l 变 量 的 初 始 化 确 保 它 只 初 始 化 了 一 次下
面 举 例 说 明 这 种 错 误
p u b lic c la ss S im p le {
f in a l in t x ;
p u b lic S im p le ( ){
fo r ( int z= 0 ; z< 1 0 ; z+ + ){
x = z;/* erro r : ca nn ot assign f inal variab le in loop */
}
}
}
编 译 器 错 误 J0 2 0 8
C o n s tr u c to r o r in s ta n c e in itia liz e r m u s t a ss ig n a v a lu e to b la n k f in a l v a r ia b le ' id e n tifie r '
编
译 器 检 测 到 说 明 了 fin a l 变 量 但 在 初 始 化 或 构 造 器 中 从
来 都 没 有 给 它赋 值 为 使 一 个 变 量 正 确 声 明 为 fin a l 必 须 给
它 赋 值
下 面 举
例 说 明 这 种 错 误
p u b lic c la s s S im p le {
f in a
l in t x ; / / erro r : f in a l variab les m u st b e ass igned a
valu e f in a l in t z = 1 0 // T h is is O K
}
编 译 器 错 误 J0 2 0 9
E x p ected '= '
编
译 器 检 测 到 在 注 释 标 记 如 @ c om ,@ s e c u r i ty ,@ d ll
属 性 中 缺 少 等 号当 在 注 释 标 记 声 明 的 属 性 中 缺 少 等 号 时
通 常 会 出 现 这 种 错 误 如 果 在编 译 器 计 算 时 另 一 个 符 号 或
字 符 隐 藏 了 等 号 也 会 出 现 这 种 错 误 确保 所 有 注 释 标 记 属
性 都 使 用 了 正 确 的 等 号 重 新 编 译
下 面 举
例 说 明 这 种 错 误
//* * @ c o m . in te r fa c e ( i id 3 1415926 -5358 -9793 -2384 -612345 678901)* /
/ / erro r : m issin g eq ual sign in 'iid ' p a ra m e ter in terfa ce Ites t {
/ / d o som e th in g m ean ingful h ere
}
编 译 器 错 误 J0 2 1 0
E x p ected ' . '
编
译 器 检 测 到 指 定 的 注 释 标 记 声 明 如 @ c om ,@ d ll
在 注 释 标 记 ( 如
@
c om . m e thod) 后 面 缺 少 句 点 如 果 在 编 译 器 计 算 时 另 一 个
符 号 或 字 符
隐
藏 了 句 点 也 会 出 现 这 种 错 误
确
保 注 释 标 记 声 明 中 在 注 释 标 记 后 面 包 含 了 句 点 重 新 编
译下 面 举 例 说 明 这 种 错 误
/** @ co m cla s s */
/ / erro r : m is s in g '. ' f ro m @ co m s ta tem en t
p u b lic c la ss S im p le {
/ / D o som e th in g m ean ingful h ere
}
编 译 器 错 误 J0 2 1 4
In v a l id G U ID s p e c i f ie d
编
译 器 检 测 到 需 要 GU ID 的 @ c o m 属 性 具 有 非 法 的 GU ID 条 目
导 致 这种 错 误 的 原 因 是 在 所 输 入 的 GU ID 中 有 句 法 错 误 检
查 GU ID 的 句 法重 新 编 译
编 译 器 错 误 J0 2 1 5
S y n ta x erro r in @ c o m de cla r a t io n
在
指 定 的 @ c o m 声 明 中 发 现 句 法 错 误 这 往 往 是 不 正 确 地 键
入 声 明 引 起的 检 查 @ c o m 语 句 的 句 法 重 新 编 译
下 面 举
例 说 明 这 种 错 误
/** @ co m in terfa ce( iid = 314 159 26- 53 58- 979 3- 238 4- 612 345 678 910 )
/ / erro r: T h e w o rd 'in tefa ce' is m is s p elled . in terfa ce IT es t {
// D o s o m eth in g h ere
}
编 译 器 错 误 J0 2 1 6
@ c o m a t tr ib u te 'id e n t i f ie r ' o n 'id e n t i f ie r ' is ille g a l in th is c o n te x t
编
译 器 检 测 到 在 一 个 @ c o m 声 明 中 给 属 性 赋 的 值 是 违 法 的
当 指 定 一 个属 性 但 是 利 用 这 个 属 性 所 需 要 的 其 他 指 定 属
性 被 指 定 时 往 往 会 出 现这 种 错 误 如 果 在 一 个 @ c o m 声 明 的
错 误 位 置 指 定 属 性 时 也 会 出 现 这种 错 误
编 译 器 错 误 J0 2 1 7
@ c o m a t tr ib u te ' id e n t i f ie r' w a s n o t sp ec if ied fo r ' id e n t i f ie r' b u t is r e q u ir e d in th is c o n te x t
编
译 器 检 测 到 缺 少 一 个 属 性 错 误 中 显 示 的 @ c o m 声 明
而 这 个 属 性
正
是 声 明 这 个 类 型 所 需 要 的 每 个 @ c o m 声 明 类 型 都 有 所 需
要 的 属 性错 误 信 息 中 列 出 的 有 关 @ c o m 声 明 所 需 要 属 性 的
更 详 细 资 料 参 见 有 关资 料 的 @ c o m 部 分
下 面 举
例 说 明 这 种 错 误
/** @ co m .c la ss() */
/ / erro r : m u s t s p ecify cla s s id fo r @ co m .c la s s p u b lic c la s s S im p le {
// D o s o m eth in g h ere
}
编 译 器 错 误 J0 2 1 8
@ c o m a ttr ib u te ' id e n tifie r ' o n ' id e n tifie r ' h a s a n in v a l id v a lu e
编
译 器 检 测 到 错 误 信 息 中 指 定 的 值 不 是 错 误 中 指 定 属 性 的
正 确 类 型 或者 这 个 属 性 的 合 法 作 用 域 外 检 查 赋 值 到 指 定
属 性 的 值 重 新 编 译
下 面 举
例 说 明 这 种 错 误
/** @ co m .c la s s ( c la s s id = 91 1C A E D 0 - 2 9 57- 11 d 1
- A 55 E- 00 A 0 C 9 0F 26E E ) */ c lass S im p le {
/** @ co m .p a ra m eters ([typ e= C U S T O M ,cu s to m M a r s h a 1 = " fo o .b a r", cu stom M a rs ha1 F la gs= 5 ] i) */
/ / erro r : cu s tom M a rs halF la gs ca n not b e set higher th an 3
native vo id m e thod 1 ( O b ject i) ;
}
编 译 器 错 误 J0 2 1 9
A n @ c o m a t tr ib u te ca n n o t b e p la ced o n m e m b e r ' id en t i f ie r ' u n le ss th e c o n ta in in g c las s o r in te r fa c e a ls o h a s an @ c o m attr ib u te
编
译 器 检 测 到 一 个 放 在 类 或 接 口 成 员 上 的 @ c o m 声 明 但 是
没 有 使 用@ c o m 声 明 来 声 明 这 个 类 或 接 口 确 保 包 含 错 误 中
指 定 方 法 的 类 或 接 口定 义 了 一 个 合 法 的 @ c o m 声 明 重 新 编
译
下 面 举
例 说 明 这 种 错 误
in terfa ce S im p le {
/** @ co m .m eth o d ( d is p id = 7 7 7 ) ; */ p u b lic v o id m e th o d 1 ( ) ;
/* erro r: in terfa ce d o es n o t h a v e a n @ co m co m m en t ta g a s s ig n ed */
}
编 译 器 错 误 J0 2 2 0
A n @ c o m a t tr ib u te c a n n o t b e p la ced o n s ta t ic m e m b er ' id en t i f ie r '
编 译 器
检 测 到 在 类 的 静 态 成 员 上 放 置 了 一 个 @ c o m 声 明 不 能 通
过 CO M
放
置 静 态 成 员 从 方 法 或 字 段 中 删 除 sta t ic 关 键 字 重 新 编
译下 面 举 例 说 明 这 种 错 误
/*@ co m .c la s s ( c la s s id = 314 159 26- 53 58- 979 3- 238 4- 612 345 678 910 ) p u b lic c la s s S im p le {
/** @ co m .m eth o d ( d is p id = 7 7 7 ) ; */ s ta tic v o id m e th o d 1 ( ) { }
/ / erro r : ca nnot ex p o s e static m e thod via C O M
}
编 译 器 错 误 J0 2 2 1
T h e @ c o m a t tr ib u te o n m e m b er ' id e n t i f ie r ' c a n n o t b e u sed in th is ty p e o f c la ss o r in terfa c e
编
译 器 检 测 到 放 在 类 或 接 口 成 员 上 的 @ c o m 声 明 但 是 由 于
用 类 或 接 口使 用 的 @ c o m 属 性 类 型 是 非 法 的 所 以 这 个 @ c o
m 声 明 不 允 许 使 用 这种 错 误 可 能 在 下 列 情 况 下 出 现
在 一 个 应 用 @ c o m . c la ss 或 @ c om . in te r fa c e 声 明 的 类 或 接 口 成 员 中 使
@ c om .
s t ruc tm a p 声 明
在
一 个 应 用 @ c om . s t ruc t 声 明 的 类 成 员 中 使 用 @ c om . m e
thod 声 明下 面 举 例 说 明 这 种 错 误
/** @ co m .s t ru ct() */
c lass S im p le {
/**@ co m .m e th od( disp id = 7 7 7 ) */ p u b lic native vo id m e thod 1 ( ) ;
/* erro r : ca nn ot u s e @ com .m e tho d in sid e of @ com .s t ruct*/
}
编 译 器 错 误 J0 2 2 2
@ c o m a ttr ib u te c a n n o t b e p la c e d o n m e th o d ' id e n tifie r ' it m u s t b e d ec la r ed ' n a t iv e' o r b e in a n in te r fa c e
编
译 器 检 测 到 用 @ c om . m e thod 或 @ c o m . p aram e ters 属 性 指
定 的 方 法 但是 没 有 使 用 na t iv e 修 饰 符 声 明 这 个 方 法 或 者
没 有 在 一 个 接 口 定 义 中声 明 这 个 方 法 对 于 通 过 CO M 接 口 公
布 的 方 法 必 须 在 一 个 接 口 声 明中 声 明 它 们 或 者 在 一 个 类
声 明 中 声 明 为 na t iv e
下 面 举
例 说 明 这 种 错 误
p u b lic c la s s S im p le {
/* @ co m .m e thod ( d is p id= 3 0 6 ) ;*/ p u b lic v o id m e th o d 1 ( ) { }
/* erro r: m e th o d m u s t b e d ecla red 'n a t iv e' o r d ecla red in a n in terfa ce*/
}
编 译 器 错 误 J0 2 2 3
T h e @ c o m . p a r a m e ters d ec la r a t io n o n m e m b er ' id en t i f ie r ' h a s th e w r o n g n u m b er o f pa r a m e ters
编
译 器 检 测 到 @ c o m . p aram e ters 属 性 错 误 信 息 中 指 定 的
与 通 过 CO M 公 布 的 方 法 有 不 同 的 参 数 个 数 确 保 这 个 方 法
的 声 明 和 @ c o m . p aram e ters 属 性 都 有 正 确 的 参 数 个 数 重
新 编 译
下 面 举
例 说 明 这 种 错 误
//* * @ c o m . in te r fa c e ( i id = 31415926 -5358 -979 3 -2384 -612345678910) * / in te r face Ite s t {
/** @ com .m e tho d( d isp id = 3 0 6 )
@ co m .p a ra m eters ( [ typ e= B O O L E A N ] v a r1 ,v a r 2 ,v a r 3 )
*/
p u b lic vo id m e thod 1 ( b o o lean v a r 1 ,int var 2 ) ;
/* erro r: ex t ra p a ra m e ter a d d ed to co m .p a ra m e ters d ecla ra t io n */
}
编 译 器 错 误 J0 2 2 4
' r e tu r n ' m u s t b e th e la s t ite m in an @ c o m . p ar am e te r s d e c lar atio n
为 一 个
方 法 声 明 @ c o m . p aram e ters 时 re tu rn 参 数 必 须 是 表 里 的
最 后 一 个
参
数 编 译 器 检 测 到 re tu rn 参 数 在 参 数 表 的 其 他 位 置 检 查 错
误 信 息 中指 出 的 @ c o m . p aram e ters 属 性 中 返 回 参 数 的 位
置 做 适 当 的 修 改 重 新 编译
下 面 举
例 说 明 这 种 错 误
/* * @ c om . c la ss ( c la ss id = 911C A E D 0 - 2 9 57 -11d1 -A 55E - 00A 0C 90F 2 6 E E ) * /
c lass S im p le {
/**@ co m .p a ra m eters ( [ typ e= I4 ] retu rn , [typ e= C U S T O M ,
cu s tom M a rs ha1 = " foo.b a r" , cu stom M a r s ha1 F la gs= 3 ] i) */
/ / erro r : 're turn' ca nnot b e defined as th e f irs t p a ra m e ter native in t m e th od1 ( O b ject i) ;
}
编 译 器 错 误 J0 2 2 5
A n @ C O M . 'id e n t i f ie r ' d e c la r a tio n is ille g a l fo r th is ty p e o f ite m
编
译 器 检 测 到 为 错 误 项 类 型 定 义 的 @ C O M 声 明 这 种 错 误 通
常 是 由 于 修改 代 码 产 生 的 但 是 它 不 属 于 @ C O M 声 明 的 句 法
或 位 置 问 题 确 保 代 码中 在 指 定 的 项 上 使 用 了 正 确 的 @ C O M
声 明
下 面 举
例 说 明 这 种 错 误
/* * @ c o m .in te r fa c e ( i id= 31415 926 -5358 -9793 -2384 -6123456789 01, dua l) * / in te r face Ite s t {
/**@ co m .s tru ct()* /
p u b lic in t m e thod1 ( ) ;
/ / erro r : w ron g ty p e of @ com declaration ap p lied
}
编 译 器 错 误 J0 2 2 6
T h e @ c o m d e c la r e d ty p e o f 'id e n t i f ie r ' is illsg a l fo r a d isp a tc h o r d u a l in terfa c e
编
译 器 检 测 到 一 个 @ c o m 接 口 声 明 为 dua l 或 d isp a tc h 接 口
具 有 一 个 包含 @ c o m . p ara m ete rs 声 明 的 成 员 而 这 个 @ c o
m . p aram e ters 声 明 使 用 错误 的 typ e
当
接 口 声 明 为 dua l 或 d isp a tc h 接 口 时 某 些 @ c o m . p aram e
ters 类 型 不 允许 在 在 接 口 里 定 义 下 面 列 表 显 示 对 于 typ e 来
说 哪 些 值 是 非 法 的
-
F IX E D A RRA Y
-
SY SF IX E D ST R IN G
-
I8
-
U8
-
S T RU CT
-
C U S T OM ,C U S T O M B YR E F /C US T O M B YV A L
-
PT R ( 除 了 VA R IA N T 以 外 的 PT R )
-
以 上 列 出 值 的 任 何 数 组
下 面 举
例 说 明 这 种 错 误
/** @ co m .in terfa ce( iid = 31 415 926 - 5 358 - 9 7 93- 23 84- 61 234 567 890 1, d u a l) * / in terfa ce Ites t {
/**@ co m .p a ra m eters ( [ in ,o u t ] n , [typ e = I8 ] j]); */
/* erro r: ca n n o t u s e 'I8 ' a s a ty p e in a d u a l in terfa ce*/ p u b lic v o id m e th o d 1 ( in t n , in t j);
}
编 译 器 错 误 J0 2 2 7
I t is im p o ss ib le fo r a n e x p r e ssio n o f ty p e 'id e n t i f ie r ' to b e a n in s ta n c e o f ' id e n tifie r '
编
译 器 检 测 到 使 用 in s ta n c e o f 运 算 符 进 行 两 个 类 的 比 较
可 能 永 远 也 不会 彼 此 成 为 实 例 为 正 确 使 用 in s ta n c e o f
运 算 符 必 须 比 较 有 共 同 类 系统 的 两 个 类 改 变 包 含 in s ta n
c e o f 运 算 符 的 表 达 式 以 便 为 它 的 比 较 使用 一 个 相 关 类 和
实 例 或 者 删 除 这 个 表 达 式 重 新 编 译
下 面 举
例 说 明 这 种 错 误
c las s S im p le 1 {
/ / d o som e th in g m ean ingful h ere
}
c las s S im p le 2 {
/ / d o som e th in g m ean ingful h ere
}
c las s C o m p C lass e s {
S imp le 1 x = n ew S imp le 1 ( ) ;
p u b lic static void m a in ( S t r ing args[]){
if( sm p . x in s ta n c e o f S im p le 2 ){
/* erro r : non rela ted c lasses ca nnot b e in s tances of ea ch oth er*/
}
}
下 面 举
例 说 明 正 确 使 用 in sta n c e so f 运 算 符 确 保 一 个 类 是 否 是
一 个 指 定 类的 实 例
cla s s S im p le 1 ex ten d s S im p le 2 {
/ / d o som e th in g m ean ingful h ere
}
c las s S im p le 2 {
/ / d o som e th in g m ean ingful h ere
}
c las s C o m p C lass e s {
S imp le 1 x = n ew S imp le 1 ( ) ;
p u b lic static void m a in ( S t r ing args[]){
if( sm p . x in s ta n c e o f S im p le 2 ){
/ / T h is is O K s in ce 'S im p le 1 ' is a s u b cla s s o f 'S im p le 2 '
}
}
编 译 器 错 误 J0 2 2 8
S y n ta x erro r in @ d l l de cla r a t io n
编
译 器 检 测 到 在 一 个 @ d l l 注 释 标 记 中 有 一 个 句 法 错 误 当
错 误 地 键 入 一个 @ d l l 注 释 标 记 时 通 常 会 出 现 这 种 错 误 检
查 语 句 的 句 法 错 误 重 新编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la s s S im p le {
/**@ d ll.im p o r t ( k ern el3 2 , a n s i)*/
/* erro r : m issing q uotes aroun d 'k ernel3 2 ' */
p
u b lic static native b o olea n G e t C om p u ter N am e S t r ingB
uffer s in t [ ] cb
}
编 译 器 错 误 J0 2 2 9
E x p ected s tr in g co n s ta n t
编
译 器 检 测 到 注 释 标 记 声 明 如 @ c om ,@ d ll ,或 @ se c u r i ty
的 字 符 串 常 数参 数 缺 少 字 符 串 常 数 或 者 输 入 的 字 符 串 常
数 不 正 确 当 传 递 到 属 性 的值 周 围 缺 少 相 匹 配 的 引 用 时 很
可 能 会 出 现 这 种 错 误 检 查 注 释 标 记 声明 的 属 性 重 新 编 译
下 面 举
例 说 明 这 种 错 误
/** @ co m .in terfa ce( iid == 314 159 26- 53 58- 979 3- 238 4- 612 345 678 901, d u a l) * / in terfa ce IT es t {
/** @ co m .m eth o d ( n a m e= m eth o d ( ) ;* /
/ / erro r : m issing q uotes arou nd 'm e thod1 ' p u b lic v o id m e th o d 1 ( ) ;
}
编 译 器 错 误 J0 2 3 0
C la ss o r in te r fa c e n a m e ' id e n tifie r ' c o n f l ic ts w i th im p o r t 'id e n t i f ie r '
指
定 的 类 或 接 口 与 导 入 的 一 个 类 冲 突 导 致 这 种 错 误 的 原 因
可 能 是 声 明一 个 已 经 在 Ja va A P I 中 声 明 的 类 或 接 口 并 且
试 图 把 那 个 AP I 类 或 接 口导 入 到 源 文 件 中
下 面 举
例 说 明 这 种 错 误
im p o r t ja v a .la n g .C lo n ea b le;
cla s s C lo n ea b le { /* erro r: C lo n ea b le h a s a lrea d y b een im p o rted */
/ / cla s s im p lem en ta t io n
}
编 译 器 错 误 J0 2 3 1
E x p ressio n s ta tem e n t m u s t b e a ss ig n m e n t , m e th o d ca l l , in cr em en t , d ecr em en t , o r " n ew "
编
译 器 检 测 到 一 个 非 法 的 表 达 式 语 句 一 个 表 达 式 语 句 是 可
以 放 在 源 代码 所 属 行 上 的 语 句 下 面 是 一 些 合 法 的 表 达 式
语 句 的 例 子
m _ ca rs .chan g e C olo r ( ) ; / / m e thod ca lls in t x = y+ z ; // A s s ig m en t s ta tem en ts
j+ + ; / / In crem en t s ta tem en t m_ tem p Va r 1 + = 3 ;
new S im p le ( ) ;
下 面 是
一 些 非 法 的 表 达 式 语 句 的 例 子
1 + 2 ; / / erro r: N o a s s ig n m en t s ta tem en t
j+ k- m e th o d 1 ( ) ; / / a m e th od ca ll b u t not a valid assigm en t statem en t
var 1 = = var 2 ; /* C o m p aris on statem en t s s h ould b e co n tained in f low co ntro l statem en t s */
编 译 器 错 误 J0 2 3 2
E x p e c te d '{ ' o r '; '
编
译 器 检 测 到 在 一 个 类 或 接 口 中 使 用 方 法 声 明 的 错 误 如 果
一 个 接 口 的方 法 声 明 在 声 明 的 末 尾 缺 少 分 号 或 类 声 明 缺
少 开 始 的 标 志 { 时 通 常会 出 现 这 种 错 误 检 查 缺 少 分 号 或 缺
少 开 始 标 志 的 指 定 类 或 接 口 的 声明 重 新 编 译
下 面 举
例 说 明 这 种 错 误
in terfa ce IS im p le {
p u b lic v o id m e th o d 1 ( )
/ / erro r : m issing sem ico lon to end d eclaratio n
}
p u b lic c la s s S im p le {
p u b lic v o id m e th o d 1 ( ) ;
/ / erro r : m issing op en ing b race
}
编 译 器 错 误 J0 2 3 3
C a tc h c la u se is un r e a c ha b le e x c e p tio n 'id e n t i f ie r ' is n e v e r th r o w n in th e co r respo n d in g tr y b lo c k
编
译 器 检 测 到 指 定 的 ca tc h 字 句 永 远 不 会 实 现 因 为 相 应 的
try 语 句 块 永远 不 会 发 出 这 个 ca tc h 语 句 的 异 常 类 型 需 要
用 ca tc h 语 句 捕 捉 异 常 或 引出 try 语 句 块 能 发 出 的 异 常 可
以 修 改 这 个 ca tc h 语 句 使 它 不 捕 捉 这 个 指定 的 异 常 类 型 而
是 捕 捉 基 本 异 常 类 型 这 样 就 可 以 避 免 这 种 错 误 修改 ca tc h
语 句 要 捕 捉 的 异 常 类 重 新 编 译
下 面 举
例 说 明 这 种 错 误
c lass S im p le {
void m e th od1 ( ) { in t I= 0 ;
t ry {
I= I+ 1 ; / / T h is t ry b lo ck has no th in g to do w ith c lo n es
}
ca tch ( C lone N o t S up p o r ted E x cep t ion c){
/ / erro r: T h e ex cep t io n typ e ca n n ev er b e ca u s ed b y t ry b lo ck
}
}
}
下 面 举
例 说 明 如 何 通 过 使 用 基 本 E x c e p tion 类 避 免 这 种 错 误
c lass S im p le {
void m
e th od1 ( ) { in t I= 0
t ry {
I= I+ 1 ; / / T h is t ry b lock has no th ing to do w ith c lones
}
ca tch ( E x cep t io n e ){
/ / T h is is O K s in ce a ll ex cep t io n s m u s t d eriv e fro m th is cla s s
}
}
}
编 译 器 错 误 J0 2 3 4
' id e n tifie r ' is n o t a fie ld in c la ss ' id e n tifie r '
编
译 器 检 测 到 一 个 引 用 的 字 段 但 是 这 个 字 段 在 指 定 的 类 里
不 存 在 当错 误 地 键 入 字 段 或 所 引 用 的 字 段 意 味 着 在 不 同
类 里 引 用 字 段 确 保 在 指定 的 类 里 存 在 这 个 字 段 引 用 的 字
段 句 法 正 确 并 且 重 新 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
in t v
a r 1
p u b lic S im p le ( ){ th is .v a r= 1 0 ;
/ / erro r: 'v a r ' is n o t a field in th is cla s s
}
}
编 译 器 错 误 J0 2 3 5
' id e n tifie r ' is n o t a m e th o d in c la s s ' id e n tifie r '
编
译 器 检 测 到 一 个 方 法 调 用 但 是 在 指 定 的 类 里 不 存 在 这 个
方 法 当 不正 确 的 调 用 方 法 调 用 或 方 法 调 用 意 味 着 在 不 同
类 里 引 用 一 个 方 法 时 通 常 出 现 此 错 误 确 保 在 指 定 的 类 里
存 在 这 个 方 法 方 法 调 用 的 句 法 正确 并 且 重 新 编 译
下 面 举
例 说 明 这 种 错 误
c las s S im p le {
p u b lic v o id m e th o d 1 ( ){
/ / do som e th ing here
}
}
c las s S im p le 2 {
p u b lic v o id m e th o d 1 ( ){
S im p le s m p = n ew S im p le ( ) ; s m p .m e th o d 2 ( ) ;
/ / erro r : 'm e thod2 ' do es n o t ex is t in th e c la s s 'S im p le '
}
}
编 译 器 错 误 J0 2 3 6
' id en t i f ie r ' is n o t a n e s ted c la ss o r in te rfa ce in c la s s ' id en t i f ie r '
编
译 器 检 测 到 引 用 一 个 嵌 套 类 或 接 口 但 是 在 指 定 的 类 中 不
存 在 这 个 嵌套 类 或 接 口 出 现 这 种 错 误 的 原 因 是 在 引 用 一
个 嵌 套 类 或 接 口 时 有 语法 错 误 检 查 引 用 内 部 类 的 语 法 错
误 并 确 保 在 指 定 的 类 里 存 在 这 个 类或 接 口 重 新 编 译
下 面 举
例 说 明 这 种 错 误
c las s N o t S im p le{
}
p u b lic c la ss S im p le {
void m e th od1 ( ){
N o t S im p le n t = n ew N o t S im p le ( ) ; O b ject o = n t .n ew In n ew C la s s ( ) ;
/ / erro r : 'In n er C las s' is n o t an inner c lass of 'N ot S im p le '
}
}
编 译 器 错 误 J0 2 3 7
' id en t i f ie r ' is n o t a f ield o r n e s ted c la s s in cla ss ' id en t i f ie r '
编
译 器 检 测 到 引 用 一 个 嵌 套 类 或 字 段 但 是 在 指 定 的 类 中 不
存 在 这 个 嵌套 类 或 字 段 出 现 这 种 错 误 的 原 因 是 在 引 用 一
个 嵌 套 类 或 字 段 时 有 语法 错 误 如 果 在 内 部 类 中 引 用 一 个
字 段 但 是 在 内 部 类 定 义 中 不 存 在 这个 字 段 时 也 会 出 现 这
种 错 误 确 保 存 在 这 个 内 部 类 或 字 段 重 新 编 译下 面 举 例 说
明 这 种 错 误
c las s S im p le 1 {
in t v a r 1 ;
}
c las s S im p le 2 {
static c lass Inner C la ss{ in t v a r 1 ;
}
s ta tic S im p le 1 s m p ;
}
p u b lic c la ss S im p le {
void m e th od1 ( ){ in t x , y;
x = S im p le 2 .inne rc la ss. v a r 1 ; /* e r ro r : 'inne rc la ss ' is not n a m e of
a n in n er c la s s . 'In n er C la s s ' is */ y = S im p le 2 .s m t .va r 1 ; /* erro r : 's m t ' is n o t th e nam e of a f ie ld in
'S im p le 2 ', S hould b e 's m p ' */
}
}
编 译 器 错 误 J0 2 3 8
C a n n o t th r o w e x c e p tio n ' id e n tifie r ' fr o m f ie ld in it ia liz e r
编
译 器 检 测 到 在 一 个 字 段 初 始 化 内 发 出 的 异 常 当 一 个 类 的
构 造 器 内 有可 发 出 的 异 常 而 这 个 类 的 实 例 声 明 并 且 实 例
化 为 另 一 个 类 的 成 员 时 通常 会 出 现 这 种 错 误 为 了 解 决 这
个 问 题 让 发 出 异 常 的 类 对 象 在 一 个 构造 器 内 实 例 化 以 便
让 它 能 组 合 使 用 t ry/ca tch 捕 捉 从 其 他 类 构 造 器 调 用的 任
何 异 常
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic in t i;
p u b lic S im p le ( b oolea n var 1 ) th ro w s E x cep t ion{ if ( v a r 1 = t ru e)
i = 0 ;
e ls e
}
}
th ro w n ew E x cep t io n ( ) ;
/ / T h is is th e in co rrect w a y to in s ta n t ia te th is cla s s c lass S im p le 2 {
S imp le s m p = n ew S imp le ( t ru e);
/* erro r : ca n n o t ca ll co n s t ru c to r th a t th ro w s ex cep t io n in field in it ia liz er*/
}
用
下 面 代 码 替 换 上 例 的 S im p le 2 类 代 码 声 明 实 例 化 S im p le
类 实 例的 正 确 方 式
/ / T h is is th e co r rect w a y to in s ta n t ia te S im p le c lass S im p le 2 {
S im p le s m p ;
p u b lic S im p le 2 ( ){
t ry{
s m p = n ew S im p le ( t ru e);} ca tch ( E x cep t io n e) { }
}
}
编 译 器 错 误 J0 2 3 9
S ta tic in itia liz e r m u s t a ssig n a v a lu e to b la n k f in a l v a r ia b le 'id e n t ifie r '
编
译 器 检 测 到 没 有 使 用 静 态 或 字 段 初 始 化 值 给 一 个 sta t ic
f in a l 变 量 初 始化 一 个 值 为 把 变 量 声 明 为 sta t ic 和 fin a l
必 须 使 用 静 态 或 字 段 初 始 化值 设 置 一 个 初 始 值 在 构 造 器
内 如 果 一 个 字 段 声 明 为 sta t ic 和 fin a l 并 且赋 值 一 个 值 也
会 出 现 这 种 错 误
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
s ta tic f in a l in t M A X _ C O N T R O L ;
} / / erro r : static f inal variab les m u st have valu e assigned
编 译 器 错 误 J0 2 4 0
S y n ta x erro r in @ s e c u r i ty d e c la r a t io n
编 译 器
检 测 到 指 定 的 @ se c u r i ty 注 释 标 记 中 有 句 法 错 误 当 注 释
标 记 缺 少一 个 结 束
括
号 或 标 记 的 属 性 不 正 确 时 通 常 会 出 现 这 种 错 误 确 保 所 指
定 的
@
se c u r i ty 注 释 标 记 声 明 的 句 法 是 正 确 的 重 新 编 译
下 面 举
例 说 明 这 种 错 误
/** @ secu r ity()*/ / / erro r : invalid @ s ecu r ity syntax p u b lic c la s s S im p le {
/ / c las s m em b ers defined h ere
}
编 译 器 错 误 J0 2 4 1
'@ s e c u r i ty ' c a n o n ly be sp ecified o n a cla ss o r in terfa c e
编
译 器 检 测 到 @ se c u r i ty 注 释 标 记 使 用 到 不 是 类 或 接 口 声
明 的 地 方@ se c u r i ty 注 释 标 记 用 来 为 类 或 接 口 定 义 安 全
设 置 不 能 应 用 到 方 法 或 类的 字 段 或 者 接 口 上
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
/**@ s ecu rity ( ch eck D llC a lls = o n )*/ p u b lic v o id m e th o d 1 ( ) {
/ / erro r : ca nnot use @ s ecu r ity ta g on m e th o d
}
}
编 译 器 错 误 J0 2 4 2
C a n n o t m a k e s ta tic c a ll to n o n - s ta tic m e th o d ' id e n tifie r '
编
译 器 检 测 到 通 过 使 用 静 态 方 法 调 用 句 法 < c la ssn am
e> .< m e th o d > 调用 的 一 个 方 法 但 这 个 方 法 不 是 静
态 方 法 用 包 含 方 法 的 类 实 例 代 替 类名 本 身 来 修 改 这 个 方
法 调 用 重 新 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic v o id em th o d 1 ( ){
/ / do som e th ing here
}
}
c las s N o t S im p le{
p u b lic v o id m e th o d x ( ) { S im p le .m e th o d 1 ( ) ;
/ / erro r : 'm e thod1 ' is n o t a static m e thod
}
}
编 译 器 错 误 J0 2 4 3
'id e n tifie r ' is o b so le te ; u s e 'id e n tifie r ' in s te a d
编
译 器 检 测 到 使 用 一 个 格 式 的 注 释 标 记 如 @ c o m ,@ d l l ,@
se c u r i ty) 而 所使 用 的 格 式 已 经 过 时 为 避 免 这 种 错 误 把
出 现 错 误 的 代 码 行 改 为 错 误信 息 中 指 定 的 新 格 式 并 且 重
新 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
/**@ d llim p o r t (" k ern el3 2 " ,a n s i)*/
/* erro r : 'd llim p o r t ' is no longer a sup p orted fo rm at fo r @ d ll.im p o r t d ecla ra t io n s */
p u b lic static native b o olea n G e t C om p u ter N am e( S t r ingB u f fer s, in t [ ] cb ) ;
}
编 译 器 错 误 J0 2 4 4
@ c on d i t ion a l a l lo w e d on ly on v o id - r e tu r n in g m e th od s
编
译 器 检 测 到 一 个 方 法 的 @ c ond it iona l 注 释 标 记 而 这 个 方
法 有 一 个 非空 的 返 回 值 把 方 法 声 明 改 为 返 回 vo id 或 删 除 @
c ond it iona l 注 释 标 记重 新 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
/* * @ c ond it iona l ( D E B U G )* /
p u b lic in t m e thod1 ( int x ) {
/ / erro r : co n d it ional m e th o d s ca nno t retu rn a valu e retu rn x * 2
}
}
编 译 器 错 误 J0 2 4 5
W a rn in g tr e a te d a s er ro r
编
译 器 使 用 /w x 开 关 运 行 编 辑 过 程 中 发 现 一 个 警 告 编 译 器
开 关 /w x 把 所 有 的 警 告 都 视 为 错 误 为 使 编 译 器 开 关 /w x 显
示 这 种 错 误 必 须 设置 足 够 高 的 警 告 级 别 开 关 /w {0 -4 }) 以
显 示 这 个 警 告 确 定 警 告 的 起 因再 次 进 行 编 译 也 可 以 从 编
译 器 选 项 中 删 除 这 个 开 关 并 且 再 次 进 行 编译
编 译 器 错 误 J0 2 4 6
In va lid to k e n o n a #d ir e c t ive
编
译 器 发 现 一 个 非 法 标 识 用 于 一 个 条 件 编 译 表 达 式 当 一 个
标 识 缺 少 类型 或 使 用 的 标 识 非 法 时 往 往 会 出 现 这 种 错 误
确 保 错 误 中 指 出 条 件 编
译
伪 指 令 正 确 并 且 再 次 进 行 编 译下 面 举 例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ){
# if f D E B U G / / erro r : 'if f ' is not a valid to ken
S ystem .o ut.p r in t ln (" D o so m e th ing m eanin g ful here" ) ; # en d if
}
}
编 译 器 错 误 J0 2 4 7
# e l if w ith o u t m a th in g # i f
编
译 器 检 测 到 一 个 #e l if 条 件 编 译 伪 指 令 但 是 没 有 检 测 到
相 匹 配 的 # if 伪 指 令 确 保 有 一 个 合 法 的 # if 条 件 编 译 伪
指 令 匹 配 #e l if 伪 指 令 再 次 进行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ) {
/ / erro r: n eed to h a v e '# if ' b efo re '# elif' # e lif D E B U G
S ystem .o ut.p r in t l( " D o som e th in g m ean ingful h ere" ) ; # en d if
}
}
编 译 器 错 误 J0 2 4 8
# e n d i f w ith o u t m a tc h in g # i f
编
译 器 检 测 到 一 个 #e nd if 条 件 编 译 伪 指 令 但 是 没 有 检 测 到
相 匹 配 的 # if 伪 指 令 这 种 错 误 的 出 现 往 往 是 因 为 提 供 了
额 外 的 #e nd if 伪 指 令 当 删除 或 注 释 掉 一 个 # if 条 件 编 译
伪 指 令 但 没 有 删 除 相 匹 配 的 #e nd if 伪 指 令时 也 会 出 现 这
种 错 误 确 保 具 有 完 全 匹 配 的 伪 指 令 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ){
/ / # if S IM P L E
/ / do som e th ing here # if D E B U G
/ / do som e th in g here # if W IN 9 5
/ / d o s o m e th in g h ere # en d if
# en d if
# en d if / / erro r: ex t ra '# en d if ' d irectiv e n o t p erm it ted
}
}
编 译 器 错 误 J0 2 4 9
# e lse w ith o u t m a tc h in g # i f
编
译 器 检 测 到 一 个 #e lse 条 件 编 译 伪 指 令 但 是 没 有 检 测 到
相 匹 配 的 # if 伪 指 令 这 种 错 误 的 出 现 往 往 是 因 为 提 供 了
额 外 的 #e lse 伪 指 令 当 删 除或 注 释 掉 一 个 # if 条 件 编 译 伪
指 令 但 没 有 删 除 相 匹 配 的 #e lse 伪 指 令 时也 会 出 现 这 种 错
误 确 保 具 有 完 全 匹 配 的 伪 指 令 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
pub lic v o id m e thod1() {
/ / D o s o m e th in g h ere
# e ls e /* erro r: th is '# els e ' d irectiv e h a s n o m a tch in g '# if ' d irectiv e */
}
}
编 译 器 错 误 J0 2 5 0
A lr e a dy h a d a n # e ls e
编
译 器 检 测 到 在 一 个 # if 伪 指 令 块 里 有 双 重 的 #e lse 条 件
编 译 伪 指 令 一个 # if 伪 指 令 只 能 有 一 个 相 匹 配 的 #e lse 伪
指 令 确 保 在 错 误 出 现 的 地 方只 有 一 个 #e lse 条 件 编 译 伪 指
令 匹 配 # if 伪 指 令 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
# if A
# if B
v o id m e th o d 1 {
/ / do som e th ing here
}
# e ls e
v o id m e th o d 2 {
/ / do som e th ing here
# e ls e / / erro r: ex t ra '# els e ' d irectiv e s u p p lied # endif
}
编 译 器 错 误 J0 2 5 1
U n e x pe cted E O F w h i le lo o k in g fo r # e n d if
编
译 器 检 测 到 一 个 # if 条 件 编 译 伪 指 令 但 是 没 有 发 现 相 匹
配 的 #e nd if 伪指 令 而 被 # if 伪 指 令 使 用 的 符 号 也 没 有 定
义 当 使 用 了 一 个 # if 条 件 编译 伪 指 令 但 是 没 有 定 义 相 匹
配 的 #e nd if 伪 指 令 来 关 闭 这 个 条 件 编 译 块时 往 往 会 出 现
这 种 错 误 确 保 有 一 个 #e nd if 伪 指 令 与 错 误 中 指 定 的 # if
伪 指 令 相 匹 配 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le { v o id m e thod1() {
# if D E B U G / / deb ug h a s n o t b een defined
S ys tem .o u t .p r in t ln (" D o s o m th in g h ere" ) ;
/ / erro r: '# en d if' n o t s p ecified fo r th e '# if ' d irectiv e
}
}
编 译 器 错 误 J0 2 5 2
# i f n e s ted to o d eep ly
编 译 器
检 测 到 嵌 套 # if 条 件 编 译 块 嵌 套 太 深 了 # if 条 件 编 译 块
的 嵌 套 极
限
是 64 层 确 保 # if 块 的 嵌 套 在 极 限 作 用 域 内 再 次 进 行 编 译
编 译 器 错 误 J0 2 5 3
C a n n o t h ave #d e f in e /#u n d e f afte r s o u r c e
编
译 器 检 测 到 在 其 他 Ja va 源 代 码 之 前 有 一 个 #de f ine 或
#unde f 条 件 编 译伪 指 令 #de f ine 或 #unde f 伪 指 令 必 须 放 在
其 他 Ja va 源 代 码 之 前 其 他 条件 编 译 伪 指 令 和 源 注 释 除 外
把
错 误 中 指 出 的 #de f ine 或 #unde f 伪 指 令 移 到 文 件 中 所 有
Ja va 源 代 码 之前 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
pa c k a g e boxe s ; #de f ine D E B U G
/ / erro r: '# d efin e ' m u s t o ccu r b efo re th e 'p a ck a g e ' s ta tem en t
p u b lic c la ss S im p le {
}
编 译 器 错 误 J0 2 5 4
C a n n o t c h a n g e pr ed efin ed sy m b o l
编
译 器 检 测 到 试 图 在 Ja va 中 已 定 义 的 符 号 上 使 用 #de f ine
或 #unde f 伪 指令 当 已 为 条 件 编 译 定 义 的 符 号 如 tru e 或 fa
lse 又 使 用 #de f ine 或 #unde f 条 件 编 译 伪 指 令 重 新 定 义 时
往 往 会 重 新 这 种 错 误 删 除 或 改 变 错 误 中指 出 的 #de f ine 或
#unde f 伪 指 令 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
# u ndef fa ls e / / erro r : ca nno t un define th e 'false' sym b ol
# d efin e t ru e / / erro r: ca n n o t u n d efin e th e p red efin ed 'tru e' s ym b o l
p u b lic c la ss S im p le {
// D o s o m eth in g h ere
}
编 译 器 错 误 J0 2 5 5
E x p ected # e n d if
编
译 器 检 测 到 一 个 # if 条 件 编 译 伪 指 令 但 是 没 有 发 现 相 匹
配 的 #e nd if 伪指 令 可 是 定 义 了 # if 伪 指 令 使 用 的 符 号 当
一 个 使 用 了 一 个 # if 条 件 编译 伪 指 令 但 是 没 有 定 义 一 个
相 匹 配 的 #e nd if 伪 指 令 来 关 闭 这 个 条 件 编译 块 而 想 要 编
译 代 码 时 往 往 会 出 现 这 种 错 误 确 保 有 一 个 #e nd if 伪指 令
与 错 误 中 指 出 的 # if 伪 指 令 相 匹 配 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
#de f ine D E B U G
p u b lic c la s s S im p le { void m e th od1 ( ) {
# if D E B U G
S y s tem .o u t .p r intln (" D o som thing here" ) ;
/ / erro r : '# en d if' h a s n o t b een s p ecified fo r th e '# if ' d irectiv e
}
}
编 译 器 错 误 J0 2 5 6
E x p ected ' c la ss',' in terfa c e ' , o r ' d e leg a te'
编
译 器 希 望 在 相 应 的 声 明 中 使 用 关 键 字 c las s , in te r face
或 d e le g a te 当 在一 个 c las s , in te r face 或 d e le g a te 声
明 中 漏 掉 关 键 字 时 往 往 会 出 现 这 种 错误 可 能 引 起 这 种 错
误 的 另 外 一 个 原 因 是 大 括 号 不 匹 配
注
意 在 项 目 中 如 果 启 用 Microsoft Extensions 则 只 会 出 现 这 种错
误 否 则 就 会 显 示 编 译 器 错 误 J0020
下 面 举
例 说 明 这 种 错 误
p u b lic S im p le { //e r ro r : m is sin g th e 'c la ss ' k e yw o rd
// D o s o m eth in g h ere
}
这 个 例
子 说 明 由 大 括 号 不 匹 配 引 起 这 种 错 误
p u b lic c la s s S im p le {
// do s o m e th in g m e a n in g ful
}} // e r ro r : a d d it iona l '} ' is not pe rm i t te d
编 译 器 错 误 J0 2 5 7
D e le g a te c a n n o t b e in itia liz e d w ith s ta t ic m e th o d 'id e n t i f ie r '
编
译 器 检 测 到 一 个 d e le g a te 实 例 但 作 为 参 数 传 递 的 方 法
引 用 是 一 个sta t ic 方 法 当 实 例 化 一 个 d e le g a te 时 必 须 把
非 静 态 方 法 作 为 参 数 来 传递 确 保 定 义 d e le g a te 要 使 用 的
方 法 是 一 个 非 静 态 方 法 再 次 进 行 编 译下 面 举 例 说 明 这 种
错 误
d e le g a te in t M y D e le g a te ( i t v a r 1 , S tr in g v a r 2 ) th ro w s E x c e p tio n ;
p u b lic c la s s S im p le{
pub lic s ta t ic in t m e thod1( in t v a r 1 , S t r ing v a r 2 ) th ro w s E x c e p tion{
/ / do som e th ing here retu rn v a r 1 ;
}
p u b l ic s ta t ic v o id m a in (S tr in g a rg s []){
S im p le s m p = n ew S im p le ( ) ;
M y D e legate m d = new M y D e legate( s m p .m e thod1 ) ;
/* erro r : th e m eth o d p a s s ed a s a p a ra m eter to th e d e leg a te is a s ta t ic m eth o d */
}
}
编 译 器 错 误 J0 2 5 8
C a n n o t d e c la re d e le g a te in in n er cla ss ' ide n t if ier'
编
译 器 检 测 到 试 图 在 一 个 内 部 类 里 声 明 一 个 d e le g a te 内
部 类 定 义 不 支持 在 它 们 内 部 声 明 的 d e le g a te 从 内 部 类 声
明 中 删 除 d e le g a te 声 明 再 次进 行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
/ / D o som e th in g m ean ingful h ere c lass In n er C la ss{
/ / D o som e th in g m ean ingful h ere
delegate in t M y D elegate ( int var 1 , S t r ing var 2 ) ;
/* erro r: d eleg a tes ca n n o t b e d ecla red in s id e in n er cla s s es */
}
}
编 译 器 错 误 J0 2 5 9
E x c e p tio n ' id e n tifie r ' fr o m m e th o d ' id e n tifie r ' is n o t a su b c la s s o f a n y e x ce ptio n s d e c la r ed th ro w n by de le g a te ' ide n t i f ie r'
编
译 器 检 测 到 通 过 一 个 发 出 异 常 方 法 初 始 化 的 一 个 d e le g
a te 这 个 发 出异 常 与 d e le g a te 声 明 的 异 常 设 置 是 不 相 容
的 每 个 通 过 方 法 使 用 的 发 出异 常 必 须 与 d e le g a te 发 出 的
异 常 有 相 同 的 类 或 是 d e le g a te 发 出 的 异 常的 子 类 改 变 通
过 d e le g a te 使 用 的 发 出 异 常 设 置 或 者 改 变 通 过 方 法 使用
的 异 常 发 出 设 置 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
d e le g a te v o id S im p le D e le g a te ( S trin g v a r 1 ) th ro w s E x c e p t io n ;
p u b lic c la s s S im p le{
p u b lic vo id m e thod 1 ( S t r ing var 1 ) th ro w s T h ro w a b le{
/ / do som e th ing here
}
p u b lic s ta tic v o id m a in ( S t rin g a rg s [ ] ){
S im p le s m p = n e w S im p le ( ) ;
S im p le D e leg a te del1 = new S im p le D e legate( s m p .m e thod1 ) ;
/* erro r: th e m e th o d referen ce a rg u m en t th ro w s a n ex cep t io n th a t is n o t th e s a m e o r a s u b c la s s o f th e ex cep t io n d ecla red b y th e d e leg a te */
}
}
编 译 器 错 误 J0 2 6 0
C a n n o t d e c la re a n in terfa c e m e th o d to b e ' p r o tected ' o r ' p riv a te'
编
译 器 检 测 到 带 有 声 明 为 pro te c te d 或 priv a te 的 方 法 的 一
个 接 口 接 口方 法 必 须 声 明 为 pub lic 或 不 带 访 问 修 饰 符 默 认
情 况 下
改 变 错 误 中指 出 的 接 口 方 法 声 明 使 它 不 声 明 为 pub lic 或
priv a te 再 次 进 行 编 译下 面 举 例 说 明 错 误
in te r face IS im p le {
p u b lic v o id m e th o d 1 ( ) ; / / th is is O K !
v o id m e th o d 2 ( ) ; / / th is is O K ! D ecla red a s 'd efa u lt ' a cces s
p ro tected v o id m e th o d 3 (); /* erro r : ca n n o t d ecla re in terfa ce m e th o d a s p ro tected */ p r iv a te v o id m e th o d 4 ( ) ; /* erro r: ca n n o t d ecla re in terfa ce m eth o d a s p r iv a te */
}
编 译 器 错 误 J0 2 6 1
A n e x p lic it en clo s in g in s ta n ce o f cla ss ' id en t i f ier' is n e e d e d to in s ta n t ia te in n er cla ss ' id en t i f ie r '
编 译 器
检 测 到 试 图 在 没 有 指 定 实 例 的 类 内 创 建 一 个 内 部 类 实 例
当 试 图
在
一 个 静 态 方 法 内 像 实 例 化 外 部 类 一 样 实 例 化 一 个 内 部 类
时 往 往 会 出现 这 种 错 误 为 创 建 一 个 内 部 类 实 例 必 须 使 用
它 的 现 有 外 部 类 实 例创 建 一 个 类 作 用 域 内 的 实 例 并 且 把
用 它 实 例 化 内 部 类 再 次 进 行 编 译下 面 举 例 说 明 这 种 错 误
p u b lic c la ss S im p le {
c lass In n er C la ss{
/ / do som e th ing here
}
p u b l ic s ta t ic v o id m a in (S tr in g a rg s []){
Inner C la ss in c = new Inner C la ss();
/* erro r: a n in s ta n ce o f th e o u ter cla s s is req u ired to in s ta n t ia te its in n er cla s s */
}
}
下 面 举
例 说 明 如 何 使 用 外 部 类 实 例 创 建 内 部 类 实 例
p u b lic c la s s S im p le{ c lass In n er C la ss{
/ / D o s o m e th in g h ere
}
p u b lic static void m a in ( S t r ing args[]){ S im p le s m p = n ew S im p le ( ) ;
/* u s e th e in s ta n ce o f 'S im p le' to crea te a n in s ta n ce o f its in n er cla s s */
Inner C la ss in c = sm p .new Inner C la ss();
}
}
编 译 器 错 误 J0 2 6 2
A n ex p l ic i t en c lo s in g in s ta n ce o f cla ss ' ide n t i f ier' is n eed ed to ca l l c o n str u c to r o f su p e r c la ss ' id e n tifie r '
编
译 器 检 测 到 试 图 通 过 没 有 超 类 实 例 的 派 生 类 调 用 它 超 类
的 构 造 器 这种 错 误 的 出 现 往 往 是 因 为 超 类 也 是 内 部 类 当
一 个 派 生 类 被 实 例 化 时它 的 超 类 实 例 也 创 建 了
并 且 超 类 构 造 器 被 引 用
为 创 建 一 个 内 部 类实 例 必 须 使 用 外 部 类 来 实 例 化 内 部 类
下 面 举
例 说 明 这 种 错 误
c las s O u te r C la ss {
c lass In n er C la ss{
// d o s o m eth in g h ere
}
}
p u b lic c la ss S im p le e x te n d s O u te r C la ss . In n e r C la ss {
// d o s o m eth in g h ere
}
/* erro r : s u p ercla s s 'In n er C la s s ' ca n n o t b e in s ta n t ia ted w ith o u t its o u ter c lass 'O u ter C lass' b e ing in s tantiated */
下 面 举
例 说 明 如 何 实 例 化 一 个 从 内 部 类 派 生 的 类
c lass O u ter C la s s {
c lass In n er C la ss{
// d o s o m eth in g h ere
}
}
pub lic c la ss S im po le e x te nds O u te r C la ss .Inne r C la ss{
S im p le ( ){
/* th is lin e crea tes a n in s ta n ce o f th e o u ter cla s s a n d ca lls th e s u p ercla s s ( th e in n er c la s s ) co n s t ru cto r */
n ew O u terC la s s ( ) . s u p er();
}
}
编 译 器 错 误 J0 2 6 4
A r r a y c a n n o t h ave a d im e n s io n
编
译 器 检 测 到 初 始 化 数 组 不 正 确 在 创 建 实 例 之 前 指 定 一 个
数 组 维 数 的大 小 时 往 往 会 出 现 这 种 错 误 在 适 当 的 地 方 给
定 数 组 维 数 但 是 又 提
供
一 个 初 始 化 表 来 设 置 数 组 值 时 也 会 出 现 这 种 错 误
当 使 用 一 个 初 始化 表 时 不 能 指 定 数 组 维 数 的 大 小
改 正 错 误 中 指 定 的 数 组 初 始 化并 且 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ){
S t r ing [ 3 ] var 1 ; /* erro r : ca nn ot sp ecify arra y s ize here s ince a r ra y is n o t in s ta n t ia ted yet */
S trin g [ ] v a r2 = n ew S trin g [3 ]; / / th is is O K !
boo le a n v a r 3 = ne w boo le a n [ 3 ]{ tru e , fa ls e , t rue };
/* erro r: ca n n o t s p ecify a n a rra y s iz e fo r th e d im en s io n w h en u s in g a n in it ia liz a t io n lis t */
b oolea n var 4 = new b o olea n[]{ t ru e , fa ls e , t rue} ; / / th is is O K !
}
}
编 译 器 错 误 J0 2 6 5
@ d l l a t tr ib u te be p la c ed o n m e th o d ' id en t i f ier ' i t m u s t be d ec la r ed 'n a tiv e '
编
译 器 检 测 到 @ d l l 注 释 标 记 放 在 了 一 个 没 有 使 用 na t iv e
修 饰 符 声 明 的 方法 上 如 果 定 义 了 @ d l l 注 释 标 记 但 删 除 或
注 释 掉 了 它 的 方 法 而 类 中 的其 他 方 法 可 能 有 相 适 应 的 注
释 标 记 时 往 往 会 出 现 这 种 错 误 确 保 使 用@ d l l 注 释 标 记 声
明 的 方 法 声 明 为 na t iv e 或 删 除 @ d l l 注 释 标 记 再 次 进
行编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
/** @ d ll.im po r t (" U S E R 32" ) */
// priv a te na t iv e s ta t ic in t M e s sa g e B ix ( int h w ndO w n e r , S t r ing te x t , S t r ing title , in t fu S tyle ) ;
/* e r ro r : th e @ d l l c o m m e nt ta g c a nnot a pp lie d to 'm e thod1 ' w h ic h is a
n on- nativ e m e th od in stea d of th e in ten d ed native m e thod */ p u b lic v o id m e th o d 1 ( ){
/ / do som e th ing here
}
}
编 译 器 错 误 J0 2 6 6
C o m p i la t io n c a n c eled by u ser
用
户 取 消 编 译 这 种 错 误 简 单 地 通 知 用 户 请 求 取 消 编 译 成 功
编 译 器 错 误 J0 2 6 7
A d e le g a te c a n n o t b e ' id e n tifie r '
编
译 器 检 测 到 试 图 使 用 非 法 的 修 饰 符 声 明 一 个 d e le g a te
只 有 修 饰 符pub lic 和 fin a l 可 以 用 于 类 外 部 的 d e le g a te
声 明 类 内 部 的 d e le g a te 声 明可 以 应 用 修 饰 符 pub lic , f
ina l , pro te c te d 和 priv a te 确 保 d e le g a te 声 明 没 有使 用
非 法 修 饰 符 再 次 进 行 编 译
注
意 虽 然 可 以 在 delegate 声 明 中 使 用 修 饰 符 final, 但 这 是 没
有 必要 的 因 为 delegate 隐 含 的 就 是 final
下 面 举
例 说 明 这 种 错 误
p riv a te d e le g a te v o id S im p le ( in t v a r 1 , in t v a r 2 ) ;
/ / erro r: ca n n o t d ecla re a d e leg a te a s 'p riv a te '
编 译 器 错 误 J0 2 6 8
A d e le g a te c a n n o t b e 'id e n t i f ie r ' a n g 'id e n t i f ie r '
编
译 器 检 测 到 在 一 个 类 内 试 图 使 用 不 允 许 的 访 问 修 饰 符 组
合 来 声 明d e le g a te 当 使 用 两 个 访 问 修 饰 符 声 明 一 个 d e
le g a te 时 往 往 会 出 现 这 种错 误 删 除 应 用 到 指 定 d e le g a
te 声 明 中 的 多 余 访 问 修 饰 符 再 次 进 行 编
译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic p r iv ate delegate void S im p le D e legate();
/ / erro r : ca n not declare a delegate to b e 'p ub lic ' and 'p r ivate'
}
编 译 器 错 误 J0 2 6 9
A m b ig u o u s n a m e : in h e r i ted ' id e n t if ier' a n d o u te r s c o p e id en t i f ier '— a n e x p l ic it 'th is ' q u a lifie r is r e q u ir e d
编
译 器 检 测 到 从 内 部 类 里 引 用 在 外 部 类 和 超 类 里 都 定 义 的
变 量 或 方 法编 译 器 不 能 确 保 使 用 哪 个 变 量 或 方 法 可 以 通
过 使 用 c las s .th is . n am e 引 用外 部 类 变 量 或 方 法 这 里 的 c
las s 是 希 望 引 用 的 变 量 和 方 法 的 外 部 类 名字 na m e 是 变 量
或 方 法 名 字 为 引 用 这 个 超 类 变 量 或 方 法 , 必 须 在 引 用之 前
使 用 关 键 字 th is s u p e r
下 面 举
例 说 明 这 种 错 误
c las s N o t S im p le{
in t v a r 1 = 20;
}
p u b lic c la ss S im p le {
in t v a r 1 = 10;
c lass In n er C la ss ex tends N o t S im p le{ in t v a r 2 = v a r 1 ;
/ / erro r : ca nn ot d e term in e w h ich 'v ar 1 ' to use
}
}
下 面 举
例 说 明 如 何 在 外 部 类 和 超 类 变 量 之 间 解 析 名 字 的 二 义 性
c lass N o t S im p le{ in t v a r 1 = 20;
}
p u b lic c la ss S im p le {
in t v a r 1 = 10;
c lass In n er C la ss ex tends N o t S im p le{ in t v a r 2 = S im p le .th is .v a r 1 ;
/ / th is is O K a n d referen ces th e o u ter cla s s v a r ia b le in t v a r 3 = s u p er.v a r 1 ;
/ / th is is O K and references th e sup ercla ss variab le
}
}
编 译 器 错 误 J0 2 7 0
A m b ig u o u s refer en c e to ' id en t i f ier ' in in te rfa ce ' ide n t if ier' a n d cla ss 'id e n tifie r '
编
译 器 检 测 到 对 字 段 的 二 义 性 引 用 当 一 个 类 的 超 类 与 这 个
类 实 现 的 接口 有 相 同 的 字 段 声 明 时 往 往 会 出 现 这 种 错 误
编 译 器 不 能 确 定 使 用 这个 字 段 的 哪 一 个 实 例 确 保 超 类 和
实 现 的 接 口 没 有 相 同 定 义 的 字 段 再次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic cla s s S im p le ex ten d s S u p erC la s s im p lem en ts S u p er In terfa ce { p u b lic s ta tic v o id m a in ( S t rin g a rg s [ ] ) {
f loat x = var 1 ; /* erro r : ca nno t determ in e w h ich in stan ce of 'v ar 1 ' to use */
}
}
c lass S u p er C la ss { f lo a t v a r 1 ;
}
in terfa ce S u p er In terfa ce { flo a t v a r 1 = 6 .0 f;
}
编 译 器 错 误 J0 2 7 1
E x p ected ' d eleg a te '
编
译 器 检 测 到 m u ltic a s t 修 饰 符 但 没 有 检 测 到 关 键 字 d e le
g a te m u ltic a s t 修 饰 符 只 能 连 同 关 键 字 d e le g a te 一 起
使 用 来 创 建 多 点 委 托 确 保 在 声 明中 有 错 误 消 息 中 指 出 的 d
e le g a te 关 键 字 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic m u ltic a s t v o id S im p le D e le g a te ( S trin g x , in t y);
/ / erro r: th e 'd eleg a te' k eyw o rd is m is s in g a f ter th e 'm u lt ica s t ' m o d ifier p u b lic c la s s S im p le {
// D o s o m eth in g h ere
}
编 译 器 错 误 J0 2 7 2
A m u l t ic as t d e le gate c a n n o t r e tu r n a va lu e
编
译 器 检 测 到 与 为 m u ltic a s t d e le g a te 声 明 的 vo id 不 同
的 返 回 类 型 虽 然d e le g a te 可 以 返 回 一 个 与 vo id 不 同 的 值
但 m u ltic a s t d e le g a te 不 能 返 回与 vo id 不 同 的 值 确 保 错
误 中 指 定 的 m u ltic a s t d e le g a te 声 明 返 回 vo id 再 次 进
行 编 译
下 面 举
例 说 明 这 种 错 误
m u ltic a s t d e le g a te in t S im p le D e le g a te ( in t x , in t y);
/ / erro r : ca nno t declare m u lt icast delegate w ith non- void retu rn typ e p u b lic c la s s S im p le{
p u b lic in t m eh to d 1 ( in t x , in t y){
/ / D o s o m e th in g h ere
}
p u b l ic s ta t ic v o id m a in (S t r in g a rg s[]) {
S im p le s m p = n ew S im p le ;
S imp le D e leg a te s d = n ew S imp le D e leg a te( s mp .m e th o d 1 ) ;
}
}
编 译 器 错 误 J0 2 7 3
C a n n ot c a s t to ' v oid '
编
译 器 检 测 到 试 图 把 方 法 调 用 的 返 回 值 设 置 为 vo id 在 Ja va
语 言 中 不 允许 把 方 法 调 用 设 为 vo id 删 除 为 错 误 中 指 出 的
方 法 调 用 设 置 的 vo id 再次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
p u b lic c la ss S im p le {
p u b lic v o id m e th o d 1 ( ){
/ / D o s o m e th in g m ea n in g fu l h ere
}
p u b lic s ta tic v o id m a in ( S t rin g a rg s [ ] ){ S im p le s m p = n ew S im p le ( ) ;
( v o id ) m e th o d 1 ( ) ;
/ / erro r : ca nn ot ca st m e th od 's retu rn valu e to 'void '.
}
}
编 译 器 错 误 J0 2 7 4
E x p ected ' id en t i f ie r ' w i th in s in g le co m m e n t pr eced in g cla ss ' id en t i f ier'
编
译 器 检 测 到 错 误 信 息 中 指 出 的 类 使 用 @ c om . typ e info 或@
c om . tra ns a c t io n 注 释 标 记 声 明 而 在 同 一 个 注 释 里 没 有
相 应 的@ c o m . re g iste r 注 释 标 记 当 声 明 一 个 @ c o m . re g
iste r 注 释 标 记 但 是 把 它放 在 独 立 的 注 释 里 时 往 往 会 出 现
这 种 错 误 确 保 为 错 误 信 息 中 指 出 的类 定 义 的 @ c o m . re g
iste r 注 释 标 记 与 定 义 的 @ c om . typ e info 或@ c om . tra ns a c
t io n 注 释 标 记 在 同 一 个 注 释 里 再 次 进 行 编 译
下 面 举
例 说 明 这 种 错 误
/* * @ c o m .re g is te r ( c ls id = A E 032C 46 -E 6 A 0 - 11d0 -8C 83 -00C 04 F C 2A A E 7) * /
/** @ co m .typein fo ( a t t r id = 3 141 592 6- 5 358 - 9 793 - 2 384 - 6 1 234 567 890 1, v a lu e= " h elp " ) */
p u b lic c la s s S im p le {
/ / erro r : th e '@ co m .reg is ter' ta g is ig n o red s in ce it is in a s ep a ra te co m m en t*/
}
/* * @ c o m .re g is te r ( c ls id = A E 032C 46 -E 6 A 0 - 11d0 -8C 83 -00C 04 F C 2A A E 7)
@ co m .typ e in fo ( a t t r id = 3 141 592 6- 535 8- 9 793 - 2 384 - 6 123 456 789 01, v a lu e= " h elp " ) */
p u b lic c la s s S im p le 2 {
/ / T h is co m m en t is O K . It co m b in es b o th ta g s in a s in g le co m m en t .
}
编 译 器 错 误 J0 2 7 5
C la ss o r in te rfa ce n a m e ' ide n t if ier' co n f l icts w ith pa c k a g e ' ide n t if ier'
指
定 类 或 接 口 名 与 软 件 包 名 发 生 冲 突 在 一 个 软 件 包 内 使 用
与 一 个 子 软件 包 名 相 同 的 名 声 明 类 或 接 口 时 可 能 引 起 这
种 错 误 删 除 引 起 冲 突 的子 软 件 包 或 类 或 接 口 再 次 进 行 编
译
下 面 举
例 说 明 这 种 错 误
// lo c a te d in a f ile c a l le d P la stic . ja v a
p a ck a g e B o x es .D is h es ; p u b lic c las s P lastic{
// d o s o m eth in g h ere
}
/ / lo ca ted in a file ca lled D is h es .ja v a p a ck a g e B o x es ;
p u b lic c las s D ishes {
// erro r: th e n a m e 'D is h es ' is a ls o th e n a m e o f th e s u b p a ck a g e
}
编 译 器 错 误 J0 5 0 0
# err o r ' tex t '
当
程 序 中 有 # e rro r 条 件 编 译 伪 指 令 时 产 生 这 种 错 误 信 息下
面 举 例 说 明 这 种 错 误
#de f ine D E B U G
p u b lic c la s s S im p le {
p u b lic v o id m e th o d 1 ( ) { # if D E B U G
# erro r yo u shou d not b e running in deb u g m o de here !
/ / erro r disp la yed w h en 'D E B U G ' is defined # en d if
}
}
编 译 器 警 告 J5 0 0 1
L o c a l v a r ia b le 'id e n tifie r ' is in itia liz e d b u t n e v e r u se d
编
译 器 检 测 到 在 任 何 类 代 码 中 都 没 有 引 用 的 初 始 化 变 量 这
种 信 息 出 现在 级 警 告 或 较 高 级 的 警 告 里 在 类 代 码 中 使 用
变 量 或 删 除 它 们
下 面 举
例 说 明 这 种 警 告
p u b lic c la ss S im p le {
p u b lic in t m e thod1 ( ) {
in t i= 1 ;
retu rn 1 ;
/ / w a rn in g : 'i' is n ev er u s ed
}
}
编 译 器 警 告 J5 0 0 2
C o m p i le r o p t io n ' id e n t if ier' is n o t s u p p o rted
编
译 器 检 测 到 指 定 一 个 不 支 持 的 命 令 行 操 作 检 查 编 译 器 开
关 设 置 再次 进 行 编 译
编 译 器 警 告 J5 0 0 3
Ig n o r in g u n k n ow n c o m p i le r op t ion ' id e n t if ie r '
编
译 器 检 测 到 在 JVC 命 令 行 上 指 定 了 一 个 不 认 识 的 操 作 当 存
在 输 入 错误 时 通 常 会 出 现 这 种 警 告 例 如 在 命 令 行 上 指 定
/W4 将 导 致 这 种 警告 因 为 警 告 级 别 操 作 必 须 使 用 小 写 w'
编 译 器 警 告 J5 0 0 4
M issin g a r g u m e n t fo r co m p i ler o p t io n ' ide n t i f ier'
编
译 器 检 测 到 一 个 合 法 的 命 令 行 操 作 没 有 指 定 所 需 要 的 变
量 检 查 编译 器 开 关 设 置 再 次 进 行 编 译
编 译 器 警 告 J5 0 0 5
P a ck a g e ' id en t i f ier' w a s a lrea d y im p l ic i t ly im p o rte d
编 译 器
检 测 到 已 经 隐 含 导 入 了 用 于 软 件 包 的 im port 语 句 例 如
Ja
va .la n g 这 种 信 息 出 现 在 级 警 告 或 较 高 级 别 的 警 告 中下 面
举 例 说 明 这 种 警 告
im p o r t ja va . la n g.*;
//w a rn in g : p ro c e ss is a l re a d y im p o r te d in th e f i rs t im p o r t s ta te m e n t
im p o r t ja v a .la n g .P ro ces s ;
p u b lic c la ss S im p le {
/ / D o som e th in g m ean ingful h ere
}
编 译 器 警 告 J5 0 0 6
' p r iv a te p r o te c te d ' n o t s u p p o r te d , u s in g ' p r o te c te d '
编
译 器 检 测 到 使 用 修 饰 符 组 合 priv a te pro te c te d 现 在 这 个
组 合 已 经 作 废而 用 pro te c te d 代 替 了 它 们 这 个 信 息 出 现 在
1 级 警 告 或 较 高 级 别 的 警 告中
编 译 器 警 告 J5 0 1 4
' ide n t i f ier' h a s be en d e p rec a te d b y th e a u th o r o f ' id en t i f ie r '
引
用 的 方 法 或 类 标 记 为 反 对 反 对 的 方 法 或 类 被 源 代 码 的 创
建 者 标记 为 过 时 的 和 可 移 动 的 内 容 为 保 持 代 码 稳 定 应 避
免 调 用 被 标 记 为 反对 的 函 数
编 译 器 警 告 J5 0 1 5
T h e p a r a m e te r ' id e n t i f ie r ' in an @ c o m . p ar am e te r s d e c lar atio n d o e s n o t m a tc h th e co rr es p o n d in g a r g u m e n t ' id e n t if ier'
—
个 @ c o m . p aram e ters 声 明 与 实 现 接 口 的 方 法 不 匹 配 这 种
错 误 表 示 数 据类 型 不 一 致 或 参 数 位 置 匹 配 错 误 确 保 @ c o m
. p aram e ters 声 明 与 声 明 的 方法 有 相 同 数 量 的 参 数 正 确 的
类 型 和 正 确 的 顺 序 再 次 进 行 编 译
下 面 举
例 说 明 这 种 警 告
/* * @ c o m .in te r fa c e ( i id= 31415926 -5358 -9793 -238 4 -612345678901 ,dua l ) * /
in terfa ce E x a m p leIn terfa ce
{
/**
@ com .m e thod( disp id = 3 0 6 )
@ co m .p a ra m eters ([typ e= B O O L E A N ] w h en ,o n )
*/
/ / erro r : @ com .p aram e ters declaration has p a ra m e ters in w rong lo ca t io n
pub lic S t r ing M e thod1( boo le a n on ,in t w h e n ) ;
}
编 译 器 警 告 J5 0 1 6
T h e ' in s ta n ceo f ' o p era to r w i l l a lw a y s b e tr u e
编
译 器 判 定 指 定 的 in s ta n c e o f 表 达 式 将 总 是 计 算 为 正 确
当 使 用in s ta n c e o f 确 保 一 个 子 类 实 例 是 否 是 一 个 基 类
成 员 或 实 现 接 口 时 可 能 会出 现 这 种 警 告 在 这 种 情 况 下 虽
然 使 用 in s ta n c e o f 运 算 符 并 没 有 错 误但 它 没 有 特 殊 用
途 因 为 表 达 式 将 总 是 计 算 正 确
下 面 举
例 说 明 这 种 警 告
in te r face I {}
c lass X { }
cla s s Y ex ten d s X im p lem en t s I { }
p u b lic c la ss S im p le {
void f ( )
{
Y y = n ew Y ( ) ; X x = n ew X ( ) ; O b ject o ;
// T h e se s ta te m e n ts g iv e J 5016 w a rn in g s…
if ( y in s ta n ceo f X ) {
/ / y is o f typ e Y , w h ich ex ten d s X , s o th is is a lw a ys t ru e
}
if ( y in s ta n ceo f I) {
// typ e Y im p lem en ts I, s o th is is a lw a y t ru e .
}
if (x in s ta n ceo f O b ject ) {
/ / ev eryth in g is o f typ e O b ject
}
}
}
编 译 器 警 告 J5 0 1 8
C lass ,in te r fac e ,o r p a c k age n a m e c o n ta in s c h ar ac te r s n o t in th e A S C II c h ar ac te r se t
编
译 器 检 测 到 c las s , in te r face 或 p ack a g e 名 字 使 用 的 字
符 没 有 在 AS C II 字符 集 里 一 些 计 算 机 系 统 可 能 不 支 持 这 个
字 符 为 确 保 c las s in te r fa c e 或 p ack a g e 名 字 可 以 被 其
他 计 算 机 系 统 上 的 虚 拟 机 VM
解 释 从 AS C II 字 符 集 中 把 非 法 字 符 变 为 合 法 字 符 再 次 进
行 编 译
编 译 器 警 告 J5 0 1 9
P u b l ic m e m b e r o f C O M - e x p o se d c las s o r in te r fac e c o n ta in s c h ar ac te r s n o t in th e A S C I I c h a r a c te r s e t
编
译 器 检 测 到 用 于 方 法 或 字 段 的 一 个 字 符 没 有 在 AS C II 字
符 集 里 这 种方 法 或 字 段 可 以 通 过 CO M 到 达 其 他 语 言 其 他 语
言 可 能 不 支 持 这 个 字符 确 保 可 以 从 其 他 语 言 中 访 问 成 员
名 字 从 AS C II 字 符 集 中 把 这 个 字符 改 为 合 法 字 符 再 次 进 行
编 译
编 译 器 警 告 J5 0 2 0
D irec t iv e ' id en t i f ier ' ig n o r e d ex te n s io n s a re tu r n e d o f f
编
译 器 检 测 到 在 源 代 码 中 应 用 了 注 释 标 记 例 如 @ c o m 或 @ d
l l 但 是 在M ic rosoft 语 言 扩 展 中 不 允 许 使 用 为 使 用 注 释 标
记 或 其 他 M ic rosoft 语言 扩 展 必 须 使 扩 展 操 作 可 用
警
告 使 用 禁 止 Microsoft 语 言 扩 展 操 作 任 何 利 用 Microsoft 语言
扩 展 的 代 码 都 不 可 能 正 确 工 作
下 面 举
例 说 明 这 种 警 告
/ / M ic rosoft L a ngu age E x ten s ions are 'd is ab led'
p u b lic c la ss S im p le {
/**@ d ll.im p o r t (" u s er 3 2 " )*/
p u b lic static native in t M essage B o x ( in t hW n d ,S t r ing tex t ,S t r ing ca p t io n , in t typ e);
/ / w a rn ing: th e 'M essage B o x ' m e thod m a y not w o rk co r rectly
编 译 器 警 告 J5 0 2 1
P a ck a g e ' id en t i f ier' s h o u ld n o t b e d e f in e d in d irecto r y ' ide n t i f ier'
编
译 器 检 测 到 在 源 文 件 中 有 p ack a g e 语 句 但 是 源 文 件 所 在
的 目 录 与p ack a g e 不 匹 配 尽 管 源 代 码 可 以 编 译 但 是 其 他
源 文 件 将 不 能 使 用p ack a g e 名 引 用 在 这 个 源 文 件 中 定 义
的 类 接 口 和 委 托
下 面 举
例 说 明 这 种 错 误
// so u rce f i le re s id e s in c :\f i les\sim p le
p a ck age b o x es; / / w a rn ing: p a ck ag e 'b ox es 'does no t m a tch directo ry n a m e 's im p le ' p u b lic cla s s N o t S im p le {
/ / w a rn in g : th is cla s s is n o t a cces s ib le u s in g th e cu rren t p a ck a g e n a m e
}
编 译 器 警 告 J5 0 2 2
R e fere n c e c la s s f i le ' f i len a m e' m a y b e o lde r th a n ' f i len a m e'
编
译 器 检 测 到 正 编 译 的 源 文 件 引 用 的 一 个 类 文 件 这 个 类 文
件 缺 少 日 期或 没 有 找 到 日 期 当 所 引 用 类 的 自 动 重 新 编 译
被 禁 止 时 使 用 re f- 编译 器 选 项
通 常 会 出 现 这 种 错 误 如 果 正 在 V isu a l J + + 内 编 译 在 默认
情 况 下 re f-选 项 已 经 传 送 到 了 编 译 器 如 果 任 何 一 个 源 文
件 引 用 的 类文 件 不 在 项 目 中 而 且 这 个 文 件 缺 少 使 用 源 的
日 期 则 需 要 修 改 所 引 用
的
类 文 件 可 以 编 译 外 部 类 文 件 使 它 们 补 上 日 期 把 外 部 类 添
加 到 项目 里 也 可 以 增 加 re f 选 项 增 加 re f 编 译 选 项 的 方 法
是 在 P ro je c t Se t t in g s 对 话 框 Co m p i le 选 项 卡 的 A d d
itio n a l C o m p ile r O p tio n 文 本 框 中 输 入 re f 编 译 器 选 项
编 译 器 警 告 J5 0 2 3
F i le ' f i le n a m e ' h a s m o r e th an 6 5535 l in e s— d e b u g in fo r m atio n m a y b e in co rr ect
编
译 器 试 图 把 调 试 信 息 放 入 包 含 多 于 65535 行 代 码 的 源 文 件
中 代 码 可以 编 译 但 是 在 这 个 文 件 中 并 不 包 含 应 用 程 序 所
需 要 的 全 部 调 试 代 码 缩 短 源 文 件 的 大 小 使 调 试 信 息 可 以
增 加 进 去 重 新 编 译
编 译 器 警 告 J5 0 2 4
P a ck a g e ' id en t i f ier' w a s a lrea d y im p o r ted
编
译 器 检 测 到 在 指 定 的 源 文 件 中 导 入 的 p ack a g e 多 于 一 次
虽 然 这 不 会导 致 编 译 失 败 也 应 该 删 除 与 警 告 信 息 中 指 定
的 p ack a g e 有 关 的 多 余im port 语 句
编 译 器 警 告 J5 5 0 0
#w ar n in g ' te x t '
在
程 序 中 有 #w a rn ing 条 件 编 译 伪 指 令 时 产 生 这 个 警 告 信
息下 面 举 例 说 明 这 种 错 误
#de f ine D E B U G
p u b lic c la s s S im p le {
p u b lic v o id m e th o d 1 ( ){ # if D E B U G
# w arning: Y ou are co m p iling fo r deb u g m o d e
/ / w a rn in g : d is p la yed w h en 'D E B U G ' is d efin ed # en d if
}
}
CO M 注 册 错 误 ( V is ual J + + )
在
CO M 类 注 册 中 可 以 使 用 错 误 或 警 告 信 息 提 示 下 面 是 许 多
带 有 普遍 性 错 误 和 警 告 的 列 表 每 个 错 误 或 警 告 包 含 的 信
息 包 括 出 现 错 误 的 可能 原 因 应 用 的 地 点 以 及 如 何 处 理 错
误 或 原 因 的 建 议
N o r e g is tr a t io n a t tr ib u te in c la ss f ile 'file n a m e ' 类 文 件 file n a m e 中 无 注
册 属 性
试
图 用 错 误 消 息 中 引 用 的 类 文 件 注 册 但 是 这 个 类 文 件 不 包
含@ c o m . re g iste r 注 释 标 记 确 保 在 类 文 件 中 正 试 图 注 册
的 CO M 类 有 一 个合 法 的 @ c o m . re g iste r 注 释 标 记
C a n n o t cre a te in s ta n ce o f cla ss ' id en t i f ier ' 不 能 创 建 id e n t i f ie r 类 的 实例
为
创 建 一 个 类 型 库 和 注 册 CO M 类 类 必 须 能 被 初 始 化 和 能 够
调 用 标 准构 造 器 这 个 构 造 器 不 包 含 任 何 参 数
如 果 CO M 类 的 任 何 一 个 非 独立 类 不 能 被 定 位 或 者 与 类 相 关
的 标 准 构 造 器 有 错 误 可 能 会 出 现 这 种 错误 确 保 与 CO M 类 相
关 的 非 独 立 类 可 以 被 访 问 并 且 类 的 标 准 构 造 器不 包 含 任
何 错 误
C a n n o t o p e n f ile n a m e 'file n a m e ' 不 能 打 开 file n a m e 文 件 名
在
CO M 注 册 进 程 中 产 生 一 个 临 时 的 类 型 库 当 临 时 的 文 件 不
能 拷 贝和 重 命 名 到 最 终 类 型 库 名 时 将 会 出 现 这 种 错 误 确
保 这 个 文 件 不 是 只读 的 没 有 在 一 个 只 读 目 录 里 或 这 个 文
件 没 有 被 其 他 应 用 程 序 所 使 用
U n a b le to crea te reg is ter k e y s fo r c la s s ' ide n t i f ier' 不 能 创 建 id e n t i f ie r
类 的 注 册 关 键 字
当
试 图 注 册 CO M 类 时 CO M 注 册 进 程 不 能 在 系 统 中 创 建 一 个 关
键 字如 果 CO M 注 册 进 程 不 能 打 开 指 定 关 键 字 或 不 能 向 注 册
中 写 入 一 个 值时 也 会 出 现 这 种 错 误 确 认 系 统 注 册 没 有 被
损 坏
C la ss f i le ' f i len a m e' do e s n o t h a v e th e ex te n s io n ' .cla ss ' 类 文 件 file n a m e
中 没 有 .c la ss 扩 展 名
为
注 册 一 个 CO M 类 编 译 类 文 件 必 须 有 .c la ss 扩 展 名 如 果 这
个 被 注 册为 CO M 类 的 文 件 不 是 合 法 的 Ja va 类 文 件 也 会 出 现
这 种 错 误 确 保 这个 正 试 图 注 册 为 CO M 类 的 类 文 件 包 含 .c la
ss 扩 展 名 而 且 是 一 个 合 法 的Ja va 类 文 件
T h e in tern a l cla ss n a m e ' id en t i f ier ' d o es n o t m a tc h th e f i le o r d ire cto r y n a m e o f c la ss f ile 'file n a m e ' it c a n n o t b e lo a d e d 内 部 类 名 id e n t i f ie r 不 能 匹 配 类 文 件 file n a m e 的 文 件 或 目 录 名 不 能 加 载 它
注
册 的 CO M 类 与 定 位 的 类 文 件 有 不 同 的 类 名 或 者 位 于 目 录
中 的 类 文件 与 这 个 类 定 义 的 软 件 包 冲 突 确 保 这 个 CO M 类 名
和 它 定 义 的 软 件 包与 这 个 类 文 件 的 位 置 和 名 字 相 匹 配
C la ss co n ta in m o re th a n o n e ty p e l ib ra r y id . O n ly o n e ty p e l ibr a r y ca n b e cr ea te d a t a t im e 类 包 括 不 止 一 个 类 型 库 id 一 次 仅 能 生 成 一 种 类型 库
在
V isu a l J + + 项 目 中 一 次 只 能 指 定 一 个 类 型 库 在 项 目 中 当
一 个 CO M 类 的 @ c o m . re g iste r 的 注 释 标 记 与 其 他 类 有 不
同 的 类 型 库 GU ID 时 通 常会 出 现 这 种 错 误 在 一 个 项 目 中 所
有 的 CO M 类 必 须 指 定 相 同 的 类 型库 在 P ro je c t P rope r t ie
s 对 话 框 的 CO M C la ss 选 项 卡 中 通 过 清 除 这 个类 旁 边 的 复
选 框 来 解 决 这 种 冲 突 应 用 这 种 改 变 然 后 重 新 复 选 这 个
类的 复 选 框 这 将 重 新 指 定 这 个 类 为 CO M 类 并 且 指 定 相 同 的
类 型 库
GU ID
B a se n a m e o f cla ss ' id en t i f ier' co n f l ic ts w ith a n o th e r c la s s in th e sa m e ty p e l ib ra ry 类 id e n tifie r 的 基 本 名 与 在 同 一 类 型 库 中 的 另 一 个 类 冲突
发
现 定 义 的 类 已 经 在 类 型 库 里 当 软 件 包 里 定 义 的 一 个 CO M
类 与 不 同软 件 包 里 的 带 有 相 同 名 字 的 CO M 类 都 添 加 到 同 一
个 类 型 库 时 通 常 会出 现 这 种 错 误 改 变 添 加 到 类 型 库 的 一
个 类 名 以 便 使 冲 突 解 决
W indow s E X E /C O M D L L 打 包 错 误 ( V is ual J + + )
在
W ind ow s E X E 或 CO M D L L 的 创 建 中 可 能 接 收 到 一 个 错 误 消
息 下面 是 可 能 出 现 的 错 误 消 息 列 表 每 个 错 误 消 息 还 列 出
了 导 致 这 种 错 误 的可 能 原 因 可 应 用 的 地 点 以 及 如 何 处 理
这 种 错 误 的 建 议
P a th to o lo n g :' p a th ' 路 径 太 长 'p a th '
W
ind ow s E X E 或 CO M D L L 的 路 径 和 文 件 名 的 长 度 超 过 256 个
字 符 缩短 路 径 和 文 件 名 的 长 度 重 新 编 译 项 目
N o m a in cla ss f i le sp ecified 没 有 指 定 主 类 文 件
试
图 创 建 一 个 W ind ow s E X E , 但 是 没 有 指 定 主 类 一 个 用 主 方
法 定 义 的类
为 创 建 一 个 W ind ow s E X E 必 须 在 P ro je c t P rope r t ie s 对
话 框 的L a unc h 选 项 卡 中 指 定 一 个 主 类
N o c la s s f i le s fo u n d 没 有 找 到 类 文 件
试
图 创 建 一 个 W ind ow s E X E 或 CO M D L L 但 是 没 有 发 现 或 没 有
指 定用 来 创 建 EX E 或 D L L 的 类 文 件 确 保 项 目 至 少 包 含 一 个
类 文 件 并 且这 个 类 文 件 在 P ro je c t P rope r t ie s 对 话 框 的
O u tput F o rm a t 选 项 卡 中 指 定
U
n a b le to o p e n o u tp u t file :' file n a m e ' 不 能 打 开 输
出 文 件 ' f i len a m e' 不 能 打 开 错 误 消 息 中 指 出 的 文 件
确 保 这 个 指 定 文 件 不 是 只 读 的 或 没 有被 其 他 程 序 应 用 如
果 这 个 指 定 文 件 位 于 不 允 许 写 的 目 录 中 也 可 能 会
出 现 这
种 错 误
U n a b le to u p d a te reso u rces in f i le : ' f i le n a m e ' 不 能 更 新 文 件 中 的 资 源
'
f i len a m e'
试
图 把 资 源 信 息 写 到 错 误 消 息 中 指 出 的 资 源 文 件 中 但 是 不
能 修 改 这 个资 源 文 件 确 保 在 计 算 机 上 有 足 够 的 可 用 磁 盘
空 间
B a d ly fo r m a t te d c la ss file :' file n a m e ' 类 文 件 格 式 非 法 ' f i len a m e'
错
误 消 息 中 指 出 的 类 文 件 使 用 了 一 个 非 法 格 式 当 类 文 件 遭
到 损 坏 或 者是 使 用 类 扩 展 的 文 件 但 它 不 是 合 法 的 Ja va 文
件 删 除 错 误 消 息 中 指 出的 类 文 件 重 新 建 立 项 目
F ile n o t fo u n d :'file n a m e ' 找 不 到 文 件 ' f i len a m e'
没
有 发 现 错 误 消 息 中 指 出 的 文 件 在 P ro je c t P rope r t ie s 对
话 框 的 O u tput Fo rm a t 项 中 确 保 这 个 文 件 的 正 确 位 置
U
n a b le to lo a d r e so u r c e s fr o m 'file n a m e
'
不 能 从 file n a m e 中 加 载 资 源
不
能 打 开 错 误 消 息 中 指 出 的 资 源 文 件 确 保 这 个 资 源 文 件
是 合 法 的W ind ow s 资 源 文 件 并 且 这 个 资 源 文 件 没 有 被 另
外 的 程 序 所 使 用
U n a b le to r e a d ty p e lib file 'file n a m e ' 不 能 读 取 类 型 库 文 件 file n a m e
不
能 打 开 错 误 消 息 中 指 出 的 类 型 库 文 件 确 保 这 个 类 型 库 文
件 是 合 法 的类 型 库 文 件 并 且 这 个 文 件 没 有 被 另 外 的 程 序
所 使 用
C o rru p t re g is tr a t io n a t tr ib u te in cla ss ' ide n t if ie tr '( 类 id e n t i f ie r 中 注 册 属性 损 坏 )
错
误 消 息 中 所 指 出 类 的 一 个 CO M 注 册 属 性 有 误 当 这 个 指 定
类 的 类 文件 被 损 坏 或 是 一 个 非 法 文 件 格 式 时 通 常 会 出 现
这 种 错 误 删 除 指 定 类的 类 文 件 重 新 建 立 项 目
C la ss ‘id e n t i f ie r ’ d o e s n o t h a v e a m e th o d o f th e fo r m ‘sta tic p u b l ic v o id m a in (S tr in g [])’ 类 id e n tifie r 没 有 s ta tic p u b l ic v o id m a in s t ir n g [ ] 形 式的 方 法
—
个 类 指 定 为 W ind ow s E X E 的 主 类 但 这 个 类 不 包 含 一 个 主
方 法 主 方法 为 W ind ow s E X E 提 供 起 点 并 且 必 须 被 指 定 向 错
误 消 息 中 指 出 的 类里 添 加 一 个 主 方 法 或 者 在 P ro je c t P
rope r t ie s 对 话 框 的 L a unc h 选 项 卡 中选 择 不 同 的 主 类 重
新 建 立 项 目
M a in c la ss n a m e ' id e n t ifie r ' is to o lo n g 主 类 名 id e n tifie r 太 长
错
误 消 息 中 指 出 的 主 类 名 长 度 超 过 256 个 字 符 缩 短 这 个 类 名
的 长 度重 新 编 译 项 目
S p e c ifie d m a in c la ss 'id e n t i f ie r ' n o t fo u n d 指 定 的 主 类 id e n t i f ie r 没 找到
创
建 一 个 W ind ow s E X E 文 件 时 没 有 发 现 为 W ind ow s E X E 指 定
为 主 类的 类 在 P ro je c t P rope r t ie s 对 话 框 的 L a unc h 选 项
卡 中 指 定 一 个 主 类 但从 类 文 件 中 把 这 个 主 类 删 除 或 改 名
时 可 能 会 出 现 这 种 错 误 在 P ro ject P rope r t ie s 对 话 框 的 L
a unc h 选 项 卡 中 指 定 一 个 新 的 主 类 重 新 建 立 项 目
U n a b le to r e a d fr o m file ' f i le n a m e ' 不 能 读 取 文 件 file n a m e
不
能 打 开 错 误 消 息 中 指 定 的 准 备 读 取 的 文 件 确 保 这 个 指 定
文 件 没 有 其他 程 序 所 使 用
C a n n o t cr ea te a D L L w i th n o C O M c la s se s 不 能 创 建 无 CO M 类 的
DL L
试
图 创 建 一 个 CO M D L L 但 是 这 个 项 目 不 包 含 任 何 CO M 类 可 以
通 过在 P ro je c t P rope r t ie s 对 话 框 的 CO M C la sse s 选 项 卡
的 类 表 中 选 择 一 个 类来 创 建 一 个 类 如 果 不 希 望 把 任 何 类
置 为 CO M 类 在 P ro je c t P rope r t ie s 对 话 框 的 O u tput F o rm
a t 选 项 卡 中 修 改 要 创 建 的 软 件 包 类 型 并 且 重 新 编译
F a ilu r e d u r in g a u to - r e g istr a tio n o f 'file n a m e ' 在 file n a m e 的 自 动 注 册时 失 败
—
个 CO M D L L 在 创 建 后 自 动 注 册 失 败 当 系 统 注 册 器 被 损 坏
时 通 常会 出 现 这 种 错 误
O u t o f m e m o r y 内 存 溢 出
创
建 一 个 W ind ow s E X E 或 CO M D L L 时 没 有 足 够 的 内 存 可 以 使
用 关闭 当 前 正 运 行 的 其 他 程 序 以 提 供 更 多 的 可 用 内 存 重
新 建 立 项 目
