1 # 2 # Copyright (c) 1999, 2019, Oracle and/or its affiliates. All rights reserved. 3 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 # 5 # This code is free software; you can redistribute it and/or modify it 6 # under the terms of the GNU General Public License version 2 only, as 7 # published by the Free Software Foundation. Oracle designates this 8 # particular file as subject to the "Classpath" exception as provided 9 # by Oracle in the LICENSE file that accompanied this code. 10 # 11 # This code is distributed in the hope that it will be useful, but WITHOUT 12 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 # version 2 for more details (a copy is included in the LICENSE file that 15 # accompanied this code). 16 # 17 # You should have received a copy of the GNU General Public License version 18 # 2 along with this work; if not, write to the Free Software Foundation, 19 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 # 21 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 # or visit www.oracle.com if you need additional information or have any 23 # questions. 24 # 25 26 # Messages in this file which use "placeholders" for values (e.g. {0}, {1}) 27 # are preceded by a stylized comment describing the type of the corresponding 28 # values. 29 # The simple types currently in use are: 30 # 31 # annotation annotation compound 32 # boolean true or false 33 # diagnostic a sub-message; see compiler.misc.* 34 # fragment similar to 'message segment', but with more specific type 35 # modifier a Java modifier; e.g. public, private, protected 36 # file a file URL 37 # file object a file URL - similar to 'file' but typically used for source/class files, hence more specific 38 # flag a Flags.Flag instance 39 # name a name, typically a Java identifier 40 # number an integer 41 # option name the name of a command line option 42 # path a path 43 # profile a profile name 44 # source a source version number, such as 1.5, 1.6, 1.7, taken from a com.sun.tools.javac.code.Source 45 # source version a source version number, such as 1.5, 1.6, 1.7, taken from a javax.lang.model.SourceVersion 46 # string a general string 47 # symbol the name of a declared type 48 # symbol kind the kind of a symbol (i.e. method, variable) 49 # kind name an informative description of the kind of a declaration; see compiler.misc.kindname.* 50 # target a target version number, such as 1.5, 1.6, 1.7, taken from a com.sun.tools.javac.jvm.Target 51 # token the name of a non-terminal in source code; see compiler.misc.token.* 52 # tree tag the name of a non-terminal in source code; see compiler.misc.token.* 53 # type a Java type; e.g. int, X, X<T> 54 # url a URL 55 # object a Java object (unspecified) 56 # unused the value is not used in this message 57 # 58 # The following compound types are also used: 59 # 60 # collection of X a comma-separated collection of items; e.g. collection of type 61 # list of X a comma-separated list of items; e.g. list of type 62 # set of X a comma-separated set of items; e.g. set of modifier 63 # 64 # These may be composed: 65 # 66 # list of type or message segment 67 # 68 # The following type aliases are supported: 69 # 70 # message segment --> diagnostic or fragment 71 # file name --> file, path or file object 72 # 73 # Custom comments are supported in parenthesis i.e. 74 # 75 # number (classfile major version) 76 # 77 # These comments are used internally in order to generate an enum-like class declaration containing 78 # a method/field for each of the diagnostic keys listed here. Those methods/fields can then be used 79 # by javac code to build diagnostics in a type-safe fashion. 80 # 81 # In addition, these comments are verified by the jtreg test test/tools/javac/diags/MessageInfo, 82 # using info derived from the collected set of examples in test/tools/javac/diags/examples. 83 # MessageInfo can also be run as a standalone utility providing more facilities 84 # for manipulating this file. For more details, see MessageInfo.java. 85 86 ## 87 ## errors 88 ## 89 90 # 0: symbol 91 compiler.err.abstract.cant.be.instantiated={0}是抽象的; 无法实例化 92 93 compiler.err.abstract.meth.cant.have.body=抽象方法不能有主体 94 95 # 0: kind name, 1: symbol 96 compiler.err.already.annotated={0} {1}已进行注释 97 98 # 0: kind name, 1: symbol, 2: kind name, 3: symbol 99 compiler.err.already.defined=已在{2} {3}中定义了{0} {1} 100 101 # 0: kind name, 1: symbol, 2: kind name, 3: kind name, 4: symbol 102 compiler.err.already.defined.in.clinit=已在{3} {4}的{2}中定义了{0} {1} 103 104 # 0: symbol 105 compiler.err.already.defined.single.import={0}的 single-type-import 已定义具有相同简名的类型 106 107 # 0: symbol 108 compiler.err.already.defined.static.single.import={0}的静态 single-type-import 已定义具有相同简名的类型 109 110 # 0: symbol 111 compiler.err.already.defined.this.unit=已在该编译单元中定义{0} 112 113 # 0: type, 1: list of name 114 compiler.err.annotation.missing.default.value=对于元素 ''{1}'', 注释 @{0} 缺少默认值 115 116 # 0: type, 1: list of name 117 compiler.err.annotation.missing.default.value.1=对于元素{1}, 注释 @{0} 缺少默认值 118 119 # 0: type 120 compiler.err.annotation.not.valid.for.type=注释对于类型{0}的元素无效 121 122 compiler.err.annotation.type.not.applicable=注释类型不适用于该类型的声明 123 124 # 0: type 125 compiler.err.annotation.type.not.applicable.to.type=注释 @{0} 在此类型上下文中不适用 126 127 compiler.err.annotation.value.must.be.annotation=注释值必须为注释 128 129 compiler.err.annotation.value.must.be.class.literal=注释值必须为类文字 130 131 compiler.err.annotation.value.must.be.name.value=注释值必须采用 ''name=value'' 格式 132 133 compiler.err.annotation.value.not.allowable.type=注释值不是允许的类型 134 135 compiler.err.expression.not.allowable.as.annotation.value=表达式不允许用作注释值 136 137 compiler.err.anon.class.impl.intf.no.args=匿名类实现接口; 不能有参数 138 139 compiler.err.anon.class.impl.intf.no.typeargs=匿名类实现接口; 不能具有类型参数 140 141 compiler.err.anon.class.impl.intf.no.qual.for.new=匿名类实现接口; 不能有限定符 - 对于新 142 143 compiler.err.cant.inherit.from.anon=无法从匿名类继承 144 145 # 0: symbol, 1: symbol, 2: symbol 146 compiler.err.array.and.varargs=无法在{2}中同时声明{0}和{1} 147 148 compiler.err.array.dimension.missing=缺少数组维 149 150 compiler.err.illegal.array.creation.both.dimension.and.initialization=同时使用维表达式和初始化创建数组是非法的 151 152 # 0: type 153 compiler.err.array.req.but.found=需要数组, 但找到{0} 154 155 compiler.err.attribute.value.must.be.constant=元素值必须为常量表达式 156 157 # 0: string (statement type) 158 compiler.err.bad.initializer={0}的初始化程序错误 159 160 compiler.err.break.outside.switch.loop=在 switch 或 loop 外部中断 161 162 compiler.err.break.outside.switch.expression=尝试从 switch 表达式中断 163 164 compiler.err.continue.outside.switch.expression=尝试从 switch 表达式继续 165 166 compiler.err.return.outside.switch.expression=尝试从 switch 表达式返回 167 168 compiler.err.rule.completes.normally=switch 规则完结但没有提供值\n(switch 表达式中的 switch 规则必须提供值或抛出) 169 170 compiler.err.switch.expression.completes.normally=switch 表达式完结但没有提供值\n(switch 表达式必须为所有可能的输入值提供值或抛出) 171 172 compiler.err.no.switch.expression =yield 在 switch 表达式外部 173 174 compiler.err.no.switch.expression.qualify=yield 在 switch 表达式外部\n(要调用称为 yield 的方法,请通过接收方或类型名称限定 yield) 175 176 compiler.err.invalid.yield=受限标识符 ''yield'' 的用法无效\n(要调用称为 yield 的方法,请通过接收方或类型名称限定 yield) 177 178 compiler.warn.invalid.yield=''yield'' 在未来发行版中可能会成为受限标识符\n(要调用称为 yield 的方法,请通过接收方或类型名称限定 yield) 179 180 compiler.err.switch.expression.empty=switch 表达式中没有任何 case 子句 181 182 compiler.err.switch.expression.no.result.expressions=switch 表达式没有任何结果表达式 183 184 # 0: name 185 compiler.err.call.must.be.first.stmt.in.ctor=对{0}的调用必须是构造器中的第一个语句 186 187 # 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 188 compiler.err.cant.apply.symbol=无法将{4} {5}中的{0} {1}应用到给定类型;\n需要: {2}\n找到: {3}\n原因: {6} 189 190 # 0: symbol kind, 1: name, 2: list of type 191 compiler.err.cant.apply.symbols=对于{1}({2}), 找不到合适的{0} 192 193 # 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 194 compiler.misc.cant.apply.symbol=无法将 {4} {5}中的 {0} {1}应用到给定类型\n需要: {2}\n找到: {3}\n原因: {6} 195 196 # 0: symbol kind, 1: name, 2: list of type 197 compiler.misc.cant.apply.symbols=对于{1}({2}), 找不到合适的{0} 198 199 # 0: kind name, 1: symbol 200 compiler.misc.no.abstracts=在 {0} {1} 中找不到抽象方法 201 202 # 0: kind name, 1: symbol 203 compiler.misc.incompatible.abstracts=在 {0} {1} 中找到多个非覆盖抽象方法 204 205 compiler.err.bad.functional.intf.anno=意外的 @FunctionalInterface 注释 206 207 # 0: message segment 208 compiler.err.bad.functional.intf.anno.1=意外的 @FunctionalInterface 注释\n{0} 209 210 # 0: message segment 211 compiler.err.anonymous.diamond.method.does.not.override.superclass=方法不会覆盖或实现超类型中的方法\n{0} 212 213 # 0: symbol 214 compiler.misc.not.a.functional.intf={0} 不是函数接口 215 216 # 0: symbol, 1: message segment 217 compiler.misc.not.a.functional.intf.1={0} 不是函数接口\n{1} 218 219 # 0: type, 1: kind name, 2: symbol 220 compiler.misc.invalid.generic.lambda.target=lambda 表达式的函数描述符无效\n{1} {2} 中的方法 {0} 为泛型方法 221 222 # 0: kind name, 1: symbol 223 compiler.misc.incompatible.descs.in.functional.intf=在 {0} {1} 中找到不兼容的函数描述符 224 225 # 0: name, 1: list of type, 2: type, 3: list of type 226 compiler.misc.descriptor=描述符: {2} {0}({1}) 227 228 # 0: name, 1: list of type, 2: type, 3: list of type 229 compiler.misc.descriptor.throws=描述符: {2} {0}({1}) 抛出{3} 230 231 # 0: type 232 compiler.misc.no.suitable.functional.intf.inst=无法推断{0}的函数接口描述符 233 234 # 0: message segment 235 compiler.misc.bad.intersection.target.for.functional.expr=lambda 或方法引用的交叉类型目标错误\n{0} 236 237 # 0: symbol or type 238 compiler.misc.not.an.intf.component=组件类型{0}不是接口 239 240 # 0: kind name, 1: message segment 241 compiler.err.invalid.mref={0}引用无效\n{1} 242 243 # 0: kind name, 1: message segment 244 compiler.misc.invalid.mref={0}引用无效\n{1} 245 246 compiler.misc.static.mref.with.targs=有关静态方法引用的参数化限定符 247 248 # 0: symbol 249 compiler.err.cant.assign.val.to.final.var=无法为最终变量{0}分配值 250 251 compiler.err.cant.assign.val.to.this=无法分配给 ''this'' 252 253 # 0: symbol, 1: message segment 254 compiler.err.cant.ref.non.effectively.final.var=从{1}引用的本地变量必须是最终变量或实际上的最终变量 255 256 compiler.err.try.with.resources.expr.needs.var=try-with-resources 资源必须是变量声明, 或者是指示对最终变量或实际上的最终变量的引用的表达式 257 258 # 0: symbol 259 compiler.err.try.with.resources.expr.effectively.final.var=用作 try-with-resources 资源的变量 {0} 既不是最终变量, 也不是实际上的最终变量 260 261 262 compiler.misc.lambda=lambda 表达式 263 264 compiler.misc.inner.cls=内部类 265 266 # 0: type 267 compiler.err.cant.deref=无法取消引用{0} 268 269 compiler.err.cant.extend.intf.annotation=对于 @interfaces, 不允许 ''extends'' 270 271 compiler.err.annotation.decl.not.allowed.here=此处不允许注释类型声明 272 273 # 0: symbol 274 compiler.err.cant.inherit.from.final=无法从最终{0}进行继承 275 276 # 0: symbol or string 277 compiler.err.cant.ref.before.ctor.called=无法在调用超类型构造器之前引用{0} 278 279 compiler.err.cant.select.static.class.from.param.type=无法从参数化的类型中选择静态类 280 281 # 0: symbol, 1: string, 2: string 282 compiler.err.cant.inherit.diff.arg=无法使用以下不同的参数继承{0}: <{1}> 和 <{2}> 283 284 compiler.err.catch.without.try=有 ''catch'', 但是没有 ''try'' 285 286 # 0: kind name, 1: symbol 287 compiler.err.clash.with.pkg.of.same.name={0} {1}与带有相同名称的程序包冲突 288 289 compiler.err.class.not.allowed=此处不允许使用类, 接口或枚举声明 290 291 compiler.err.const.expr.req=需要常量表达式 292 293 compiler.err.cont.outside.loop=continue 在 loop 外部 294 295 # 0: symbol or type 296 compiler.err.cyclic.inheritance=涉及{0}的循环继承 297 298 # 0: symbol 299 compiler.err.cyclic.annotation.element=元素 {0} 的类型为循环 300 301 # 0: symbol 302 compiler.err.call.to.super.not.allowed.in.enum.ctor=在枚举构造器中不允许调用超类 303 304 # 0: type 305 compiler.err.no.superclass={0}不具有超类。 306 307 # 0: symbol, 1: type, 2: symbol, 3: type, 4: type 308 compiler.err.concrete.inheritance.conflict={1}中的方法{0}和{3}中的方法{2}是使用相同的签名继承的 309 310 compiler.err.default.allowed.in.intf.annotation.member=注释类型声明中仅允许默认值 311 312 # 0: symbol 313 compiler.err.doesnt.exist=程序包{0}不存在 314 315 # 0: type 316 compiler.err.duplicate.annotation.invalid.repeated=注释{0}不是有效的可重复注释 317 318 # 0: name, 1: type 319 compiler.err.duplicate.annotation.member.value=注释@{1}中的元素 ''{0}'' 重复。 320 321 # 0: type 322 compiler.err.duplicate.annotation.missing.container={0} 不是可重复的注释类型 323 324 # 0: symbol 325 compiler.err.invalid.repeatable.annotation=注释重复: 使用无效的 @Repeatable 注释对{0}进行了注释 326 327 # 0: symbol or type 328 compiler.err.invalid.repeatable.annotation.no.value={0}不是有效的 @Repeatable, 未声明任何值元素方法 329 330 # 0: type, 1: number 331 compiler.err.invalid.repeatable.annotation.multiple.values={0}不是有效的 @Repeatable, 已声明 {1} 个名为 ''value'' 的元素方法 332 333 # 0: type 334 compiler.err.invalid.repeatable.annotation.invalid.value={0}不是有效的 @Repeatable: 值元素无效 335 336 # 0: symbol or type, 1: type, 2: type 337 compiler.err.invalid.repeatable.annotation.value.return=包含注释类型 ({0}) 必须声明类型{2}的名为 ''value'' 的元素 338 339 # 0: symbol or type, 1: symbol 340 compiler.err.invalid.repeatable.annotation.elem.nondefault=对于元素 {1}, 包含注释类型 ({0}) 没有默认值 341 342 # 0: symbol, 1: string, 2: symbol, 3: string 343 compiler.err.invalid.repeatable.annotation.retention=包含注释类型 ({0}) 的保留期短于可重复注释类型 ({2}) 的保留期 344 345 # 0: symbol, 1: symbol 346 compiler.err.invalid.repeatable.annotation.not.documented=可重复注释类型 ({1}) 是 @Documented, 而包含注释类型 ({0}) 则不是 347 348 # 0: symbol, 1: symbol 349 compiler.err.invalid.repeatable.annotation.not.inherited=可重复注释类型 ({1}) 是 @Inherited, 而包含注释类型 ({0}) 则不是 350 351 # 0: symbol, 1: symbol 352 compiler.err.invalid.repeatable.annotation.incompatible.target=包含注释类型 ({0}) 适用的目标多于可重复注释类型 ({1}) 353 354 # 0: symbol 355 compiler.err.invalid.repeatable.annotation.repeated.and.container.present=容器 {0} 不得与其包含的元素同时存在 356 357 # 0: type, 1: symbol 358 compiler.err.invalid.repeatable.annotation.not.applicable=容器{0}不适用于元素 {1} 359 360 # 0: type 361 compiler.err.invalid.repeatable.annotation.not.applicable.in.context=容器{0}在此类型上下文中不适用 362 363 # 0: name 364 compiler.err.duplicate.class=类重复: {0} 365 366 # 0: name, 1: name 367 compiler.err.same.binary.name=类:{0} 和 {1} 具有相同的二进制名称 368 369 compiler.err.duplicate.case.label=case 标签重复 370 371 compiler.err.duplicate.default.label=default 标签重复 372 373 compiler.err.else.without.if=有 ''if'', 但是没有 ''else'' 374 375 compiler.err.empty.char.lit=空字符文字 376 377 # 0: symbol 378 compiler.err.encl.class.required=需要包含{0}的封闭实例 379 380 compiler.err.enum.annotation.must.be.enum.constant=枚举注释值必须是枚举常量 381 382 compiler.err.enum.cant.be.instantiated=无法实例化枚举类型 383 384 compiler.err.enum.label.must.be.unqualified.enum=枚举 switch case 标签必须为枚举常量的非限定名称 385 386 compiler.err.enum.no.subclassing=类无法直接扩展 java.lang.Enum 387 388 compiler.err.enum.types.not.extensible=枚举类型不可继承 389 390 compiler.err.enum.no.finalize=枚举不能有 finalize 方法 391 392 # 0: file name, 1: string 393 compiler.err.error.reading.file=读取{0}时出错; {1} 394 395 # 0: type 396 compiler.err.except.already.caught=已捕获到异常错误{0} 397 398 # 0: type 399 compiler.err.except.never.thrown.in.try=在相应的 try 语句主体中不能抛出异常错误{0} 400 401 # 0: symbol 402 compiler.err.final.parameter.may.not.be.assigned=不能分配最终参数{0} 403 404 # 0: symbol 405 compiler.err.try.resource.may.not.be.assigned=可能未分配可自动关闭的资源{0} 406 407 # 0: symbol 408 compiler.err.multicatch.parameter.may.not.be.assigned=可能未分配 multi-catch 参数{0} 409 410 # 0: type, 1: type 411 compiler.err.multicatch.types.must.be.disjoint=multi-catch 语句中的替代无法通过子类化关联\n替代{0}是替代{1}的子类 412 413 compiler.err.finally.without.try=有 ''finally'', 但是没有 ''try'' 414 415 # 0: type, 1: message segment 416 compiler.err.foreach.not.applicable.to.type=for-each 不适用于表达式类型\n要求: {1}\n找到: {0} 417 418 compiler.err.fp.number.too.large=浮点数过大 419 420 compiler.err.fp.number.too.small=浮点数过小 421 422 compiler.err.generic.array.creation=创建泛型数组 423 424 compiler.err.generic.throwable=泛型类不能扩展 java.lang.Throwable 425 426 # 0: symbol 427 compiler.err.icls.cant.have.static.decl=内部类{0}中的静态声明非法\n修饰符 ''static'' 仅允许在常量变量声明中使用 428 429 # 0: string 430 compiler.err.illegal.char=非法字符: ''{0}'' 431 432 # 0: string, 1: string 433 compiler.err.illegal.char.for.encoding=编码 {1} 的不可映射字符 (0x{0}) 434 435 # 0: set of flag, 1: set of flag 436 compiler.err.illegal.combination.of.modifiers=非法的修饰符组合: {0}和{1} 437 438 compiler.err.illegal.enum.static.ref=初始化程序中对静态字段的引用不合法 439 440 compiler.err.illegal.esc.char=非法转义符 441 442 compiler.err.illegal.forward.ref=非法前向引用 443 444 # 0: symbol, 1: object 445 compiler.err.not.in.profile={0}在配置文件 ''{1}'' 中不可用 446 447 # 0: symbol 448 compiler.warn.forward.ref=先引用变量 ''{0}'', 然后再对其初始化 449 450 compiler.err.illegal.self.ref=初始化程序中存在自引用 451 452 # 0: symbol 453 compiler.warn.self.ref=变量 ''{0}'' 的初始化程序中存在自引用 454 455 compiler.err.illegal.generic.type.for.instof=instanceof 的泛型类型不合法 456 457 # 0: type 458 compiler.err.illegal.initializer.for.type={0}的初始化程序不合法 459 460 compiler.err.illegal.line.end.in.char.lit=字符文字的行结尾不合法 461 462 compiler.err.illegal.text.block.open=文本块起始分隔符序列非法,缺少行终止符 463 464 compiler.warn.inconsistent.white.space.indentation=空格缩进不一致 465 466 compiler.warn.trailing.white.space.will.be.removed=将删除尾随空格 467 468 compiler.err.illegal.nonascii.digit=非法的非 ASCII 数字 469 470 compiler.err.illegal.underscore=非法下划线 471 472 compiler.err.illegal.dot=非法 ''.'' 473 474 # 0: symbol 475 compiler.err.illegal.qual.not.icls=非法限定符; {0}不是内部类 476 477 compiler.err.illegal.start.of.expr=非法的表达式开始 478 479 compiler.err.illegal.start.of.stmt=非法的语句开始 480 481 compiler.err.illegal.start.of.type=非法的类型开始 482 483 compiler.err.illegal.parenthesized.expression=非法的含括号表达式 484 485 compiler.err.illegal.unicode.esc=非法的 Unicode 转义 486 487 # 0: symbol 488 compiler.err.import.requires.canonical=导入需要{0}的规范名称 489 490 compiler.err.improperly.formed.type.param.missing=类型的格式不正确, 缺少某些参数 491 492 compiler.err.improperly.formed.type.inner.raw.param=类型的格式不正确, 给出了原始类型的类型参数 493 494 # 0: type, 1: type 495 compiler.err.incomparable.types=不可比较的类型: {0}和{1} 496 497 # 0: string 498 compiler.err.int.number.too.large=整数太大 499 500 compiler.err.intf.annotation.members.cant.have.params=注释类型声明中的元素无法声明形参 501 502 # 0: symbol 503 compiler.err.intf.annotation.cant.have.type.params=注释类型 {0} 不能为泛型 504 505 compiler.err.intf.annotation.members.cant.have.type.params=注释类型声明中的元素不能为泛型方法 506 507 # 0: symbol, 1: type 508 compiler.err.intf.annotation.member.clash=注释类型{1}声明与方法 {0} 同名的元素 509 510 compiler.err.intf.expected.here=此处需要接口 511 512 compiler.err.intf.meth.cant.have.body=接口抽象方法不能带有主体 513 514 compiler.err.invalid.annotation.member.type=注释类型元素的类型无效 515 516 compiler.err.invalid.binary.number=二进制数字中必须包含至少一个二进制数 517 518 compiler.err.invalid.hex.number=十六进制数字必须包含至少一位十六进制数 519 520 compiler.err.invalid.meth.decl.ret.type.req=方法声明无效; 需要返回类型 521 522 compiler.err.varargs.and.old.array.syntax=variable-arity 参数中不允许使用传统数组记号 523 524 compiler.err.varargs.and.receiver =接收方参数不允许使用 varargs 记号 525 526 compiler.err.varargs.must.be.last =varargs 参数必须是最后一个参数 527 528 compiler.err.array.and.receiver =接收方参数不允许使用传统数组记号 529 530 compiler.err.wrong.receiver =错误的接收方参数名 531 532 compiler.err.variable.not.allowed=此处不允许使用变量声明 533 534 # 0: name 535 compiler.err.label.already.in.use=标签{0}已使用 536 537 # 0: symbol 538 compiler.err.local.var.accessed.from.icls.needs.final=从内部类中访问本地变量{0}; 需要被声明为最终类型 539 540 compiler.err.local.enum=枚举类型不能为本地类型 541 542 compiler.err.cannot.create.array.with.type.arguments=无法创建具有类型变量的数组 543 544 compiler.err.cannot.create.array.with.diamond=无法创建具有 ''<>'' 的数组 545 546 compiler.err.invalid.module.directive=预期为模块指令关键字或 ''}'' 547 548 # 549 # limits. We don't give the limits in the diagnostic because we expect 550 # them to change, yet we want to use the same diagnostic. These are all 551 # detected during code generation. 552 # 553 compiler.err.limit.code=代码过长 554 555 compiler.err.limit.code.too.large.for.try.stmt=try 语句的代码过长 556 557 compiler.err.limit.dimensions=数组类型维过多 558 559 compiler.err.limit.locals=本地变量过多 560 561 compiler.err.limit.parameters=参数过多 562 563 compiler.err.limit.pool=常量过多 564 565 compiler.err.limit.pool.in.class=类{0}中的常量过多 566 567 compiler.err.limit.stack=代码需要过多堆栈 568 569 compiler.err.limit.string=常量字符串过长 570 571 # 0: string 572 compiler.err.limit.string.overflow=对于常量池来说, 字符串 "{0}..." 的 UTF8 表示过长 573 574 compiler.err.malformed.fp.lit=浮点文字的格式错误 575 576 compiler.err.method.does.not.override.superclass=方法不会覆盖或实现超类型的方法 577 578 compiler.err.static.methods.cannot.be.annotated.with.override=不能使用 @Override 注释静态方法 579 580 compiler.err.missing.meth.body.or.decl.abstract=缺少方法主体, 或声明抽象 581 582 compiler.err.missing.ret.stmt=缺少返回语句 583 584 # 0: type 585 compiler.misc.missing.ret.val=缺少返回值 586 587 compiler.misc.unexpected.ret.val=意外的返回值 588 589 # 0: set of flag 590 compiler.err.mod.not.allowed.here=此处不允许使用修饰符{0} 591 592 # 0: name 593 compiler.err.modifier.not.allowed.here=此处不允许使用修饰符{0} 594 595 compiler.err.intf.not.allowed.here=此处不允许使用接口 596 597 compiler.err.enums.must.be.static=只有在静态上下文中才允许使用枚举声明 598 599 # 0: symbol, 1: symbol 600 compiler.err.name.clash.same.erasure=名称冲突: {0}和{1}具有相同疑符 601 602 # 0: name, 1: list of type, 2: symbol, 3: name, 4: list of type, 5: symbol 603 compiler.err.name.clash.same.erasure.no.override=名称冲突: {2} 中的 {0}({1}) 和 {5} 中的 {3}({4}) 具有相同疑符, 但两者均不覆盖对方 604 605 # 0: string, 1: name, 2: name, 3: list of type, 4: symbol, 5: name, 6: list of type, 7: symbol 606 compiler.err.name.clash.same.erasure.no.override.1=名称冲突: {0} {1} 的两种方法具有相同的疑符, 但两者均不覆盖对方\n第一种方法: {4} 中的 {2}({3})\n第二种方法: {7} 中的 {5}({6}) 607 608 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 609 compiler.err.name.clash.same.erasure.no.hide=名称冲突: {1} 中的 {0} 和 {3} 中的 {2} 具有相同疑符, 但两者均不隐藏对方 610 611 compiler.err.name.reserved.for.internal.use={0}为内部使用保留 612 613 compiler.err.native.meth.cant.have.body=本机方法不能带有主体 614 615 616 # 0: message segment 617 compiler.misc.incompatible.type.in.conditional=条件表达式中的类型错误\n{0} 618 619 compiler.misc.conditional.target.cant.be.void=条件表达式的目标类型不能为空 620 621 compiler.misc.switch.expression.target.cant.be.void=switch 表达式的目标类型不能为空 622 623 # 0: message segment 624 compiler.misc.incompatible.type.in.switch.expression=switch 表达式中的类型错误\n{0} 625 626 # 0: message segment 627 compiler.misc.incompatible.ret.type.in.lambda=lambda 表达式中的返回类型错误\n{0} 628 629 compiler.misc.stat.expr.expected=lambda 主体与 void 函数接口不兼容\n(请考虑使用块 lambda 主体, 或者改为使用语句表达式) 630 631 # 0: message segment 632 compiler.misc.incompatible.ret.type.in.mref=方法引用中的返回类型错误\n{0} 633 634 compiler.err.lambda.body.neither.value.nor.void.compatible=lambda 主体不是值, 也不与 void 兼容 635 636 # 0: list of type 637 compiler.err.incompatible.thrown.types.in.mref=函数表达式中抛出的类型 {0} 不兼容 638 639 compiler.misc.incompatible.arg.types.in.lambda=lambda 表达式中的参数类型不兼容 640 641 compiler.misc.incompatible.arg.types.in.mref=方法引用中的参数类型不兼容 642 643 compiler.err.new.not.allowed.in.annotation=注释中不允许使用 ''new'' 644 645 # 0: name, 1: type 646 compiler.err.no.annotation.member={1}中没有注释成员{0} 647 648 # 0: symbol 649 compiler.err.no.encl.instance.of.type.in.scope=作用域中没有类型为{0}的封闭实例 650 651 compiler.err.no.intf.expected.here=此处不需要接口 652 653 compiler.err.no.match.entry={0}在{1}的条目中没有匹配项; 需要{2} 654 655 # 0: type 656 compiler.err.not.annotation.type={0}不是注释类型 657 658 # 0: symbol, 1: symbol, 2: message segment 659 compiler.err.not.def.access.package.cant.access={0} 不可见\n({2}) 660 661 # 0: symbol, 1: symbol, 2: message segment 662 compiler.misc.not.def.access.package.cant.access={0} 不可见\n({2}) 663 664 # 0: symbol, 1: message segment 665 compiler.err.package.not.visible=程序包 {0} 不可见\n({1}) 666 667 # 0: symbol, 1: message segment 668 compiler.misc.package.not.visible=程序包 {0} 不可见\n({1}) 669 670 # {0} - current module 671 # {1} - package in which the invisible class is declared 672 # {2} - module in which {1} is declared 673 # 0: symbol, 1: symbol, 2: symbol 674 compiler.misc.not.def.access.does.not.read=程序包 {1} 已在模块 {2} 中声明, 但模块 {0} 未读取它 675 676 # {0} - package in which the invisible class is declared 677 # {1} - module in which {0} is declared 678 # 0: symbol, 1: symbol 679 compiler.misc.not.def.access.does.not.read.from.unnamed=程序包 {0} 已在模块 {1} 中声明, 但该模块不在模块图中 680 681 # {0} - package in which the invisible class is declared 682 # {1} - current module 683 # 0: symbol, 1: symbol 684 compiler.misc.not.def.access.does.not.read.unnamed=程序包 {0} 已在未命名模块中声明, 但模块 {0} 未读取它 685 686 # {0} - package in which the invisible class is declared 687 # {1} - module in which {0} is declared 688 # 0: symbol, 1: symbol 689 compiler.misc.not.def.access.not.exported=程序包 {0} 已在模块 {1} 中声明, 但该模块未导出它 690 691 # {0} - package in which the invisible class is declared 692 # {1} - module in which {0} is declared 693 # 0: symbol, 1: symbol 694 compiler.misc.not.def.access.not.exported.from.unnamed=程序包 {0} 已在模块 {1} 中声明, 但该模块未导出它 695 696 # {0} - package in which the invisible class is declared 697 # {1} - module in which {0} is declared 698 # {2} - current module 699 # 0: symbol, 1: symbol, 2: symbol 700 compiler.misc.not.def.access.not.exported.to.module=程序包 {0} 已在模块 {1} 中声明, 但该模块未将它导出到模块 {2} 701 702 # {0} - package in which the invisible class is declared 703 # {1} - module in which {0} is declared 704 # 0: symbol, 1: symbol 705 compiler.misc.not.def.access.not.exported.to.module.from.unnamed=程序包 {0} 已在模块 {1} 中声明, 但该模块未将它导出到未命名模块 706 707 # 0: symbol, 1: symbol 708 compiler.err.not.def.access.class.intf.cant.access={1}.{0} 是在不可访问的类或接口中定义的 709 710 # 0: symbol, 1: symbol 711 compiler.misc.not.def.access.class.intf.cant.access={1}.{0} 是在不可访问的类或接口中定义的 712 713 # 0: symbol, 1: symbol, 2: symbol, 3: message segment 714 compiler.err.not.def.access.class.intf.cant.access.reason=程序包 {2} 中的 {1}.{0} 不可访问\n({3}) 715 716 # 0: symbol, 1: symbol, 2: symbol, 3: message segment 717 compiler.misc.not.def.access.class.intf.cant.access.reason=程序包 {2} 中的 {1}.{0} 不可访问\n({3}) 718 719 # 0: symbol, 1: list of type, 2: type 720 compiler.misc.cant.access.inner.cls.constr=无法访问构造器 {0}({1})\n作用域中没有类型为{2}的封闭实例 721 722 # 0: symbol, 1: symbol 723 compiler.err.not.def.public.cant.access={0}在{1}中不是公共的; 无法从外部程序包中对其进行访问 724 725 # 0: symbol, 1: symbol 726 compiler.err.not.def.public={0} 在 {1} 中不是公共的 727 728 # 0: symbol, 1: symbol 729 compiler.misc.not.def.public.cant.access={0}在{1}中不是公共的; 无法从外部程序包中对其进行访问 730 731 # 0: name 732 compiler.err.not.loop.label=不是 loop 标签: {0} 733 734 compiler.err.not.stmt=不是语句 735 736 # 0: symbol 737 compiler.err.not.encl.class=不是封闭类: {0} 738 739 # 0: name, 1: type 740 compiler.err.operator.cant.be.applied=一元运算符 ''{0}'' 的操作数类型{1}错误 741 742 # 0: name, 1: type, 2: type 743 compiler.err.operator.cant.be.applied.1=二元运算符 ''{0}'' 的操作数类型错误\n第一个类型: {1}\n第二个类型: {2} 744 745 compiler.err.pkg.annotations.sb.in.package-info.java=程序包注释应在文件 package-info.java 中 746 747 compiler.err.no.pkg.in.module-info.java=文件 module-info.java 中不允许使用程序包声明 748 749 # 0: symbol 750 compiler.err.pkg.clashes.with.class.of.same.name=程序包{0}与带有相同名称的类冲突 751 752 compiler.err.warnings.and.werror=发现警告, 但指定了 -Werror 753 754 # Errors related to annotation processing 755 756 # 0: symbol, 1: message segment, 2: string (stack-trace) 757 compiler.err.proc.cant.access=无法访问{0}\n{1}\n有关详细信息, 请参阅以下堆栈跟踪。\n{2} 758 759 # 0: symbol, 1: message segment 760 compiler.err.proc.cant.access.1=无法访问{0}\n{1} 761 762 # 0: string 763 compiler.err.proc.cant.find.class=找不到 ''{0}'' 的类文件。 764 765 # 0: string 766 compiler.err.proc.cant.load.class=由于 ''{0}'',无法加载处理器类文件。 767 768 # Print a client-generated error message; assumed to be localized, no translation required 769 # 0: string 770 compiler.err.proc.messager={0} 771 772 # 0: string 773 compiler.misc.exception.message={0} 774 775 compiler.misc.user.selected.completion.failure=按类名列出的用户选择输入提示失败 776 777 # 0: collection of string 778 compiler.err.proc.no.explicit.annotation.processing.requested=仅当显式请求注释处理时才接受类名称 ''{0}'' 779 780 compiler.err.proc.no.service=ServiceLoader 不可用, 但它是注释处理所必需的。 781 782 # 0: string, 1: string 783 compiler.err.proc.processor.bad.option.name=处理程序 ''{1}'' 提供的选项名称 ''{0}'' 错误 784 785 # 0: string 786 compiler.err.proc.processor.cant.instantiate=无法实例化处理程序 ''{0}'' 的实例 787 788 # 0: string 789 compiler.err.proc.processor.not.found=找不到注释处理程序 ''{0}'' 790 791 # 0: string 792 compiler.err.proc.processor.wrong.type=注释处理程序 ''{0}'' 未实现 javax.annotation.processing.Processor 793 794 compiler.err.proc.service.problem=创建服务加载器以加载处理程序时出错。 795 796 # 0: string 797 compiler.err.proc.bad.config.file=服务配置文件不正确, 或构造处理程序对象{0}时抛出异常错误 798 799 compiler.err.proc.cant.create.loader=无法为注释处理程序{0}创建类加载器 800 801 # 0: symbol 802 compiler.err.qualified.new.of.static.class=限定的新静态类 803 804 compiler.err.recursive.ctor.invocation=递归构造器调用 805 806 # 0: name, 1: symbol kind, 2: symbol, 3: symbol, 4: symbol kind, 5: symbol, 6: symbol 807 compiler.err.ref.ambiguous=对{0}的引用不明确\n{3} 中的{1} {2} 和 {6} 中的{4} {5} 都匹配 808 809 # 0: name, 1: symbol kind, 2: symbol, 3: symbol, 4: symbol kind, 5: symbol, 6: symbol 810 compiler.misc.ref.ambiguous=对{0}的引用不明确\n{3} 中的{1} {2} 和 {6} 中的{4} {5} 都匹配 811 812 compiler.err.repeated.annotation.target=注释目标重复 813 814 compiler.err.repeated.interface=接口重复 815 816 compiler.err.repeated.modifier=修饰符重复 817 818 # 0: symbol, 1: set of modifier, 2: symbol 819 compiler.err.report.access={0} 在 {2} 中是 {1} 访问控制 820 821 # 0: symbol, 1: set of modifier, 2: symbol 822 compiler.misc.report.access={0} 在 {2} 中是 {1} 访问控制 823 824 compiler.err.ret.outside.meth=返回外部方法 825 826 compiler.err.signature.doesnt.match.supertype=签名与{0}不匹配; 不兼容的超类型 827 828 compiler.err.signature.doesnt.match.intf=签名与{0}不匹配; 不兼容的接口 829 830 # 0: symbol, 1: symbol, 2: symbol 831 compiler.err.does.not.override.abstract={0}不是抽象的, 并且未覆盖{2}中的抽象方法{1} 832 833 # 0: file object 834 compiler.err.source.cant.overwrite.input.file=写入源时出错; 无法覆盖输入文件{0} 835 836 # 0: symbol 837 compiler.err.stack.sim.error=内部错误: {0}中的堆栈 sim 错误 838 839 compiler.err.static.imp.only.classes.and.interfaces=仅从类和接口静态导入 840 841 compiler.err.string.const.req=需要常量字符串表达式 842 843 # 0: symbol, 1: fragment 844 compiler.err.cannot.generate.class=生成类 {0} 时出错\n({1}) 845 846 # 0: symbol, 1: symbol 847 compiler.misc.synthetic.name.conflict=符号{0}与{1}中的 compiler-synthesized 符号冲突 848 849 # 0: symbol, 1: type 850 compiler.misc.illegal.signature=类型 {1} 的签名属性非法 851 852 compiler.err.throws.not.allowed.in.intf.annotation=@interface 成员中不允许使用 throws 子句 853 854 compiler.err.try.without.catch.finally.or.resource.decls=''try'' 不带有 ''catch'', ''finally'' 或资源声明 855 856 # 0: symbol 857 compiler.err.type.doesnt.take.params=类型{0}不带有参数 858 859 compiler.err.type.var.cant.be.deref=无法从类型变量中进行选择 860 861 compiler.err.type.var.may.not.be.followed.by.other.bounds=类型变量后面不能带有其他限制范围 862 863 compiler.err.type.var.more.than.once=类型变量{0}在{1}的结果类型中多次出现; 必须对其进行实例化 864 865 compiler.err.type.var.more.than.once.in.result=类型变量{0}在{1}的类型中多次出现; 必须对其进行实例化 866 867 # 0: type, 1: type, 2: fragment 868 compiler.err.types.incompatible=类型 {0} 和 {1} 不兼容;\n{2} 869 870 # 0: name, 1: list of type 871 compiler.misc.incompatible.diff.ret=两者都定义了 {0}({1}),但却带有不相关的返回类型 872 873 # 0: kind name, 1: type, 2: name, 3: list of type, 4: symbol, 5: symbol 874 compiler.misc.incompatible.unrelated.defaults={0} {1}从类型 {4} 和 {5} 中继承了{2}({3}) 的不相关默认值 875 876 # 0: kind name, 1: type, 2: name, 3: list of type, 4: symbol, 5: symbol 877 compiler.misc.incompatible.abstract.default={0} {1}从类型 {4} 和 {5} 中继承了{2}({3}) 的抽象和默认值 878 879 # 0: name, 1: kind name, 2: symbol 880 compiler.err.default.overrides.object.member={1} {2} 中的默认方法{0}覆盖了 java.lang.Object 的成员 881 882 # 0: type 883 compiler.err.illegal.static.intf.meth.call=静态接口方法调用非法\n应将接收方表达式替换为类型限定符 ''{0}'' 884 885 # 0: symbol or type, 1: message segment 886 compiler.err.illegal.default.super.call=默认超级调用中的类型限定符{0}错误\n{1} 887 888 # 0: symbol, 1: type 889 compiler.misc.overridden.default=覆盖了{1}中的方法 {0} 890 891 # 0: symbol, 1: type or symbol 892 compiler.misc.redundant.supertype=冗余接口 {0} 已由 {1} 扩展 893 894 compiler.err.unclosed.char.lit=未结束的字符文字 895 896 compiler.err.unclosed.comment=未结束的注释 897 898 compiler.err.unclosed.str.lit=未结束的字符串文字 899 900 compiler.err.unclosed.text.block=文本块未闭合 901 902 # 0: string 903 compiler.err.unsupported.encoding=不支持的编码: {0} 904 905 compiler.err.io.exception=读取源文件时出错: {0} 906 907 # 0: name 908 compiler.err.undef.label=未定义的标签: {0} 909 910 # 0: name 911 compiler.err.illegal.ref.to.restricted.type=对受限制类型 ''{0}'' 的引用非法 912 913 # 0: name 914 compiler.warn.illegal.ref.to.restricted.type=对受限制类型 ''{0}'' 的引用非法 915 916 # 0: name, 1: source 917 compiler.err.restricted.type.not.allowed=此处不允许使用 ''{0}''\n从发行版 {1} 开始,''{0}'' 是受限类型名称,不能用于类型声明 918 919 # 0: name, 1: source 920 compiler.warn.restricted.type.not.allowed=从发行版 {1} 开始,''{0}'' 是受限类型名称,不能用于类型声明,也不能用作数组的元素类型 921 922 # 0: name, 1: source 923 compiler.warn.restricted.type.not.allowed.preview=''{0}'' 在未来发行版中可能会成为受限类型名称,可能无法用于类型声明,也不能用作数组的元素类型 924 925 # 0: name (variable), 1: message segment 926 compiler.err.cant.infer.local.var.type=无法推断本地变量 {0} 的类型\n({1}) 927 928 # 0: name 929 compiler.err.restricted.type.not.allowed.here=此处不允许使用 ''{0}'' 930 931 # 0: name 932 compiler.err.restricted.type.not.allowed.array=''{0}'' 不允许用作数组的元素类型 933 934 # 0: name 935 compiler.err.restricted.type.not.allowed.compound=''{0}'' 不允许在复合声明中使用 936 937 # 0: fragment 938 compiler.err.invalid.lambda.parameter.declaration=无效的 lambda 参数声明\n({0}) 939 940 compiler.misc.implicit.and.explicit.not.allowed=不能将隐式类型和显式类型的参数混合使用 941 942 compiler.misc.var.and.explicit.not.allowed=不能将 ''var'' 和显式类型的参数混合使用 943 944 compiler.misc.var.and.implicit.not.allowed=不能将 ''var'' 和隐式类型的参数混合使用 945 946 compiler.misc.local.cant.infer.null=变量初始化程序为 ''null'' 947 948 compiler.misc.local.cant.infer.void=变量初始化程序为 ''void'' 949 950 compiler.misc.local.missing.init=无法在不带初始化程序的变量上使用 ''var'' 951 952 compiler.misc.local.lambda.missing.target=lambda 表达式需要显式目标类型 953 954 compiler.misc.local.mref.missing.target=方法引用需要显式目标类型 955 956 compiler.misc.local.array.missing.target=数组初始化程序需要显式目标类型 957 958 compiler.misc.local.self.ref=无法在自引用变量上使用 ''var'' 959 960 # 0: message segment, 1: unused 961 compiler.err.cant.apply.diamond=无法推断{0}的类型参数 962 963 # 0: message segment or type, 1: message segment 964 compiler.err.cant.apply.diamond.1=无法推断{0}的类型参数\n原因: {1} 965 966 # 0: message segment or type, 1: message segment 967 compiler.misc.cant.apply.diamond.1=无法推断{0}的类型参数\n原因: {1} 968 969 compiler.err.unreachable.stmt=无法访问的语句 970 971 compiler.err.not.exhaustive=switch 表达式不包含所有可能的输入值 972 973 compiler.err.initializer.must.be.able.to.complete.normally=初始化程序必须能够正常完成 974 975 compiler.err.initializer.not.allowed=接口中不允许有初始化程序 976 977 # 0: type 978 compiler.err.unreported.exception.need.to.catch.or.throw=未报告的异常错误{0}; 必须对其进行捕获或声明以便抛出 979 980 # 0: type 981 compiler.err.unreported.exception.default.constructor=默认构造器中未报告的异常错误{0} 982 983 # 0: type, 1: name 984 compiler.err.unreported.exception.implicit.close=未报告的异常错误{0}; 必须对其进行捕获或声明以便抛出\n对资源变量 ''{1}'' 隐式调用 close() 时抛出了异常错误 985 986 compiler.err.unsupported.cross.fp.lit=该 VM 不支持十六进制浮点文字 987 988 compiler.err.void.not.allowed.here=此处不允许使用 ''空'' 类型 989 990 # 0: string 991 compiler.err.wrong.number.type.args=类型变量数目错误; 需要{0} 992 993 # 0: symbol 994 compiler.err.var.might.already.be.assigned=可能已分配变量{0} 995 996 # 0: symbol 997 compiler.err.var.might.not.have.been.initialized=可能尚未初始化变量{0} 998 999 # 0: symbol 1000 compiler.err.var.not.initialized.in.default.constructor=变量 {0} 未在默认构造器中初始化 1001 1002 # 0: symbol 1003 compiler.err.var.might.be.assigned.in.loop=可能在 loop 中分配了变量{0} 1004 1005 # 0: symbol, 1: message segment 1006 compiler.err.varargs.invalid.trustme.anno={0} 注释无效。{1} 1007 1008 # 0: type 1009 compiler.misc.varargs.trustme.on.reifiable.varargs=Varargs 元素类型{0}可具体化。 1010 1011 # 0: symbol 1012 compiler.misc.varargs.trustme.on.non.varargs.meth=方法 {0} 不是 varargs 方法。 1013 1014 # 0: symbol 1015 compiler.misc.varargs.trustme.on.virtual.varargs=实例方法 {0} 既不是最终的, 也不是私有的。 1016 1017 # 0: symbol 1018 compiler.misc.varargs.trustme.on.virtual.varargs.final.only=实例方法 {0} 不是最终的。 1019 1020 # 0: type, 1: symbol kind, 2: symbol 1021 compiler.misc.inaccessible.varargs.type=形式 varargs 元素类型{0}无法从 {1} {2} 进行访问 1022 1023 # In the following string, {1} will always be the detail message from 1024 # java.io.IOException. 1025 # 0: symbol, 1: string 1026 compiler.err.class.cant.write=写入{0}时出错: {1} 1027 1028 # In the following string, {0} is the name of the class in the Java source. 1029 # It really should be used two times.. 1030 # 0: kind name, 1: name 1031 compiler.err.class.public.should.be.in.file={0} {1} 是公共的, 应在名为 {1}.java 的文件中声明 1032 1033 ## All errors which do not refer to a particular line in the source code are 1034 ## preceded by this string. 1035 compiler.err.error=错误: 1036 1037 # The following error messages do not refer to a line in the source code. 1038 compiler.err.cant.read.file=无法读取: {0} 1039 1040 # 0: string 1041 compiler.err.plugin.not.found=找不到插件: {0} 1042 1043 # 0: path 1044 compiler.warn.locn.unknown.file.on.module.path=模块路径中的未知文件: {0} 1045 1046 1047 # 0: path 1048 compiler.err.locn.bad.module-info=读取 {0} 中的 module-info.class 时出现问题 1049 1050 # 0: path 1051 compiler.err.locn.cant.read.directory=无法读取目录 {0} 1052 1053 # 0: path 1054 compiler.err.locn.cant.read.file=无法读取文件 {0} 1055 1056 # 0: path 1057 compiler.err.locn.cant.get.module.name.for.jar=无法确定 {0} 的模块名称 1058 1059 # 0: path 1060 compiler.err.multi-module.outdir.cannot.be.exploded.module=在多模块模式下, 输出目录不能是展开的模块: {0} 1061 1062 # 0: path 1063 compiler.warn.outdir.is.in.exploded.module=输出目录位于展开的模块中: {0} 1064 1065 # 0: file object 1066 compiler.err.locn.module-info.not.allowed.on.patch.path=在补丁程序路径中不允许 module-info.class: {0} 1067 1068 # 0: string 1069 compiler.err.locn.invalid.arg.for.xpatch=--patch-module 选项的参数无效: {0} 1070 1071 compiler.err.file.sb.on.source.or.patch.path.for.module=文件应在源路径或模块的补丁程序路径中 1072 1073 ##### 1074 1075 # Fatal Errors 1076 1077 compiler.misc.fatal.err.no.java.lang=致命错误: 在类路径或引导类路径中找不到程序包 java.lang 1078 1079 # 0: name 1080 compiler.misc.fatal.err.cant.locate.meth=致命错误: 找不到方法{0} 1081 1082 # 0: name 1083 compiler.misc.fatal.err.cant.locate.field=致命错误: 找不到字段{0} 1084 1085 # 0: type 1086 compiler.misc.fatal.err.cant.locate.ctor=致命错误: 找不到{0}的构造器 1087 1088 compiler.misc.fatal.err.cant.close=致命错误: 无法关闭编译器资源 1089 1090 ##### 1091 1092 ## 1093 ## miscellaneous strings 1094 ## 1095 1096 compiler.misc.diamond.anonymous.methods.implicitly.override=(由于 <>, 匿名类中声明的每个非私有方法必须覆盖或实现超类型中的方法) 1097 1098 compiler.misc.source.unavailable=(源不可用) 1099 1100 compiler.misc.base.membership=您的所有基类都属于我们 1101 1102 # 0: string, 1: string, 2: boolean 1103 compiler.misc.x.print.processor.info=处理程序{0}与{1}匹配并返回{2}。 1104 1105 # 0: number, 1: string, 2: set of symbol, 3: boolean 1106 compiler.misc.x.print.rounds=循环 {0}:\n\t输入文件: {1}\n\t注释: {2}\n\t最后一个循环: {3} 1107 1108 # 0: file name 1109 compiler.warn.file.from.future=文件 {0} 的修改日期是未来的日期 1110 1111 ##### 1112 1113 ## The following string will appear before all messages keyed as: 1114 ## "compiler.note". 1115 1116 compiler.note.compressed.diags=某些消息已经过简化; 请使用 -Xdiags:verbose 重新编译以获得完整输出 1117 1118 # 0: boolean, 1: symbol 1119 compiler.note.lambda.stat=转换 lambda 表达式\n替代 metafactory = {0}\n合成方法 = {1} 1120 1121 # 0: boolean, 1: unused 1122 compiler.note.mref.stat=转换方法引用\n替代 metafactory = {0}\n 1123 # 0: boolean, 1: symbol 1124 compiler.note.mref.stat.1=转换方法引用\n替代 metafactory = {0}\nbridge 方法 = {1} 1125 1126 compiler.note.note=注: 1127 1128 # 0: file name 1129 compiler.note.deprecated.filename={0}使用或覆盖了已过时的 API。 1130 1131 compiler.note.deprecated.plural=某些输入文件使用或覆盖了已过时的 API。 1132 1133 # The following string may appear after one of the above deprecation 1134 # messages. 1135 compiler.note.deprecated.recompile=有关详细信息, 请使用 -Xlint:deprecation 重新编译。 1136 1137 # 0: file name 1138 compiler.note.deprecated.filename.additional={0}还使用或覆盖了已过时的 API。 1139 1140 compiler.note.deprecated.plural.additional=某些输入文件还使用或覆盖了已过时的 API。 1141 1142 # 0: file name 1143 compiler.note.removal.filename={0} 使用或覆盖了标记为待删除的已过时 API。 1144 1145 compiler.note.removal.plural=某些输入文件使用或覆盖了标记为待删除的已过时 API。 1146 1147 # The following string may appear after one of the above removal messages. 1148 compiler.note.removal.recompile=有关详细信息, 请使用 -Xlint:removal 重新编译。 1149 1150 # 0: file name 1151 compiler.note.removal.filename.additional={0} 额外使用或覆盖了标记为待删除的已过时 API。 1152 1153 compiler.note.removal.plural.additional=某些输入文件额外使用或覆盖了标记为待删除的已过时 API。 1154 1155 # 0: file name 1156 compiler.note.unchecked.filename={0}使用了未经检查或不安全的操作。 1157 1158 compiler.note.unchecked.plural=某些输入文件使用了未经检查或不安全的操作。 1159 1160 # The following string may appear after one of the above unchecked messages. 1161 compiler.note.unchecked.recompile=有关详细信息, 请使用 -Xlint:unchecked 重新编译。 1162 1163 # 0: file name 1164 compiler.note.unchecked.filename.additional={0}还有未经检查或不安全的操作。 1165 1166 compiler.note.unchecked.plural.additional=某些输入文件还使用了未经检查或不安全的操作。 1167 1168 # 0: file name 1169 compiler.note.preview.filename={0} 使用预览语言功能。 1170 1171 compiler.note.preview.plural=某些输入文件使用预览语言功能。 1172 1173 # The following string may appear after one of the above deprecation 1174 # messages. 1175 compiler.note.preview.recompile=有关详细信息,请使用 -Xlint:preview 重新编译。 1176 1177 # 0: file name 1178 compiler.note.preview.filename.additional={0} 还使用预览语言功能。 1179 1180 compiler.note.preview.plural.additional=某些输入文件还使用预览语言功能。 1181 1182 # Notes related to annotation processing 1183 1184 # Print a client-generated note; assumed to be localized, no translation required 1185 # 0: string 1186 compiler.note.proc.messager={0} 1187 1188 # 0: string, 1: string, 2: string 1189 compiler.note.multiple.elements=通过 javax.lang.model.util.Elements.{0} 在模块 ''{2}'' 中找到了多个名为 ''{1}'' 的元素。 1190 1191 ##### 1192 1193 # 0: number 1194 compiler.misc.count.error={0} 个错误 1195 1196 # 0: number 1197 compiler.misc.count.error.plural={0} 个错误 1198 1199 # 0: number, 1: number 1200 compiler.misc.count.error.recompile=仅显示前 {0} 个错误(共 {1} 个);若要查看更多错误,请使用 -Xmaxerrs 1201 1202 # 0: number, 1: number 1203 compiler.misc.count.warn.recompile=仅显示前 {0} 个警告(共 {1} 个);若要查看更多错误,请使用 -Xmaxwarns 1204 1205 # 0: number 1206 compiler.misc.count.warn={0} 个警告 1207 1208 # 0: number 1209 compiler.misc.count.warn.plural={0} 个警告 1210 1211 compiler.misc.version.not.available=(版本信息不可用) 1212 1213 ## extra output when using -verbose (JavaCompiler) 1214 1215 # 0: symbol 1216 compiler.misc.verbose.checking.attribution=[正在检查{0}] 1217 1218 # 0: string 1219 compiler.misc.verbose.parsing.done=[语法分析已完成, 用时 {0} 毫秒] 1220 1221 # 0: file name 1222 compiler.misc.verbose.parsing.started=[语法分析开始时间 {0}] 1223 1224 # 0: string 1225 compiler.misc.verbose.total=[共 {0} 毫秒] 1226 1227 # 0: file name 1228 compiler.misc.verbose.wrote.file=[已写入{0}] 1229 1230 ## extra output when using -verbose (code/ClassReader) 1231 # 0: string 1232 compiler.misc.verbose.loading=[正在加载{0}] 1233 1234 # 0: string 1235 compiler.misc.verbose.sourcepath=[源文件的搜索路径: {0}] 1236 1237 # 0: string 1238 compiler.misc.verbose.classpath=[类文件的搜索路径: {0}] 1239 1240 ## extra output when using -prompt (util/Log) 1241 compiler.misc.resume.abort=继续(R), 放弃(A)> 1242 1243 ##### 1244 1245 ## 1246 ## warnings 1247 ## 1248 1249 ## All warning messages are preceded by the following string. 1250 compiler.warn.warning=警告: 1251 1252 ## Warning messages may also include the following prefix to identify a 1253 ## lint option 1254 # 0: option name 1255 compiler.warn.lintOption=[{0}] 1256 1257 # 0: symbol 1258 compiler.warn.constant.SVUID=serialVersionUID 在类{0}中必须是常量 1259 1260 # 0: path 1261 compiler.warn.dir.path.element.not.found=错误的路径元素 "{0}": 没有这种目录 1262 1263 # 0: file name 1264 compiler.warn.dir.path.element.not.directory=错误的路径元素 "{0}": 不是目录 1265 1266 compiler.warn.finally.cannot.complete=finally 子句无法正常完成 1267 1268 # 0: name 1269 compiler.warn.poor.choice.for.module.name=模块名称组成部分 {0} 应避免以数字结尾 1270 1271 # 0: string 1272 compiler.warn.incubating.modules=使用 incubating 模块: {0} 1273 1274 # 0: symbol, 1: symbol 1275 compiler.warn.has.been.deprecated={1}中的{0}已过时 1276 1277 # 0: symbol, 1: symbol 1278 compiler.warn.has.been.deprecated.for.removal={1} 中的 {0} 已过时, 且标记为待删除 1279 1280 # 0: symbol 1281 compiler.warn.has.been.deprecated.module=模块 {0} 已过时 1282 1283 # 0: symbol 1284 compiler.warn.has.been.deprecated.for.removal.module=模块 {0} 已过时, 且标记为待删除 1285 1286 # 0: symbol 1287 compiler.warn.sun.proprietary={0}是内部专用 API, 可能会在未来发行版中删除 1288 1289 compiler.warn.illegal.char.for.encoding=编码{0}的不可映射字符 1290 1291 # 0: symbol 1292 compiler.warn.improper.SVUID=必须在类{0}中将 serialVersionUID 声明为 static final 1293 1294 # 0: type, 1: type 1295 compiler.warn.inexact.non-varargs.call=最后一个参数使用了不准确的变量类型的 varargs 方法的非 varargs 调用; \n对于 varargs 调用, 应使用 {0}\n对于非 varargs 调用, 应使用 {1}, 这样也可以抑制此警告 1296 1297 # 0: list of type 1298 compiler.warn.unreachable.catch=catch 子句无法访问\n已捕获到抛出的类型{0} 1299 1300 # 0: list of type 1301 compiler.warn.unreachable.catch.1=catch 子句无法访问\n已捕获到抛出的类型{0} 1302 1303 # 0: symbol 1304 compiler.warn.long.SVUID=serialVersionUID 在类{0}中必须是 long 类型 1305 1306 # 0: symbol 1307 compiler.warn.missing.SVUID=可序列化类{0}没有 serialVersionUID 的定义 1308 1309 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 1310 compiler.warn.potentially.ambiguous.overload={1} 中的 {0} 可能与 {3} 中的 {2} 混淆 1311 1312 # 0: message segment 1313 compiler.warn.override.varargs.missing={0}; 被覆盖的方法没有 ''...'' 1314 1315 # 0: message segment 1316 compiler.warn.override.varargs.extra={0}; 覆盖的方法缺少 ''...'' 1317 1318 # 0: message segment 1319 compiler.warn.override.bridge={0}; 被覆盖的方法为 bridge 方法 1320 1321 # 0: symbol 1322 compiler.warn.pkg-info.already.seen=已找到程序包{0}的 package-info.java 文件 1323 1324 # 0: path 1325 compiler.warn.path.element.not.found=错误的路径元素 "{0}": 没有这种文件或目录 1326 1327 compiler.warn.possible.fall-through.into.case=可能无法实现 case 1328 1329 # 0: type 1330 compiler.warn.redundant.cast=出现冗余的到{0}的转换 1331 1332 # 0: number 1333 compiler.warn.position.overflow=行 {0} 处的位置编码溢出 1334 1335 # 0: file name, 1: number, 2: number 1336 compiler.warn.big.major.version={0}: 主版本 {1} 比 {2} 新, 此编译器支持最新的主版本。\n建议升级此编译器。 1337 1338 # 0: kind name, 1: symbol 1339 compiler.warn.static.not.qualified.by.type=static {0}应由类型名称{1}而不是表达式限定 1340 1341 # 0: string 1342 compiler.warn.source.no.bootclasspath=未与 -source {0} 一起设置引导类路径 1343 1344 # 0: string 1345 compiler.warn.option.obsolete.source=源值{0}已过时, 将在未来所有发行版中删除 1346 1347 # 0: target 1348 compiler.warn.option.obsolete.target=目标值{0}已过时, 将在未来所有发行版中删除 1349 1350 # 0: string, 1: string 1351 compiler.err.option.removed.source=不再支持源选项 {0}。请使用 {1} 或更高版本。 1352 1353 # 0: target, 1: target 1354 compiler.err.option.removed.target=不再支持目标选项 {0}。请使用 {1} 或更高版本。 1355 1356 1357 # 0: target, 1: target 1358 compiler.warn.option.parameters.unsupported=目标值 {0} 不支持 -parameters。请使用 {1} 或更高版本。 1359 1360 compiler.warn.option.obsolete.suppression=要隐藏有关已过时选项的警告, 请使用 -Xlint:-options。 1361 1362 # 0: name, 1: number, 2: number, 3: number, 4: number 1363 compiler.warn.future.attr={1}.{2} 版类文件中引入的 {0} 属性在 {3}.{4} 版类文件中被忽略 1364 1365 compiler.warn.requires.automatic=需要自动模块的指令 1366 1367 compiler.warn.requires.transitive.automatic=需要自动模块的过渡指令 1368 1369 # Warnings related to annotation processing 1370 # 0: string 1371 compiler.warn.proc.package.does.not.exist=程序包{0}不存在 1372 1373 # 0: string 1374 compiler.warn.proc.file.reopening=尝试多次为 ''{0}'' 创建文件 1375 1376 # 0: string 1377 compiler.warn.proc.type.already.exists=类型 ''{0}'' 的文件已经存在于源路径或类路径中 1378 1379 # 0: string 1380 compiler.warn.proc.type.recreate=尝试多次创建类型 ''{0}'' 的文件 1381 1382 # 0: string 1383 compiler.warn.proc.illegal.file.name=无法创建带有非法名称 ''{0}'' 的文件。 1384 1385 # 0: string, 1: string 1386 compiler.warn.proc.suspicious.class.name=正在为名称以{1}结尾的类型创建文件: ''{0}'' 1387 1388 # 0: string 1389 compiler.warn.proc.file.create.last.round=将不对在最后一个循环中创建的类型为 ''{0}'' 的文件进行注释处理。 1390 1391 # 0: string, 1: string 1392 compiler.warn.proc.malformed.supported.string=处理程序 ''{1}'' 为支持的注释类型返回格式错误的字符串 ''{0}'' 1393 1394 # 0: set of string 1395 compiler.warn.proc.annotations.without.processors=没有处理程序要使用以下任何注释: {0} 1396 1397 # 0: source version, 1: string, 2: string 1398 compiler.warn.proc.processor.incompatible.source.version=来自注释处理程序 ''{1}'' 的受支持 source 版本 ''{0}'' 低于 -source ''{2}'' 1399 1400 # 0: string, 1: string 1401 compiler.warn.proc.duplicate.option.name=注释处理程序 ''{1}'' 返回重复的支持的选项 ''{0}'' 1402 1403 # 0: string, 1: string 1404 compiler.warn.proc.duplicate.supported.annotation=注释处理程序 ''{1}'' 返回重复的支持的注释类型 ''{0}'' 1405 1406 # 0: string 1407 compiler.warn.proc.redundant.types.with.wildcard=注释处理程序 ''{0}'' 重复支持 ''*'' 和其他注释类型 1408 1409 compiler.warn.proc.proc-only.requested.no.procs=在未请求编译的情况下进行注释处理, 但找不到处理程序。 1410 1411 compiler.warn.proc.use.implicit=注释处理不适用于隐式编译的文件。\n使用 -implicit 指定用于隐式编译的策略。 1412 1413 compiler.warn.proc.use.proc.or.implicit=注释处理不适用于隐式编译的文件。\n使用 -proc:none 禁用注释处理或使用 -implicit 指定用于隐式编译的策略。 1414 1415 # Print a client-generated warning; assumed to be localized, no translation required 1416 # 0: string 1417 compiler.warn.proc.messager={0} 1418 1419 # 0: set of string 1420 compiler.warn.proc.unclosed.type.files=类型 ''{0}'' 的文件未关闭; 将不针对这些类型进行注释处理 1421 1422 # 0: string 1423 compiler.warn.proc.unmatched.processor.options=以下选项未被任何处理程序识别: ''{0}'' 1424 1425 compiler.warn.try.explicit.close.call=在可自动结束的资源上显式调用 close() 1426 1427 # 0: symbol 1428 compiler.warn.try.resource.not.referenced=不能在相应的 try 语句的正文中引用可自动结束的资源{0} 1429 1430 # 0: type 1431 compiler.warn.try.resource.throws.interrupted.exc=可自动关闭的资源{0}包含的成员方法 close() 可能抛出 InterruptedException 1432 1433 compiler.warn.unchecked.assign=未经检查的分配: 将{0}分配给{1} 1434 1435 # 0: symbol, 1: type 1436 compiler.warn.unchecked.assign.to.var=对作为原始类型{1}的成员的变量{0}的分配未经过检查 1437 1438 # 0: symbol, 1: type 1439 compiler.warn.unchecked.call.mbr.of.raw.type=对作为原始类型{1}的成员的{0}的调用未经过检查 1440 1441 compiler.warn.unchecked.cast.to.type=向类型{0}的转换未经过检查 1442 1443 # 0: kind name, 1: name, 2: object, 3: object, 4: kind name, 5: symbol 1444 compiler.warn.unchecked.meth.invocation.applied=方法调用未经过检查: 将{4} {5}中的{0} {1}应用到给定的类型\n需要: {2}\n找到: {3} 1445 1446 # 0: type 1447 compiler.warn.unchecked.generic.array.creation=对于类型为{0}的 varargs 参数, 泛型数组创建未经过检查 1448 1449 # 0: type 1450 compiler.warn.unchecked.varargs.non.reifiable.type=参数化 vararg 类型{0}的堆可能已受污染 1451 1452 # 0: symbol 1453 compiler.warn.varargs.unsafe.use.varargs.param=Varargs 方法可能导致来自不可具体化 varargs 参数 {0} 的堆污染 1454 1455 compiler.warn.missing.deprecated.annotation=未使用 @Deprecated 对已过时的项目进行注释 1456 1457 # 0: kind name 1458 compiler.warn.deprecated.annotation.has.no.effect=@Deprecated 注释对此 {0} 声明没有任何效果 1459 1460 # 0: string 1461 compiler.warn.invalid.path=无效文件名: {0} 1462 1463 # 0: string 1464 compiler.err.invalid.path=无效文件名: {0} 1465 1466 1467 # 0: path 1468 compiler.warn.invalid.archive.file=以下路径中存在意外的文件: {0} 1469 1470 # 0: path 1471 compiler.warn.unexpected.archive.file=以下档案文件存在意外的扩展名: {0} 1472 1473 # 0: path 1474 compiler.err.no.zipfs.for.archive=没有任何文件系统提供方可处理此文件: {0} 1475 1476 compiler.warn.div.zero=除数为零 1477 1478 compiler.warn.empty.if=if 之后没有语句 1479 1480 # 0: type, 1: name 1481 compiler.warn.annotation.method.not.found=无法找到类型 ''{0}'' 的注释方法 ''{1}()'' 1482 1483 # 0: type, 1: name, 2: message segment 1484 compiler.warn.annotation.method.not.found.reason=无法找到类型 ''{0}'' 的注释方法 ''{1}()'': {2} 1485 1486 # 0: file object, 1: symbol, 2: name 1487 compiler.warn.unknown.enum.constant=未知的枚举常量 {1}.{2} 1488 1489 # 0: file object, 1: symbol, 2: name, 3: message segment 1490 compiler.warn.unknown.enum.constant.reason=未知的枚举常量 {1}.{2}\n原因: {3} 1491 1492 # 0: type, 1: type 1493 compiler.warn.raw.class.use=找到原始类型: {0}\n缺少泛型类{1}的类型参数 1494 1495 compiler.warn.diamond.redundant.args=新表达式中存在冗余类型参数 (改用 diamond 运算符)。 1496 1497 compiler.warn.local.redundant.type=本地变量的冗余类型 (使用 ''var'' 替换显式类型)。 1498 1499 compiler.warn.potential.lambda.found=可将此匿名内部类创建转换为 lambda 表达式。 1500 1501 compiler.warn.method.redundant.typeargs=方法调用中存在冗余类型参数。 1502 1503 # 0: symbol, 1: message segment 1504 compiler.warn.varargs.redundant.trustme.anno=冗余的 {0} 注释。{1} 1505 1506 # 0: symbol 1507 compiler.warn.access.to.member.from.serializable.element=可串行化元素对成员 {0} 的访问可以由不受信任的代码公开执行 1508 1509 # 0: symbol 1510 compiler.warn.access.to.member.from.serializable.lambda=可串行化 lambda 对成员 {0} 的访问可以由不受信任的代码公开执行 1511 1512 ##### 1513 1514 ## The following are tokens which are non-terminals in the language. They should 1515 ## be named as JLS3 calls them when translated to the appropriate language. 1516 compiler.misc.token.identifier=<标识符> 1517 1518 compiler.misc.token.character=<字符> 1519 1520 compiler.misc.token.string=<字符串> 1521 1522 compiler.misc.token.integer=<整型> 1523 1524 compiler.misc.token.long-integer=<长整型> 1525 1526 compiler.misc.token.float=<浮点型> 1527 1528 compiler.misc.token.double=<双精度型> 1529 1530 compiler.misc.token.bad-symbol=<错误符号> 1531 1532 compiler.misc.token.end-of-input=<输入结束> 1533 1534 ## The argument to the following string will always be one of the following: 1535 ## 1. one of the above non-terminals 1536 ## 2. a keyword (JLS1.8) 1537 ## 3. a boolean literal (JLS3.10.3) 1538 ## 4. the null literal (JLS3.10.7) 1539 ## 5. a Java separator (JLS3.11) 1540 ## 6. an operator (JLS3.12) 1541 ## 1542 ## This is the only place these tokens will be used. 1543 # 0: token 1544 compiler.err.expected=需要{0} 1545 1546 # 0: string 1547 compiler.err.expected.str=需要 {0} 1548 1549 # 0: token, 1: token 1550 compiler.err.expected2=需要{0}或{1} 1551 1552 # 0: token, 1: token, 2: token 1553 compiler.err.expected3=需要{0}, {1}或{2} 1554 1555 compiler.err.premature.eof=进行语法分析时已到达文件结尾 1556 1557 ## The following are related in form, but do not easily fit the above paradigm. 1558 compiler.err.expected.module=需要 ''module'' 1559 1560 compiler.err.expected.module.or.open=需要 ''module'' 或 ''open'' 1561 1562 compiler.err.dot.class.expected=需要 ''.class'' 1563 1564 ## The argument to this string will always be either 'case' or 'default'. 1565 # 0: token 1566 compiler.err.orphaned=孤立的{0} 1567 1568 # 0: name 1569 compiler.misc.anonymous.class=<匿名{0}> 1570 1571 # 0: name, 1: type 1572 compiler.misc.type.captureof=capture#{0}, 共 {1} 1573 1574 compiler.misc.type.captureof.1=capture#{0} 1575 1576 compiler.misc.type.none=<无> 1577 1578 compiler.misc.unnamed.package=未命名程序包 1579 1580 compiler.misc.unnamed.module=未命名模块 1581 1582 ##### 1583 1584 # 0: symbol, 1: message segment 1585 compiler.err.cant.access=无法访问{0}\n{1} 1586 1587 # 0: name 1588 compiler.misc.bad.class.file=类文件对于类 {0} 无效 1589 1590 # 0: file name, 1: string (expected constant pool entry type), 2: number (constant pool index) 1591 compiler.misc.bad.const.pool.entry={0} 中错误的常量池条目\n预期为索引 {2} 处的 {1} 1592 1593 # 0: file name, 1: number (constant pool index), 2: number (constant pool size) 1594 compiler.misc.bad.const.pool.index={0} 中的常量池索引错误\n索引 {1} 不在池大小 {2} 内。 1595 1596 # 0: file name, 1: message segment 1597 compiler.misc.bad.class.file.header=错误的类文件: {0}\n{1}\n请删除该文件或确保该文件位于正确的类路径子目录中。 1598 1599 # 0: file name, 1: message segment 1600 compiler.misc.bad.source.file.header=错误的源文件: {0}\n{1}\n请删除该文件或确保该文件位于正确的源路径子目录中。 1601 1602 ## The following are all possible strings for the second argument ({1}) of the 1603 ## above strings. 1604 compiler.misc.bad.class.signature=错误的类签名: {0} 1605 1606 #0: symbol, 1: symbol 1607 compiler.misc.bad.enclosing.class={0}的封闭类错误: {1} 1608 1609 # 0: symbol 1610 compiler.misc.bad.enclosing.method=类 {0} 的封闭方法属性错误 1611 1612 compiler.misc.bad.runtime.invisible.param.annotations=错误的 RuntimeInvisibleParameterAnnotations 属性: {0} 1613 1614 compiler.misc.bad.const.pool.tag=错误的常量池标记: {0} 1615 1616 compiler.misc.bad.const.pool.tag.at=错误的常量池标记: {0}, 位于{1} 1617 1618 compiler.misc.bad.signature=错误的签名: {0} 1619 1620 compiler.misc.bad.type.annotation.value=错误的类型注释目标类型值: {0} 1621 1622 compiler.misc.bad.module-info.name=错误的类名 1623 1624 compiler.misc.class.file.wrong.class=类文件包含错误的类: {0} 1625 1626 compiler.misc.module.info.invalid.super.class=带有无效超类的 module-info 1627 1628 # 0: name 1629 compiler.misc.class.file.not.found=找不到{0}的类文件 1630 1631 # 0: string (constant value), 1: symbol (constant field), 2: type (field type) 1632 compiler.misc.bad.constant.range={1} 的常量值 ''{0}'' 超出了 {2} 的预期范围 1633 1634 # 0: string (constant value), 1: symbol (constant field), 2: string (expected class) 1635 compiler.misc.bad.constant.value={1} 的常量值 ''{0}'' 错误, 预期为 {2} 1636 1637 # 0: string (classfile major version), 1: string (classfile minor version) 1638 compiler.misc.invalid.default.interface=在 {0}.{1} 版类文件中找到默认方法 1639 1640 # 0: string (classfile major version), 1: string (classfile minor version) 1641 compiler.misc.invalid.static.interface=在 {0}.{1} 版类文件中找到静态方法 1642 1643 # 0: string (classfile major version), 1: string (classfile minor version) 1644 compiler.misc.anachronistic.module.info=在 {0}.{1} 版类文件中找到模块声明 1645 1646 # 0: name 1647 compiler.misc.file.doesnt.contain.class=文件不包含类{0} 1648 1649 # 0: symbol 1650 compiler.misc.file.does.not.contain.package=文件不包含程序包{0} 1651 1652 compiler.misc.file.does.not.contain.module=文件不包含模块声明 1653 1654 compiler.misc.illegal.start.of.class.file=非法的类文件开始 1655 1656 compiler.misc.unable.to.access.file=无法访问文件: {0} 1657 1658 compiler.misc.unicode.str.not.supported=不支持类文件中的 Unicode 字符串 1659 1660 compiler.misc.undecl.type.var=未声明的类型变量: {0} 1661 1662 compiler.misc.malformed.vararg.method=类文件包含格式错误的变量元数方法: {0} 1663 1664 compiler.misc.wrong.version=类文件具有错误的版本 {0}.{1}, 应为 {2}.{3} 1665 1666 ##### 1667 1668 # 0: type, 1: type or symbol 1669 compiler.err.not.within.bounds=类型参数{0}不在类型变量{1}的范围内 1670 1671 ## The following are all possible strings for the second argument ({1}) of the 1672 ## above string. 1673 1674 ## none yet... 1675 1676 ##### 1677 1678 # 0: message segment 1679 compiler.err.prob.found.req=不兼容的类型: {0} 1680 1681 # 0: message segment 1682 compiler.misc.prob.found.req=不兼容的类型: {0} 1683 1684 # 0: message segment, 1: type, 2: type 1685 compiler.warn.prob.found.req={0}\n需要: {2}\n找到: {1} 1686 1687 # 0: type, 1: type 1688 compiler.misc.inconvertible.types={0}无法转换为{1} 1689 1690 # 0: type, 1: type 1691 compiler.misc.possible.loss.of.precision=从{0}转换到{1}可能会有损失 1692 1693 compiler.misc.unchecked.assign=未经检查的转换 1694 1695 # compiler.misc.storecheck=\ 1696 # assignment might cause later store checks to fail 1697 # compiler.misc.unchecked=\ 1698 # assigned array cannot dynamically check its stores 1699 compiler.misc.unchecked.cast.to.type=未经检查的转换 1700 1701 # compiler.err.star.expected=\ 1702 # ''*'' expected 1703 # compiler.err.no.elem.type=\ 1704 # \[\*\] cannot have a type 1705 1706 # 0: message segment 1707 compiler.misc.try.not.applicable.to.type=try-with-resources 不适用于变量类型\n({0}) 1708 1709 ##### 1710 1711 # 0: object, 1: message segment 1712 compiler.err.type.found.req=意外的类型\n需要: {1}\n找到: {0} 1713 1714 ## The following are all possible strings for the first argument ({0}) of the 1715 ## above string. 1716 compiler.misc.type.req.class=类 1717 1718 compiler.misc.type.req.class.array=类或数组 1719 1720 compiler.misc.type.req.array.or.iterable=数组或 java.lang.Iterable 1721 1722 compiler.misc.type.req.ref=引用 1723 1724 compiler.misc.type.req.exact=不带限制范围的类或接口 1725 1726 # 0: type 1727 compiler.misc.type.parameter=类型参数{0} 1728 1729 ##### 1730 1731 ## The following are all possible strings for the last argument of all those 1732 ## diagnostics whose key ends in ".1" 1733 1734 # 0: type, 1: list of type 1735 compiler.misc.no.unique.maximal.instance.exists=对于上限为{1}的类型变量{0}, 不存在唯一最大实例 1736 1737 # 0: type, 1: list of type 1738 compiler.misc.no.unique.minimal.instance.exists=对于下限为{1}的类型变量{0}, 不存在唯一最小实例 1739 1740 # 0: type, 1: list of type 1741 compiler.misc.incompatible.upper.bounds=推论变量 {0} 具有不兼容的上限 {1} 1742 1743 # 0: type, 1: list of type 1744 compiler.misc.incompatible.eq.bounds=推论变量{0}具有不兼容的等式约束条件{1} 1745 1746 # 0: type, 1: fragment, 2: fragment 1747 compiler.misc.incompatible.bounds=推论变量 {0} 具有不兼容的上限\n{1}\n{2} 1748 1749 # 0: list of type 1750 compiler.misc.lower.bounds=下限:{0} 1751 1752 # 0: list of type 1753 compiler.misc.eq.bounds=等式约束条件:{0} 1754 1755 # 0: list of type 1756 compiler.misc.upper.bounds=下限:{0} 1757 1758 # 0: list of type, 1: type, 2: type 1759 compiler.misc.infer.no.conforming.instance.exists=不存在类型变量{0}的实例, 以使{1}与{2}一致 1760 1761 # 0: list of type, 1: message segment 1762 compiler.misc.infer.no.conforming.assignment.exists=无法推断类型变量 {0}\n(参数不匹配; {1}) 1763 1764 # 0: list of type 1765 compiler.misc.infer.arg.length.mismatch=无法推断类型变量 {0}\n(实际参数列表和形式参数列表长度不同) 1766 1767 # 0: list of type, 1: message segment 1768 compiler.misc.infer.varargs.argument.mismatch=无法推断类型变量 {0}\n(varargs 不匹配; {1}) 1769 1770 # 0: type, 1: list of type 1771 compiler.misc.inferred.do.not.conform.to.upper.bounds=推断类型不符合上限\n推断: {0}\n上限: {1} 1772 1773 # 0: type, 1: list of type 1774 compiler.misc.inferred.do.not.conform.to.lower.bounds=推断类型不符合下限\n推断: {0}\n下限: {1} 1775 1776 # 0: type, 1: list of type 1777 compiler.misc.inferred.do.not.conform.to.eq.bounds=推断类型不符合等式约束条件\n推断: {0}\n等式约束条件: {1} 1778 1779 # 0: symbol 1780 compiler.misc.diamond={0}<> 1781 1782 # 0: type 1783 compiler.misc.diamond.non.generic=无法将 ''<>'' 与非泛型类{0}一起使用 1784 1785 # 0: list of type, 1: message segment 1786 compiler.misc.diamond.invalid.arg=此上下文中不允许使用为{1}推断的类型参数{0}\n推断参数在签名属性中无法表达 1787 1788 # 0: list of type, 1: message segment 1789 compiler.misc.diamond.invalid.args=此上下文中不允许使用为{1}推断的类型参数{0}\n推断参数在签名属性中无法表达 1790 1791 # 0: type 1792 compiler.misc.diamond.and.explicit.params=不能将 ''<>'' 与构造器的显式类型参数一起使用 1793 1794 compiler.misc.mref.infer.and.explicit.params=不能将原始构造器引用与构造器的显式类型参数一起使用 1795 1796 # 0: type, 1: list of type 1797 compiler.misc.explicit.param.do.not.conform.to.bounds=显式类型参数{0}不符合声明的范围{1} 1798 1799 compiler.misc.arg.length.mismatch=实际参数列表和形式参数列表长度不同 1800 1801 # 0: string 1802 compiler.misc.wrong.number.type.args=类型变量数目错误; 需要{0} 1803 1804 # 0: message segment 1805 compiler.misc.no.conforming.assignment.exists=参数不匹配; {0} 1806 1807 # 0: message segment 1808 compiler.misc.varargs.argument.mismatch=varargs 不匹配; {0} 1809 1810 ##### 1811 1812 # 0: symbol or type, 1: file name 1813 compiler.warn.auxiliary.class.accessed.from.outside.of.its.source.file={1} 中的辅助类{0}不应从其自身的源文件以外访问 1814 1815 ## The first argument ({0}) is a "kindname". 1816 # 0: kind name, 1: symbol, 2: symbol 1817 compiler.err.abstract.cant.be.accessed.directly=无法直接访问{2}中的抽象{0} {1} 1818 1819 ## The first argument ({0}) is a "kindname". 1820 # 0: symbol kind, 1: symbol 1821 compiler.err.non-static.cant.be.ref=无法从静态上下文中引用非静态 {0} {1} 1822 1823 # 0: symbol kind, 1: symbol 1824 compiler.misc.bad.static.method.in.unbound.lookup=在未绑定查找中找到意外的静态 {0} {1} 1825 1826 # 0: symbol kind, 1: symbol 1827 compiler.misc.bad.instance.method.in.unbound.lookup=在未绑定查找中找到意外的实例 {0} {1} 1828 1829 # 0: symbol kind, 1: symbol 1830 compiler.misc.bad.static.method.in.bound.lookup=在绑定查找中找到意外的静态 {0} {1} 1831 1832 ## Both arguments ({0}, {1}) are "kindname"s. {0} is a comma-separated list 1833 ## of kindnames (the list should be identical to that provided in source. 1834 # 0: set of kind name, 1: set of kind name 1835 compiler.err.unexpected.type=意外的类型\n需要: {0}\n找到: {1} 1836 1837 compiler.err.unexpected.lambda=此处不应为 lambda 表达式 1838 1839 compiler.err.unexpected.mref=此处不应为方法引用 1840 1841 ## The first argument {0} is a "kindname" (e.g. 'constructor', 'field', etc.) 1842 ## The second argument {1} is the non-resolved symbol 1843 ## The third argument {2} is a list of type parameters (non-empty if {1} is a method) 1844 ## The fourth argument {3} is a list of argument types (non-empty if {1} is a method) 1845 # 0: kind name, 1: name, 2: unused, 3: unused 1846 compiler.err.cant.resolve=找不到符号\n符号: {0} {1} 1847 1848 # 0: kind name, 1: name, 2: unused, 3: list of type 1849 compiler.err.cant.resolve.args=找不到符号\n符号: {0} {1}({3}) 1850 1851 # 0: kind name, 1: name, 2: unused, 3: list of type 1852 compiler.misc.cant.resolve.args=找不到符号\n符号: {0} {1}({3}) 1853 1854 # 0: kind name, 1: name, 2: list of type, 3: list of type 1855 compiler.err.cant.resolve.args.params=找不到符号\n符号: {0} <{2}>{1}({3}) 1856 1857 ## arguments from {0} to {3} have the same meaning as above 1858 ## The fifth argument {4} is a location subdiagnostic (see below) 1859 # 0: kind name, 1: name, 2: unused, 3: unused, 4: message segment 1860 compiler.err.cant.resolve.location=找不到符号\n符号: {0} {1}\n位置: {4} 1861 1862 # 0: kind name, 1: name, 2: unused, 3: list of type, 4: message segment 1863 compiler.err.cant.resolve.location.args=找不到符号\n符号: {0} {1}({3})\n位置: {4} 1864 1865 # 0: kind name, 1: name, 2: list of type, 3: list, 4: message segment 1866 compiler.err.cant.resolve.location.args.params=找不到符号\n符号: {0} <{2}>{1}({3})\n位置: {4} 1867 1868 ### Following are replicated/used for method reference diagnostics 1869 1870 # 0: kind name, 1: name, 2: unused, 3: list of type, 4: message segment 1871 compiler.misc.cant.resolve.location.args=找不到符号\n符号: {0} {1}({3})\n位置: {4} 1872 1873 # 0: kind name, 1: name, 2: list of type, 3: list, 4: message segment 1874 compiler.misc.cant.resolve.location.args.params=找不到符号\n符号: {0} <{2}>{1}({3})\n位置: {4} 1875 1876 ##a location subdiagnostic is composed as follows: 1877 ## The first argument {0} is the location "kindname" (e.g. 'constructor', 'field', etc.) 1878 ## The second argument {1} is the location name 1879 ## The third argument {2} is the location type (only when {1} is a variable name) 1880 1881 # 0: kind name, 1: type or symbol, 2: unused 1882 compiler.misc.location={0} {1} 1883 1884 # 0: kind name, 1: symbol, 2: type 1885 compiler.misc.location.1=类型为{2}的{0} {1} 1886 1887 ## The following are all possible string for "kindname". 1888 ## They should be called whatever the JLS calls them after it been translated 1889 ## to the appropriate language. 1890 # compiler.misc.kindname.constructor=\ 1891 # static member 1892 compiler.misc.kindname.annotation=@interface 1893 1894 compiler.misc.kindname.constructor=构造器 1895 1896 compiler.misc.kindname.enum=枚举 1897 1898 compiler.misc.kindname.interface=接口 1899 1900 compiler.misc.kindname.static=静态 1901 1902 compiler.misc.kindname.type.variable=类型变量 1903 1904 compiler.misc.kindname.type.variable.bound=类型变量的限制范围 1905 1906 compiler.misc.kindname.variable=变量 1907 1908 compiler.misc.kindname.value=值 1909 1910 compiler.misc.kindname.method=方法 1911 1912 compiler.misc.kindname.class=类 1913 1914 compiler.misc.kindname.package=程序包 1915 1916 compiler.misc.kindname.module=模块 1917 1918 compiler.misc.kindname.static.init=静态初始化程序 1919 1920 compiler.misc.kindname.instance.init=实例初始化程序 1921 1922 ##### 1923 1924 compiler.misc.no.args=没有参数 1925 1926 # 0: message segment 1927 compiler.err.override.static={0}\n覆盖的方法为 static 1928 1929 # 0: message segment, 1: set of flag 1930 compiler.err.override.meth={0}\n被覆盖的方法为{1} 1931 1932 # 0: message segment, 1: type 1933 compiler.err.override.meth.doesnt.throw={0}\n被覆盖的方法未抛出{1} 1934 1935 # In the following string {1} is a space separated list of Java Keywords, as 1936 # they would have been declared in the source code 1937 # 0: message segment, 1: set of flag or string 1938 compiler.err.override.weaker.access={0}\n正在尝试分配更低的访问权限; 以前为{1} 1939 1940 # 0: message segment, 1: type, 2: type 1941 compiler.err.override.incompatible.ret={0}\n返回类型{1}与{2}不兼容 1942 1943 # 0: message segment, 1: type, 2: type 1944 compiler.warn.override.unchecked.ret={0}\n返回类型需要从{1}到{2}的未经检查的转换 1945 1946 # 0: message segment, 1: type 1947 compiler.warn.override.unchecked.thrown={0}\n被覆盖的方法未抛出{1} 1948 1949 # 0: symbol 1950 compiler.warn.override.equals.but.not.hashcode=类{0}覆盖了 equals, 但该类或任何超类都未覆盖 hashCode 方法 1951 1952 ## The following are all possible strings for the first argument ({0}) of the 1953 ## above strings. 1954 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 1955 compiler.misc.cant.override={1}中的{0}无法覆盖{3}中的{2} 1956 1957 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 1958 compiler.misc.cant.hide={1} 中的 {0} 无法隐藏 {3} 中的 {2} 1959 1960 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 1961 compiler.misc.cant.implement={1}中的{0}无法实现{3}中的{2} 1962 1963 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 1964 compiler.misc.clashes.with={1}中的{0}与{3}中的{2}冲突 1965 1966 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 1967 compiler.misc.unchecked.override={1}中的{0}覆盖了{3}中的{2} 1968 1969 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 1970 compiler.misc.unchecked.implement={1}中的{0}实现了{3}中的{2} 1971 1972 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 1973 compiler.misc.unchecked.clash.with={1}中的{0}覆盖了{3}中的{2} 1974 1975 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 1976 compiler.misc.varargs.override={1}中的{0}覆盖了{3}中的{2} 1977 1978 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 1979 compiler.misc.varargs.implement={1}中的{0}实现了{3}中的{2} 1980 1981 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 1982 compiler.misc.varargs.clash.with={1}中的{0}覆盖了{3}中的{2} 1983 1984 # 0: kind name, 1: symbol, 2: symbol, 3: message segment 1985 compiler.misc.inapplicable.method={0} {1}.{2}不适用\n({3}) 1986 1987 ######################################## 1988 # Diagnostics for language feature changes. 1989 # Such diagnostics have a common template which can be customized by using a feature 1990 # diagnostic fragment (one of those given below). 1991 ######################################## 1992 1993 # 0: message segment (feature), 1: string (found version), 2: string (expected version) 1994 compiler.err.feature.not.supported.in.source=-source {1} 中不支持 {0}\n(请使用 -source {2} 或更高版本以启用 {0}) 1995 1996 # 0: message segment (feature), 1: string (found version), 2: string (expected version) 1997 compiler.err.feature.not.supported.in.source.plural=-source {1} 中不支持 {0}\n(请使用 -source {2} 或更高版本以启用 {0}) 1998 1999 # 0: message segment (feature), 1: string (found version), 2: string (expected version) 2000 compiler.misc.feature.not.supported.in.source=-source {1} 中不支持 {0}\n(请使用 -source {2} 或更高版本以启用 {0}) 2001 2002 # 0: message segment (feature), 1: string (found version), 2: string (expected version) 2003 compiler.misc.feature.not.supported.in.source.plural=-source {1} 中不支持 {0}\n(请使用 -source {2} 或更高版本以启用 {0}) 2004 2005 # 0: message segment (feature) 2006 compiler.err.preview.feature.disabled={0} 是预览功能,默认情况下禁用。\n(请使用 --enable-preview 以启用 {0}) 2007 2008 # 0: message segment (feature) 2009 compiler.err.preview.feature.disabled.plural={0} 是预览功能,默认情况下禁用。\n(请使用 --enable-preview 以启用 {0}) 2010 2011 # 0: file object (classfile), 1: string (expected version) 2012 compiler.err.preview.feature.disabled.classfile={0} 的类文件使用 Java SE {1} 的预览功能。\n(请使用 --enable-preview 以允许加载包含预览功能的类文件) 2013 2014 # 0: message segment (feature) 2015 compiler.warn.preview.feature.use={0} 是预览功能,可能会在未来发行版中删除。 2016 2017 # 0: message segment (feature) 2018 compiler.warn.preview.feature.use.plural={0} 是预览功能,可能会在未来发行版中删除。 2019 2020 # 0: file object (classfile), 1: string (expected version) 2021 compiler.warn.preview.feature.use.classfile={0} 的类文件使用 Java SE {1} 的预览功能。 2022 2023 2024 compiler.misc.feature.modules=模块 2025 2026 compiler.misc.feature.diamond.and.anon.class=''<>'' 具有匿名的内部类 2027 2028 compiler.misc.feature.var.in.try.with.resources=try-with-resources 中的变量 2029 2030 compiler.misc.feature.type.annotations=类型注释 2031 2032 compiler.misc.feature.annotations.after.type.params=在方法类型参数之后的注释 2033 2034 compiler.misc.feature.repeatable.annotations=重复的注释 2035 2036 compiler.misc.feature.diamond=diamond 运算符 2037 2038 compiler.misc.feature.lambda=lambda 表达式 2039 2040 compiler.misc.feature.method.references=方法引用 2041 2042 compiler.misc.feature.default.methods=默认方法 2043 2044 compiler.misc.feature.intersection.types.in.cast=交叉类型 2045 2046 compiler.misc.feature.static.intf.methods=静态接口方法 2047 2048 compiler.misc.feature.static.intf.method.invoke=静态接口方法调用 2049 2050 compiler.misc.feature.private.intf.methods=私有接口方法 2051 2052 compiler.misc.feature.text.blocks=文本块 2053 2054 compiler.misc.feature.multiple.case.labels=多个 case 标签 2055 2056 compiler.misc.feature.switch.rules=switch 规则 2057 2058 compiler.misc.feature.switch.expressions=switch 表达式 2059 2060 compiler.misc.feature.var.syntax.in.implicit.lambda=隐式 lambda 中的 var 语法 2061 2062 compiler.warn.underscore.as.identifier=从发行版 9 开始, ''_'' 为关键字, 不能用作标识符 2063 2064 compiler.err.underscore.as.identifier=从发行版 9 开始, ''_'' 为关键字, 不能用作标识符 2065 2066 compiler.err.underscore.as.identifier.in.lambda=''_'' 用作标识符\n(对于 lambda 参数, 禁止将 ''_'' 用作标识符) 2067 2068 compiler.err.enum.as.identifier=从发行版 5 开始, ''enum'' 为关键字, 不能用作标识符 2069 2070 compiler.err.assert.as.identifier=从发行版 1.4 开始, ''assert'' 为关键字, 不能用作标识符 2071 2072 # TODO 308: make a better error message 2073 compiler.err.this.as.identifier=从发行版 8 开始,''this'' 只能作为接收方类型的参数名,\n该参数必须为第一个参数,并且不能是 lambda 参数 2074 2075 compiler.err.receiver.parameter.not.applicable.constructor.toplevel.class=接收方参数不适用于顶层类的构造器 2076 2077 # TODO 308: make a better error message 2078 # 0: annotation 2079 compiler.err.cant.type.annotate.scoping.1=无法使用 type-use 注释 {0} 来注释确定作用域结构 2080 2081 # TODO 308: make a better error message 2082 # 0: list of annotation 2083 compiler.err.cant.type.annotate.scoping=无法使用 type-use 注释 {0} 来注释确定作用域结构 2084 2085 # 0: type, 1: type 2086 compiler.err.incorrect.receiver.name=接收方名称与封闭类类型不匹配\n需要: {0}\n找到: {1} 2087 2088 # 0: type, 1: type 2089 compiler.err.incorrect.receiver.type=接收方类型与封闭类类型不匹配\n需要: {0}\n找到: {1} 2090 2091 # 0: type, 1: type 2092 compiler.err.incorrect.constructor.receiver.type=接收方类型与外部封闭类类型不匹配\n需要: {0}\n找到: {1} 2093 2094 # 0: type, 1: type 2095 compiler.err.incorrect.constructor.receiver.name=接收方名称与外部封闭类类型不匹配\n需要: {0}\n找到: {1} 2096 2097 compiler.err.no.annotations.on.dot.class=类文字类型中不允许使用任何注释 2098 2099 ######################################## 2100 # Diagnostics for verbose resolution 2101 # used by Resolve (debug only) 2102 ######################################## 2103 2104 # 0: number, 1: symbol, 2: unused 2105 compiler.misc.applicable.method.found=找到第 {0} 个适用方法: {1} 2106 2107 # 0: number, 1: symbol, 2: message segment 2108 compiler.misc.applicable.method.found.1=找到第 {0} 个适用方法: {1}\n({2}) 2109 2110 # 0: number, 1: symbol, 2: message segment 2111 compiler.misc.not.applicable.method.found=找到第 {0} 个不适用的方法: {1}\n({2}) 2112 2113 # 0: type 2114 compiler.misc.partial.inst.sig=部分实例化为: {0} 2115 2116 # 0: name, 1: symbol, 2: number, 3: string (method resolution phase), 4: list of type or message segment, 5: list of type or message segment 2117 compiler.note.verbose.resolve.multi=将类型 {1} 的方法 {0} 解析为候选项 {2}\n阶段: {3}\n具有实际值: {4}\n具有类型参数: {5}\n候选项: 2118 2119 # 0: name, 1: symbol, 2: unused, 3: string (method resolution phase), 4: list of type or message segment, 5: list of type or message segment 2120 compiler.note.verbose.resolve.multi.1=类型 {1} 的方法 {0} 解析错误\n阶段: {3}\n具有实际值: {4}\n具有类型参数: {5}\n候选项: 2121 2122 # 0: symbol, 1: type, 2: type 2123 compiler.note.deferred.method.inst=方法 {0} 的延迟实例化\n实例化签名: {1}\n目标类型: {2} 2124 2125 ######################################## 2126 # Diagnostics for lambda deduplication 2127 # used by LambdaToMethod (debug only) 2128 ######################################## 2129 2130 # 0: symbol 2131 compiler.note.verbose.l2m.deduplicate=正在对 lambda 函数实现方法 {0} 进行重复数据删除 2132 2133 ######################################## 2134 # Diagnostics for where clause implementation 2135 # used by the RichDiagnosticFormatter. 2136 ######################################## 2137 2138 compiler.misc.type.null=<空值> 2139 2140 # X#n (where n is an int id) is disambiguated tvar name 2141 # 0: name, 1: number 2142 compiler.misc.type.var={0}#{1} 2143 2144 # CAP#n (where n is an int id) is an abbreviation for 'captured type' 2145 # 0: number 2146 compiler.misc.captured.type=CAP#{0} 2147 2148 # <INT#n> (where n is an int id) is an abbreviation for 'intersection type' 2149 # 0: number 2150 compiler.misc.intersection.type=INT#{0} 2151 2152 # where clause for captured type: contains upper ('extends {1}') and lower 2153 # ('super {2}') bound along with the wildcard that generated this captured type ({3}) 2154 # 0: type, 1: type, 2: type, 3: type 2155 compiler.misc.where.captured={0}从{3}的捕获扩展{1} 超 {2} 2156 2157 # compact where clause for captured type: contains upper ('extends {1}') along 2158 # with the wildcard that generated this captured type ({3}) 2159 # 0: type, 1: type, 2: unused, 3: type 2160 compiler.misc.where.captured.1={0}从{3}的捕获扩展{1} 2161 2162 # where clause for type variable: contains upper bound(s) ('extends {1}') along with 2163 # the kindname ({2}) and location ({3}) in which the typevar has been declared 2164 # 0: type, 1: list of type, 2: symbol kind, 3: symbol 2165 compiler.misc.where.typevar={0}扩展已在{2} {3}中声明的{1} 2166 2167 # compact where clause for type variable: contains the kindname ({2}) and location ({3}) 2168 # in which the typevar has been declared 2169 # 0: type, 1: list of type, 2: symbol kind, 3: symbol 2170 compiler.misc.where.typevar.1={0}已在{2} {3}中声明 2171 2172 # where clause for fresh type variable: contains upper bound(s) ('extends {1}'). 2173 # Since a fresh type-variable is synthetic - there's no location/kindname here. 2174 # 0: type, 1: list of type 2175 compiler.misc.where.fresh.typevar={0}扩展{1} 2176 2177 # where clause for type variable: contains all the upper bound(s) ('extends {1}') 2178 # of this intersection type 2179 # 0: type, 1: list of type 2180 compiler.misc.where.intersection={0}扩展{1} 2181 2182 ### Where clause headers ### 2183 compiler.misc.where.description.captured=其中, {0}是新类型变量: 2184 2185 # 0: set of type 2186 compiler.misc.where.description.typevar=其中, {0}是类型变量: 2187 2188 # 0: set of type 2189 compiler.misc.where.description.intersection=其中, {0}是交叉类型: 2190 2191 # 0: set of type 2192 compiler.misc.where.description.captured.1=其中, {0}是新类型变量: 2193 2194 # 0: set of type 2195 compiler.misc.where.description.typevar.1=其中, {0}是类型变量: 2196 2197 # 0: set of type 2198 compiler.misc.where.description.intersection.1=其中, {0}是交叉类型: 2199 2200 ### 2201 # errors related to doc comments 2202 2203 compiler.err.dc.bad.entity=HTML 实体错误 2204 2205 compiler.err.dc.bad.gt=''>'' 的用法错误 2206 2207 compiler.err.dc.bad.inline.tag=内嵌标记的用法不正确 2208 2209 compiler.err.dc.identifier.expected=需要标识符 2210 2211 compiler.err.dc.malformed.html=格式错误的 HTML 2212 2213 compiler.err.dc.missing.semicolon=缺少分号 2214 2215 compiler.err.dc.no.content=无内容 2216 2217 compiler.err.dc.no.tag.name='@' 后没有标记名 2218 2219 compiler.err.dc.gt.expected=需要 ''>'' 2220 2221 compiler.err.dc.ref.bad.parens=引用中缺少 '')'' 2222 2223 compiler.err.dc.ref.syntax.error=引用中出现语法错误 2224 2225 compiler.err.dc.ref.unexpected.input=意外的文本 2226 2227 compiler.err.dc.unexpected.content=意外的内容 2228 2229 compiler.err.dc.unterminated.inline.tag=未终止的内嵌标记 2230 2231 compiler.err.dc.unterminated.signature=未终止的签名 2232 2233 compiler.err.dc.unterminated.string=未终止的字符串 2234 2235 ### 2236 # errors related to modules 2237 2238 compiler.err.expected.module=预期 ''module'' 2239 2240 # 0: symbol 2241 compiler.err.module.not.found=找不到模块: {0} 2242 2243 # 0: symbol 2244 compiler.warn.module.not.found=找不到模块: {0} 2245 2246 compiler.err.too.many.modules=找到太多的模块声明 2247 2248 compiler.err.module.not.found.on.module.source.path=在模块源路径中找不到模块 2249 2250 compiler.err.not.in.module.on.module.source.path=不在模块源路径上的模块中 2251 2252 # 0: symbol 2253 compiler.err.duplicate.module=重复的模块: {0} 2254 2255 # 0: symbol 2256 compiler.err.duplicate.requires=重复的 requires 指令: {0} 2257 2258 # 0: symbol 2259 compiler.err.conflicting.exports=重复或冲突的导出操作: {0} 2260 2261 # 0: symbol 2262 compiler.err.conflicting.opens=重复或冲突的打开操作: {0} 2263 2264 # 0: symbol 2265 compiler.err.conflicting.exports.to.module=重复或冲突的导出到模块操作: {0} 2266 2267 # 0: symbol 2268 compiler.err.conflicting.opens.to.module=重复或冲突的打开到模块操作: {0} 2269 2270 compiler.err.no.opens.unless.strong=只允许在强模块中使用 ''opens'' 2271 2272 # 0: symbol 2273 compiler.err.repeated.provides.for.service=服务 {0} 有多个 ''provides'' 2274 2275 # 0: symbol, 1: symbol 2276 compiler.err.duplicate.provides=重复的 provides 指令: 服务 {0}, 实现 {1} 2277 2278 # 0: symbol 2279 compiler.err.duplicate.uses=重复的 uses 指令: {0} 2280 2281 # 0: symbol 2282 compiler.err.service.implementation.is.abstract=服务实现是抽象类: {0} 2283 2284 compiler.err.service.implementation.must.be.subtype.of.service.interface=服务实现类型必须是服务接口类型的子类型, 或者具有名为 "provider" 的, 返回服务实现的公共静态无参数方法 2285 2286 compiler.err.service.implementation.provider.return.must.be.subtype.of.service.interface="provider" 方法返回类型必须是服务接口类型的子类型 2287 2288 # 0: symbol 2289 compiler.err.service.implementation.is.inner=服务实现是内部类: {0} 2290 2291 # 0: symbol 2292 compiler.err.service.definition.is.enum=服务定义是枚举: {0} 2293 2294 # 0: symbol 2295 compiler.err.service.implementation.doesnt.have.a.no.args.constructor=服务实现没有默认的构造器: {0} 2296 2297 # 0: symbol 2298 compiler.err.service.implementation.no.args.constructor.not.public=服务实现的无参数构造器不是公共构造器: {0} 2299 2300 # 0: symbol 2301 compiler.err.package.empty.or.not.found=程序包为空或不存在: {0} 2302 2303 # 0: symbol 2304 compiler.warn.package.empty.or.not.found=程序包为空或不存在: {0} 2305 2306 compiler.err.no.output.dir=未指定类输出目录 2307 2308 compiler.err.unnamed.pkg.not.allowed.named.modules=命名模块中不允许未命名程序包 2309 2310 # 0: name, 1: name 2311 compiler.err.module.name.mismatch=模块名称 {0} 与预期名称 {1} 不匹配 2312 2313 # 0: name, 1: name 2314 compiler.misc.module.name.mismatch=模块名称 {0} 与预期名称 {1} 不匹配 2315 2316 # 0: name 2317 compiler.err.module.non.zero.opens=打开的模块 {0} 具有非零 opens_count 2318 2319 # 0: name 2320 compiler.misc.module.non.zero.opens=打开的模块 {0} 具有非零 opens_count 2321 2322 compiler.err.module.decl.sb.in.module-info.java=模块声明应该在名为 module-info.java 的文件中 2323 2324 # 0: set of string 2325 compiler.err.too.many.patched.modules=太多打补丁的模块 ({0}), 请使用 --module-source-path 2326 2327 # 0: name, 1: name 2328 compiler.err.file.patched.and.msp=可从 --patch-module 和 --module-source-path 访问文件, 但该文件在每个路径中属于不同的模块: {0}, {1} 2329 2330 compiler.err.processorpath.no.processormodulepath=-processorpath 与 --processor-module-path 的组合非法 2331 2332 # 0: symbol 2333 compiler.err.package.in.other.module=程序包已存在于另一个模块中: {0} 2334 2335 # 0: symbol, 1: name, 2: symbol, 3: symbol 2336 compiler.err.package.clash.from.requires=模块 {0} 同时从 {2} 和 {3} 读取程序包 {1} 2337 2338 # 0: name, 1: symbol, 2: symbol 2339 compiler.err.package.clash.from.requires.in.unnamed=未命名的模块同时从 {1} 和 {2} 读取程序包 {0} 2340 2341 # 0: string 2342 compiler.err.module.not.found.in.module.source.path=在模块源路径中找不到模块 {0} 2343 2344 compiler.err.output.dir.must.be.specified.with.dash.m.option=如果使用 -m 选项, 则必须指定类输出目录 2345 2346 compiler.err.modulesourcepath.must.be.specified.with.dash.m.option=如果使用 -m 选项, 则必须指定模块源路径 2347 2348 # 0: symbol 2349 compiler.err.service.implementation.not.in.right.module=必须在与 provides 指令相同的模块中定义服务实现 2350 2351 # 0: symbol 2352 compiler.err.cyclic.requires=涉及 {0} 的循环被依赖对象 2353 2354 # 0: fragment, 1: name 2355 compiler.err.duplicate.module.on.path={1} 中的 {0} 上存在\n重复的模块 2356 2357 # 0: option name, 1: string 2358 compiler.warn.bad.name.for.option={0} 选项的值中有错误的名称: ''{1}'' 2359 2360 # 0: option name, 1: string 2361 compiler.err.bad.name.for.option={0} 选项的值中有错误的名称: ''{1}'' 2362 2363 # 0: option name, 1: symbol 2364 compiler.warn.module.for.option.not.found=找不到 {0} 选项中的模块名称: {1} 2365 2366 compiler.err.addmods.all.module.path.invalid=--add-modules ALL-MODULE-PATH 只能在编译未命名模块或在自动模块的上下文中编译时使用 2367 2368 # 0: symbol 2369 compiler.err.add.exports.with.release=不允许在使用 --release 时从系统模块 {0} 导出程序包: 2370 2371 # 0: symbol 2372 compiler.err.add.reads.with.release=不允许在使用 --release 时为系统模块 {0} 添加读取维边: 2373 2374 compiler.warn.addopens.ignored=--add-opens 在编译时没有任何效果 2375 2376 compiler.misc.locn.module_source_path=模块源路径 2377 2378 compiler.misc.locn.upgrade_module_path=升级模块路径 2379 2380 compiler.misc.locn.system_modules=系统模块 2381 2382 compiler.misc.locn.module_path=应用程序模块路径 2383 2384 compiler.misc.cant.resolve.modules=无法解析模块 2385 2386 compiler.misc.bad.requires.flag=错误的请求标记:{0} 2387 2388 # 0: string 2389 compiler.err.invalid.module.specifier=不允许模块说明符: {0} 2390 2391 # 0: symbol 2392 compiler.warn.service.provided.but.not.exported.or.used=已提供服务接口, 但未导出或使用服务接口 2393 2394 # 0: kind name, 1: symbol, 2: symbol 2395 compiler.warn.leaks.not.accessible=模块 {2} 中的 {0} {1} 对需要该模块的客户机不可访问 2396 # 0: kind name, 1: symbol, 2: symbol 2397 compiler.warn.leaks.not.accessible.unexported=未导出模块 {2} 中的 {0} {1} 2398 # 0: kind name, 1: symbol, 2: symbol 2399 compiler.warn.leaks.not.accessible.not.required.transitive=未使用 ''requires transitive'' 间接导出模块 {2} 中的 {0} {1} 2400 # 0: kind name, 1: symbol, 2: symbol 2401 compiler.warn.leaks.not.accessible.unexported.qualified=模块 {2} 中的 {0} {1} 可能对需要该模块的所有客户机都不可见 2402 2403 ### 2404 # errors related to options 2405 2406 # 0: string, 1: string 2407 compiler.err.illegal.argument.for.option={0} 的参数非法: {1} 2408 2409 compiler.err.switch.null.not.allowed=case 中不允许使用空标签 2410 2411 compiler.err.switch.case.unexpected.statement=case 中存在意外语句,应为表达式、块或抛出语句 2412 2413 compiler.err.switch.mixing.case.types=在 switch 中使用了不同 case 类型 2414 2415 ############################################ 2416 # messages previouly at javac.properties 2417 2418 compiler.err.empty.A.argument=-A 需要一个参数; 使用 ''-Akey'' 或 ''-Akey=value'' 2419 2420 # 0: string 2421 compiler.err.invalid.A.key=注释处理程序选项 ''{0}'' 中的关键字不是以点分隔的标识符序列 2422 2423 # 0: string 2424 compiler.err.invalid.flag=无效的标记: {0} 2425 2426 compiler.err.profile.bootclasspath.conflict=概要信息和引导类路径选项不能同时使用 2427 2428 # 0: string 2429 compiler.err.invalid.profile=无效的配置文件:{0} 2430 2431 # 0: string 2432 compiler.err.invalid.target=无效的目标发行版:{0} 2433 2434 # 0: option name, 1: target 2435 compiler.err.option.not.allowed.with.target=目标 {1} 不允许选项 {0} 2436 2437 # 0: string 2438 compiler.err.option.too.many=选项 {0} 只能指定一次 2439 2440 compiler.err.no.source.files=无源文件 2441 2442 compiler.err.no.source.files.classes=无源文件或类名 2443 2444 # 0: string 2445 compiler.err.req.arg={0} 需要参数 2446 2447 # 0: string 2448 compiler.err.invalid.source=无效的源发行版:{0} 2449 2450 # 0: string, 1: string 2451 compiler.err.error.writing.file=写入 {0} 时出错;{1} 2452 2453 compiler.err.sourcepath.modulesourcepath.conflict=无法同时指定 --source-path 与 --module-source-path 2454 2455 # 0: string, 1: target 2456 compiler.warn.source.target.conflict=源发行版 {0} 需要目标发行版 {1} 2457 2458 # 0: string, 1: target 2459 compiler.warn.target.default.source.conflict=目标发行版 {0} 与默认的源发行版 {1} 冲突 2460 2461 # 0: profile, 1: target 2462 compiler.warn.profile.target.conflict=配置文件{0}对于目标发行版 {1} 无效 2463 2464 # 0: string 2465 compiler.err.file.not.directory=不是目录:{0} 2466 2467 # 0: object 2468 compiler.err.file.not.file=不是文件:{0} 2469 2470 compiler.err.two.class.loaders.1=javac 在多个类加载器之间拆分: 请检查配置 2471 2472 # 0: url, 1: url 2473 compiler.err.two.class.loaders.2=javac 在多个类加载器之间拆分:\n一个类来自文件: {0}\n而 javac 来自 {1} 2474 2475 # 0: string, 1: string 2476 compiler.err.bad.value.for.option={0} 选项的值错误: ''{1}'' 2477 2478 # 0: string 2479 compiler.err.no.value.for.option={0} 选项没有值 2480 2481 # 0: string 2482 compiler.err.repeated.value.for.patch.module=为模块 {0} 多次指定了 --patch-module 2483 2484 # 0: string 2485 compiler.err.repeated.value.for.module.source.path=为模块 {0} 多次指定了 --module-source-path 2486 2487 compiler.err.multiple.values.for.module.source.path=使用模式参数多次指定了 --module-source-path 2488 2489 # 0: string 2490 compiler.err.unmatched.quote=环境变量 {0} 中的引号不成对 2491 2492 # 0: option name 2493 compiler.err.release.bootclasspath.conflict=选项 {0} 不能与 --release 一起使用 2494 2495 # 0: string 2496 compiler.err.unsupported.release.version=不支持发行版本 {0} 2497 2498 # 0: string 2499 compiler.err.file.not.found=找不到文件: {0} 2500 2501 # 0: string, 1: source 2502 compiler.err.preview.not.latest=源发行版 {0} 与 --enable-preview 一起使用时无效\n(仅发行版 {1} 支持预览语言功能) 2503 2504 compiler.err.preview.without.source.or.release=--enable-preview 必须与 -source 或 --release 一起使用