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 # source version    a source version number, such as 1.5, 1.6, 1.7



  43 # string            a general string
  44 # symbol            the name of a declared type
  45 # symbol kind       the kind of a symbol (i.e. method, variable)
  46 # kind name         an informative description of the kind of a declaration; see compiler.misc.kindname.*

  47 # token             the name of a non-terminal in source code; see compiler.misc.token.*
  48 # type              a Java type; e.g. int, X, X<T>

  49 # object            a Java object (unspecified)
  50 # unused            the value is not used in this message
  51 #
  52 # The following compound types are also used:
  53 #
  54 # collection of X   a comma-separated collection of items; e.g. collection of type
  55 # list of X         a comma-separated list of items; e.g. list of type
  56 # set of X          a comma-separated set of items; e.g. set of modifier
  57 #
  58 # These may be composed:
  59 #
  60 # list of type or message segment
  61 #
  62 # The following type aliases are supported:
  63 #
  64 # message segment --> diagnostic or fragment
  65 # file name --> file, path or file object
  66 #
  67 # Custom comments are supported in parenthesis i.e.
  68 #

 195 compiler.misc.incompatible.descs.in.functional.intf=在 {0} {1} 中找到不兼容的函数描述符
 196 
 197 # 0: name, 1: list of type, 2: type, 3: list of type
 198 compiler.misc.descriptor=描述符: {2} {0}({1})
 199 
 200 # 0: name, 1: list of type, 2: type, 3: list of type
 201 compiler.misc.descriptor.throws=描述符: {2} {0}({1}) 抛出{3}
 202 
 203 # 0: type
 204 compiler.misc.no.suitable.functional.intf.inst=无法推断{0}的函数接口描述符
 205 
 206 # 0: message segment
 207 compiler.misc.bad.intersection.target.for.functional.expr=lambda 或方法引用的交叉类型目标错误\n{0}
 208 
 209 # 0: symbol or type
 210 compiler.misc.not.an.intf.component=组件类型{0}不是接口
 211 
 212 # 0: kind name, 1: message segment
 213 compiler.err.invalid.mref={0}引用无效\n{1}
 214 
 215 # 0: symbol kind, 1: message segment
 216 compiler.misc.invalid.mref={0}引用无效\n{1}
 217 
 218 compiler.misc.static.mref.with.targs=有关静态方法引用的参数化限定符
 219 
 220 # 0: symbol
 221 compiler.err.cant.assign.val.to.final.var=无法为最终变量{0}分配值
 222 
 223 compiler.err.cant.assign.val.to.this=无法分配给 ''this''
 224 
 225 # 0: symbol, 1: message segment
 226 compiler.err.cant.ref.non.effectively.final.var=从{1}引用的本地变量必须是最终变量或实际上的最终变量
 227 
 228 compiler.err.try.with.resources.expr.needs.var=try-with-resources 资源必须是变量声明, 或者是指示对最终变量或实际上的最终变量的引用的表达式
 229 
 230 # 0: symbol
 231 compiler.err.try.with.resources.expr.effectively.final.var=用作 try-with-resources 资源的变量 {0} 既不是最终变量, 也不是实际上的最终变量
 232 
 233 
 234 compiler.misc.lambda=lambda 表达式
 235 

 443 compiler.err.illegal.start.of.expr=非法的表达式开始
 444 
 445 compiler.err.illegal.start.of.stmt=非法的语句开始
 446 
 447 compiler.err.illegal.start.of.type=非法的类型开始
 448 
 449 compiler.err.illegal.parenthesized.expression=非法的含括号表达式
 450 
 451 compiler.err.illegal.unicode.esc=非法的 Unicode 转义
 452 
 453 # 0: symbol
 454 compiler.err.import.requires.canonical=导入需要{0}的规范名称
 455 
 456 compiler.err.improperly.formed.type.param.missing=类型的格式不正确, 缺少某些参数
 457 
 458 compiler.err.improperly.formed.type.inner.raw.param=类型的格式不正确, 给出了原始类型的类型参数
 459 
 460 # 0: type, 1: type
 461 compiler.err.incomparable.types=不可比较的类型: {0}和{1}
 462 
 463 # 0: number
 464 compiler.err.int.number.too.large=过大的整数: {0}
 465 
 466 compiler.err.intf.annotation.members.cant.have.params=注释类型声明中的元素无法声明形参
 467 
 468 # 0: symbol
 469 compiler.err.intf.annotation.cant.have.type.params=注释类型 {0} 不能为泛型
 470 
 471 compiler.err.intf.annotation.members.cant.have.type.params=注释类型声明中的元素不能为泛型方法
 472 
 473 # 0: symbol, 1: type
 474 compiler.err.intf.annotation.member.clash=注释类型{1}声明与方法 {0} 同名的元素
 475 
 476 compiler.err.intf.expected.here=此处需要接口
 477 
 478 compiler.err.intf.meth.cant.have.body=接口抽象方法不能带有主体
 479 
 480 compiler.err.invalid.annotation.member.type=注释类型元素的类型无效
 481 
 482 compiler.err.invalid.binary.number=二进制数字中必须包含至少一个二进制数
 483 
 484 compiler.err.invalid.hex.number=十六进制数字必须包含至少一位十六进制数
 485 
 486 compiler.err.invalid.meth.decl.ret.type.req=方法声明无效; 需要返回类型
 487 
 488 compiler.err.varargs.and.old.array.syntax=variable-arity 参数中不允许使用传统数组记号
 489 
 490 compiler.err.varargs.and.receiver =接收方参数不允许使用 varargs 记号
 491 
 492 compiler.err.varargs.must.be.last =varargs 参数必须是最后一个参数
 493 
 494 compiler.err.array.and.receiver =接收方参数不允许使用传统数组记号
 495 


 496 compiler.err.variable.not.allowed=此处不允许使用变量声明
 497 
 498 # 0: name
 499 compiler.err.label.already.in.use=标签{0}已使用
 500 
 501 # 0: symbol
 502 compiler.err.local.var.accessed.from.icls.needs.final=从内部类中访问本地变量{0}; 需要被声明为最终类型
 503 
 504 compiler.err.local.enum=枚举类型不能为本地类型
 505 
 506 compiler.err.cannot.create.array.with.type.arguments=无法创建具有类型变量的数组
 507 
 508 compiler.err.cannot.create.array.with.diamond=无法创建具有 ''<>'' 的数组
 509 
 510 compiler.err.invalid.module.directive=预期为模块指令关键字或 ''}''
 511 
 512 #
 513 # limits.  We don't give the limits in the diagnostic because we expect
 514 # them to change, yet we want to use the same diagnostic.  These are all
 515 # detected during code generation.

 769 compiler.misc.ref.ambiguous=对{0}的引用不明确\n{3} 中的{1} {2} 和 {6} 中的{4} {5} 都匹配
 770 
 771 compiler.err.repeated.annotation.target=注释目标重复
 772 
 773 compiler.err.repeated.interface=接口重复
 774 
 775 compiler.err.repeated.modifier=修饰符重复
 776 
 777 # 0: symbol, 1: set of modifier, 2: symbol
 778 compiler.err.report.access={0} 在 {2} 中是 {1} 访问控制
 779 
 780 # 0: symbol, 1: set of modifier, 2: symbol
 781 compiler.misc.report.access={0} 在 {2} 中是 {1} 访问控制
 782 
 783 compiler.err.ret.outside.meth=返回外部方法
 784 
 785 compiler.err.signature.doesnt.match.supertype=签名与{0}不匹配; 不兼容的超类型
 786 
 787 compiler.err.signature.doesnt.match.intf=签名与{0}不匹配; 不兼容的接口
 788 
 789 # 0: number, 1: number
 790 compiler.err.method.invoked.with.incorrect.number.arguments=使用不正确数量的参数调用了方法; 预期为 {0} 个, 找到 {1} 个
 791 
 792 # 0: symbol, 1: symbol, 2: symbol
 793 compiler.err.does.not.override.abstract={0}不是抽象的, 并且未覆盖{2}中的抽象方法{1}
 794 
 795 # 0: file object
 796 compiler.err.source.cant.overwrite.input.file=写入源时出错; 无法覆盖输入文件{0}
 797 
 798 # 0: symbol
 799 compiler.err.stack.sim.error=内部错误: {0}中的堆栈 sim 错误
 800 
 801 compiler.err.static.imp.only.classes.and.interfaces=仅从类和接口静态导入
 802 
 803 compiler.err.string.const.req=需要常量字符串表达式
 804 



 805 # 0: symbol, 1: symbol
 806 compiler.err.synthetic.name.conflict=符号{0}与{1}中的 compiler-synthesized 符号冲突



 807 
 808 compiler.err.throws.not.allowed.in.intf.annotation=@interface 成员中不允许使用 throws 子句
 809 
 810 compiler.err.try.without.catch.or.finally=有 ''try'', 但是没有 ''catch'' 或 ''finally''
 811 
 812 compiler.err.try.without.catch.finally.or.resource.decls=''try'' 不带有 ''catch'', ''finally'' 或资源声明
 813 
 814 # 0: symbol
 815 compiler.err.type.doesnt.take.params=类型{0}不带有参数
 816 
 817 compiler.err.type.var.cant.be.deref=无法从类型变量中进行选择
 818 
 819 compiler.err.type.var.may.not.be.followed.by.other.bounds=类型变量后面不能带有其他限制范围
 820 
 821 compiler.err.type.var.more.than.once=类型变量{0}在{1}的结果类型中多次出现; 必须对其进行实例化
 822 
 823 compiler.err.type.var.more.than.once.in.result=类型变量{0}在{1}的类型中多次出现; 必须对其进行实例化
 824 
 825 # 0: type, 1: type, 2: string
 826 compiler.err.types.incompatible.diff.ret=类型{0}和{1}不兼容; 两者都定义了{2}, 但却带有不相关的返回类型



 827 
 828 # 0: kind name, 1: type, 2: name, 3: list of type, 4: symbol, 5: symbol
 829 compiler.err.types.incompatible.unrelated.defaults={0} {1}从类型 {4} 和 {5} 中继承了{2}({3}) 的不相关默认值
 830 
 831 # 0: kind name, 1: type, 2: name, 3: list of type, 4: symbol, 5: symbol
 832 compiler.err.types.incompatible.abstract.default={0} {1}从类型 {4} 和 {5} 中继承了{2}({3}) 的抽象和默认值
 833 
 834 # 0: name, 1: kind name, 2: symbol
 835 compiler.err.default.overrides.object.member={1} {2} 中的默认方法{0}覆盖了 java.lang.Object 的成员
 836 
 837 # 0: type
 838 compiler.err.illegal.static.intf.meth.call=静态接口方法调用非法\n应将接收方表达式替换为类型限定符 ''{0}''
 839 
 840 # 0: symbol or type, 1: message segment
 841 compiler.err.illegal.default.super.call=默认超级调用中的类型限定符{0}错误\n{1}
 842 
 843 # 0: symbol, 1: type
 844 compiler.misc.overridden.default=覆盖了{1}中的方法 {0}
 845 
 846 # 0: symbol, 1: type or symbol
 847 compiler.misc.redundant.supertype=冗余接口 {0} 已由 {1} 扩展
 848 
 849 compiler.err.unclosed.char.lit=未结束的字符文字
 850 
 851 compiler.err.unclosed.comment=未结束的注释
 852 
 853 compiler.err.unclosed.str.lit=未结束的字符串文字
 854 
 855 # 0: string
 856 compiler.err.unsupported.encoding=不支持的编码: {0}
 857 
 858 compiler.err.io.exception=读取源文件时出错: {0}
 859 
 860 # 0: name
 861 compiler.err.undef.label=未定义的标签: {0}
 862 
 863 # 0: name (type)
 864 compiler.err.illegal.ref.to.var.type=对受限制类型 ''{0}'' 的引用非法
 865 
 866 # 0: token
 867 compiler.err.var.not.allowed=从发行版 10 开始,\n此处不允许使用 ''{0}'', ''{0}'' 是受限制的本地变量类型, 无法用于类型声明
 868 
 869 compiler.warn.var.not.allowed=从发行版 10 开始，''var'' 是受限制的本地变量类型，无法用于类型声明
 870 
 871 # 0: name (variable), 1: message segment
 872 compiler.err.cant.infer.local.var.type=无法推断本地变量 {0} 的类型\n({1})
 873 
 874 compiler.err.var.not.allowed.here=此处不允许使用 ''var''
 875 
 876 compiler.err.var.not.allowed.array=''var'' 不允许用作数组的元素类型
 877 
 878 compiler.err.var.not.allowed.compound=''var'' 不允许在复合声明中使用
 879 









 880 compiler.misc.local.cant.infer.null=变量初始化程序为 ''null''
 881 
 882 compiler.misc.local.cant.infer.void=变量初始化程序为 ''void''
 883 
 884 compiler.misc.local.missing.init=无法在不带初始化程序的变量上使用 ''var''
 885 
 886 compiler.misc.local.lambda.missing.target=lambda 表达式需要显式目标类型
 887 
 888 compiler.misc.local.mref.missing.target=方法引用需要显式目标类型
 889 
 890 compiler.misc.local.array.missing.target=数组初始化程序需要显式目标类型
 891 
 892 compiler.misc.local.self.ref=无法在自引用变量上使用 ''var''
 893 
 894 # 0: message segment, 1: unused
 895 compiler.err.cant.apply.diamond=无法推断{0}的类型参数
 896 
 897 # 0: message segment or type, 1: message segment
 898 compiler.err.cant.apply.diamond.1=无法推断{0}的类型参数\n原因: {1}
 899 

1080 compiler.note.removal.recompile=有关详细信息, 请使用 -Xlint:removal 重新编译。
1081 
1082 # 0: file name
1083 compiler.note.removal.filename.additional={0} 额外使用或覆盖了标记为待删除的已过时 API。
1084 
1085 compiler.note.removal.plural.additional=某些输入文件额外使用或覆盖了标记为待删除的已过时 API。
1086 
1087 # 0: file name
1088 compiler.note.unchecked.filename={0}使用了未经检查或不安全的操作。
1089 
1090 compiler.note.unchecked.plural=某些输入文件使用了未经检查或不安全的操作。
1091 
1092 # The following string may appear after one of the above unchecked messages.
1093 compiler.note.unchecked.recompile=有关详细信息, 请使用 -Xlint:unchecked 重新编译。
1094 
1095 # 0: file name
1096 compiler.note.unchecked.filename.additional={0}还有未经检查或不安全的操作。
1097 
1098 compiler.note.unchecked.plural.additional=某些输入文件还使用了未经检查或不安全的操作。
1099 














1100 # Notes related to annotation processing
1101 
1102 # Print a client-generated note; assumed to be localized, no translation required
1103 # 0: string
1104 compiler.note.proc.messager={0}
1105 
1106 # 0: string, 1: string, 2: string
1107 compiler.note.multiple.elements=通过 javax.lang.model.util.Elements.{0} 在模块 ''{2}'' 中找到了多个名为 ''{1}'' 的元素。
1108 
1109 #####
1110 
1111 # 0: number
1112 compiler.misc.count.error={0} 个错误
1113 
1114 # 0: number
1115 compiler.misc.count.error.plural={0} 个错误
1116 
1117 # 0: number
1118 compiler.misc.count.warn={0} 个警告
1119 

1189 # 0: symbol, 1: symbol
1190 compiler.warn.has.been.deprecated.for.removal={1} 中的 {0} 已过时, 且标记为待删除
1191 
1192 # 0: symbol
1193 compiler.warn.has.been.deprecated.module=模块 {0} 已过时
1194 
1195 # 0: symbol
1196 compiler.warn.has.been.deprecated.for.removal.module=模块 {0} 已过时, 且标记为待删除
1197 
1198 # 0: symbol
1199 compiler.warn.sun.proprietary={0}是内部专用 API, 可能会在未来发行版中删除
1200 
1201 compiler.warn.illegal.char.for.encoding=编码{0}的不可映射字符
1202 
1203 # 0: symbol
1204 compiler.warn.improper.SVUID=必须在类{0}中将 serialVersionUID 声明为 static final
1205 
1206 # 0: type, 1: type
1207 compiler.warn.inexact.non-varargs.call=最后一个参数使用了不准确的变量类型的 varargs 方法的非 varargs 调用; \n对于 varargs 调用, 应使用 {0}\n对于非 varargs 调用, 应使用 {1}, 这样也可以抑制此警告
1208 



1209 # 0: list of type
1210 compiler.warn.unreachable.catch=catch 子句无法访问\n已捕获到抛出的类型{0}
1211 
1212 # 0: list of type
1213 compiler.warn.unreachable.catch.1=catch 子句无法访问\n已捕获到抛出的类型{0}
1214 
1215 # 0: symbol
1216 compiler.warn.long.SVUID=serialVersionUID 在类{0}中必须是 long 类型
1217 
1218 # 0: symbol
1219 compiler.warn.missing.SVUID=可序列化类{0}没有 serialVersionUID 的定义
1220 
1221 # 0: symbol, 1: symbol, 2: symbol, 3: symbol
1222 compiler.warn.potentially.ambiguous.overload={1} 中的 {0} 可能与 {3} 中的 {2} 混淆
1223 
1224 # 0: message segment
1225 compiler.warn.override.varargs.missing={0}; 被覆盖的方法没有 ''...''
1226 
1227 # 0: message segment
1228 compiler.warn.override.varargs.extra={0}; 覆盖的方法缺少 ''...''

1230 # 0: message segment
1231 compiler.warn.override.bridge={0}; 被覆盖的方法为 bridge 方法
1232 
1233 # 0: symbol
1234 compiler.warn.pkg-info.already.seen=已找到程序包{0}的 package-info.java 文件
1235 
1236 # 0: path
1237 compiler.warn.path.element.not.found=错误的路径元素 "{0}": 没有这种文件或目录
1238 
1239 compiler.warn.possible.fall-through.into.case=可能无法实现 case
1240 
1241 # 0: type
1242 compiler.warn.redundant.cast=出现冗余的到{0}的转换
1243 
1244 # 0: number
1245 compiler.warn.position.overflow=行 {0} 处的位置编码溢出
1246 
1247 # 0: file name, 1: number, 2: number
1248 compiler.warn.big.major.version={0}: 主版本 {1} 比 {2} 新, 此编译器支持最新的主版本。\n建议升级此编译器。
1249 
1250 # 0: symbol kind, 1: symbol
1251 compiler.warn.static.not.qualified.by.type=static {0}应由类型名称{1}而不是表达式限定
1252 
1253 # 0: string
1254 compiler.warn.source.no.bootclasspath=未与 -source {0} 一起设置引导类路径
1255 
1256 # 0: string
1257 compiler.warn.option.obsolete.source=源值{0}已过时, 将在未来所有发行版中删除
1258 
1259 # 0: string
1260 compiler.warn.option.obsolete.target=目标值{0}已过时, 将在未来所有发行版中删除
1261 
1262 # 0: string, 1: string
1263 compiler.err.option.removed.source=不再支持源选项 {0}。请使用 {1} 或更高版本。
1264 
1265 # 0: string, 1: string
1266 compiler.err.option.removed.target=不再支持目标选项 {0}。请使用 {1} 或更高版本。
1267 




1268 compiler.warn.option.obsolete.suppression=要隐藏有关已过时选项的警告, 请使用 -Xlint:-options。
1269 
1270 # 0: name, 1: number, 2: number, 3: number, 4: number
1271 compiler.warn.future.attr={1}.{2} 版类文件中引入的 {0} 属性在 {3}.{4} 版类文件中被忽略
1272 
1273 compiler.warn.requires.automatic=需要自动模块的指令
1274 
1275 compiler.warn.requires.transitive.automatic=需要自动模块的过渡指令
1276 
1277 # Warnings related to annotation processing
1278 # 0: string
1279 compiler.warn.proc.package.does.not.exist=程序包{0}不存在
1280 
1281 # 0: string
1282 compiler.warn.proc.file.reopening=尝试多次为 ''{0}'' 创建文件
1283 
1284 # 0: name
1285 compiler.warn.proc.type.already.exists=类型 ''{0}'' 的文件已经存在于源路径或类路径中
1286 
1287 # 0: string
1288 compiler.warn.proc.type.recreate=尝试多次创建类型 ''{0}'' 的文件
1289 
1290 # 0: string
1291 compiler.warn.proc.illegal.file.name=无法创建带有非法名称 ''{0}'' 的文件。
1292 
1293 # 0: string, 1: string
1294 compiler.warn.proc.suspicious.class.name=正在为名称以{1}结尾的类型创建文件: ''{0}''
1295 
1296 # 0: string
1297 compiler.warn.proc.file.create.last.round=将不对在最后一个循环中创建的类型为 ''{0}'' 的文件进行注释处理。
1298 
1299 # 0: string, 1: string
1300 compiler.warn.proc.malformed.supported.string=处理程序 ''{1}'' 为支持的注释类型返回格式错误的字符串 ''{0}''
1301 
1302 # 0: set of string
1303 compiler.warn.proc.annotations.without.processors=没有处理程序要使用以下任何注释: {0}
1304 

1322 compiler.warn.proc.unmatched.processor.options=以下选项未被任何处理程序识别: ''{0}''
1323 
1324 compiler.warn.try.explicit.close.call=在可自动结束的资源上显式调用 close()
1325 
1326 # 0: symbol
1327 compiler.warn.try.resource.not.referenced=不能在相应的 try 语句的正文中引用可自动结束的资源{0}
1328 
1329 # 0: type
1330 compiler.warn.try.resource.throws.interrupted.exc=可自动关闭的资源{0}包含的成员方法 close() 可能抛出 InterruptedException
1331 
1332 compiler.warn.unchecked.assign=未经检查的分配: 将{0}分配给{1}
1333 
1334 # 0: symbol, 1: type
1335 compiler.warn.unchecked.assign.to.var=对作为原始类型{1}的成员的变量{0}的分配未经过检查
1336 
1337 # 0: symbol, 1: type
1338 compiler.warn.unchecked.call.mbr.of.raw.type=对作为原始类型{1}的成员的{0}的调用未经过检查
1339 
1340 compiler.warn.unchecked.cast.to.type=向类型{0}的转换未经过检查
1341 
1342 # 0: symbol kind, 1: name, 2: list of type, 3: list of type, 4: symbol kind, 5: symbol
1343 compiler.warn.unchecked.meth.invocation.applied=方法调用未经过检查: 将{4} {5}中的{0} {1}应用到给定的类型\n需要: {2}\n找到: {3}
1344 
1345 # 0: type
1346 compiler.warn.unchecked.generic.array.creation=对于类型为{0}的 varargs 参数, 泛型数组创建未经过检查
1347 
1348 # 0: type
1349 compiler.warn.unchecked.varargs.non.reifiable.type=参数化 vararg 类型{0}的堆可能已受污染
1350 
1351 # 0: symbol
1352 compiler.warn.varargs.unsafe.use.varargs.param=Varargs 方法可能导致来自不可具体化 varargs 参数 {0} 的堆污染
1353 
1354 compiler.warn.missing.deprecated.annotation=未使用 @Deprecated 对已过时的项目进行注释
1355 
1356 # 0: kind name
1357 compiler.warn.deprecated.annotation.has.no.effect=@Deprecated 注释对此 {0} 声明没有任何效果
1358 
1359 # 0: string
1360 compiler.warn.invalid.path=无效文件名: {0}
1361 
1362 # 0: path

1421 compiler.misc.token.float=<浮点型>
1422 
1423 compiler.misc.token.double=<双精度型>
1424 
1425 compiler.misc.token.bad-symbol=<错误符号>
1426 
1427 compiler.misc.token.end-of-input=<输入结束>
1428 
1429 ## The argument to the following string will always be one of the following:
1430 ## 1. one of the above non-terminals
1431 ## 2. a keyword (JLS1.8)
1432 ## 3. a boolean literal (JLS3.10.3)
1433 ## 4. the null literal (JLS3.10.7)
1434 ## 5. a Java separator (JLS3.11)
1435 ## 6. an operator (JLS3.12)
1436 ##
1437 ## This is the only place these tokens will be used.
1438 # 0: token
1439 compiler.err.expected=需要{0}
1440 



1441 # 0: token, 1: token
1442 compiler.err.expected2=需要{0}或{1}
1443 
1444 # 0: token, 1: token, 2: token
1445 compiler.err.expected3=需要{0}, {1}或{2}
1446 
1447 compiler.err.premature.eof=进行语法分析时已到达文件结尾
1448 
1449 ## The following are related in form, but do not easily fit the above paradigm.
1450 compiler.err.expected.module=需要 ''module''
1451 
1452 compiler.err.expected.module.or.open=需要 ''module'' 或 ''open''
1453 
1454 compiler.err.dot.class.expected=需要 ''.class''
1455 
1456 ## The argument to this string will always be either 'case' or 'default'.
1457 # 0: token
1458 compiler.err.orphaned=孤立的{0}
1459 
1460 # 0: name

1606 
1607 compiler.misc.type.req.class.array=类或数组
1608 
1609 compiler.misc.type.req.array.or.iterable=数组或 java.lang.Iterable
1610 
1611 compiler.misc.type.req.ref=引用
1612 
1613 compiler.misc.type.req.exact=不带限制范围的类或接口
1614 
1615 # 0: type
1616 compiler.misc.type.parameter=类型参数{0}
1617 
1618 #####
1619 
1620 ## The following are all possible strings for the last argument of all those
1621 ## diagnostics whose key ends in ".1"
1622 
1623 # 0: type, 1: list of type
1624 compiler.misc.no.unique.maximal.instance.exists=对于上限为{1}的类型变量{0}, 不存在唯一最大实例
1625 

1626 compiler.misc.no.unique.minimal.instance.exists=对于下限为{1}的类型变量{0}, 不存在唯一最小实例
1627 
1628 # 0: type, 1: list of type
1629 compiler.misc.incompatible.upper.bounds=推论变量 {0} 具有不兼容的上限 {1}
1630 
1631 # 0: type, 1: list of type
1632 compiler.misc.incompatible.eq.bounds=推论变量{0}具有不兼容的等式约束条件{1}
1633 
1634 # 0: type, 1: list of type, 2: list of type
1635 compiler.misc.incompatible.eq.upper.bounds=推论变量 {0} 具有不兼容的限制范围\n等式约束条件: {1}\n上限: {2}



1636 
1637 # 0: type, 1: list of type, 2: list of type
1638 compiler.misc.incompatible.upper.lower.bounds=推论变量{0}具有不兼容的边界\n上限: {1}\n下限: {2}
1639 
1640 # 0: type, 1: list of type, 2: list of type
1641 compiler.misc.incompatible.eq.lower.bounds=推论变量{0}具有不兼容的限制范围\n等式约束条件: {1}\n下限: {2}
1642 
1643 # 0: list of type, 1: type, 2: type
1644 compiler.misc.infer.no.conforming.instance.exists=不存在类型变量{0}的实例, 以使{1}与{2}一致
1645 
1646 # 0: list of type, 1: message segment
1647 compiler.misc.infer.no.conforming.assignment.exists=无法推断类型变量 {0}\n(参数不匹配; {1})
1648 
1649 # 0: list of type
1650 compiler.misc.infer.arg.length.mismatch=无法推断类型变量 {0}\n(实际参数列表和形式参数列表长度不同)
1651 
1652 # 0: list of type, 1: message segment
1653 compiler.misc.infer.varargs.argument.mismatch=无法推断类型变量 {0}\n(varargs 不匹配; {1})
1654 
1655 # 0: type, 1: list of type
1656 compiler.misc.inferred.do.not.conform.to.upper.bounds=推断类型不符合上限\n推断: {0}\n上限: {1}
1657 
1658 # 0: type, 1: list of type
1659 compiler.misc.inferred.do.not.conform.to.lower.bounds=推断类型不符合下限\n推断: {0}\n下限: {1}
1660 
1661 # 0: type, 1: list of type

1716 
1717 ## Both arguments ({0}, {1}) are "kindname"s.  {0} is a comma-separated list
1718 ## of kindnames (the list should be identical to that provided in source.
1719 # 0: set of kind name, 1: set of kind name
1720 compiler.err.unexpected.type=意外的类型\n需要: {0}\n找到:    {1}
1721 
1722 compiler.err.unexpected.lambda=此处不应为 lambda 表达式
1723 
1724 compiler.err.unexpected.mref=此处不应为方法引用
1725 
1726 ## The first argument {0} is a "kindname" (e.g. 'constructor', 'field', etc.)
1727 ## The second argument {1} is the non-resolved symbol
1728 ## The third argument {2} is a list of type parameters (non-empty if {1} is a method)
1729 ## The fourth argument {3} is a list of argument types (non-empty if {1} is a method)
1730 # 0: kind name, 1: name, 2: unused, 3: unused
1731 compiler.err.cant.resolve=找不到符号\n符号: {0} {1}
1732 
1733 # 0: kind name, 1: name, 2: unused, 3: list of type
1734 compiler.err.cant.resolve.args=找不到符号\n符号: {0} {1}({3})
1735 



1736 # 0: kind name, 1: name, 2: list of type, 3: list of type
1737 compiler.err.cant.resolve.args.params=找不到符号\n符号: {0} <{2}>{1}({3})
1738 
1739 ## arguments from {0} to {3} have the same meaning as above
1740 ## The fifth argument {4} is a location subdiagnostic (see below)
1741 # 0: kind name, 1: name, 2: unused, 3: unused, 4: message segment
1742 compiler.err.cant.resolve.location=找不到符号\n符号:   {0} {1}\n位置: {4}
1743 
1744 # 0: kind name, 1: name, 2: unused, 3: list of type, 4: message segment
1745 compiler.err.cant.resolve.location.args=找不到符号\n符号:   {0} {1}({3})\n位置: {4}
1746 
1747 # 0: kind name, 1: name, 2: list of type, 3: list, 4: message segment
1748 compiler.err.cant.resolve.location.args.params=找不到符号\n符号:   {0} <{2}>{1}({3})\n位置: {4}
1749 
1750 ### Following are replicated/used for method reference diagnostics
1751 
1752 # 0: kind name, 1: name, 2: unused, 3: list of type, 4: message segment
1753 compiler.misc.cant.resolve.location.args=找不到符号\n符号:   {0} {1}({3})\n位置: {4}
1754 
1755 # 0: kind name, 1: name, 2: list of type, 3: list, 4: message segment

1867 compiler.misc.inapplicable.method={0} {1}.{2}不适用\n({3})
1868 
1869 ########################################
1870 # Diagnostics for language feature changes.
1871 # Such diagnostics have a common template which can be customized by using a feature
1872 # diagnostic fragment (one of those given below).
1873 ########################################
1874 
1875 # 0: message segment (feature), 1: string (found version), 2: string (expected version)
1876 compiler.err.feature.not.supported.in.source=-source {1} 中不支持 {0}\n(请使用 -source {2} 或更高版本以启用 {0})
1877 
1878 # 0: message segment (feature), 1: string (found version), 2: string (expected version)
1879 compiler.err.feature.not.supported.in.source.plural=-source {1} 中不支持 {0}\n(请使用 -source {2} 或更高版本以启用 {0})
1880 
1881 # 0: message segment (feature), 1: string (found version), 2: string (expected version)
1882 compiler.misc.feature.not.supported.in.source=-source {1} 中不支持 {0}\n(请使用 -source {2} 或更高版本以启用 {0})
1883 
1884 # 0: message segment (feature), 1: string (found version), 2: string (expected version)
1885 compiler.misc.feature.not.supported.in.source.plural=-source {1} 中不支持 {0}\n(请使用 -source {2} 或更高版本以启用 {0})
1886 



















1887 compiler.misc.feature.modules=模块
1888 
1889 compiler.misc.feature.diamond.and.anon.class=''<>'' 具有匿名的内部类
1890 
1891 compiler.misc.feature.binary.lit=二进制文字
1892 
1893 compiler.misc.feature.underscore.lit=文字中的下划线
1894 
1895 compiler.misc.feature.try.with.resources=try-with-resources
1896 
1897 compiler.misc.feature.var.in.try.with.resources=try-with-resources 中的变量
1898 
1899 compiler.misc.feature.type.annotations=类型注释
1900 
1901 compiler.misc.feature.annotations.after.type.params=在方法类型参数之后的注释
1902 
1903 compiler.misc.feature.repeatable.annotations=重复的注释
1904 
1905 compiler.misc.feature.diamond=diamond 运算符
1906 

1916 
1917 compiler.misc.feature.intersection.types.in.cast=交叉类型
1918 
1919 compiler.misc.feature.static.intf.methods=静态接口方法
1920 
1921 compiler.misc.feature.static.intf.method.invoke=静态接口方法调用
1922 
1923 compiler.misc.feature.private.intf.methods=私有接口方法
1924 
1925 compiler.warn.underscore.as.identifier=从发行版 9 开始, ''_'' 为关键字, 不能用作标识符
1926 
1927 compiler.err.underscore.as.identifier=从发行版 9 开始, ''_'' 为关键字, 不能用作标识符
1928 
1929 compiler.err.underscore.as.identifier.in.lambda=''_'' 用作标识符\n(对于 lambda 参数, 禁止将 ''_'' 用作标识符)
1930 
1931 compiler.err.enum.as.identifier=从发行版 5 开始, ''enum'' 为关键字, 不能用作标识符
1932 
1933 compiler.err.assert.as.identifier=从发行版 1.4 开始, ''assert'' 为关键字, 不能用作标识符
1934 
1935 # TODO 308: make a better error message
1936 compiler.err.this.as.identifier=从发行版 8 开始, ''this'' 只能作为接收方类型的参数名, 该参数必须为第一个参数
1937 
1938 compiler.err.receiver.parameter.not.applicable.constructor.toplevel.class=接收方参数不适用于顶层类的构造器
1939 
1940 # TODO 308: make a better error message
1941 # 0: annotation
1942 compiler.err.cant.type.annotate.scoping.1=无法使用 type-use 注释 {0} 来注释确定作用域结构
1943 
1944 # TODO 308: make a better error message
1945 # 0: list of annotation
1946 compiler.err.cant.type.annotate.scoping=无法使用 type-use 注释 {0} 来注释确定作用域结构
1947 
1948 # 0: type, 1: type
1949 compiler.err.incorrect.receiver.name=接收方名称与封闭类类型不匹配\n需要: {0}\n找到: {1}
1950 
1951 # 0: type, 1: type
1952 compiler.err.incorrect.receiver.type=接收方类型与封闭类类型不匹配\n需要: {0}\n找到: {1}
1953 
1954 # 0: type, 1: type
1955 compiler.err.incorrect.constructor.receiver.type=接收方类型与外部封闭类类型不匹配\n需要: {0}\n找到: {1}
1956 

1969 
1970 # 0: number, 1: symbol, 2: message segment
1971 compiler.misc.applicable.method.found.1=找到第 {0} 个适用方法: {1}\n({2})
1972 
1973 # 0: number, 1: symbol, 2: message segment
1974 compiler.misc.not.applicable.method.found=找到第 {0} 个不适用的方法: {1}\n({2})
1975 
1976 # 0: type
1977 compiler.misc.partial.inst.sig=部分实例化为: {0}
1978 
1979 # 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
1980 compiler.note.verbose.resolve.multi=将类型 {1} 的方法 {0} 解析为候选项 {2}\n阶段: {3}\n具有实际值: {4}\n具有类型参数: {5}\n候选项:
1981 
1982 # 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
1983 compiler.note.verbose.resolve.multi.1=类型 {1} 的方法 {0} 解析错误\n阶段: {3}\n具有实际值: {4}\n具有类型参数: {5}\n候选项:
1984 
1985 # 0: symbol, 1: type, 2: type
1986 compiler.note.deferred.method.inst=方法 {0} 的延迟实例化\n实例化签名: {1}\n目标类型: {2}
1987 
1988 ########################################








1989 # Diagnostics for where clause implementation
1990 # used by the RichDiagnosticFormatter.
1991 ########################################
1992 
1993 compiler.misc.type.null=<空值>
1994 
1995 # X#n (where n is an int id) is disambiguated tvar name
1996 # 0: name, 1: number
1997 compiler.misc.type.var={0}#{1}
1998 
1999 # CAP#n (where n is an int id) is an abbreviation for 'captured type'
2000 # 0: number
2001 compiler.misc.captured.type=CAP#{0}
2002 
2003 # <INT#n> (where n is an int id) is an abbreviation for 'intersection type'
2004 # 0: number
2005 compiler.misc.intersection.type=INT#{0}
2006 
2007 # where clause for captured type: contains upper ('extends {1}') and lower
2008 # ('super {2}') bound along with the wildcard that generated this captured type ({3})

2243 # 0: string
2244 compiler.err.invalid.module.specifier=不允许模块说明符: {0}
2245 
2246 # 0: symbol
2247 compiler.warn.service.provided.but.not.exported.or.used=已提供服务接口, 但未导出或使用服务接口
2248 
2249 # 0: kind name, 1: symbol, 2: symbol
2250 compiler.warn.leaks.not.accessible=模块 {2} 中的 {0} {1} 对需要该模块的客户机不可访问
2251 # 0: kind name, 1: symbol, 2: symbol
2252 compiler.warn.leaks.not.accessible.unexported=未导出模块 {2} 中的 {0} {1}
2253 # 0: kind name, 1: symbol, 2: symbol
2254 compiler.warn.leaks.not.accessible.not.required.transitive=未使用 ''requires transitive'' 间接导出模块 {2} 中的 {0} {1}
2255 # 0: kind name, 1: symbol, 2: symbol
2256 compiler.warn.leaks.not.accessible.unexported.qualified=模块 {2} 中的 {0} {1} 可能对需要该模块的所有客户机都不可见
2257 
2258 ###
2259 # errors related to options
2260 
2261 # 0: string, 1: string
2262 compiler.err.illegal.argument.for.option={0} 的参数非法: {1}

  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 #

 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 

 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.

 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 

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 

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}; 覆盖的方法缺少 ''...''

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 

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

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

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

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

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 

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 

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})

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 一起使用