一、选择
 
1.Java中提供了名为()的包装类来包装字符类型 ©
 
A. Integer
 
B. String
 
C. Character
 
D. Char/
 
2.以下哪一选项不是基本数据类型 ©
 
A. boolean
 
B. float
 
C. Integer
 
D. char
 
3.下列关于基本类型和包装类的叙述中错误的是(多选)(B C)
 
A. Java中的数据类型包括基本数据类型和引用类型
 
B. Byte是基本数据类型
 
C. 基本数据类型可以调用方法
 
D. 每个基本数据类型都有对应的包装类
 
4.Double 类，Math类，System类分别存储于()哪个包中 (D)
 
A. java.io，java.io，java.lang
 
B. java.io，java.util，java.lang
 
C. java.io，java.io，java.util
 
D. java.lang，java.lang，java.lang
 
5.下列选项中继承自Number的是 (D)
 
A. Integer和long
 
B. Character和 Integer
 
C. Byte和Integer
 
D. long和short
 
6.下面代码运行的正确结果是 (B)
 
public class BuildStuff {
 
int test(Boolean b, int i) {
 
if (b)
 
return (i / 7);
 
return (i / 49);
 
}
 
public static void main(String[] args) {
 
Boolean bool = new Boolean(true);
 
Integer x = 343;
 
Integer y = new BuildStuff().test(bool, x);
 
System.out.println(y);
 
}
 
}
 
A. 350
 
B. 49
 
C. 7
 
D. 编译错误，无法正常运行
 
7.下面代码运行正确的是 (C)
 
public class Wrap {
 
Integer i;
 
int x;
 
public Wrap (int y) {
 
x = i + y;
 
System.out.println(x);
 
}
 
public static void main(String[] args) {
 
new Wrap (new Integer(4));
 
}
 
}
 
A. 4
 
B. 8
 
C. 编译错误，无法正常运行
 
D. 编译正确，但运行时产生错误
 
8.下面代码运行正确的是 (A)
 
public class Wrap {
 
public static void main(String[] args) {
 
Integer i = new Integer(1) + new Integer(2);
 
switch (i) {
 
case 3:
 
System.out.println("hello");
 
break;
 
default:
 
System.out.println("baby");
 
break;
 
}
 
}
 
}
 
A. hello
 
B. baby
 
C. 编译错误，无法正常运行
 
D. 以上说法都不对
 
二、编程
 
1.完成基本数据类型和包装类之间的转换。
 
 
 
2.完成基本数据类型和包装类之间的转换。
 
 
 
3.完成基本数据类型和字符串之间的转换。
 
 

 
 
      Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)，有些地方也翻译为外覆类或数据类型类。
 
 
 
      包装类均位于java.lang包，包装类和基本数据类型的对应关系如下表所示：
 
 
基本数据类型
 
 
包装类
 
 
byte
 
 
Byte
 
 
boolean
 
 
Boolean
 
 
short
 
 
Short
 
 
char
 
 
Character
 
 
int
 
 
Integer
 
 
long
 
 
Long
 
 
float
 
 
Float
 
 
double
 
 
Double
 
     
 
在这八个类名中，除了Integer和Character类以后，其它六个类的类名和基本数据类型一致，只是类名的第一个字母大写即可。对于包装类说，这些类的用途主要有：
 
      (1)带有基本值参数并创建包装类对象的构造函数.如可以利用Integer包装类创建对象,Integer obj=new Integer(145);
       (2)带有字符串参数并创建包装类对象的构造函数.如new Integer("-45.36");
       (3)可生成对象基本值的typeValue方法,如obj.intValue();
       (4)将字符串转换为基本值的 parseType方法,如Integer.parseInt(args[0]);
       (5)生成哈稀表代码的hashCode方法,如obj.hasCode();
       (6)对同一个类的两个对象进行比较的equals()方法,如obj1.eauqls(obj2);
       (7)生成字符串表示法的toString()方法,如obj.toString().
 
      由于八个包装类的使用比较类似，下面以最常用的Integer类为例子介绍包装类的实际使用。
 

1、实现int和Integer类之间的转换
      
 
在实际转换时，使用Integer类的构造方法和Integer类内部的intValue方法实现这些类型之间的相互转换，实现的代码如下：
 
int n = 10;
Integer in = new Integer(100);
//将int类型转换为Integer类型
Integer in1 = new Integer(n);
//将Integer类型的对象转换为int类型
int m = in.intValue();
 
2、Integer类内部的常用方法
a、parseInt方法
      
 
public static int parseInt(String s)
       该方法的作用是将数字字符串转换为int数值。在以后的界面编程中，将字符串转换为对应的int数字是一种比较常见的操作。使用示例如下：
 
String s = “123”;
int n = Integer.parseInt(s);
 
      则int变量n的值是123，该方法实际上实现了字符串和int之间的转换，如果字符串都包含的不是都是数字字符，则程序执行将出现异常。(说明：异常的概念将在下一章进行讲述)
 

       另外一个parseInt方法：
       public static int parseInt(String s, int radix)
 
      则实现将字符串按照参数radix指定的进制转换为int，使用示例如下：
 
//将字符串”120”按照十进制转换为int，则结果为120
int n = Integer.parseInt(“120”,10);
//将字符串”12”按照十六进制转换为int，则结果为18
int n = Integer.parseInt(“12”,16);
//将字符串”ff”按照十六进制转换为int，则结果为255
int n = Integer.parseInt(“ff”,16);
 
      这样可以实现更灵活的转换。
 

b、toString方法
 
      public static String toString(int i)
 
      该方法的作用是将int类型转换为对应的String类型。使用示例代码如下：
       int m = 1000;
       String s = Integer.toString(m);
       则字符串s的值是”1000”。
 

       另外一个toString方法则实现将int值转换为特定进制的字符串：
       public static int parseInt(String s, int radix)
       使用示例代码如下：
       int m = 20;
       String s = Integer.toString(m);
       则字符串s的值是”14”。
 
       其实，JDK自从1.5(5.0)版本以后，就引入了自动拆装箱的语法，也就是在进行基本数据类型和对应的包装类转换时，系统将自动进行，这将大大方便程序员的代码书写。使用示例代码如下：
 
//int类型会自动转换为Integer类型
int m = 12;
Integer in = m;
//Integer类型会自动转换为int类型
int n = in;
 
 
 
 

一、选择
 
1. Java中提供了名为（）的包装类来包装字符类型 C
 
A. Integer
 B. String
 C. Character
 D. Char
 
2. 以下哪一选项不是基本数据类型 C
 
A. boolean
 B. float
 C. Integer
 D. char
 
3. 下列关于基本类型和包装类的叙述中错误的是（多选） BC
 
A. Java中的数据类型包括基本数据类型和引用类型
 B. Byte是基本数据类型
 C. 基本数据类型可以调用方法
 D. 每个基本数据类型都有对应的包装类
 
4. Double 类，Math类，System类分别存储于（）哪个包中 D
 
A. java.io，java.io，java.lang
 B. java.io，java.util，java.lang
 C. java.io，java.io，java.util
 D. java.lang，java.lang，java.lang
 
5. 下列选项中继承自Number的是 C
 
A. Integer和long
 B. Character和 Integer
 C. Byte和Integer
 D. long和short
 
6. 下面代码运行的正确结果是 B
 

 A. 350
 B. 49
 C. 7
 D. 编译错误，无法正常运行
 
7. 下面代码运行的正确结果是 D
 

 A. 4
 B. 8
 C. 编译错误，无法正常运行
 D. 编译正确，但运行时产生错误
 
8. 下面代码运行的正确结果是 A
 

 A. hello
 B. baby
 C. 编译错误，无法正常运行
 D. 以上说法都不对
 
二、编程
 
完成基本数据类型和包装类之间的转换。
 运行效果参考图
 
 
public class HelloWorld {
 public static void main(String[] args) {
 // 定义int类型变量，值为100
 int score = 100; 
 // 创建Integer包装类对象，表示变量score1的值
 Integer score1 = new Integer(score);
 // 将Integer包装类转换为double类型
 double score2 = score1.doubleValue();
 // 将Integer包装类转换为long类型
 long score3 = score1.longValue();
 // 将Integer包装类转换为int类型
 int score4 = score1.Value();
 //打印输出
 System.out.println("score对应的Integer类型结果为：" + score1);
 System.out.println("score对应的double类型结果为：" + score2);
 System.out.println("score对应的long类型结果为：" + score3);
 System.out.println("重新由Integer转换为int类型的结果为：" + score4);
 }
}
 
2.完成基本数据类型和包装类之间的转换。
 运行效果参考图
 
 
public class StringUse {
 public static void main(String[] args) {
 double a = 12.5;
 //将基本类型转换为字符串
 String str1 = Double.toString(a);
 System.out.println("a 转换为String型后+10的结果为： "+ (str1 + 10)); 
 String str = "2.8";
 // 将字符串转换为基本类型
 double b = Double.parseDouble(str);
 System.out.println("str 转换为double型后+10的结果为： "+ (b + 10));
 
 }
}
 
完成基本数据类型和字符串之间的转换。
 运行效果参考图
 
 
public class HelloWorld {
 public static void main(String[] args) {
 //定义float类型变量，赋值为88.99
 float f1 = 88.99F;
 //将基本类型转换为字符串
 String s = Float.toString(f1);
 //打印输出
 System.out.println("f1转换为String型后与整数20的求和结果为：" + (s + 20));
 //定义String类型变量，赋值为"188.55"
 String str = "188.55";
 // 将字符串转换为基本类型double
 double b = Double.parseDouble(str); 
 //打印输出
 System.out.println("str转换为double型后与整数20的求和结果为：" + (b + 20));
 }
}

Java包装类
 
基本概述
 
 
 
在某些场合要求所有的数据内容都必须是类类型的对象，而Java语言中有8种基本数据类型声明的变量都不是对象，为了使得这些数据在该场合种能够使用，则需要好进行对象化处理，此时就需要借助包装类将变量包装成对象再进行使用
 
 
包装类是为了值类型数据和对象间能互相转换、提供装箱和拆箱机制的类
 
 
基本数据类型
包装类型
byte
Byte
Boolean
Boolean
short
Short
char
Character
int
Integer
long
Long
float
Float
double
Double
自动拆箱与装箱
 
自动拆箱： 自动进行包装类向基本数据类型的转换
自动装箱： 自动进行基本数据类型向包装类的转换
 
Integer类型
 
 
java.lang.Integer 类是Object类的间接子类，用于包装int类型的数据
该类由final关键字修饰，表示该类不能被继承
常用方法 
  
该类重写了Object类的equals()、hashCode()以及toString()方法
Integer(int value) - 根据参数指定的整数值来构造对象
Integer(String s) - 根据参数指定的字符串来构造对象
int intValue() - 用于获取调用对象种含有的int类型数据并返回 
    
用于实现将Integer类型拆包为int类型（自动拆箱）
 
static Integer valueOf(int i) - 根据参数指定的整数来得到对象 
    
用于实现将int类型包装成Integer类型（自动装箱）
 
static int parseInt(String s) - 用于将字符转类型的数据转换为int类型的整数
 
案例
 
/*
 * 若尘
 */
package packing;

/**
 * 演示Integer类的使用
 * @author ruochen
 * @version 1.0
 */
public class TestInteger {
	public static void main(String[] args) {
		// 使用Integer类中的构造方法来构造对象，该类没有无参构造方法
		
		Integer it = new Integer(123);
		// 自动调用toString()方法, 得到字符串类型的十进制整数
		System.out.println(it);
		
		Integer it2 = new Integer("234");
		System.out.println(it2);
		System.out.println("----------------------");
		
		// 实现int类型和Integer类型之间的相互转换
		Integer it3 = Integer.valueOf(222);
		System.out.println(it3);  // String 类型
		
		int res = it3.intValue();
		System.out.println(res);  // int 类型

		System.out.println("----------------------");
		// 实现String类型向int类型的转换
		int res2 = Integer.parseInt("33333");
		System.out.println(res2);
		
		// java.lang.NumberFormatException
		// 要求字符串中每个字符都是十进制整数的字符，否则产生数字格式异常
		// int res3 = Integer.parseInt("1234a");
		// System.out.println(res3);
		
		System.out.println("----------------------");
		// 自动装箱和自动拆箱的机制
		Integer it4 = 100;  // int -> Integer 发生自动装箱，自动调用ValueOf()
		res = it4;  // Integer -> int  发生自动拆箱，自动调用intValue()
		
		
		System.out.println("----------------------");
		Integer it5 = 128;
		Integer it6 = 128;
		Integer it7 = new Integer(128);
		Integer it8 = new Integer(128);
		
		System.out.println(it5.equals(it6));  // true 比较内容
		System.out.println(it5 == it6);  // false 比较地址
		System.out.println(it7.equals(it8));  // true 比较内容
		System.out.println(it7 == it8);  // false 比较地址
		
		
		System.out.println("----------------------");
		// 源码993行
		// 耗时
		// -128~127 提前装箱完毕
		// 此处127已经提前装箱，不需要重新创建对象，两个指向同一个对象
		// 上面128不在范围内，需要创建对象
		Integer it9 = 127;
		Integer it10 = 127;
		// 下面是自己手动new的两个对象，地址不同
		Integer it11 = new Integer(128);
		Integer it12 = new Integer(128);
		
		System.out.println(it9.equals(it10));  // true 比较内容
		System.out.println(it9 == it10);  // false 比较地址
		System.out.println(it11.equals(it12));  // true 比较内容
		System.out.println(it11 == it12);  // false 比较地址
	}
}

 
123
234
----------------------
222
222
----------------------
33333
----------------------
----------------------
true
false
true
false
----------------------
true
true
true
false
 
自动装箱池(-128~127)
 
为了提高性能在Integer类的内部提供了自动装箱池，也就是把-128 ~ 127 之间的整数提前装箱完毕，若程序中需要该范围内的数据则直接从装箱池中获取，无需创建新对象