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