一切尽在代码中
package package0002;
public class WrapperClass {
public static void main(String[] args) {
/* 基本类型————>包装类型 */
/**
* 可以直接把基本类型的变量赋值给包装类(或者说引用)；
* 实际上在这里，编译器自动地调用了包装类的{@code valueOf()}方法；
* 这只是一个语法糖，而非真正的把基本类型赋值给了包装类型。
*/
//#statement001-001
Integer intNum1 = 23;
//#statement001-002
Float floatNum1 = 3.14F;
//#statement001-003
Double doubleNum1 = 3.1415926;
//#statement001-004
Short shortNum1 = 223;
//#statement001-005
Long longNum1 = 666L;
//#statement001-006
Byte byteNum1 = 127;
//#statement001-007
Character charWord1 = 'k';
//#statement001-008
Boolean bool1 = true;
/**
* 用包装类的构造方法实例化一个包装类对象，入参为对应的基本类型；
* 值得一提的是：java的基本数据类型中，整型的默认类型是{@code int}，浮点型的默认类型是{@code double}。
*/
//#statement002-001
Integer intNum2 = new Integer(23);
//#statement002-002
Float floatNum2 = new Float(3.14F);
//#statement002-003
Double doubleNum2 = new Double(3.1415926);
//#statement002-004
short shortValue2 = 223;
Short shortNum2 = new Short(shortValue2); //这里直接在括号内写数值的话，编译器会把它认作 int 类型，什么鬼？？？
//#statement002-005
Long longNum2 = new Long(666L);
//#statement002-006
byte byteValue2 = 127; //必须注意的是 byte 类型的取值是 -128~127,超过这个数值会被默认为 int 类型
Byte byteNum2 = new Byte(byteValue2); //同上#statement002-004，真奇葩！
//#statement002-007
Character charWord2 = new Character('k');
//#statement002-008
Boolean bool2 = new Boolean(true);
/**
* 使用包装类的静态方法{@code valueOf()}，入参为对应的基本类型；
*/
//#statement003-001
Integer intNum3 = Integer.valueOf(23);
//#statement003-002
Float floatNum3 = Float.valueOf(3.14F);
//#statement003-003
Double doubleNum3 = Double.valueOf(3.1415926);
//#statement003-004
short shortValue3 = 223;
Short shortNum3 = Short.valueOf(shortValue3);
//#statement003-005
Long longNum3 = Long.valueOf(666L);
//#statement003-006
byte byteValue3 = 127;
Byte byteNum3 = Byte.valueOf(byteValue2);
//#statement003-007
Character charWord3 = Character.valueOf('k');
//#statement003-008
Boolean bool3 = Boolean.valueOf(true);
/* 包装类型————>基本类型 */
/**
* 使用包装类的实例方法{@code *Value()};
*/
//#statement006-001
int intvalue6 = intNum3.intValue();
//#statement006-002
float floatValue6 = floatNum3.floatValue();
//#statement006-003
double doubleValue6 = doubleNum3.doubleValue();
//#statement006-004
short shortValue6 = shortNum3.shortValue();
//#statement006-005
long longValue6 = longNum3.longValue();
//#statement006-006
byte byteValue6 = byteNum3.byteValue();
//#statement006-007
char charValue6 = charWord3.charValue();
//#statement006-008
boolean boolValue6 = bool3.booleanValue();
/* String类型————>包装类型 */
/**
* 同样用构造方法来实现；是以{@code value}为入参的构造方法的重载；
* 用包装类的构造方法实例化一个包装类对象，入参为字面量对应的{@code String}类型；
* 必须注意的是：{@code Character}类是没有这个方法的，因为String怎么可以转成char嘛！
* 还有就是：字符串字面量是不能超出类型本身的取值范围或者类型不匹配的，否则会报错；
* 比如：{@code Integer intNum3 = new Integer("sug")}，肯定会报错,因为{@code "sug"}不是一个合法的int类型；
* 再比如{@code Byte byteNum3 = new Byte("369")}也会报错，因为{code 369}超过了byte类型的取值范围,
*/
//#statement004-001
Integer intNum4 = new Integer("23");
//#statement004-002
Float floatNum4 = new Float("3.14F");
//#statement004-003
Double doubleNum4 = new Double("3.1415926");
//#statement004-004
Short shortNum4 = new Short("223");
//#statement004-005
Long longNum4 = new Long(666L);
//#statement004-006
Byte byteNum4 = new Byte("127");
//#statement004-008
Boolean bool4 = new Boolean("true");
/**
* 使用包装类的静态方法{@code valueOf()}，入参为字面量对应的{@code String}类型；
* 同理，{@code Character}类没有这个方法;
*/
//#statement005-001
Integer intNum5 = Integer.valueOf("23");
//#statement005-002
Float floatNum5 = Float.valueOf("3.14F");
//#statement005-003
Double doubleNum5 = Double.valueOf("3.1415926");
//#statement005-004
Short shortNum5 = Short.valueOf("223");
//#statement005-005
Long longNum5 = Long.valueOf("666L");
//#statement005-006
Byte byteNum5 = Byte.valueOf("127");
//#statement005-008
Boolean bool5 = Boolean.valueOf("true");
/* 包装类型————>String类型 */
/* 基本类型————>String类型 */
/**
* 使用包装类的静态方法{@code toString()}；
*/
//#statement007-001
String intStr7 = intNum2.toString();
String intStr71 = Integer.toString(23);
//#statement007-002
String floatStr7 = floatNum2.toString();
String floatStr71 = Float.toString(3.14F);
//#statement007-003
String doubleStr7 = doubleNum2.toString();
String doubleStr71 = Double.toString(3.1415926);
//#statement007-004
String shortStr7 = shortNum2.toString();
short shortValue71 = 223;
String shortStr71 = Short.toString(shortValue71);
//#statement007-005
String longStr7 = longNum2.toString();
String longStr71 = Long.toString(666L);
//#statement007-006
String byteStr7 = byteNum2.toString();
byte byteValue71 = 127;
String byteStr71 = Byte.toString(byteValue71);
//#statement007-007
String charStr7 = charWord2.toString();
String charStr71 = Character.toString('k');
//#statement007-008
String boolStr7 = bool2.toString();
String boolStr71 = Boolean.toString(true);
/* String类型————>基本类型 */
/**
* 使用包装类的静态方法{@code parse*()}；
* 同理，{@code Character}类没有这个方法;
*/
//#statement008-001
int intNum8 = Integer.parseInt("23");
//#statement008-002
float floatNum8 = Float.parseFloat("3.14F");
//#statement008-003
double doubleNum8 = Double.parseDouble("3.1415926");
//#statement008-004
short shortNum8 = Short.parseShort("223");
//#statement008-005
long longNum8 = Long.parseLong("666L");
//#statement008-006
byte byteNum8 = Byte.parseByte("127");
//#statement008-008
boolean bool8 = Boolean.parseBoolean("true");
/**
* 其实在这么多方法的背后，更多的是原理；
* 在平时的代码中，若非必须，可以直接用“=”来连接包装类型和基本类型；
* 因为在Java5以后的版本中，编译器会自动帮你装箱拆箱。
*/
}
}
