48 # set of X a comma-separated collection of items; e.g. set of modifier
49 #
50 # These may be composed: e.g. list of type or message segment
51 #
52 # These comments are verified by the jtreg test test/tools/javac/diags/MessageInfo,
53 # using info derived from the collected set of examples in test/tools/javac/diags/examples.
54 # MessageInfo can also be run as a standalone utility providing more facilities
55 # for manipulating this file. For more details, see MessageInfo.java.
56
57 ##
58 ## errors
59 ##
60
61 # 0: symbol
62 compiler.err.abstract.cant.be.instantiated={0}是抽象的; 无法实例化
63
64 compiler.err.abstract.meth.cant.have.body=抽象方法不能有主体
65
66 compiler.err.already.annotated={0} {1}已进行注释
67
68 # 0: symbol, 1: symbol
69 compiler.err.already.defined=已在{1}中定义{0}
70
71 # 0: string
72 compiler.err.already.defined.single.import=已在 single-type 导入中定义{0}
73
74 # 0: string
75 compiler.err.already.defined.static.single.import=已在静态 single-type 导入中定义{0}
76
77 compiler.err.already.defined.this.unit=已在该编译单元中定义{0}
78
79 # 0: type, 1: list of name
80 compiler.err.annotation.missing.default.value=对于属性{1}, 注释{0}缺少值
81
82 # 0: type, 1: list of name
83 compiler.err.annotation.missing.default.value.1=对于属性{1}, 注释{0}缺少值
84
85 # 0: type
86 compiler.err.annotation.not.valid.for.type=对于类型为{0}的值, 注释无效
87
88 compiler.err.annotation.type.not.applicable=注释类型不适用于该类型的声明
89
90 compiler.err.annotation.value.must.be.annotation=注释值必须为注释
92 compiler.err.annotation.value.must.be.class.literal=注释值必须为类文字
93
94 compiler.err.annotation.value.must.be.name.value=注释值必须采用 ''name=value'' 格式
95
96 compiler.err.annotation.value.not.allowable.type=注释值不是允许的类型
97
98 compiler.err.anon.class.impl.intf.no.args=匿名类实现接口; 不能有参数
99
100 compiler.err.anon.class.impl.intf.no.typeargs=匿名类实现接口; 不能具有类型参数
101
102 compiler.err.anon.class.impl.intf.no.qual.for.new=匿名类实现接口; 不能有限定符 - 对于新
103
104 # 0: symbol, 1: symbol, 2: symbol
105 compiler.err.array.and.varargs=无法在{2}中同时声明{0}和{1}
106
107 compiler.err.array.dimension.missing=缺少数组维
108
109 # 0: type
110 compiler.err.array.req.but.found=需要数组, 但找到{0}
111
112 compiler.err.assignment.from.super-bound=通过通配符 {0} 分配
113
114 compiler.err.assignment.to.extends-bound=分配给通配符 {0}
115
116 compiler.err.attribute.value.must.be.constant=属性值必须为常量
117
118 compiler.err.break.outside.switch.loop=在 switch 或 loop 外部中断
119
120 # 0: name
121 compiler.err.call.must.be.first.stmt.in.ctor=对{0}的调用必须是构造器中的第一个语句
122
123 compiler.err.cant.apply.symbol=无法将{4} {5}中的{0} {1}应用到给定类型\n需要: {2}\n找到: {3}
124
125 # 0: symbol kind, 1: name, 2: list of type or message segment, 3: list of type or message segment, 4: symbol kind, 5: type, 6: message segment
126 compiler.err.cant.apply.symbol.1=无法将{4} {5}中的{0} {1}应用到给定类型;\n需要: {2}\n找到: {3}\n原因: {6}
127
128 # 0: symbol kind, 1: name, 2: list of type
129 compiler.err.cant.apply.symbols=对于{1}({2}), 找不到合适的{0}
130
131 # 0: symbol
132 compiler.err.cant.assign.val.to.final.var=无法为最终变量{0}分配值
133
134 # 0: type
135 compiler.err.cant.deref=无法取消引用{0}
136
137 compiler.err.cant.extend.intf.annotation=对于 @interfaces, 不允许 ''extends''
138
139 # 0: symbol
140 compiler.err.cant.inherit.from.final=无法从最终{0}进行继承
141
142 # 0: symbol
143 compiler.err.cant.ref.before.ctor.called=无法在调用超类型构造器之前引用{0}
144
145 compiler.err.cant.ret.val.from.meth.decl.void=对于结果类型为空的方法, 无法返回值
146
147 compiler.err.cant.select.static.class.from.param.type=无法从参数化的类型中选择静态类
148
149 # 0: symbol, 1: string, 2: string
150 compiler.err.cant.inherit.diff.arg=无法使用以下不同的参数继承{0}: <{1}> 和 <{2}>
151
152 compiler.err.catch.without.try=有 ''catch'', 但是没有 ''try''
153
154 # 0: symbol kind, 1: symbol
155 compiler.err.clash.with.pkg.of.same.name={0} {1}与带有相同名称的程序包冲突
156
157 compiler.err.const.expr.req=需要常量表达式
158
159 compiler.err.cont.outside.loop=continue 在 loop 外部
160
161 # 0: symbol
162 compiler.err.cyclic.inheritance=涉及{0}的循环继承
163
164 compiler.err.cyclic.annotation.element=循环注释元素类型
165
166 # 0: unused
167 compiler.err.call.to.super.not.allowed.in.enum.ctor=在枚举构造器中不允许调用超类
168
169 # 0: type
170 compiler.err.no.superclass={0}不具有超类
171
172 compiler.err.wrong.target.for.polymorphic.signature.definition=MethodHandle API 构建需要 -target 7 运行时或更高; 当前为 -target {0}
173
174 # 0: symbol, 1: type, 2: symbol, 3: type, 4: unused
175 compiler.err.concrete.inheritance.conflict={1}中的方法{0}和{3}中的方法{2}是使用相同的签名继承的
176
177 compiler.err.default.allowed.in.intf.annotation.member=仅在 @interface 成员中允许使用默认值
178
179 # 0: symbol
180 compiler.err.doesnt.exist=程序包{0}不存在
181
182 compiler.err.duplicate.annotation=注释重复
183
184 # 0: name, 1: type
185 compiler.err.duplicate.annotation.member.value={1}中的注释成员值{0}重复
186
187 # 0: name
188 compiler.err.duplicate.class=类重复: {0}
189
190 compiler.err.duplicate.case.label=case 标签重复
191
192 compiler.err.duplicate.default.label=default 标签重复
193
194 compiler.err.else.without.if=有 ''if'', 但是没有 ''else''
195
196 compiler.err.empty.char.lit=空字符文字
197
198 # 0: symbol
199 compiler.err.encl.class.required=需要包含{0}的封闭实例
200
201 compiler.err.enum.annotation.must.be.enum.constant=枚举注释值必须是枚举常量
202
203 compiler.err.enum.cant.be.instantiated=无法实例化枚举类型
204
205 compiler.err.enum.label.must.be.unqualified.enum=枚举 switch case 标签必须为枚举常量的非限定名称
206
228 # 0: symbol
229 compiler.err.multicatch.parameter.may.not.be.assigned=可能未分配 multi-catch 参数{0}
230
231 # 0: type, 1: type
232 compiler.err.multicatch.types.must.be.disjoint=multi-catch 语句中的替代无法通过子类化关联\n替代{0}是替代{1}的子类
233
234 compiler.err.finally.without.try=有 ''finally'', 但是没有 ''try''
235
236 # 0: type, 1: message segment
237 compiler.err.foreach.not.applicable.to.type=for-each 不适用于表达式类型\n要求: {1}\n找到: {0}
238
239 compiler.err.fp.number.too.large=浮点数过大
240
241 compiler.err.fp.number.too.small=浮点数过小
242
243 compiler.err.generic.array.creation=创建泛型数组
244
245 compiler.err.generic.throwable=泛型类不能扩展 java.lang.Throwable
246
247 # 0: symbol
248 compiler.err.icls.cant.have.static.decl=内部类{0}中的静态声明非法\n修饰符 \''static\'' 仅允许在常量变量声明中使用
249
250 # 0: string
251 compiler.err.illegal.char=非法字符: \\{0}
252
253 compiler.err.illegal.char.for.encoding=编码{0}的不可映射字符
254
255 # 0: set of modifier, 1: set of modifier
256 compiler.err.illegal.combination.of.modifiers=非法的修饰符组合: {0}和{1}
257
258 compiler.err.illegal.enum.static.ref=初始化程序中对静态字段的引用不合法
259
260 compiler.err.illegal.esc.char=非法转义符
261
262 compiler.err.illegal.forward.ref=非法前向引用
263
264 # 0: symbol
265 compiler.warn.forward.ref=先引用变量 ''{0}'', 然后再对其初始化
266
267 compiler.err.illegal.self.ref=初始化程序中存在自引用
268
269 # 0: symbol
270 compiler.warn.self.ref=变量 ''{0}'' 的初始化程序中存在自引用
271
272 compiler.err.illegal.generic.type.for.instof=instanceof 的泛型类型不合法
273
274 # 0: type
275 compiler.err.illegal.initializer.for.type={0}的初始化程序不合法
276
277 compiler.err.illegal.line.end.in.char.lit=字符文字的行结尾不合法
278
279 compiler.err.illegal.nonascii.digit=非法的非 ASCII 数字
280
281 compiler.err.illegal.underscore=非法下划线
282
283 # 0: symbol
284 compiler.err.illegal.qual.not.icls=非法限定符; {0}不是内部类
285
286 compiler.err.illegal.start.of.expr=非法的表达式开始
287
288 compiler.err.illegal.start.of.type=非法的类型开始
289
290 compiler.err.illegal.unicode.esc=非法的 Unicode 转义
291
292 # 0: symbol
293 compiler.err.import.requires.canonical=导入需要{0}的规范名称
294
295 compiler.err.improperly.formed.type.param.missing=类型的格式不正确, 缺少某些参数
296
297 compiler.err.improperly.formed.type.inner.raw.param=类型的格式不正确, 给出了原始类型的类型参数
298
299 # 0: type, 1: type
300 compiler.err.incomparable.types=不可比较的类型: {0}和{1}
301
302 # 0: number
303 compiler.err.int.number.too.large=过大的整数: {0}
304
305 compiler.err.internal.error.cant.instantiate=内部错误; 无法将位于{1}的{0}实例化为 ({2})
306
307 compiler.err.intf.annotation.members.cant.have.params=@interface 成员不能带有参数
308
309 compiler.err.intf.annotation.cant.have.type.params=@interface 不能带有类型参数
310
311 compiler.err.intf.annotation.members.cant.have.type.params=@interface 成员不能带有类型参数
312
313 # 0: symbol, 1: type
314 compiler.err.intf.annotation.member.clash=@interface 成员与{1}中的方法 ''{0}'' 冲突
315
316 compiler.err.intf.expected.here=此处需要接口
317
318 compiler.err.intf.meth.cant.have.body=接口方法不能带有主体
319
320 compiler.err.invalid.annotation.member.type=注释成员的类型无效
321
322 compiler.err.invalid.binary.number=二进制数字中必须包含至少一个二进制数
323
324 compiler.err.invalid.hex.number=十六进制数字必须包含至少一位十六进制数
325
326 compiler.err.invalid.meth.decl.ret.type.req=方法声明无效; 需要返回类型
327
328 compiler.err.varargs.and.old.array.syntax=variable-arity 参数中不允许使用传统数组记号
329
330 # 0: name
331 compiler.err.label.already.in.use=标签{0}已使用
332
333 # 0: symbol
334 compiler.err.local.var.accessed.from.icls.needs.final=从内部类中访问本地变量{0}; 需要被声明为最终类型
335
336 compiler.err.local.enum=枚举类型不能为本地类型
337
338 compiler.err.cannot.create.array.with.type.arguments=无法创建具有类型变量的数组
339
340 #
341 # limits. We don't give the limits in the diagnostic because we expect
342 # them to change, yet we want to use the same diagnostic. These are all
343 # detected during code generation.
344 #
345 compiler.err.limit.code=代码过长
346
347 compiler.err.limit.code.too.large.for.try.stmt=try 语句的代码过长
348
349 compiler.err.limit.dimensions=数组类型维过多
350
351 compiler.err.limit.locals=本地变量过多
352
353 compiler.err.limit.parameters=参数过多
354
355 compiler.err.limit.pool=常量过多
356
357 compiler.err.limit.pool.in.class=类{0}中的常量过多
358
359 compiler.err.limit.stack=代码需要过多堆栈
360
361 compiler.err.limit.string=常量字符串过长
362
363 compiler.err.limit.string.overflow=对于常量池来说, 字符串 \"{0}...\" 的 UTF8 表示过长
364
365 compiler.err.malformed.fp.lit=浮点文字的格式错误
366
367 compiler.err.method.does.not.override.superclass=方法不会覆盖或实现超类型的方法
368
369 compiler.err.missing.meth.body.or.decl.abstract=缺少方法主体, 或声明抽象
370
371 compiler.err.missing.ret.stmt=缺少返回语句
372
373 compiler.err.missing.ret.val=缺少返回值
374
375 # 0: set of modifier
376 compiler.err.mod.not.allowed.here=此处不允许使用修饰符{0}
377
378 compiler.err.intf.not.allowed.here=此处不允许使用接口
379
380 compiler.err.enums.must.be.static=只有在静态上下文中才允许使用枚举声明
381
382 # 0: symbol, 1: symbol
383 compiler.err.name.clash.same.erasure=名称冲突: {0}和{1}具有相同疑符
384
385 # 0: symbol, 1: symbol, 2: symbol, 3: symbol, 4: unused, 5: unused
386 compiler.err.name.clash.same.erasure.no.override=名称冲突: {1}中的{0}和{3}中的{2}具有相同疑符, 但两者均不覆盖对方
387
388 # 0: symbol, 1: symbol, 2: symbol, 3: symbol, 4: symbol, 5: symbol
389 compiler.err.name.clash.same.erasure.no.override.1=名称冲突: {1} 中的 {0} 覆盖的方法的疑符与另一个方法的相同, 但两者均不覆盖对方\n第一个方法: {3} 中的 {2}\n第二个方法: {5} 中的 {4}
390
391 # 0: symbol, 1: symbol, 2: symbol, 3: symbol
392 compiler.err.name.clash.same.erasure.no.hide=名称冲突: {1} 中的 {0} 和 {3} 中的 {2} 具有相同疑符, 但两者均不隐藏对方
393
394 compiler.err.name.reserved.for.internal.use={0}为内部使用保留
395
396 compiler.err.native.meth.cant.have.body=本机方法不能带有主体
397
398 # 0: type, 1: type
399 compiler.err.neither.conditional.subtype=? 的不兼容类型: 两者都不是对方的子类型\n第二个操作数: {0}\n第三个操作数: {1}
400
401 compiler.err.new.not.allowed.in.annotation=注释中不允许使用 ''new''
402
403 compiler.err.no.annotation.member={1}中没有注释成员{0}
404
405 compiler.err.no.encl.instance.of.type.in.scope=作用域中没有类型为{0}的封闭实例
406
407 compiler.err.no.intf.expected.here=此处不需要接口
408
409 compiler.err.no.match.entry={0}在{1}的条目中没有匹配项; 需要{2}
410
411 compiler.err.not.annotation.type={0}不是注释类型
412
413 # 0: symbol, 1: symbol
414 compiler.err.not.def.access.class.intf.cant.access={1}中的{0}是在不可访问的类或接口中定义的
415
416 # 0: symbol, 1: symbol
417 compiler.err.not.def.public.cant.access={0}在{1}中不是公共的; 无法从外部程序包中对其进行访问
418
419 # 0: name
420 compiler.err.not.loop.label=不是 loop 标签: {0}
421
422 compiler.err.not.stmt=不是语句
423
424 # 0: symbol
425 compiler.err.not.encl.class=不是封闭类: {0}
426
427 # 0: name, 1: type, 2: unused
428 compiler.err.operator.cant.be.applied=一元运算符 ''{0}'' 的操作数类型{1}错误
429
430 # 0: name, 1: type, 2: type
431 compiler.err.operator.cant.be.applied.1=二元运算符 ''{0}'' 的操作数类型错误\n第一个类型: {1}\n第二个类型: {2}
432
433 compiler.err.pkg.annotations.sb.in.package-info.java=程序包注释应在文件 package-info.java 中
434
435 # 0: symbol
436 compiler.err.pkg.clashes.with.class.of.same.name=程序包{0}与带有相同名称的类冲突
438 compiler.err.warnings.and.werror=发现警告, 但指定了 -Werror
439
440 # Errors related to annotation processing
441
442 # 0: symbol, 1: string, 2: stack-trace
443 compiler.err.proc.cant.access=无法访问{0}\n{1}\n有关详细信息, 请参阅以下堆栈跟踪。\n{2}
444
445 # 0: symbol, 1: string
446 compiler.err.proc.cant.access.1=无法访问{0}\n{1}
447
448 # 0: string
449 compiler.err.proc.cant.find.class=找不到 ''{0}'' 的类文件。
450
451 # Print a client-generated error message; assumed to be localized, no translation required
452 # 0: string
453 compiler.err.proc.messager={0}
454
455 # 0: list of string
456 compiler.err.proc.no.explicit.annotation.processing.requested=仅当显式请求注释处理时才接受类名称 ''{0}''
457
458 compiler.err.proc.no.service=找不到服务加载器类。\njava.util.ServiceLoader 或 sun.misc.Service 必须可用。
459
460 compiler.err.proc.processor.bad.option.name=处理程序 ''{1}'' 提供的选项名称 ''{0}'' 错误
461
462 # 0: string
463 compiler.err.proc.processor.cant.instantiate=无法实例化处理程序 ''{0}'' 的实例
464
465 compiler.err.proc.processor.constructor.error=构造处理程序对象{0}时抛出异常错误
466
467 # 0: string
468 compiler.err.proc.processor.not.found=找不到注释处理程序 ''{0}''
469
470 # 0: string
471 compiler.err.proc.processor.wrong.type=注释处理程序 ''{0}'' 未实现 javax.annotation.processing.Processor
472
473 compiler.err.proc.service.problem=创建服务加载器以加载处理程序时出错。
474
475 compiler.err.proc.bad.config.file=服务配置文件不正确, 或构造处理程序对象{0}时抛出异常错误
476
477 compiler.err.proc.cant.create.loader=无法为注释处理程序{0}创建类加载器
478
479 # 0: unused
480 compiler.err.qualified.new.of.static.class=限定的新静态类
481
482 compiler.err.recursive.ctor.invocation=递归构造器调用
483
484 # 0: name, 1: symbol kind, 2: symbol, 3: symbol, 4: symbol kind, 5: symbol, 6: symbol
485 compiler.err.ref.ambiguous=对{0}的引用不明确, {3}中的{1} {2}和{6}中的{4} {5}都匹配
486
487 compiler.err.repeated.annotation.target=注释目标重复
488
489 compiler.err.repeated.interface=接口重复
490
491 compiler.err.repeated.modifier=修饰符重复
492
493 # 0: symbol, 1: set of modifier, 2: symbol
494 compiler.err.report.access={0}可以在{2}中访问{1}
495
496 compiler.err.ret.outside.meth=返回外部方法
497
498 compiler.err.signature.doesnt.match.supertype=签名与{0}不匹配; 不兼容的超类型
499
500 compiler.err.signature.doesnt.match.intf=签名与{0}不匹配; 不兼容的接口
501
502 # 0: symbol, 1: symbol, 2: symbol
503 compiler.err.does.not.override.abstract={0}不是抽象的, 并且未覆盖{2}中的抽象方法{1}
504
505 compiler.err.source.cant.overwrite.input.file=写入源时出错; 无法覆盖输入文件{0}
506
519 compiler.err.throws.not.allowed.in.intf.annotation=@interface 成员中不允许使用 throws 子句
520
521 compiler.err.try.without.catch.or.finally=有 ''try'', 但是没有 ''catch'' 或 ''finally''
522
523 compiler.err.try.without.catch.finally.or.resource.decls=''try'' 不带有 ''catch'', ''finally'' 或资源声明
524
525 # 0: symbol
526 compiler.err.type.doesnt.take.params=类型{0}不带有参数
527
528 compiler.err.type.var.cant.be.deref=无法从类型变量中进行选择
529
530 compiler.err.type.var.may.not.be.followed.by.other.bounds=类型变量后面不能带有其他限制范围
531
532 compiler.err.type.var.more.than.once=类型变量{0}在{1}的结果类型中多次出现; 必须对其进行实例化
533
534 compiler.err.type.var.more.than.once.in.result=类型变量{0}在{1}的类型中多次出现; 必须对其进行实例化
535
536 # 0: type, 1: type, 2: string
537 compiler.err.types.incompatible.diff.ret=类型{0}和{1}不兼容; 两者都定义了{2}, 但却带有不相关的返回类型
538
539 compiler.err.unclosed.char.lit=未结束的字符文字
540
541 compiler.err.unclosed.comment=未结束的注释
542
543 compiler.err.unclosed.str.lit=未结束的字符串文字
544
545 # 0: name
546 compiler.err.unsupported.encoding=不支持的编码: {0}
547
548 compiler.err.io.exception=读取源文件时出错: {0}
549
550 # 0: name
551 compiler.err.undef.label=未定义的标签: {0}
552
553 compiler.err.undetermined.type=无法推断{0}的类型参数
554
555 # 0: type, 1: message segment
556 compiler.err.undetermined.type.1=无法推断{0}的类型参数;\n原因: {1}
557
558 # 0: list of type, 1: message segment
559 compiler.err.invalid.inferred.types={0}的推断类型无效; {1}
560
561 # 0: message segment, 1: unused
562 compiler.err.cant.apply.diamond=无法推断{0}的类型参数
563
564 # 0: message segment, 1: message segment
565 compiler.err.cant.apply.diamond.1=无法推断{0}的类型参数;\n原因: {1}
566
567 compiler.err.unreachable.stmt=无法访问的语句
568
569 compiler.err.initializer.must.be.able.to.complete.normally=初始化程序必须能够正常完成
570
571 # 0: type
572 compiler.err.unreported.exception.need.to.catch.or.throw=未报告的异常错误{0}; 必须对其进行捕获或声明以便抛出
573
574 # 0: type
575 compiler.err.unreported.exception.default.constructor=默认构造器中未报告的异常错误{0}
576
577 # 0: type, 1: name
578 compiler.err.unreported.exception.implicit.close=未报告的异常错误{0}; 必须对其进行捕获或声明以便抛出\n对资源变量 ''{1}'' 隐式调用 close() 时抛出了异常错误
579
580 compiler.err.unsupported.cross.fp.lit=该 VM 不支持十六进制浮点文字
581
582 compiler.err.void.not.allowed.here=此处不允许使用 ''空'' 类型
583
584 # 0: string
585 compiler.err.wrong.number.type.args=类型变量数目错误; 需要{0}
586
588 compiler.err.var.might.already.be.assigned=可能已分配变量{0}
589
590 # 0: symbol
591 compiler.err.var.might.not.have.been.initialized=可能尚未初始化变量{0}
592
593 # 0: symbol
594 compiler.err.var.might.be.assigned.in.loop=可能在 loop 中分配了变量{0}
595
596 # 0: symbol, 1: message segment
597 compiler.err.varargs.invalid.trustme.anno={0} 注释无效。{1}
598
599 # 0: type
600 compiler.misc.varargs.trustme.on.reifiable.varargs=Varargs 元素类型{0}可具体化。
601
602 # 0: symbol
603 compiler.misc.varargs.trustme.on.non.varargs.meth=方法 {0} 不是 varargs 方法。
604
605 # 0: symbol
606 compiler.misc.varargs.trustme.on.virtual.varargs=实例方法 {0} 不是最终的。
607
608 # 0: type, 1: kind, 2: symbol
609 compiler.misc.inaccessible.varargs.type=形式 varargs 元素类型{0}无法从 {1} {2} 进行访问
610
611 # In the following string, {1} will always be the detail message from
612 # java.io.IOException.
613 # 0: symbol, 1: string
614 compiler.err.class.cant.write=写入{0}时出错: {1}
615
616 # In the following string, {0} is the name of the class in the Java source.
617 # It really should be used two times..
618 # 0: name
619 compiler.err.class.public.should.be.in.file=类{0}是公共的, 应在名为 {0}.java 的文件中声明
620
621 ## All errors which do not refer to a particular line in the source code are
622 ## preceded by this string.
623 compiler.err.error=错误:
624
625 # The following error messages do not refer to a line in the source code.
626 compiler.err.cant.read.file=无法读取: {0}
627
628 #####
629
630 # Fatal Errors
631
632 compiler.misc.fatal.err.no.java.lang=致命错误: 在类路径或引导类路径中找不到程序包 java.lang
633
634 compiler.misc.fatal.err.cant.locate.meth=致命错误: 找不到方法{0}
635
636 compiler.misc.fatal.err.cant.locate.field=致命错误: 找不到字段{0}
637
638 compiler.misc.fatal.err.cant.locate.ctor=致命错误: 找不到{0}的构造器
639
640 compiler.misc.fatal.err.cant.close.loader=致命错误: 无法关闭注释处理程序的类加载器
641
642 #####
643
644 ##
645 ## miscellaneous strings
646 ##
647
648 compiler.misc.source.unavailable=(源不可用)
649
650 compiler.misc.base.membership=您的所有基类都属于我们
651
652 # 0: string, 1: string, 2: boolean
653 compiler.misc.x.print.processor.info=处理程序{0}与{1}匹配并返回{2}。
654
655 # 0: number, 1: string, 2: set of symbol, 3: boolean
656 compiler.misc.x.print.rounds=循环 {0}:\n\t输入文件: {1}\n\t注释: {2}\n\t最后一个循环: {3}
657
658 #####
659
660 ## The following string will appear before all messages keyed as:
661 ## "compiler.note".
662 compiler.note.note=注:
663
664 # 0: file name
665 compiler.note.deprecated.filename={0}使用或覆盖了已过时的 API。
666
667 compiler.note.deprecated.plural=某些输入文件使用或覆盖了已过时的 API。
668
669 # The following string may appear after one of the above deprecation
670 # messages.
671 compiler.note.deprecated.recompile=有关详细信息, 请使用 -Xlint:deprecation 重新编译。
672
673 # 0: file name
674 compiler.note.deprecated.filename.additional={0}还使用或覆盖了已过时的 API。
675
676 compiler.note.deprecated.plural.additional=某些输入文件还使用或覆盖了已过时的 API。
677
678 # 0: file name
679 compiler.note.unchecked.filename={0}使用了未经检查或不安全的操作。
680
681 compiler.note.unchecked.plural=某些输入文件使用了未经检查或不安全的操作。
682
683 # The following string may appear after one of the above deprecation
756 compiler.misc.verbose.sourcepath=[源文件的搜索路径: {0}]
757
758 # 0: string
759 compiler.misc.verbose.classpath=[类文件的搜索路径: {0}]
760
761 ## extra output when using -checkclassfile (code/ClassReader)
762 compiler.misc.ccf.found.later.version=类文件的版本高于预期: {0}
763
764 compiler.misc.ccf.unrecognized.attribute=无法识别的属性: {0}
765
766 ## extra output when using -prompt (util/Log)
767 compiler.misc.resume.abort=继续(R), 放弃(A)>
768
769 #####
770
771 ##
772 ## warnings
773 ##
774
775 ## All warning messages are preceded by the following string.
776 compiler.warn.warning=警告:
777
778 ## Warning messages may also include the following prefix to identify a
779 ## lint option
780 # 0: option name
781 compiler.warn.lintOption=[{0}]
782
783 # 0: symbol
784 compiler.warn.constant.SVUID=serialVersionUID 在类{0}中必须是常量
785
786 # 0: file name
787 compiler.warn.dir.path.element.not.found=错误的路径元素 "{0}": 没有这种目录
788
789 compiler.warn.finally.cannot.complete=finally 子句无法正常完成
790
791 # 0: symbol, 1: symbol
792 compiler.warn.has.been.deprecated={1}中的{0}已过时
793
794 # 0: symbol
795 compiler.warn.sun.proprietary={0}是内部专用 API, 可能会在未来发行版中删除
796
797 compiler.warn.illegal.char.for.encoding=编码{0}的不可映射字符
798
799 # 0: symbol
800 compiler.warn.improper.SVUID=必须在类{0}中将 serialVersionUID 声明为 static final
801
1029 compiler.misc.bad.source.file.header=错误的源文件: {0}\n{1}\n请删除该文件或确保该文件位于正确的源路径子目录中。
1030
1031 ## The following are all possible strings for the second argument ({1}) of the
1032 ## above strings.
1033 compiler.misc.bad.class.signature=错误的类签名: {0}
1034
1035 #0: symbol, 1: symbol
1036 compiler.misc.bad.enclosing.class={0}的封闭类错误: {1}
1037
1038 # 0: symbol
1039 compiler.misc.bad.enclosing.method=类 {0} 的封闭方法属性错误
1040
1041 compiler.misc.bad.runtime.invisible.param.annotations=错误的 RuntimeInvisibleParameterAnnotations 属性: {0}
1042
1043 compiler.misc.bad.const.pool.tag=错误的常量池标记: {0}
1044
1045 compiler.misc.bad.const.pool.tag.at=错误的常量池标记: {0}, 位于{1}
1046
1047 compiler.misc.bad.signature=错误的签名: {0}
1048
1049 compiler.misc.class.file.wrong.class=类文件包含错误的类: {0}
1050
1051 compiler.misc.class.file.not.found=找不到{0}的类文件
1052
1053 # 0: name
1054 compiler.misc.file.doesnt.contain.class=文件不包含类{0}
1055
1056 compiler.misc.file.does.not.contain.package=文件不包含程序包{0}
1057
1058 compiler.misc.illegal.start.of.class.file=非法的类文件开始
1059
1060 compiler.misc.unable.to.access.file=无法访问文件: {0}
1061
1062 compiler.misc.unicode.str.not.supported=不支持类文件中的 Unicode 字符串
1063
1064 compiler.misc.undecl.type.var=未声明的类型变量: {0}
1065
1066 compiler.misc.wrong.version=类文件具有错误的版本 {0}.{1}, 应为 {2}.{3}
1067
1068 #####
1069
1070 # 0: type, 1: type or symbol
1071 compiler.err.not.within.bounds=类型参数{0}不在类型变量{1}的范围内
1072
1073 ## The following are all possible strings for the second argument ({1}) of the
1074 ## above string.
1075
1076 ## none yet...
1077
1078 #####
1079
1080 # 0: message segment, 1: type, 2: type
1081 compiler.err.prob.found.req={0}\n需要: {2}\n找到: {1}
1082
1083 # 0: message segment, 1: type, 2: type
1084 compiler.warn.prob.found.req={0}\n需要: {2}\n找到: {1}
1085
1086 compiler.err.prob.found.req.1={0} {3}\n需要: {2}\n找到: {1}
1087
1088 ## The following are all possible strings for the first argument ({0}) of the
1089 ## above strings.
1090 compiler.misc.incompatible.types=不兼容的类型
1091
1092 # 0: message segment
1093 compiler.misc.incompatible.types.1=不兼容的类型; {0}
1094
1095 compiler.misc.inconvertible.types=不可转换的类型
1096
1097 compiler.misc.possible.loss.of.precision=可能损失精度
1098
1099 compiler.misc.unchecked.assign=未经检查的转换
1100
1101 # compiler.misc.storecheck=\
1102 # assignment might cause later store checks to fail
1103 # compiler.misc.unchecked=\
1104 # assigned array cannot dynamically check its stores
1105 compiler.misc.unchecked.cast.to.type=未经检查的转换
1106
1107 compiler.misc.assignment.from.super-bound=从 super-bound 类型{0}进行分配
1108
1109 compiler.misc.assignment.to.extends-bound=到 extends-bound 类型{0}的分配
1110
1111 # compiler.err.star.expected=\
1112 # ''*'' expected
1113 # compiler.err.no.elem.type=\
1114 # \[\*\] cannot have a type
1115
1116 compiler.misc.try.not.applicable.to.type=try-with-resources 不适用于变量类型
1117
1118 #####
1119
1120 # 0: message segment or type, 1: message segment
1121 compiler.err.type.found.req=意外的类型\n需要: {1}\n找到: {0}
1122
1123 ## The following are all possible strings for the first argument ({0}) of the
1124 ## above string.
1125 compiler.misc.type.req.class=类
1126
1127 compiler.misc.type.req.class.array=类或数组
1128
1129 compiler.misc.type.req.array.or.iterable=数组或 java.lang.Iterable
1130
1131 compiler.misc.type.req.ref=引用
1132
1133 compiler.misc.type.req.exact=不带限制范围的类或接口
1134
1135 # 0: type
1136 compiler.misc.type.parameter=类型参数{0}
1137
1138 #####
1139
1140 ## The following are all possible strings for the last argument of all those
1141 ## diagnostics whose key ends in ".1"
1142 compiler.misc.undetermined.type=未确定的类型
1143
1144 compiler.misc.type.variable.has.undetermined.type=类型变量{0}带有未确定的类型
1145
1146 # 0: type, 1: list of type
1147 compiler.misc.no.unique.maximal.instance.exists=对于上限为{1}的类型变量{0}, 不存在唯一最大实例
1148
1149 compiler.misc.no.unique.minimal.instance.exists=对于下限为{1}的类型变量{0}, 不存在唯一最小实例
1150
1151 # 0: list of type, 1: type, 2: type
1152 compiler.misc.infer.no.conforming.instance.exists=不存在类型变量{0}的实例, 以使{1}与{2}一致
1153
1154 # 0: list of type, 1: type, 2: type
1155 compiler.misc.infer.no.conforming.assignment.exists=不存在类型变量{0}的实例, 以使参数类型{1}与形式参数类型{2}一致
1156
1157 compiler.misc.infer.arg.length.mismatch=无法从参数进行实例化, 因为实际参数列表和形式参数列表长度不同
1158
1159 # 0: type, 1: list of type
1160 compiler.misc.inferred.do.not.conform.to.bounds=推断类型不符合声明的范围\n推断: {0}\n范围: {1}
1161
1162 # 0: symbol
1163 compiler.misc.diamond={0}<>
1164
1165 # 0: type
1166 compiler.misc.diamond.non.generic=无法将 ''<>'' 与非泛型类{0}一起使用
1167
1168 compiler.misc.diamond.and.explicit.params=不能将 ''<>'' 与构造器的显式类型参数一起使用
1169
1170 # 0: type, 1: list of type
1171 compiler.misc.explicit.param.do.not.conform.to.bounds=显式类型参数{0}不符合声明的范围{1}
1172
1173 compiler.misc.arg.length.mismatch=实际参数列表和形式参数列表长度不同
1174
1175 # 0: type, 1: type
1176 compiler.misc.no.conforming.assignment.exists=无法通过方法调用转换将实际参数{0}转换为{1}
1177
1178 # 0: type, 1: type
1179 compiler.misc.varargs.argument.mismatch=参数类型{0}不符合 vararg 元素类型{1}
1180
1181 #####
1182
1183 ## The first argument ({0}) is a "kindname".
1184 # 0: symbol kind, 1: symbol, 2: symbol
1185 compiler.err.abstract.cant.be.accessed.directly=无法直接访问{2}中的抽象{0} {1}
1186
1187 ## The first argument ({0}) is a "kindname".
1188 # 0: symbol kind, 1: symbol
1189 compiler.err.non-static.cant.be.ref=无法从静态上下文中引用非静态 {0} {1}
1190
1191 ## Both arguments ({0}, {1}) are "kindname"s. {0} is a comma-separated list
1192 ## of kindnames (the list should be identical to that provided in source.
1193 compiler.err.unexpected.type=意外的类型\n需要: {0}\n找到: {1}
1194
1195 ## The first argument {0} is a "kindname" (e.g. 'constructor', 'field', etc.)
1196 ## The second argument {1} is the non-resolved symbol
1197 ## The third argument {2} is a list of type parameters (non-empty if {1} is a method)
1198 ## The fourth argument {3} is a list of argument types (non-empty if {1} is a method)
1199 # 0: symbol kind, 1: name, 2: unused, 3: unused
1200 compiler.err.cant.resolve=找不到符号\n符号: {0} {1}
1201
1202 # 0: symbol kind, 1: name, 2: unused, 3: list of type
1203 compiler.err.cant.resolve.args=找不到符号\n符号: {0} {1}({3})
1204
1205 # 0: symbol kind, 1: name, 2: list of type, 3: list of type
1206 compiler.err.cant.resolve.args.params=找不到符号\n符号: {0} <{2}>{1}({3})
1207
1208 ## arguments from {0} to {3} have the same meaning as above
1209 ## The fifth argument {4} is a location subdiagnostic (see below)
1210 # 0: symbol kind, 1: name, 2: unused, 3: unused, 4: message segment
1211 compiler.err.cant.resolve.location=找不到符号\n符号: {0} {1}\n位置: {4}
1212
1213 # 0: symbol kind, 1: name, 2: unused, 3: list of type, 4: message segment
1214 compiler.err.cant.resolve.location.args=找不到符号\n符号: {0} {1}({3})\n位置: {4}
1215
1216 # 0: symbol kind, 1: name, 2: list of type, 3: list, 4: message segment
1217 compiler.err.cant.resolve.location.args.params=找不到符号\n符号: {0} <{2}>{1}({3})\n位置: {4}
1218
1219 ##a location subdiagnostic is composed as follows:
1220 ## The first argument {0} is the location "kindname" (e.g. 'constructor', 'field', etc.)
1221 ## The second argument {1} is the location name
1222 ## The third argument {2} is the location type (only when {1} is a variable name)
1223
1224 # 0: symbol kind, 1: symbol, 2: unused
1225 compiler.misc.location={0} {1}
1226
1227 # 0: symbol kind, 1: symbol, 2: type
1228 compiler.misc.location.1=类型为{2}的{0} {1}
1229
1230 ## The following are all possible string for "kindname".
1231 ## They should be called whatever the JLS calls them after it been translated
1232 ## to the appropriate language.
1233 # compiler.misc.kindname.constructor=\
1234 # static member
1235 compiler.misc.kindname.annotation=@interface
1236
1237 compiler.misc.kindname.constructor=构造器
1238
1239 compiler.misc.kindname.enum=枚举
1240
1241 compiler.misc.kindname.interface=接口
1242
1243 compiler.misc.kindname.static=静态
1244
1245 compiler.misc.kindname.type.variable=类型变量
1246
1247 compiler.misc.kindname.type.variable.bound=类型变量的限制范围
1248
1249 compiler.misc.kindname.variable=变量
1250
1251 compiler.misc.kindname.value=值
1252
1253 compiler.misc.kindname.method=方法
1254
1255 compiler.misc.kindname.class=类
1256
1257 compiler.misc.kindname.package=程序包
1258
1259 #####
1260
1261 compiler.misc.no.args=没有参数
1262
1263 # 0: message segment
1264 compiler.err.override.static={0}\n覆盖的方法为 static
1265
1266 # 0: message segment, 1: set of modifier
1267 compiler.err.override.meth={0}\n被覆盖的方法为{1}
1268
1269 # 0: message segment, 1: type
1270 compiler.err.override.meth.doesnt.throw={0}\n被覆盖的方法未抛出{1}
1271
1272 # In the following string {1} is a space separated list of Java Keywords, as
1273 # they would have been declared in the source code
1274 # 0: message segment, 1: set of modifier
1275 compiler.err.override.weaker.access={0}\n正在尝试分配更低的访问权限; 以前为{1}
1276
1277 # 0: message segment, 1: type, 2: type
1278 compiler.err.override.incompatible.ret={0}\n返回类型{1}与{2}不兼容
1295 compiler.misc.clashes.with={1}中的{0}与{3}中的{2}冲突
1296
1297 # 0: symbol, 1: symbol, 2: symbol, 3: symbol
1298 compiler.misc.unchecked.override={1}中的{0}覆盖了{3}中的{2}
1299
1300 # 0: symbol, 1: symbol, 2: symbol, 3: symbol
1301 compiler.misc.unchecked.implement={1}中的{0}实现了{3}中的{2}
1302
1303 # 0: symbol, 1: symbol, 2: symbol, 3: symbol
1304 compiler.misc.unchecked.clash.with={1}中的{0}覆盖了{3}中的{2}
1305
1306 # 0: symbol, 1: symbol, 2: symbol, 3: symbol
1307 compiler.misc.varargs.override={1}中的{0}覆盖了{3}中的{2}
1308
1309 # 0: symbol, 1: symbol, 2: symbol, 3: symbol
1310 compiler.misc.varargs.implement={1}中的{0}实现了{3}中的{2}
1311
1312 # 0: symbol, 1: symbol, 2: symbol, 3: symbol
1313 compiler.misc.varargs.clash.with={1}中的{0}覆盖了{3}中的{2}
1314
1315 compiler.misc.diamond.and.anon.class=无法将 ''<>'' 与匿名内部类一起使用
1316
1317 # 0: symbol kind, 1: symbol, 2: symbol, 3: message segment
1318 compiler.misc.inapplicable.method={0} {1}.{2}不适用\n({3})
1319
1320 ########################################
1321 # Diagnostics for language feature changes
1322 ########################################
1323 # 0: string
1324 compiler.err.unsupported.fp.lit=-source {0} 中不支持十六进制浮点文字\n(请使用 -source 5 或更高版本以启用十六进制浮点文字)
1325
1326 # 0: string
1327 compiler.err.unsupported.binary.lit=-source {0} 中不支持二进制文字\n(请使用 -source 7 或更高版本以启用二进制文字)
1328
1329 # 0: string
1330 compiler.err.unsupported.underscore.lit=-source {0} 中不支持文字中存在下划线\n(请使用 -source 7 或更高版本以允许文字中存在下划线)
1331
1332 # 0: string
1333 compiler.err.try.with.resources.not.supported.in.source=-source {0} 中不支持 try-with-resources\n(请使用 -source 7 或更高版本以启用 try-with-resources)
1334
1335 compiler.warn.enum.as.identifier=从发行版 5 开始, ''enum'' 为关键字, 而不用作标识符\n(请使用 -source 5 或更高版本以将 ''enum'' 用作关键字)
1336
1337 compiler.warn.assert.as.identifier=从发行版 1.4 开始, ''assert'' 是一个关键字, 但不能用作标识符\n(请使用 -source 1.4 或更高版本以将 ''assert'' 用作关键字)
1338
1339 compiler.err.enum.as.identifier=从发行版 5 开始, ''enum'' 为关键字, 而不用作标识符\n(请使用 -source 1.4 或更低版本以将 ''enum'' 用作标识符)
1340
1341 compiler.err.assert.as.identifier=从发行版 1.4 开始, ''assert'' 是一个关键字, 但不能用作标识符\n(请使用 -source 1.3 或更低版本以将 ''assert'' 用作标识符)
1342
1343 # TODO 308: make a better error message
1344 # compiler.err.this.as.identifier=\
1345 # as of release 8, ''this'' is allowed as the parameter name for the receiver type only, which has to be the first parameter
1346
1347 # 0: string
1348 compiler.err.generics.not.supported.in.source=-source {0} 中不支持泛型\n(请使用 -source 5 或更高版本以启用泛型)
1349
1350 # 0: string
1351 compiler.err.varargs.not.supported.in.source=-source {0} 中不支持 variable-arity 方法\n(请使用 -source 5 或更高版本以启用 variable-arity 方法)
1352
1353 # 0: string
1354 compiler.err.annotations.not.supported.in.source=-source {0} 中不支持注释\n(请使用 -source 5 或更高版本以启用注释)
1355
1356 #308 compiler.err.type.annotations.not.supported.in.source=\
1357 #308 type annotations are not supported in -source {0}\n\
1358 #308 (use -source 8 or higher to enable type annotations)
1359
1360 # 0: string
1361 compiler.err.foreach.not.supported.in.source=-source {0} 中不支持 for-each 循环\n(请使用 -source 5 或更高版本以启用 for-each 循环)
1362
1363 # 0: string
1364 compiler.err.static.import.not.supported.in.source=-source {0} 中不支持静态导入声明\n(请使用 -source 5 或更高版本以启用静态导入声明)
1365
1366 # 0: string
1367 compiler.err.enums.not.supported.in.source=-source {0} 中不支持枚举\n(请使用 -source 5 或更高版本以启用枚举)
1368
1369 # 0: string
1370 compiler.err.diamond.not.supported.in.source=-source {0} 中不支持 diamond 运算符\n(请使用 -source 7 或更高版本以启用 diamond 运算符)
1371
1372 # 0: string
1373 compiler.err.multicatch.not.supported.in.source=-source {0} 中不支持 multi-catch 语句\n(请使用 -source 7 或更高版本以启用 multi-catch 语句)
1374
1375 # 0: string
1376 compiler.err.string.switch.not.supported.in.source=-source {0} 中不支持 switch 中存在字符串\n(请使用 -source 7 或更高版本以允许 switch 中存在字符串)
1377
1378 ########################################
1379 # Diagnostics for where clause implementation
1380 # used by the RichDiagnosticFormatter.
1381 ########################################
1382
1383 compiler.misc.type.null=<空值>
1384
1385 # X#n (where n is an int id) is disambiguated tvar name
1386 # 0: name, 1: number
1387 compiler.misc.type.var={0}#{1}
1388
1389 # CAP#n (where n is an int id) is an abbreviation for 'captured type'
1390 # 0: number
1391 compiler.misc.captured.type=CAP#{0}
1392
1393 # <INT#n> (where n is an int id) is an abbreviation for 'intersection type'
1394 # 0: number
1395 compiler.misc.intersection.type=INT#{0}
1396
1397 # where clause for captured type: contains upper ('extends {1}') and lower
1398 # ('super {2}') bound along with the wildcard that generated this captured type ({3})
1399 # 0: type, 1: type, 2: type, 3: type
1400 compiler.misc.where.captured={0}从{3}的捕获扩展{1} 超 {2}
1401
1402 # compact where clause for captured type: contains upper ('extends {1}') along
1403 # with the wildcard that generated this captured type ({3})
1404 # 0: type, 1: type, 2: unused, 3: type
1405 compiler.misc.where.captured.1={0}从{3}的捕获扩展{1}
1406
1407 # where clause for type variable: contains upper bound(s) ('extends {1}') along with
1408 # the kindname ({2}) and location ({3}) in which the typevar has been declared
1409 # 0: type, 1: list of type, 2: symbol kind, 3: symbol
1410 compiler.misc.where.typevar={0}扩展已在{2} {3}中声明的{1}
1411
1412 # compact where clause for type variable: contains the kindname ({2}) and location ({3})
1413 # in which the typevar has been declared
1414 compiler.misc.where.typevar.1={0}已在{2} {3}中声明
1415
1416 # where clause for type variable: contains all the upper bound(s) ('extends {1}')
1417 # of this intersection type
1418 # 0: type, 1: list of type
1419 compiler.misc.where.intersection={0}扩展{1}
1420
1421 ### Where clause headers ###
1422 compiler.misc.where.description.captured=其中, {0}是新类型变量:
1423
1424 # 0: set of type
1425 compiler.misc.where.description.typevar=其中, {0}是类型变量:
1426
1427 # 0: set of type
1428 compiler.misc.where.description.intersection=其中, {0}是交叉类型:
1429
1430 # 0: set of type
1431 compiler.misc.where.description.captured.1=其中, {0}是新类型变量:
1432
1433 # 0: set of type
1434 compiler.misc.where.description.typevar.1=其中, {0}是类型变量:
1435
1436 compiler.misc.where.description.intersection.1=其中, {0}是交叉类型:
1437
1438
|
48 # set of X a comma-separated collection of items; e.g. set of modifier
49 #
50 # These may be composed: e.g. list of type or message segment
51 #
52 # These comments are verified by the jtreg test test/tools/javac/diags/MessageInfo,
53 # using info derived from the collected set of examples in test/tools/javac/diags/examples.
54 # MessageInfo can also be run as a standalone utility providing more facilities
55 # for manipulating this file. For more details, see MessageInfo.java.
56
57 ##
58 ## errors
59 ##
60
61 # 0: symbol
62 compiler.err.abstract.cant.be.instantiated={0}是抽象的; 无法实例化
63
64 compiler.err.abstract.meth.cant.have.body=抽象方法不能有主体
65
66 compiler.err.already.annotated={0} {1}已进行注释
67
68 # 0: symbol kind, 1: symbol, 2: symbol kind, 3: symbol
69 compiler.err.already.defined=已在{2} {3}中定义了{0} {1}
70
71 # 0: symbol kind, 1: symbol, 2: symbol kind, 3: symbol kind, 4: symbol
72 compiler.err.already.defined.in.clinit=已在{3} {4}的{2}中定义了{0} {1}
73
74 # 0: string
75 compiler.err.already.defined.single.import=已在 single-type 导入中定义{0}
76
77 # 0: string
78 compiler.err.already.defined.static.single.import=已在静态 single-type 导入中定义{0}
79
80 compiler.err.already.defined.this.unit=已在该编译单元中定义{0}
81
82 # 0: type, 1: list of name
83 compiler.err.annotation.missing.default.value=对于属性{1}, 注释{0}缺少值
84
85 # 0: type, 1: list of name
86 compiler.err.annotation.missing.default.value.1=对于属性{1}, 注释{0}缺少值
87
88 # 0: type
89 compiler.err.annotation.not.valid.for.type=对于类型为{0}的值, 注释无效
90
91 compiler.err.annotation.type.not.applicable=注释类型不适用于该类型的声明
92
93 compiler.err.annotation.value.must.be.annotation=注释值必须为注释
95 compiler.err.annotation.value.must.be.class.literal=注释值必须为类文字
96
97 compiler.err.annotation.value.must.be.name.value=注释值必须采用 ''name=value'' 格式
98
99 compiler.err.annotation.value.not.allowable.type=注释值不是允许的类型
100
101 compiler.err.anon.class.impl.intf.no.args=匿名类实现接口; 不能有参数
102
103 compiler.err.anon.class.impl.intf.no.typeargs=匿名类实现接口; 不能具有类型参数
104
105 compiler.err.anon.class.impl.intf.no.qual.for.new=匿名类实现接口; 不能有限定符 - 对于新
106
107 # 0: symbol, 1: symbol, 2: symbol
108 compiler.err.array.and.varargs=无法在{2}中同时声明{0}和{1}
109
110 compiler.err.array.dimension.missing=缺少数组维
111
112 # 0: type
113 compiler.err.array.req.but.found=需要数组, 但找到{0}
114
115 compiler.err.attribute.value.must.be.constant=属性值必须为常量
116
117 # 0: statement type
118 compiler.err.bad.initializer={0}的初始化程序错误
119
120 compiler.err.break.outside.switch.loop=在 switch 或 loop 外部中断
121
122 # 0: name
123 compiler.err.call.must.be.first.stmt.in.ctor=对{0}的调用必须是构造器中的第一个语句
124
125 # 0: symbol kind, 1: name, 2: list of type or message segment, 3: list of type or message segment, 4: symbol kind, 5: type, 6: message segment
126 compiler.err.cant.apply.symbol=无法将{4} {5}中的{0} {1}应用到给定类型;\n需要: {2}\n找到: {3}\n原因: {6}
127
128 # 0: symbol kind, 1: name, 2: list of type
129 compiler.err.cant.apply.symbols=对于{1}({2}), 找不到合适的{0}
130
131 # 0: symbol kind, 1: name, 2: list of type or message segment, 3: list of type or message segment, 4: symbol kind, 5: type, 6: message segment
132 compiler.misc.cant.apply.symbol=无法将 {4} {5}中的 {0} {1}应用到给定类型\n需要: {2}\n找到: {3}\n原因: {6}
133
134 # 0: symbol kind, 1: name, 2: list of type
135 compiler.misc.cant.apply.symbols=对于{1}({2}), 找不到合适的{0}
136
137 # 0: symbol kind, 1: symbol
138 compiler.misc.no.abstracts=在 {0} {1} 中找不到抽象方法
139
140 # 0: symbol kind, 1: symbol
141 compiler.misc.incompatible.abstracts=在 {0} {1} 中找到多个非覆盖抽象方法
142
143 compiler.err.bad.functional.intf.anno=意外的 @FunctionalInterface 注释
144
145 # 0: message segment
146 compiler.err.bad.functional.intf.anno.1=意外的 @FunctionalInterface 注释\n{0}
147
148 # 0: symbol
149 compiler.misc.not.a.functional.intf={0} 不是函数接口
150
151 # 0: symbol, 1: message segment
152 compiler.misc.not.a.functional.intf.1={0} 不是函数接口\n{1}
153
154 # 0: symbol, 1: symbol kind, 2: symbol
155 compiler.misc.invalid.generic.lambda.target=lambda 表达式的函数描述符无效\n{1} {2} 中的方法 {0} 为泛型方法
156
157 # 0: symbol kind, 1: symbol
158 compiler.misc.incompatible.descs.in.functional.intf=在 {0} {1} 中找到不兼容的函数描述符
159
160 # 0: name, 1: list of type, 2: type, 3: list of type
161 compiler.misc.descriptor=描述符: {2} {0}({1})
162
163 # 0: name, 1: list of type, 2: type, 3: list of type
164 compiler.misc.descriptor.throws=描述符: {2} {0}({1}) 抛出{3}
165
166 # 0: type
167 compiler.misc.no.suitable.functional.intf.inst=无法推断{0}的函数接口描述符
168
169 # 0: type
170 compiler.misc.secondary.bound.must.be.marker.intf=次级限制范围{0}必须为标记接口
171
172 # 0: symbol kind, 1: message segment
173 compiler.err.invalid.mref={0} 引用无效; {1}
174
175 # 0: symbol kind, 1: message segment
176 compiler.misc.invalid.mref={0} 引用无效; {1}
177
178 compiler.misc.static.mref.with.targs=有关静态方法引用的参数化限定符
179
180 compiler.misc.static.bound.mref=静态限制范围方法引用
181
182 # 0: symbol
183 compiler.err.cant.assign.val.to.final.var=无法为最终变量{0}分配值
184
185 # 0: symbol, 1: message segment
186 compiler.err.cant.ref.non.effectively.final.var=从{1}引用的本地变量必须是最终变量或实际上的最终变量
187
188
189 compiler.misc.lambda=lambda 表达式
190
191 compiler.misc.inner.cls=内部类
192
193 # 0: type
194 compiler.err.cant.deref=无法取消引用{0}
195
196 compiler.err.cant.extend.intf.annotation=对于 @interfaces, 不允许 ''extends''
197
198 # 0: symbol
199 compiler.err.cant.inherit.from.final=无法从最终{0}进行继承
200
201 # 0: symbol
202 compiler.err.cant.ref.before.ctor.called=无法在调用超类型构造器之前引用{0}
203
204 compiler.err.cant.select.static.class.from.param.type=无法从参数化的类型中选择静态类
205
206 # 0: symbol, 1: string, 2: string
207 compiler.err.cant.inherit.diff.arg=无法使用以下不同的参数继承{0}: <{1}> 和 <{2}>
208
209 compiler.err.catch.without.try=有 ''catch'', 但是没有 ''try''
210
211 # 0: symbol kind, 1: symbol
212 compiler.err.clash.with.pkg.of.same.name={0} {1}与带有相同名称的程序包冲突
213
214 compiler.err.class.not.allowed=此处不允许使用类, 接口或枚举声明
215
216 compiler.err.const.expr.req=需要常量表达式
217
218 compiler.err.cont.outside.loop=continue 在 loop 外部
219
220 # 0: symbol
221 compiler.err.cyclic.inheritance=涉及{0}的循环继承
222
223 compiler.err.cyclic.annotation.element=循环注释元素类型
224
225 # 0: unused
226 compiler.err.call.to.super.not.allowed.in.enum.ctor=在枚举构造器中不允许调用超类
227
228 # 0: type
229 compiler.err.no.superclass={0}不具有超类
230
231 # 0: symbol, 1: type, 2: symbol, 3: type, 4: unused
232 compiler.err.concrete.inheritance.conflict={1}中的方法{0}和{3}中的方法{2}是使用相同的签名继承的
233
234 compiler.err.default.allowed.in.intf.annotation.member=仅在 @interface 成员中允许使用默认值
235
236 # 0: symbol
237 compiler.err.doesnt.exist=程序包{0}不存在
238
239 compiler.err.duplicate.annotation=注释重复
240
241 # 0: type
242 compiler.err.duplicate.annotation.invalid.repeated=无法重复注释{0}\n它没有定义有效的包含注释。
243
244 # 0: name, 1: type
245 compiler.err.duplicate.annotation.member.value={1}中的注释成员值{0}重复
246
247 # 0: type, 1: type
248 compiler.err.duplicate.annotation.missing.container=注释重复, {0}的声明没有有效的{1}注释
249
250 # 0: type
251 compiler.err.invalid.repeatable.annotation=注释重复, 使用无效的可重复注释对{0}进行了注释
252
253 # 0: type
254 compiler.err.invalid.repeatable.annotation.no.value=注释重复, {0}不是有效的可重复类型, 未声明任何值元素方法
255
256 # 0: type, 1: number
257 compiler.err.invalid.repeatable.annotation.multiple.values=注释重复, {0}不是有效的可重复类型, 已声明 {1} 个值元素方法
258
259 # 0: type
260 compiler.err.invalid.repeatable.annotation.invalid.value=注释重复, {0}不是有效的可重复类型, 值元素无效, 需要方法
261
262 # 0: type, 1: type, 2: type
263 compiler.err.invalid.repeatable.annotation.value.return=注释重复, 包含注释{0}的值元素应具有类型{2}, 但找到的是{1}
264
265 # 0: type, 1: symbol
266 compiler.err.invalid.repeatable.annotation.elem.nondefault=包含注释{0}没有元素 {1} 的默认值
267
268 # 0: symbol, 1: type, 2: symbol, 3: type
269 compiler.err.invalid.repeatable.annotation.retention=包含注释 {0} 的保留期 ({1}) 短于已包含注释 {2} 的保留期 ({3})
270
271 # 0: symbol, 1: symbol
272 compiler.err.invalid.repeatable.annotation.not.documented=包含注释类型 {0} 不是 @Documented, 而重复的注释类型 {1} 为
273
274 # 0: symbol, 1: symbol
275 compiler.err.invalid.repeatable.annotation.not.inherited=包含注释类型 {0} 不是 @Inherited, 而重复的注释类型 {1} 为
276
277 # 0: symbol, 1: symbol
278 compiler.err.invalid.repeatable.annotation.incompatible.target=容器注释 {0} 的目标不是重复注释 {1} 的目标子集
279
280 # 0: symbol
281 compiler.err.invalid.repeatable.annotation.repeated.and.container.present=容器 {0} 不得与其包含的元素同时存在
282
283 # 0: name
284 compiler.err.duplicate.class=类重复: {0}
285
286 compiler.err.duplicate.case.label=case 标签重复
287
288 compiler.err.duplicate.default.label=default 标签重复
289
290 compiler.err.else.without.if=有 ''if'', 但是没有 ''else''
291
292 compiler.err.empty.char.lit=空字符文字
293
294 # 0: symbol
295 compiler.err.encl.class.required=需要包含{0}的封闭实例
296
297 compiler.err.enum.annotation.must.be.enum.constant=枚举注释值必须是枚举常量
298
299 compiler.err.enum.cant.be.instantiated=无法实例化枚举类型
300
301 compiler.err.enum.label.must.be.unqualified.enum=枚举 switch case 标签必须为枚举常量的非限定名称
302
324 # 0: symbol
325 compiler.err.multicatch.parameter.may.not.be.assigned=可能未分配 multi-catch 参数{0}
326
327 # 0: type, 1: type
328 compiler.err.multicatch.types.must.be.disjoint=multi-catch 语句中的替代无法通过子类化关联\n替代{0}是替代{1}的子类
329
330 compiler.err.finally.without.try=有 ''finally'', 但是没有 ''try''
331
332 # 0: type, 1: message segment
333 compiler.err.foreach.not.applicable.to.type=for-each 不适用于表达式类型\n要求: {1}\n找到: {0}
334
335 compiler.err.fp.number.too.large=浮点数过大
336
337 compiler.err.fp.number.too.small=浮点数过小
338
339 compiler.err.generic.array.creation=创建泛型数组
340
341 compiler.err.generic.throwable=泛型类不能扩展 java.lang.Throwable
342
343 # 0: symbol
344 compiler.err.icls.cant.have.static.decl=内部类{0}中的静态声明非法\n修饰符 ''static'' 仅允许在常量变量声明中使用
345
346 # 0: string
347 compiler.err.illegal.char=非法字符: ''{0}''
348
349 compiler.err.illegal.char.for.encoding=编码{0}的不可映射字符
350
351 # 0: set of modifier, 1: set of modifier
352 compiler.err.illegal.combination.of.modifiers=非法的修饰符组合: {0}和{1}
353
354 compiler.err.illegal.enum.static.ref=初始化程序中对静态字段的引用不合法
355
356 compiler.err.illegal.esc.char=非法转义符
357
358 compiler.err.illegal.forward.ref=非法前向引用
359
360 # 0: symbol
361 compiler.warn.forward.ref=先引用变量 ''{0}'', 然后再对其初始化
362
363 compiler.err.illegal.self.ref=初始化程序中存在自引用
364
365 # 0: symbol
366 compiler.warn.self.ref=变量 ''{0}'' 的初始化程序中存在自引用
367
368 compiler.err.illegal.generic.type.for.instof=instanceof 的泛型类型不合法
369
370 # 0: type
371 compiler.err.illegal.initializer.for.type={0}的初始化程序不合法
372
373 compiler.err.illegal.line.end.in.char.lit=字符文字的行结尾不合法
374
375 compiler.err.illegal.nonascii.digit=非法的非 ASCII 数字
376
377 compiler.err.illegal.underscore=非法下划线
378
379 compiler.err.illegal.dot=非法 ''.''
380
381 # 0: symbol
382 compiler.err.illegal.qual.not.icls=非法限定符; {0}不是内部类
383
384 compiler.err.illegal.start.of.expr=非法的表达式开始
385
386 compiler.err.illegal.start.of.stmt=非法的语句开始
387
388 compiler.err.illegal.start.of.type=非法的类型开始
389
390 compiler.err.illegal.unicode.esc=非法的 Unicode 转义
391
392 # 0: symbol
393 compiler.err.import.requires.canonical=导入需要{0}的规范名称
394
395 compiler.err.improperly.formed.type.param.missing=类型的格式不正确, 缺少某些参数
396
397 compiler.err.improperly.formed.type.inner.raw.param=类型的格式不正确, 给出了原始类型的类型参数
398
399 # 0: type, 1: type
400 compiler.err.incomparable.types=不可比较的类型: {0}和{1}
401
402 # 0: number
403 compiler.err.int.number.too.large=过大的整数: {0}
404
405 compiler.err.intf.annotation.members.cant.have.params=@interface 成员不能带有参数
406
407 compiler.err.intf.annotation.cant.have.type.params=@interface 不能带有类型参数
408
409 compiler.err.intf.annotation.members.cant.have.type.params=@interface 成员不能带有类型参数
410
411 # 0: symbol, 1: type
412 compiler.err.intf.annotation.member.clash=@interface 成员与{1}中的方法 ''{0}'' 冲突
413
414 compiler.err.intf.expected.here=此处需要接口
415
416 compiler.err.intf.meth.cant.have.body=接口抽象方法不能带有主体
417
418 compiler.err.invalid.annotation.member.type=注释成员的类型无效
419
420 compiler.err.invalid.binary.number=二进制数字中必须包含至少一个二进制数
421
422 compiler.err.invalid.hex.number=十六进制数字必须包含至少一位十六进制数
423
424 compiler.err.invalid.meth.decl.ret.type.req=方法声明无效; 需要返回类型
425
426 compiler.err.varargs.and.old.array.syntax=variable-arity 参数中不允许使用传统数组记号
427
428 compiler.err.variable.not.allowed=此处不允许使用变量声明
429
430 # 0: name
431 compiler.err.label.already.in.use=标签{0}已使用
432
433 # 0: symbol
434 compiler.err.local.var.accessed.from.icls.needs.final=从内部类中访问本地变量{0}; 需要被声明为最终类型
435
436 compiler.err.local.enum=枚举类型不能为本地类型
437
438 compiler.err.cannot.create.array.with.type.arguments=无法创建具有类型变量的数组
439
440 compiler.err.cannot.create.array.with.diamond=无法创建具有 ''<>'' 的数组
441
442 #
443 # limits. We don't give the limits in the diagnostic because we expect
444 # them to change, yet we want to use the same diagnostic. These are all
445 # detected during code generation.
446 #
447 compiler.err.limit.code=代码过长
448
449 compiler.err.limit.code.too.large.for.try.stmt=try 语句的代码过长
450
451 compiler.err.limit.dimensions=数组类型维过多
452
453 compiler.err.limit.locals=本地变量过多
454
455 compiler.err.limit.parameters=参数过多
456
457 compiler.err.limit.pool=常量过多
458
459 compiler.err.limit.pool.in.class=类{0}中的常量过多
460
461 compiler.err.limit.stack=代码需要过多堆栈
462
463 compiler.err.limit.string=常量字符串过长
464
465 compiler.err.limit.string.overflow=对于常量池来说, 字符串 "{0}..." 的 UTF8 表示过长
466
467 compiler.err.malformed.fp.lit=浮点文字的格式错误
468
469 compiler.err.method.does.not.override.superclass=方法不会覆盖或实现超类型的方法
470
471 compiler.err.missing.meth.body.or.decl.abstract=缺少方法主体, 或声明抽象
472
473 compiler.err.missing.ret.stmt=缺少返回语句
474
475 compiler.misc.missing.ret.val=缺少返回值
476
477 compiler.misc.unexpected.ret.val=意外的返回值
478
479 # 0: set of modifier
480 compiler.err.mod.not.allowed.here=此处不允许使用修饰符{0}
481
482 compiler.err.intf.not.allowed.here=此处不允许使用接口
483
484 compiler.err.enums.must.be.static=只有在静态上下文中才允许使用枚举声明
485
486 # 0: symbol, 1: symbol
487 compiler.err.name.clash.same.erasure=名称冲突: {0}和{1}具有相同疑符
488
489 # 0: symbol, 1: symbol, 2: symbol, 3: symbol, 4: unused, 5: unused
490 compiler.err.name.clash.same.erasure.no.override=名称冲突: {1}中的{0}和{3}中的{2}具有相同疑符, 但两者均不覆盖对方
491
492 # 0: symbol, 1: symbol, 2: symbol, 3: symbol, 4: symbol, 5: symbol
493 compiler.err.name.clash.same.erasure.no.override.1=名称冲突: {1} 中的 {0} 覆盖的方法的疑符与另一个方法的相同, 但两者均不覆盖对方\n第一个方法: {3} 中的 {2}\n第二个方法: {5} 中的 {4}
494
495 # 0: symbol, 1: symbol, 2: symbol, 3: symbol
496 compiler.err.name.clash.same.erasure.no.hide=名称冲突: {1} 中的 {0} 和 {3} 中的 {2} 具有相同疑符, 但两者均不隐藏对方
497
498 compiler.err.name.reserved.for.internal.use={0}为内部使用保留
499
500 compiler.err.native.meth.cant.have.body=本机方法不能带有主体
501
502 # 0: type, 1: type
503 compiler.err.neither.conditional.subtype=? 的不兼容类型: 两者都不是对方的子类型\n第二个操作数: {0}\n第三个操作数: {1}
504
505 # 0: message segment
506 compiler.misc.incompatible.type.in.conditional=条件表达式中的类型错误; {0}
507
508 compiler.misc.conditional.target.cant.be.void=条件表达式的目标类型不能为空
509
510 # 0: type
511 compiler.misc.incompatible.ret.type.in.lambda=lambda 表达式中的返回类型错误\n{0}
512
513 # 0: type
514 compiler.misc.incompatible.ret.type.in.mref=方法引用中的返回类型错误\n{0}
515
516 # 0: list of type
517 compiler.err.incompatible.thrown.types.in.lambda=lambda 表达式中抛出的类型{0}不兼容
518
519 # 0: list of type
520 compiler.err.incompatible.thrown.types.in.mref=方法引用中抛出的类型{0}不兼容
521
522 compiler.misc.incompatible.arg.types.in.lambda=lambda 表达式中的参数类型不兼容
523
524 compiler.err.new.not.allowed.in.annotation=注释中不允许使用 ''new''
525
526 compiler.err.no.annotation.member={1}中没有注释成员{0}
527
528 compiler.err.no.encl.instance.of.type.in.scope=作用域中没有类型为{0}的封闭实例
529
530 compiler.err.no.intf.expected.here=此处不需要接口
531
532 compiler.err.no.match.entry={0}在{1}的条目中没有匹配项; 需要{2}
533
534 compiler.err.not.annotation.type={0}不是注释类型
535
536 # 0: symbol, 1: symbol
537 compiler.err.not.def.access.class.intf.cant.access={1}中的{0}是在不可访问的类或接口中定义的
538
539 # 0: symbol, 1: symbol
540 compiler.misc.not.def.access.class.intf.cant.access={1}中的{0}是在不可访问的类或接口中定义的
541
542 # 0: symbol, 1: list of type, 2: type
543 compiler.misc.cant.access.inner.cls.constr=无法访问构造器 {0}({1})\n作用域中没有类型为{2}的封闭实例
544
545 # 0: symbol, 1: symbol
546 compiler.err.not.def.public.cant.access={0}在{1}中不是公共的; 无法从外部程序包中对其进行访问
547
548 # 0: name
549 compiler.err.not.loop.label=不是 loop 标签: {0}
550
551 compiler.err.not.stmt=不是语句
552
553 # 0: symbol
554 compiler.err.not.encl.class=不是封闭类: {0}
555
556 # 0: name, 1: type, 2: unused
557 compiler.err.operator.cant.be.applied=一元运算符 ''{0}'' 的操作数类型{1}错误
558
559 # 0: name, 1: type, 2: type
560 compiler.err.operator.cant.be.applied.1=二元运算符 ''{0}'' 的操作数类型错误\n第一个类型: {1}\n第二个类型: {2}
561
562 compiler.err.pkg.annotations.sb.in.package-info.java=程序包注释应在文件 package-info.java 中
563
564 # 0: symbol
565 compiler.err.pkg.clashes.with.class.of.same.name=程序包{0}与带有相同名称的类冲突
567 compiler.err.warnings.and.werror=发现警告, 但指定了 -Werror
568
569 # Errors related to annotation processing
570
571 # 0: symbol, 1: string, 2: stack-trace
572 compiler.err.proc.cant.access=无法访问{0}\n{1}\n有关详细信息, 请参阅以下堆栈跟踪。\n{2}
573
574 # 0: symbol, 1: string
575 compiler.err.proc.cant.access.1=无法访问{0}\n{1}
576
577 # 0: string
578 compiler.err.proc.cant.find.class=找不到 ''{0}'' 的类文件。
579
580 # Print a client-generated error message; assumed to be localized, no translation required
581 # 0: string
582 compiler.err.proc.messager={0}
583
584 # 0: list of string
585 compiler.err.proc.no.explicit.annotation.processing.requested=仅当显式请求注释处理时才接受类名称 ''{0}''
586
587 compiler.err.proc.no.service=ServiceLoader 不可用, 但它是注释处理所必需的。
588
589 compiler.err.proc.processor.bad.option.name=处理程序 ''{1}'' 提供的选项名称 ''{0}'' 错误
590
591 # 0: string
592 compiler.err.proc.processor.cant.instantiate=无法实例化处理程序 ''{0}'' 的实例
593
594 # 0: string
595 compiler.err.proc.processor.not.found=找不到注释处理程序 ''{0}''
596
597 # 0: string
598 compiler.err.proc.processor.wrong.type=注释处理程序 ''{0}'' 未实现 javax.annotation.processing.Processor
599
600 compiler.err.proc.service.problem=创建服务加载器以加载处理程序时出错。
601
602 compiler.err.proc.bad.config.file=服务配置文件不正确, 或构造处理程序对象{0}时抛出异常错误
603
604 compiler.err.proc.cant.create.loader=无法为注释处理程序{0}创建类加载器
605
606 # 0: unused
607 compiler.err.qualified.new.of.static.class=限定的新静态类
608
609 compiler.err.recursive.ctor.invocation=递归构造器调用
610
611 # 0: name, 1: symbol kind, 2: symbol, 3: symbol, 4: symbol kind, 5: symbol, 6: symbol
612 compiler.err.ref.ambiguous=对{0}的引用不明确\n{3} 中的{1} {2} 和 {6} 中的{4} {5} 都匹配
613
614 # 0: name, 1: symbol kind, 2: symbol, 3: symbol, 4: symbol kind, 5: symbol, 6: symbol
615 compiler.misc.ref.ambiguous=对{0}的引用不明确\n{3} 中的{1} {2} 和 {6} 中的{4} {5} 都匹配
616
617 compiler.err.repeated.annotation.target=注释目标重复
618
619 compiler.err.repeated.interface=接口重复
620
621 compiler.err.repeated.modifier=修饰符重复
622
623 # 0: symbol, 1: set of modifier, 2: symbol
624 compiler.err.report.access={0}可以在{2}中访问{1}
625
626 compiler.err.ret.outside.meth=返回外部方法
627
628 compiler.err.signature.doesnt.match.supertype=签名与{0}不匹配; 不兼容的超类型
629
630 compiler.err.signature.doesnt.match.intf=签名与{0}不匹配; 不兼容的接口
631
632 # 0: symbol, 1: symbol, 2: symbol
633 compiler.err.does.not.override.abstract={0}不是抽象的, 并且未覆盖{2}中的抽象方法{1}
634
635 compiler.err.source.cant.overwrite.input.file=写入源时出错; 无法覆盖输入文件{0}
636
649 compiler.err.throws.not.allowed.in.intf.annotation=@interface 成员中不允许使用 throws 子句
650
651 compiler.err.try.without.catch.or.finally=有 ''try'', 但是没有 ''catch'' 或 ''finally''
652
653 compiler.err.try.without.catch.finally.or.resource.decls=''try'' 不带有 ''catch'', ''finally'' 或资源声明
654
655 # 0: symbol
656 compiler.err.type.doesnt.take.params=类型{0}不带有参数
657
658 compiler.err.type.var.cant.be.deref=无法从类型变量中进行选择
659
660 compiler.err.type.var.may.not.be.followed.by.other.bounds=类型变量后面不能带有其他限制范围
661
662 compiler.err.type.var.more.than.once=类型变量{0}在{1}的结果类型中多次出现; 必须对其进行实例化
663
664 compiler.err.type.var.more.than.once.in.result=类型变量{0}在{1}的类型中多次出现; 必须对其进行实例化
665
666 # 0: type, 1: type, 2: string
667 compiler.err.types.incompatible.diff.ret=类型{0}和{1}不兼容; 两者都定义了{2}, 但却带有不相关的返回类型
668
669 # 0: kind, 1: type, 2: name, 3: list of type, 4: symbol, 5: symbol
670 compiler.err.types.incompatible.unrelated.defaults={0} {1}从类型 {4} 和 {5} 中继承了{2}({3}) 的不相关默认值
671
672 # 0: kind, 1: type, 2: name, 3: list of type, 4: symbol, 5: symbol
673 compiler.err.types.incompatible.abstract.default={0} {1}从类型 {4} 和 {5} 中继承了{2}({3}) 的抽象和默认值
674
675 # 0: name, 1: kind, 2: symbol
676 compiler.err.default.overrides.object.member={1} {2} 中的默认方法{0}覆盖了 java.lang.Object 的成员
677
678 # 0: type
679 compiler.err.illegal.static.intf.meth.call=静态接口方法调用非法\n应将接收方表达式替换为类型限定符 ''{0}''
680
681 # 0: type, 1: message segment
682 compiler.err.illegal.default.super.call=默认超级调用中的类型限定符{0}错误\n{1}
683
684 # 0: symbol, 1: type
685 compiler.misc.overridden.default=覆盖了{1}中的方法 {0}
686
687 # 0: symbol, 1: symbol
688 compiler.misc.redundant.supertype=冗余接口 {0} 已由 {1} 扩展
689
690 compiler.err.unclosed.char.lit=未结束的字符文字
691
692 compiler.err.unclosed.comment=未结束的注释
693
694 compiler.err.unclosed.str.lit=未结束的字符串文字
695
696 # 0: name
697 compiler.err.unsupported.encoding=不支持的编码: {0}
698
699 compiler.err.io.exception=读取源文件时出错: {0}
700
701 # 0: name
702 compiler.err.undef.label=未定义的标签: {0}
703
704 # 0: message segment, 1: unused
705 compiler.err.cant.apply.diamond=无法推断{0}的类型参数
706
707 # 0: message segment or type, 1: message segment
708 compiler.err.cant.apply.diamond.1=无法推断{0}的类型参数\n原因: {1}
709
710 # 0: message segment or type, 1: message segment
711 compiler.misc.cant.apply.diamond.1=无法推断{0}的类型参数\n原因: {1}
712
713 compiler.err.unreachable.stmt=无法访问的语句
714
715 compiler.err.initializer.must.be.able.to.complete.normally=初始化程序必须能够正常完成
716
717 # 0: type
718 compiler.err.unreported.exception.need.to.catch.or.throw=未报告的异常错误{0}; 必须对其进行捕获或声明以便抛出
719
720 # 0: type
721 compiler.err.unreported.exception.default.constructor=默认构造器中未报告的异常错误{0}
722
723 # 0: type, 1: name
724 compiler.err.unreported.exception.implicit.close=未报告的异常错误{0}; 必须对其进行捕获或声明以便抛出\n对资源变量 ''{1}'' 隐式调用 close() 时抛出了异常错误
725
726 compiler.err.unsupported.cross.fp.lit=该 VM 不支持十六进制浮点文字
727
728 compiler.err.void.not.allowed.here=此处不允许使用 ''空'' 类型
729
730 # 0: string
731 compiler.err.wrong.number.type.args=类型变量数目错误; 需要{0}
732
734 compiler.err.var.might.already.be.assigned=可能已分配变量{0}
735
736 # 0: symbol
737 compiler.err.var.might.not.have.been.initialized=可能尚未初始化变量{0}
738
739 # 0: symbol
740 compiler.err.var.might.be.assigned.in.loop=可能在 loop 中分配了变量{0}
741
742 # 0: symbol, 1: message segment
743 compiler.err.varargs.invalid.trustme.anno={0} 注释无效。{1}
744
745 # 0: type
746 compiler.misc.varargs.trustme.on.reifiable.varargs=Varargs 元素类型{0}可具体化。
747
748 # 0: symbol
749 compiler.misc.varargs.trustme.on.non.varargs.meth=方法 {0} 不是 varargs 方法。
750
751 # 0: symbol
752 compiler.misc.varargs.trustme.on.virtual.varargs=实例方法 {0} 不是最终的。
753
754 # 0: type, 1: symbol kind, 2: symbol
755 compiler.misc.inaccessible.varargs.type=形式 varargs 元素类型{0}无法从 {1} {2} 进行访问
756
757 # In the following string, {1} will always be the detail message from
758 # java.io.IOException.
759 # 0: symbol, 1: string
760 compiler.err.class.cant.write=写入{0}时出错: {1}
761
762 # In the following string, {0} is the name of the class in the Java source.
763 # It really should be used two times..
764 # 0: name
765 compiler.err.class.public.should.be.in.file=类{0}是公共的, 应在名为 {0}.java 的文件中声明
766
767 ## All errors which do not refer to a particular line in the source code are
768 ## preceded by this string.
769 compiler.err.error=错误:
770
771 # The following error messages do not refer to a line in the source code.
772 compiler.err.cant.read.file=无法读取: {0}
773
774 #####
775
776 # Fatal Errors
777
778 compiler.misc.fatal.err.no.java.lang=致命错误: 在类路径或引导类路径中找不到程序包 java.lang
779
780 compiler.misc.fatal.err.cant.locate.meth=致命错误: 找不到方法{0}
781
782 compiler.misc.fatal.err.cant.locate.field=致命错误: 找不到字段{0}
783
784 compiler.misc.fatal.err.cant.locate.ctor=致命错误: 找不到{0}的构造器
785
786 compiler.misc.fatal.err.cant.close=致命错误: 无法关闭编译器资源
787
788 #####
789
790 ##
791 ## miscellaneous strings
792 ##
793
794 compiler.misc.source.unavailable=(源不可用)
795
796 compiler.misc.base.membership=您的所有基类都属于我们
797
798 # 0: string, 1: string, 2: boolean
799 compiler.misc.x.print.processor.info=处理程序{0}与{1}匹配并返回{2}。
800
801 # 0: number, 1: string, 2: set of symbol, 3: boolean
802 compiler.misc.x.print.rounds=循环 {0}:\n\t输入文件: {1}\n\t注释: {2}\n\t最后一个循环: {3}
803
804 #####
805
806 ## The following string will appear before all messages keyed as:
807 ## "compiler.note".
808
809 compiler.note.potential.lambda.found=可将此匿名内部类创建转换为 lambda 表达式。
810
811 compiler.note.note=注:
812
813 # 0: file name
814 compiler.note.deprecated.filename={0}使用或覆盖了已过时的 API。
815
816 compiler.note.deprecated.plural=某些输入文件使用或覆盖了已过时的 API。
817
818 # The following string may appear after one of the above deprecation
819 # messages.
820 compiler.note.deprecated.recompile=有关详细信息, 请使用 -Xlint:deprecation 重新编译。
821
822 # 0: file name
823 compiler.note.deprecated.filename.additional={0}还使用或覆盖了已过时的 API。
824
825 compiler.note.deprecated.plural.additional=某些输入文件还使用或覆盖了已过时的 API。
826
827 # 0: file name
828 compiler.note.unchecked.filename={0}使用了未经检查或不安全的操作。
829
830 compiler.note.unchecked.plural=某些输入文件使用了未经检查或不安全的操作。
831
832 # The following string may appear after one of the above deprecation
905 compiler.misc.verbose.sourcepath=[源文件的搜索路径: {0}]
906
907 # 0: string
908 compiler.misc.verbose.classpath=[类文件的搜索路径: {0}]
909
910 ## extra output when using -checkclassfile (code/ClassReader)
911 compiler.misc.ccf.found.later.version=类文件的版本高于预期: {0}
912
913 compiler.misc.ccf.unrecognized.attribute=无法识别的属性: {0}
914
915 ## extra output when using -prompt (util/Log)
916 compiler.misc.resume.abort=继续(R), 放弃(A)>
917
918 #####
919
920 ##
921 ## warnings
922 ##
923
924 ## All warning messages are preceded by the following string.
925 compiler.warn.warning=警告:
926
927 ## Warning messages may also include the following prefix to identify a
928 ## lint option
929 # 0: option name
930 compiler.warn.lintOption=[{0}]
931
932 # 0: symbol
933 compiler.warn.constant.SVUID=serialVersionUID 在类{0}中必须是常量
934
935 # 0: file name
936 compiler.warn.dir.path.element.not.found=错误的路径元素 "{0}": 没有这种目录
937
938 compiler.warn.finally.cannot.complete=finally 子句无法正常完成
939
940 # 0: symbol, 1: symbol
941 compiler.warn.has.been.deprecated={1}中的{0}已过时
942
943 # 0: symbol
944 compiler.warn.sun.proprietary={0}是内部专用 API, 可能会在未来发行版中删除
945
946 compiler.warn.illegal.char.for.encoding=编码{0}的不可映射字符
947
948 # 0: symbol
949 compiler.warn.improper.SVUID=必须在类{0}中将 serialVersionUID 声明为 static final
950
1178 compiler.misc.bad.source.file.header=错误的源文件: {0}\n{1}\n请删除该文件或确保该文件位于正确的源路径子目录中。
1179
1180 ## The following are all possible strings for the second argument ({1}) of the
1181 ## above strings.
1182 compiler.misc.bad.class.signature=错误的类签名: {0}
1183
1184 #0: symbol, 1: symbol
1185 compiler.misc.bad.enclosing.class={0}的封闭类错误: {1}
1186
1187 # 0: symbol
1188 compiler.misc.bad.enclosing.method=类 {0} 的封闭方法属性错误
1189
1190 compiler.misc.bad.runtime.invisible.param.annotations=错误的 RuntimeInvisibleParameterAnnotations 属性: {0}
1191
1192 compiler.misc.bad.const.pool.tag=错误的常量池标记: {0}
1193
1194 compiler.misc.bad.const.pool.tag.at=错误的常量池标记: {0}, 位于{1}
1195
1196 compiler.misc.bad.signature=错误的签名: {0}
1197
1198 compiler.misc.bad.type.annotation.value=错误的类型注释目标类型值: {0}
1199
1200 compiler.misc.class.file.wrong.class=类文件包含错误的类: {0}
1201
1202 compiler.misc.class.file.not.found=找不到{0}的类文件
1203
1204 # 0: name
1205 compiler.misc.file.doesnt.contain.class=文件不包含类{0}
1206
1207 compiler.misc.file.does.not.contain.package=文件不包含程序包{0}
1208
1209 compiler.misc.illegal.start.of.class.file=非法的类文件开始
1210
1211 compiler.misc.unable.to.access.file=无法访问文件: {0}
1212
1213 compiler.misc.unicode.str.not.supported=不支持类文件中的 Unicode 字符串
1214
1215 compiler.misc.undecl.type.var=未声明的类型变量: {0}
1216
1217 compiler.misc.wrong.version=类文件具有错误的版本 {0}.{1}, 应为 {2}.{3}
1218
1219 #####
1220
1221 # 0: type, 1: type or symbol
1222 compiler.err.not.within.bounds=类型参数{0}不在类型变量{1}的范围内
1223
1224 ## The following are all possible strings for the second argument ({1}) of the
1225 ## above string.
1226
1227 ## none yet...
1228
1229 #####
1230
1231 # 0: message segment
1232 compiler.err.prob.found.req=不兼容的类型: {0}
1233
1234 # 0: message segment, 1: type, 2: type
1235 compiler.warn.prob.found.req={0}\n需要: {2}\n找到: {1}
1236
1237 # 0: type, 1: type
1238 compiler.misc.inconvertible.types={0}无法转换为{1}
1239
1240 # 0: type, 1: type
1241 compiler.misc.possible.loss.of.precision=从{0}转换到{1}可能会有损失
1242
1243 compiler.misc.unchecked.assign=未经检查的转换
1244
1245 # compiler.misc.storecheck=\
1246 # assignment might cause later store checks to fail
1247 # compiler.misc.unchecked=\
1248 # assigned array cannot dynamically check its stores
1249 compiler.misc.unchecked.cast.to.type=未经检查的转换
1250
1251 # compiler.err.star.expected=\
1252 # ''*'' expected
1253 # compiler.err.no.elem.type=\
1254 # \[\*\] cannot have a type
1255
1256 # 0: type
1257 compiler.misc.try.not.applicable.to.type=try-with-resources 不适用于变量类型\n({0})
1258
1259 #####
1260
1261 # 0: message segment or type, 1: message segment
1262 compiler.err.type.found.req=意外的类型\n需要: {1}\n找到: {0}
1263
1264 ## The following are all possible strings for the first argument ({0}) of the
1265 ## above string.
1266 compiler.misc.type.req.class=类
1267
1268 compiler.misc.type.req.class.array=类或数组
1269
1270 compiler.misc.type.req.array.or.iterable=数组或 java.lang.Iterable
1271
1272 compiler.misc.type.req.ref=引用
1273
1274 compiler.misc.type.req.exact=不带限制范围的类或接口
1275
1276 # 0: type
1277 compiler.misc.type.parameter=类型参数{0}
1278
1279 #####
1280
1281 ## The following are all possible strings for the last argument of all those
1282 ## diagnostics whose key ends in ".1"
1283
1284 # 0: type, 1: list of type
1285 compiler.misc.no.unique.maximal.instance.exists=对于上限为{1}的类型变量{0}, 不存在唯一最大实例
1286
1287 compiler.misc.no.unique.minimal.instance.exists=对于下限为{1}的类型变量{0}, 不存在唯一最小实例
1288
1289 # 0: type, 1: list of type
1290 compiler.misc.incompatible.upper.bounds=推论变量 {0} 具有不兼容的上限 {1}
1291
1292 # 0: type, 1: list of type, 2: list of type
1293 compiler.misc.incompatible.eq.upper.bounds=推论变量 {0} 具有不兼容的限制范围\n等式约束条件: {1}\n上限: {2}
1294
1295 # 0: type, 1: list of type, 2: list of type
1296 compiler.misc.incompatible.eq.lower.bounds=推论变量{0}具有不兼容的限制范围\n等式约束条件: {1}\n下限: {2}
1297
1298 # 0: list of type, 1: type, 2: type
1299 compiler.misc.infer.no.conforming.instance.exists=不存在类型变量{0}的实例, 以使{1}与{2}一致
1300
1301 # 0: list of type, 1: message segment
1302 compiler.misc.infer.no.conforming.assignment.exists=无法推断类型变量 {0}\n(参数不匹配; {1})
1303
1304 # 0: list of type
1305 compiler.misc.infer.arg.length.mismatch=无法推断类型变量 {0}\n(实际参数列表和形式参数列表长度不同)
1306
1307 # 0: list of type, 1: message segment
1308 compiler.misc.infer.varargs.argument.mismatch=无法推断类型变量 {0}\n(varargs 不匹配; {1})
1309
1310 # 0: type, 1: list of type
1311 compiler.misc.inferred.do.not.conform.to.upper.bounds=推断类型不符合上限\n推断: {0}\n上限: {1}
1312
1313 # 0: type, 1: list of type
1314 compiler.misc.inferred.do.not.conform.to.lower.bounds=推断类型不符合下限\n推断: {0}\n下限: {1}
1315
1316 # 0: type, 1: list of type
1317 compiler.misc.inferred.do.not.conform.to.eq.bounds=推断类型不符合等式约束条件\n推断: {0}\n等式约束条件: {1}
1318
1319 # 0: list of type
1320 compiler.misc.cyclic.inference=由于推论循环, 无法实例化推论变量{0}
1321
1322 # 0: symbol
1323 compiler.misc.diamond={0}<>
1324
1325 # 0: type
1326 compiler.misc.diamond.non.generic=无法将 ''<>'' 与非泛型类{0}一起使用
1327
1328 # 0: unused
1329 compiler.misc.diamond.and.explicit.params=不能将 ''<>'' 与构造器的显式类型参数一起使用
1330
1331 # 0: type, 1: list of type
1332 compiler.misc.explicit.param.do.not.conform.to.bounds=显式类型参数{0}不符合声明的范围{1}
1333
1334 compiler.misc.arg.length.mismatch=实际参数列表和形式参数列表长度不同
1335
1336 # 0: message segment
1337 compiler.misc.no.conforming.assignment.exists=参数不匹配; {0}
1338
1339 # 0: message segment
1340 compiler.misc.varargs.argument.mismatch=varargs 不匹配; {0}
1341
1342 #####
1343
1344 # 0: type, 1: file name
1345 compiler.warn.auxiliary.class.accessed.from.outside.of.its.source.file={1} 中的辅助类{0}不应从其自身的源文件以外访问
1346
1347
1348 ## The first argument ({0}) is a "kindname".
1349 # 0: symbol kind, 1: symbol, 2: symbol
1350 compiler.err.abstract.cant.be.accessed.directly=无法直接访问{2}中的抽象{0} {1}
1351
1352 ## The first argument ({0}) is a "kindname".
1353 # 0: symbol kind, 1: symbol
1354 compiler.err.non-static.cant.be.ref=无法从静态上下文中引用非静态 {0} {1}
1355
1356 # 0: symbol kind, 1: symbol
1357 compiler.misc.non-static.cant.be.ref=无法从静态上下文中引用非静态 {0} {1}
1358
1359 ## Both arguments ({0}, {1}) are "kindname"s. {0} is a comma-separated list
1360 ## of kindnames (the list should be identical to that provided in source.
1361 compiler.err.unexpected.type=意外的类型\n需要: {0}\n找到: {1}
1362
1363 compiler.err.unexpected.lambda=此处不应为 lambda 表达式
1364
1365 compiler.err.unexpected.mref=此处不应为方法引用
1366
1367 ## The first argument {0} is a "kindname" (e.g. 'constructor', 'field', etc.)
1368 ## The second argument {1} is the non-resolved symbol
1369 ## The third argument {2} is a list of type parameters (non-empty if {1} is a method)
1370 ## The fourth argument {3} is a list of argument types (non-empty if {1} is a method)
1371 # 0: symbol kind, 1: name, 2: unused, 3: unused
1372 compiler.err.cant.resolve=找不到符号\n符号: {0} {1}
1373
1374 # 0: symbol kind, 1: name, 2: unused, 3: list of type
1375 compiler.err.cant.resolve.args=找不到符号\n符号: {0} {1}({3})
1376
1377 # 0: symbol kind, 1: name, 2: list of type, 3: list of type
1378 compiler.err.cant.resolve.args.params=找不到符号\n符号: {0} <{2}>{1}({3})
1379
1380 ## arguments from {0} to {3} have the same meaning as above
1381 ## The fifth argument {4} is a location subdiagnostic (see below)
1382 # 0: symbol kind, 1: name, 2: unused, 3: unused, 4: message segment
1383 compiler.err.cant.resolve.location=找不到符号\n符号: {0} {1}\n位置: {4}
1384
1385 # 0: symbol kind, 1: name, 2: unused, 3: list of type, 4: message segment
1386 compiler.err.cant.resolve.location.args=找不到符号\n符号: {0} {1}({3})\n位置: {4}
1387
1388 # 0: symbol kind, 1: name, 2: list of type, 3: list, 4: message segment
1389 compiler.err.cant.resolve.location.args.params=找不到符号\n符号: {0} <{2}>{1}({3})\n位置: {4}
1390
1391 ### Following are replicated/used for method reference diagnostics
1392
1393 # 0: symbol kind, 1: name, 2: unused, 3: list of type, 4: message segment
1394 compiler.misc.cant.resolve.location.args=找不到符号\n符号: {0} {1}({3})\n位置: {4}
1395
1396 # 0: symbol kind, 1: name, 2: list of type, 3: list, 4: message segment
1397 compiler.misc.cant.resolve.location.args.params=找不到符号\n符号: {0} <{2}>{1}({3})\n位置: {4}
1398
1399 ##a location subdiagnostic is composed as follows:
1400 ## The first argument {0} is the location "kindname" (e.g. 'constructor', 'field', etc.)
1401 ## The second argument {1} is the location name
1402 ## The third argument {2} is the location type (only when {1} is a variable name)
1403
1404 # 0: symbol kind, 1: type or symbol, 2: unused
1405 compiler.misc.location={0} {1}
1406
1407 # 0: symbol kind, 1: symbol, 2: type
1408 compiler.misc.location.1=类型为{2}的{0} {1}
1409
1410 ## The following are all possible string for "kindname".
1411 ## They should be called whatever the JLS calls them after it been translated
1412 ## to the appropriate language.
1413 # compiler.misc.kindname.constructor=\
1414 # static member
1415 compiler.misc.kindname.annotation=@interface
1416
1417 compiler.misc.kindname.constructor=构造器
1418
1419 compiler.misc.kindname.enum=枚举
1420
1421 compiler.misc.kindname.interface=接口
1422
1423 compiler.misc.kindname.static=静态
1424
1425 compiler.misc.kindname.type.variable=类型变量
1426
1427 compiler.misc.kindname.type.variable.bound=类型变量的限制范围
1428
1429 compiler.misc.kindname.variable=变量
1430
1431 compiler.misc.kindname.value=值
1432
1433 compiler.misc.kindname.method=方法
1434
1435 compiler.misc.kindname.class=类
1436
1437 compiler.misc.kindname.package=程序包
1438
1439 compiler.misc.kindname.static.init=静态初始化程序
1440
1441 compiler.misc.kindname.instance.init=实例初始化程序
1442
1443 #####
1444
1445 compiler.misc.no.args=没有参数
1446
1447 # 0: message segment
1448 compiler.err.override.static={0}\n覆盖的方法为 static
1449
1450 # 0: message segment, 1: set of modifier
1451 compiler.err.override.meth={0}\n被覆盖的方法为{1}
1452
1453 # 0: message segment, 1: type
1454 compiler.err.override.meth.doesnt.throw={0}\n被覆盖的方法未抛出{1}
1455
1456 # In the following string {1} is a space separated list of Java Keywords, as
1457 # they would have been declared in the source code
1458 # 0: message segment, 1: set of modifier
1459 compiler.err.override.weaker.access={0}\n正在尝试分配更低的访问权限; 以前为{1}
1460
1461 # 0: message segment, 1: type, 2: type
1462 compiler.err.override.incompatible.ret={0}\n返回类型{1}与{2}不兼容
1479 compiler.misc.clashes.with={1}中的{0}与{3}中的{2}冲突
1480
1481 # 0: symbol, 1: symbol, 2: symbol, 3: symbol
1482 compiler.misc.unchecked.override={1}中的{0}覆盖了{3}中的{2}
1483
1484 # 0: symbol, 1: symbol, 2: symbol, 3: symbol
1485 compiler.misc.unchecked.implement={1}中的{0}实现了{3}中的{2}
1486
1487 # 0: symbol, 1: symbol, 2: symbol, 3: symbol
1488 compiler.misc.unchecked.clash.with={1}中的{0}覆盖了{3}中的{2}
1489
1490 # 0: symbol, 1: symbol, 2: symbol, 3: symbol
1491 compiler.misc.varargs.override={1}中的{0}覆盖了{3}中的{2}
1492
1493 # 0: symbol, 1: symbol, 2: symbol, 3: symbol
1494 compiler.misc.varargs.implement={1}中的{0}实现了{3}中的{2}
1495
1496 # 0: symbol, 1: symbol, 2: symbol, 3: symbol
1497 compiler.misc.varargs.clash.with={1}中的{0}覆盖了{3}中的{2}
1498
1499 # 0: unused
1500 compiler.misc.diamond.and.anon.class=无法将 ''<>'' 与匿名内部类一起使用
1501
1502 # 0: symbol kind, 1: symbol, 2: symbol, 3: message segment
1503 compiler.misc.inapplicable.method={0} {1}.{2}不适用\n({3})
1504
1505 ########################################
1506 # Diagnostics for language feature changes
1507 ########################################
1508 # 0: string
1509 compiler.err.unsupported.fp.lit=-source {0} 中不支持十六进制浮点文字\n(请使用 -source 5 或更高版本以启用十六进制浮点文字)
1510
1511 # 0: string
1512 compiler.err.unsupported.binary.lit=-source {0} 中不支持二进制文字\n(请使用 -source 7 或更高版本以启用二进制文字)
1513
1514 # 0: string
1515 compiler.err.unsupported.underscore.lit=-source {0} 中不支持文字中存在下划线\n(请使用 -source 7 或更高版本以允许文字中存在下划线)
1516
1517 # 0: string
1518 compiler.err.try.with.resources.not.supported.in.source=-source {0} 中不支持 try-with-resources\n(请使用 -source 7 或更高版本以启用 try-with-resources)
1519
1520 compiler.warn.enum.as.identifier=从发行版 5 开始, ''enum'' 为关键字, 而不用作标识符\n(请使用 -source 5 或更高版本以将 ''enum'' 用作关键字)
1521
1522 compiler.warn.assert.as.identifier=从发行版 1.4 开始, ''assert'' 是一个关键字, 但不能用作标识符\n(请使用 -source 1.4 或更高版本以将 ''assert'' 用作关键字)
1523
1524 compiler.warn.underscore.as.identifier=''_'' 已用作标识符\n(以后的发行版可能不支持将 ''_'' 用作标识符)
1525
1526 compiler.err.enum.as.identifier=从发行版 5 开始, ''enum'' 为关键字, 而不用作标识符\n(请使用 -source 1.4 或更低版本以将 ''enum'' 用作标识符)
1527
1528 compiler.err.assert.as.identifier=从发行版 1.4 开始, ''assert'' 是一个关键字, 但不能用作标识符\n(请使用 -source 1.3 或更低版本以将 ''assert'' 用作标识符)
1529
1530 # TODO 308: make a better error message
1531 compiler.err.this.as.identifier=从发行版 8 开始, ''this'' 只能作为接收方类型的参数名, 该参数必须为第一个参数
1532
1533 # TODO 308: make a better error message
1534 compiler.err.cant.annotate.static.class=无法对封闭静态嵌套类进行注释
1535 # TODO 308: make a better error message
1536 compiler.err.cant.annotate.nested.type=无法对嵌套类型进行注释
1537
1538 compiler.err.incorrect.receiver.type=接收方类型与封闭类类型不匹配
1539
1540 compiler.err.no.annotations.on.dot.class=类文字类型中不允许使用任何注释
1541
1542 # 0: string
1543 compiler.err.generics.not.supported.in.source=-source {0} 中不支持泛型\n(请使用 -source 5 或更高版本以启用泛型)
1544
1545 # 0: string
1546 compiler.err.varargs.not.supported.in.source=-source {0} 中不支持 variable-arity 方法\n(请使用 -source 5 或更高版本以启用 variable-arity 方法)
1547
1548 # 0: string
1549 compiler.err.annotations.not.supported.in.source=-source {0} 中不支持注释\n(请使用 -source 5 或更高版本以启用注释)
1550
1551 # 0: string
1552 compiler.err.type.annotations.not.supported.in.source=-source {0} 中不支持类型注释\n(请使用 -source 8 或更高版本以启用类型注释)
1553
1554 # 0: string
1555 compiler.err.foreach.not.supported.in.source=-source {0} 中不支持 for-each 循环\n(请使用 -source 5 或更高版本以启用 for-each 循环)
1556
1557 # 0: string
1558 compiler.err.static.import.not.supported.in.source=-source {0} 中不支持静态导入声明\n(请使用 -source 5 或更高版本以启用静态导入声明)
1559
1560 # 0: string
1561 compiler.err.enums.not.supported.in.source=-source {0} 中不支持枚举\n(请使用 -source 5 或更高版本以启用枚举)
1562
1563 # 0: string
1564 compiler.err.diamond.not.supported.in.source=-source {0} 中不支持 diamond 运算符\n(请使用 -source 7 或更高版本以启用 diamond 运算符)
1565
1566 # 0: string
1567 compiler.err.multicatch.not.supported.in.source=-source {0} 中不支持 multi-catch 语句\n(请使用 -source 7 或更高版本以启用 multi-catch 语句)
1568
1569 # 0: string
1570 compiler.err.string.switch.not.supported.in.source=-source {0} 中不支持 switch 中存在字符串\n(请使用 -source 7 或更高版本以允许 switch 中存在字符串)
1571
1572 # 0: string
1573 compiler.err.lambda.not.supported.in.source=-source {0} 中不支持 lambda 表达式\n(请使用 -source 8 或更高版本以启用 lambda 表达式)
1574
1575 # 0: string
1576 compiler.err.method.references.not.supported.in.source=-source {0} 中不支持方法引用\n(请使用 -source 8 或更高版本以启用方法引用)
1577
1578 # 0: string
1579 compiler.err.default.methods.not.supported.in.source=-source {0} 中不支持默认方法\n(请使用 -source 8 或更高版本以启用默认方法)
1580
1581 # 0: string
1582 compiler.err.intersection.types.in.cast.not.supported.in.source=-source {0} 中不支持转换中的交叉类型\n(请使用 -source 8 或更高版本以启用默认方法)
1583
1584 # 0: string
1585 compiler.err.static.intf.methods.not.supported.in.source=-source {0} 中不支持静态接口方法\n(请使用 -source 8 或更高版本以启用静态接口方法)
1586
1587 ########################################
1588 # Diagnostics for verbose resolution
1589 # used by Resolve (debug only)
1590 ########################################
1591
1592 # 0: number, 1: symbol, 2: unused
1593 compiler.misc.applicable.method.found=找到第 {0} 个适用方法: {1}
1594
1595 # 0: number, 1: symbol, 2: message segment
1596 compiler.misc.applicable.method.found.1=找到第 {0} 个适用方法: {1}\n({2})
1597
1598 # 0: number, 1: symbol, 2: message segment
1599 compiler.misc.not.applicable.method.found=找到第 {0} 个不适用的方法: {1}\n({2})
1600
1601 # 0: type
1602 compiler.misc.partial.inst.sig=部分实例化为: {0}
1603
1604 # 0: name, 1: symbol, 2: number, 3: MethodResolutionPhase, 4: list of type or message segment, 5: list of type or message segment
1605 compiler.note.verbose.resolve.multi=将类型 {1} 的方法 {0} 解析为候选项 {2}\n阶段: {3}\n具有实际值: {4}\n具有类型参数: {5}\n候选项:
1606
1607 # 0: name, 1: symbol, 2: unused, 3: MethodResolutionPhase, 4: list of type or message segment, 5: list of type or message segment
1608 compiler.note.verbose.resolve.multi.1=类型 {1} 的方法 {0} 解析错误\n阶段: {3}\n具有实际值: {4}\n具有类型参数: {5}\n候选项:
1609
1610 # 0: symbol, 1: type, 2: type
1611 compiler.note.deferred.method.inst=方法 {0} 的延迟实例化\n实例化签名: {1}\n目标类型: {2}
1612
1613 ########################################
1614 # Diagnostics for where clause implementation
1615 # used by the RichDiagnosticFormatter.
1616 ########################################
1617
1618 compiler.misc.type.null=<空值>
1619
1620 # X#n (where n is an int id) is disambiguated tvar name
1621 # 0: name, 1: number
1622 compiler.misc.type.var={0}#{1}
1623
1624 # CAP#n (where n is an int id) is an abbreviation for 'captured type'
1625 # 0: number
1626 compiler.misc.captured.type=CAP#{0}
1627
1628 # <INT#n> (where n is an int id) is an abbreviation for 'intersection type'
1629 # 0: number
1630 compiler.misc.intersection.type=INT#{0}
1631
1632 # where clause for captured type: contains upper ('extends {1}') and lower
1633 # ('super {2}') bound along with the wildcard that generated this captured type ({3})
1634 # 0: type, 1: type, 2: type, 3: type
1635 compiler.misc.where.captured={0}从{3}的捕获扩展{1} 超 {2}
1636
1637 # compact where clause for captured type: contains upper ('extends {1}') along
1638 # with the wildcard that generated this captured type ({3})
1639 # 0: type, 1: type, 2: unused, 3: type
1640 compiler.misc.where.captured.1={0}从{3}的捕获扩展{1}
1641
1642 # where clause for type variable: contains upper bound(s) ('extends {1}') along with
1643 # the kindname ({2}) and location ({3}) in which the typevar has been declared
1644 # 0: type, 1: list of type, 2: symbol kind, 3: symbol
1645 compiler.misc.where.typevar={0}扩展已在{2} {3}中声明的{1}
1646
1647 # compact where clause for type variable: contains the kindname ({2}) and location ({3})
1648 # in which the typevar has been declared
1649 # 0: type, 1: list of type, 2: symbol kind, 3: symbol
1650 compiler.misc.where.typevar.1={0}已在{2} {3}中声明
1651
1652 # where clause for fresh type variable: contains upper bound(s) ('extends {1}').
1653 # Since a fresh type-variable is synthetic - there's no location/kindname here.
1654 # 0: type, 1: list of type
1655 compiler.misc.where.fresh.typevar={0}扩展{1}
1656
1657 # where clause for type variable: contains all the upper bound(s) ('extends {1}')
1658 # of this intersection type
1659 # 0: type, 1: list of type
1660 compiler.misc.where.intersection={0}扩展{1}
1661
1662 ### Where clause headers ###
1663 compiler.misc.where.description.captured=其中, {0}是新类型变量:
1664
1665 # 0: set of type
1666 compiler.misc.where.description.typevar=其中, {0}是类型变量:
1667
1668 # 0: set of type
1669 compiler.misc.where.description.intersection=其中, {0}是交叉类型:
1670
1671 # 0: set of type
1672 compiler.misc.where.description.captured.1=其中, {0}是新类型变量:
1673
1674 # 0: set of type
1675 compiler.misc.where.description.typevar.1=其中, {0}是类型变量:
1676
1677 compiler.misc.where.description.intersection.1=其中, {0}是交叉类型:
1678
1679 ###
1680 # errors related to doc comments
1681
1682 compiler.err.dc.bad.entity=HTML 实体错误
1683
1684 compiler.err.dc.bad.gt=''>'' 的用法错误
1685
1686 compiler.err.dc.bad.inline.tag=内嵌标记的用法不正确
1687
1688 compiler.err.dc.identifier.expected=需要标识符
1689
1690 compiler.err.dc.malformed.html=格式错误的 HTML
1691
1692 compiler.err.dc.missing.semicolon=缺少分号
1693
1694 compiler.err.dc.no.content=无内容
1695
1696 compiler.err.dc.no.tag.name='@' 后没有标记名
1697
1698 compiler.err.dc.gt.expected=需要 ''>''
1699
1700 compiler.err.dc.ref.bad.parens=引用中缺少 '')''
1701
1702 compiler.err.dc.ref.syntax.error=引用中出现语法错误
1703
1704 compiler.err.dc.ref.unexpected.input=意外的文本
1705
1706 compiler.err.dc.unexpected.content=意外的内容
1707
1708 compiler.err.dc.unterminated.inline.tag=未终止的内嵌标记
1709
1710 compiler.err.dc.unterminated.signature=未终止的签名
1711
1712 compiler.err.dc.unterminated.string=未终止的字符串
1713
1714
|