西铁城全自动机械手表后背的英文是啥意思

Posted 2023-04-12

CITIZEN WATCH CO.
W.R.5BAR
ST STEEL
8200-S047935 HST
9N0204
MADE IN JAPAN
GN-OW-S
请求解释英文，此表是日本原装的还是中国组装的？

CITIZEN WATCH CO.西铁城手表公司
W.R.5BAR： 50米防水
ST STEEL： 不锈钢
8200-S04795 3HST： 这个是表壳的编号
9N0204： 生产日期 指的是09年11月生产的， 生产序号是0204
MADE IN JAPAN：日本制造
GN-OW-S： 指机械机芯

参考资料：回答不容易，满意请采纳！谢谢！

参考技术A 您好！
以下为相关信息：
8200代表机芯型号
S047935代表表壳型号
9N0204 代表制造号码
ST.STEEL代表表壳为不锈钢材质，请将不锈钢理解为不易生锈的金属。不锈钢的主要成分是铁。在铁中加入铬和镍，就具有了可以防止生锈的性质，这就是不锈钢。
CITIZEN WATCH CO代表西铁城钟表公司
W.R.5BAR手表的防水系数为5气压防水，具备日常生活防水功能，可以供工作中经常接触水和进行水上运动的人士使用。
GN-4W-S 代表管理编号

MADE IN JAPAN 代表此表为日本进口。

以上请了解！

1178

参考资料：西铁城腕表官方旗舰店： http://citizenwatch.tmall.com

参考技术B CITIZEN WATCH CO.西铁城手表公司
W.R.5BAR：5巴防水
ST STEEL：全不锈钢
8200-S04795 3HST： 机芯-机壳号
9N0204：09年生产，序号0204
MADE IN JAPAN：日本制造
GN-OW-S： 指机械表 参考技术C CITIZEN
WATCH
CO
CITIZEN
WATCH
COMPANY西铁城
手表
公司
W.R.10BAR
Water
Resistent
10BAR
防水10个大气压，即防水100米
ST.
STEEL
stainless
STEEL
不锈钢后背壳
日本生产和型号
HST可能是High
speed
tester
高速旋转试验机的检测号---猜的
不好意思不知道 参考技术D 第一行，西铁城公司，第二行，50米防水，第三行，不锈钢，第四第五行不知道，第六行，日本制造，第七行不知道

java自动封箱是啥意思

java语言中integer i=128是怎么运行的。会自动解箱吗？

3 Autoboxing and Unboxing 自动装箱与解箱
3.1 Converting Primitives to Wrapper Types
看一下代码
int foo = 0;
Integer integer = foo;
反编译class文件看到
int foo = 0;
Integer integer = Integer.valueOf(foo);
是编译器帮助做了类型转换,各原始类型分别与它wrapper之间对应
Number n = 0.0f;
上面的申明显示从float转到Float,再从Float转到Number
3.2 Converting Wrapper Types to Primitives
看一下代码
Integer integer = 1;
int i = integer;
反编译class文件看到
Integer integer = Integer.valueOf(1);
int i = integer.intValue();
先装箱再解箱,从上代码可以看出,如果
Integer integer = null;
int i = integer.intValue();
那么这个代码必定报NullPointerException,所以在解箱的时候需特别注意这点
3.3 Incrementing and Decrementing Wrapper Types
看一下代码
Integer counter = 1;
while (counter<10)
System.out.printf("Iteration %d%n", counter++);

反编译class文件看到
Object aobj[];
for(Integer counter = Integer.valueOf(1); counter.intValue() < 10; System.out.printf("Iteration %d%n", aobj))

aobj = new Object[1];
counter = Integer.valueOf(counter.intValue() + 1);
aobj[0] = counter;

在这里我们看到自增长运算符++在这里也是可以使用的,编译后实际上在在int上操作,然后再赋给counter
3.4 Boolean Versus boolean
看一下代码A
Boolean case1 = true;
Boolean case2 = true;
boolean case3 = false;
Boolean result = (case1 || case2) && case3;
反编译class文件看到
Boolean case1 = Boolean.valueOf(true);
Boolean case2 = Boolean.valueOf(true);
boolean case3 = false;
Boolean result = Boolean.valueOf((case1.booleanValue() || case2.booleanValue()) && case3);
在进行或运算和与运算的时候都用到了unboxing,然后再把结果autoboxing
For inquiring minds, primitives are boxed up to wrapper types in equality comparisons. For operators such as <, >=, and so forth, the wrapper types are unboxed to primitive types.
看一下代码B
Integer i1 = 256;
Integer i2 = 256;
if (i1 == i2)
System.out.println("Equal!");
else
System.out.println("Not equal!");

在大多数的jvm里返回的是not equal,==运算符直接是对两个object intances的比较,不多内存地址,结果当然是not equal,当然也有少部分最优化的jvm可能会返回equal,如果优化的策略是创建一个instance实例
看一下代码C
Integer i1 = 100;
Integer i2 = 100;
if (i1 == i2)
System.out.println("Equal!");
else
System.out.println("Not equal!");

返回结果是equal,记住int值在-127到127的范围里,这样的两个同int值的Integer对象jvm是只分配一个内存地址的
3.5 Conditionals and Unboxing
看一下代码A
Boolean arriving = false;
Boolean late = true;
System.out.println(arriving ? (late ? "It's about time!" : "Hello!") :
(late ? "Better hurry!" : "Goodbye"));
反编译看
Boolean arriving = Boolean.valueOf(false);
Boolean late = Boolean.valueOf(true);
System.out.println(arriving.booleanValue() ? late.booleanValue() ? "It's about time!" : "Hello!" : late.booleanValue() ? "Better hurry!" : "Goodbye");
输出是Better hurry!
看一下代码B
String s = "hello";
StringBuffer sb = new StringBuffer("world");
boolean mutable = true;
CharSequence cs = mutable ? sb : s;
反编译看到
String s = "hello";
StringBuffer sb = new StringBuffer("world");
boolean mutable = true;
CharSequence cs = ((CharSequence) (mutable ? ((CharSequence) (sb)) : ((CharSequence) (s))));
现在的jdk中String和StringBuffer都实现了CharSequence,故String和StringBuffer都转成CharSequence

3.6 Method Overload Resolution
看一下代码
public static void main(String[] args)
int foo = 1;
doSomething(foo);


public static void doSomething(double num)
System.out.println("double called");


public static void doSomething(Integer num)
System.out.println("Integer called");

猜一下哪个被调用呢?
输入的结果是"double called",在这里,你是不是会想到autoboxing?实际上在新的java中方法的调用遵循以下3个规则
1:不考虑boxing,unboxing及变参,而是先遵循1.4下的调用顺序
2:1.4下的规则找不到,参数boxing或者unboxing,找可调用的方法
3:以上规则找不到,考虑变参的方式调用方法 参考技术A 基本类型数据包装到对象中，作为对象来使用，这是封箱，这个封箱过程由java自动实现，就叫做自动封箱。

int类型数据j可以作为Integer类型使用，这就是自动封装。
Integer类型数据可以作为int类型使用，这就是自动拆箱。

java的原则是万物皆对象，对象是类的实例。
java中数据被分为八类：byte、short、int、long、char、boolean、float、double。
这八种数据类型可用对象表示，分别是八个类的实例：Byte、Short、Integer、Long、Character、Boolean、Float、Double，这八个类可在java.lang包中找到。
八种数据基本上写java代码都需要使用，每次都要创建数据对象很繁琐。
为了方便使用，八大数据可以不以对象的形式使用，比如整形数据的使用，从Integer i = new Integer(9);简化到int j = 9;
而且，这个int类型的j可以作为Integer类型的i使用,这就是自动封装。 参考技术B 不是很清楚 帮不了你了 参考技术C 用EHDHJ来解