2021-01-18

                     ***java练习题30道***

1.java有8种基本类型，请问byte、int、long、char、float、double、boolean各占多少个字节？
正确答案: B 你的答案: A (错误)
1 2 8 2 4 8 1
1 4 8 2 4 8 1
1 4 4 2 4 4 2
1 4 4 2 4 8 2
解析：byte：8位 一个字节 int：32位 四个字节 long：64位 八个字节 char：16位 两个字节 float:32位 四个字节 double：64位 八个字节 boolean：8位 一个字节。

2.输入流将数据从文件，标准输入或其他外部输入设备中加载道内存，在 java 中其对应于抽象类（）及其子类。

正确答案: A 你的答案: A (正确)
java.io.InputStream
java.io.OutputStream
java.os.InputStream
java.os.OutputStream
解析：java.io.InputStream : 此抽象类是表示字节输入流的所有类的超类
java.io.OutputStream : 此抽象类是表示字节输出流的所有类的超类
java.os.InputStream , java.os.OutputStream 应该是不存在的，干扰项

3.若有定义：byte[]x={11,22,33,﹣66}；其中0≤k≤3，则对x数组元素错误的引用是（）
正确答案: C 你的答案: C (正确)
x[5-3]
x[k]
x[k+5]
x[0]
解析：下标越界问题：数组中有4个元素，小标范围为0~3
A: x[5-3]，小标为2 √
B: x[k], k的范围0~3 √
C: x[k+5], 小标范围为5~8 越界×
D: x[0], 小标为0 √

4.设A为已知定义的类名，下列声明A类的对象a的语句( )

正确答案: D 你的答案: C (错误)
float A a
public a=A（）
A a=new int ()
A a=new A()
解析：声明 a ＝new A( )；实例化 题目问的不是很准确

5.下列叙述错误的是（ ）

正确答案: C 你的答案: C (正确)
java程序的输入输出功能是通过流来实现的
java中的流按照处理单位可分成两种：字节流和字符流
InputStream是一个基本的输出流类。
通过调用相应的close（）方法关闭输入输出流
解析：大家相对纠结的应该是C选项吧，
C.InputStream是一个基本的输出流类
这里"基本的"，其实就是将流分为节点流和处理流，而“基本的”是表示节点流
所以C选项可以看成：InputStream是属于节点输出流；
所以我们就要判断InputStream是节点流还是处理流，是输出流还是输入流
这就涉及到哪些是节点流，哪些是处理流了，而且很明显，他是一个输入流
节点流：
FileInputStream，FileOutputStrean，FileReader，FileWriter
StringReader，StringWriter

ByteArrayInputStream ，ByteArrayOutputStream ，CharArrayReader

PipedInputStream PipedOutputStream PipedReaderPipedWriter

处理流：
BufferedInputStrean，BufferedOutputStream，BufferedReader，BufferedWriter
InputStreamReader，OutputStreamReader

DataInputStream，DataOutputStream

PrintWriter

6.以下的变量定义语句中，合法的是（）

正确答案: C 你的答案: C (正确)
byte=128
boolean=null
long a=123L
double=0.9239d
这没有变量的名的题根本就是上传的时候漏了变量名。
A byte b=128;
B boolean flag =null;
C long a=123L ;
D float f = 0.9239 ;
解析：选 C
A byte能表示的范围[-128,127]
B boolean的取值只能是true或false
C 对的
D 0.9239为double类型

7.public static void main(String[] args) {
Thread t = new Thread() {

public void run() {
my360DW();
}
};

t.run();
System.out.print(“DW”);

}

static void my360DW() {

System.out.print(“360”);

}

正确答案: C 你的答案: A (错误)
DW
360
360DW
都不输出
解析：
第一：方法名不能以数字开头，所以编译通不过 第二：改正确方法名后输出“360DW”，本题意在考察开启线程的方法t.start()和直接调用t.run()的区别。但在题目中没有提现 注：直接调用线程的run()方法不是开启线程，就是普通调用，会直接执行run()方法中的内容

8.main()
{
int m=12,n=34;
printf("%d%d",m++,++n);
printf("%d%d\n",n++,++m);
}
程序运行后的输出结果是（）
正确答案: A 你的答案: A (正确)
12353514
12353513
12343514
12343513
解析：答案选A，++在前表示先使用再计算，++在后表示先计算再使用。第一次输出时，先使用m的值（12），再将m加1（13），先将n加1（35）,在使用n的值（35）.所以此时输出的结果为1235，第二次输出之前m = 13,n = 35,同理，此时输出为3514，两次输出加起来即为12353514，所以选A

9.在异常处理中，如释放资源，关闭数据库、关闭文件应由（ ）语句来完成。
正确答案: C 你的答案: A (错误)
try子句
catch子句
finally子句
throw子句
解析：
try:可能发生异常的语句
catch:捕获，并处理异常（printStackTrace()用来跟踪异常事件发生时执行堆栈的内容）
throw:方法内部抛异常
throws:声明方法异常
finaly：代码中无论是否有异常都会执行，清除资源

10.定义有StringBuffer s1=new StringBuffer(10);s1.append(“1234”)则s1.length()和s1.capacity()分别是多少?
正确答案: A 你的答案: A (正确)
4 10
4 4
10 10
10 4
解析：StringBuffer s = new StringBuffer(x); x为初始化容量长度
s.append(“Y”); "Y"表示长度为y的字符串
length始终返回当前长度即y；
对于s.capacity()：
1.当y<x时，值为x
以下情况，容器容量需要扩展
2.当x<y<2x+2时，值为 2x+2
3.当y>2*x+2时，值为y

11.指出下来程序运行的结果是

正确答案: B 你的答案: B (正确)
good and abc
good and gbc
tst ok and abc
tst ok and gbc
解析：我从内存模型分析下，这道题从内存模型上可以这样分析：
内存分析：

首先主线程调用main方法，在主线程栈中main方法执行，main方法对应的栈帧（一个线程一个栈，一个方法一个栈帧）入栈。

1）当代码执行到

Example ex = new Example();

这条语句时，内存模型如下图：

解释：ex作为对象引用保存在栈帧内的局部变量表内，指向在堆中的对象实例，而该对象内的成员str、ch分别指向堆中分配的另外两个对象实例(new String(“good”)、以及数组，数组和对象实例在堆中分配)

2）当主线程代码执行到ex.change(ex.str, ex.ch);这段代码，change方法执行，对应栈帧在主线程栈内入栈，方法内的局部变量存放在栈帧的局部变量表内。

该语句执行时，内存模型如下图：

解释：

Change方法的传入的值

本质上都是字符数组和good的对象实例在堆中的地址，因此change方法内的局部变量ch、str也是分别指向这两个地址，如上图栈帧2中所示。

当change方法内的语句执行完

str = “test ok”;

ch[0] = ‘g’;

这两句时，内存模型如下图：

解释：

1，str = “test ok”;

右边这种写法，会直接在运行时常量池内分配字符串“test ok”，并将该地址传递给栈帧2内的局部变量str。

自行百度：

String str = “test”;

和

String str = new String(“test”);

的区别。

2，ch[0] = ‘g’;

该语句表示将指向的数组对象的第一个字符内容改成’g’。

总结：

由于栈帧1的ex局部变量指向的对象内的成员str指向的对象没有任何变化，因此

System.out.println(ex.str+“and”); 依然打印结果为：good and

而成员ch指向的对象内容有所变化，因此

System.out.println(ex.ch);打印结果为：gbc

12.下面的程序 编译运行后，在屏幕上显示的结果是（）

public class test {

public static void main(String args[]) {

int x,y;

x=5>>2;

y=x>>>2;

System.out.println(y);
}
}
正确答案: A 你的答案: D (错误)
0
2
5
80
解析：5的二进制是0101。
x=5>>2 （>>带符号右移）

将0101右移2位，为：0001。
y=x>>>2 （>>>无符号右移，左边空缺补充为0）

将0001右移2位，补0。结果为：0000。

所以得出答案0

这道题首先要知道二进制的计算方式
举例：0011
二进制换算十进制，从右到左，以当前位数字 乘以 2 的索引字幂，然后相加，索引从0开始计算。
如：
右一数字为1，索引为0。所以为：1*2^0（1乘以2的0次方）

右二数字为1，索引为1。所以为：1*2^1（1乘以2的1次方）

右三数字为0，索引为2。所以为：0*2^2（0乘以2的2次方）

右四数字为0，索引为3。所以为：0*2^3（0乘以2的3次方）

最后把结果相加。所以计算方式为：

02^3+0*22+12^1+1*20

=0+0+2+1

=3

13.以下描述错误的一项是（ ）？

正确答案: C 你的答案: A (错误)
程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行 到了第几行，是线程隔离的
原则上讲，所有的对象都是在堆区上分配内存，是线程之间共享的
方法区用于存储JVM加载的类信息、常量、静态变量，即使编译器编译后的代码等数据，是线程隔离的
Java方法执行内存模型，用于存储局部变量，操作数栈，动态链接，方法出口等信息，是线程隔离的
解析：
JAVA的JVM的内存可分为3个区：堆(heap)、栈(stack)和方法区(method)
栈区:
每个线程包含一个栈区，栈中只保存方法中（不包括对象的成员变量）的基础数据类型和自定义对象的引用(不是对象)，对象都存放在堆区中
每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问。
栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。
堆区:
存储的全部是对象实例，每个对象都包含一个与之对应的class的信息(class信息存放在方法区)。
jvm只有一个堆区(heap)被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身，几乎所有的对象实例和数组都在堆中分配。
方法区:
又叫静态区，跟堆一样，被所有的线程共享。它用于存储已经被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

14.一般用()创建InputStream对象,表示从标准输入中获取数据,用()创建OutputStream对象，表示输出到标准输出设备中。
正确答案: A 你的答案: C (错误)
System.in System.out
System.out System.in
System.io.in System.io.out
System.io.out System.io.in
解析：标准输入system.in 标准输出system.out
inputstream,outputstream都位于system.io包中

15.下面关于Java package的描述，哪个是正确的:（）
I. 包不提供将所有类名分区为更易管理的块的机制.
II. 包提供可见性控制机制.
III. 包的一个重要属性是包内定义的所有类都可以通过该包外的代码访问.
IV. 声明为包的一部分的类的.class文件可以存储在多个目录中.

正确答案: B 你的答案: D (错误)
只有I
只有II
只有III
只有IV
解析：为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

包的作用
1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。

2、如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。

3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

16.程序读入用户输入的一个值，要求创建一个自定义的异常，如果输入值大于 10 ，使用 throw 语句显式地引发异常，异常输出信息为 ”something’swrong!” ，语句为（）

正确答案: A 你的答案: C (错误)
if(i>10)throw new Exception(“something’swrong!”);
if(i>10)throw Exception e(“something’swrong!”);
if(i>10) throw new Exception e(“something’swrong!”);
if(i>10)throw Exception( “something’swrong!”);
解析：
throw是语句抛出异常，有两种用法: //***抛出异常e实例或新的Exception实例1.catch中的throw e; 2.方法体中的throw new Exception(); 区别如下: throw e是将已经catch到的e重新抛出，而throw new Exception()是重新生成一个Exception类的对象并抛出。有两点重要区别，第一e中记录了原异常的信息，如除零异常的信息，而new Exception()是一个新对象，当中不包含任何有用的信息；第二e可能存在向上转型，即e的实际类型可能是Exception的子类，而new Exception()就是Exception类的对象。

17.设有下面两个赋值语句：

a = Integer.parseInt(“1024”);

b = Integer.valueOf(“1024”).intValue();

下述说法正确的是（）
正确答案: D 你的答案: B (错误)
a是整数类型变量，b是整数类对象。
a是整数类对象，b是整数类型变量。
a和b都是整数类对象并且它们的值相等。
a和b都是整数类型变量并且它们的值相等。
解析：intValue()是把Integer对象类型变成int的基础数据类型；
parseInt()是把String 变成int的基础数据类型；
Valueof()是把String 转化成Integer对象类型；（现在JDK版本支持自动装箱拆箱了。）
本题：parseInt得到的是基础数据类型int，valueof得到的是装箱数据类型Integer，然后再通过valueInt转换成int，所以选择D

18.Given the following code:
public class Test {
private static int j = 0;

private static Boolean methodB(int k) {
    j += k;
    return true;
}

public static void methodA(int i) {
    boolean b;
    b = i < 10 | methodB(4);
    b = i < 10 || methodB(8);

}

public static void main(String args[]) {
    methodA(0);
    System.out.println(j);
}

}
What is the result?
正确答案: B 你的答案: D (错误)
The program prints”0”
The program prints”4”
The program prints”8”
The program prints”12”
The code does not complete.
解析：这道题主要考的是"|“与”||"的区别
用法：condition 1 | condition 2、condition 1 || condition 2
"|"是按位或：先判断条件1，不管条件1是否可以决定结果（这里决定结果为true)，都会执行条件2
"||"是逻辑或：先判断条件1，如果条件1可以决定结果（这里决定结果为true)，那么就不会执行条件2
代码如下：
//i=0, i<10为true，但是依然执行methodB(4),之后 j=4

b = i < 10| methodB(4);

//i=0, i<10位true，可以决定结果，所以不会执行methodB(8)，j依然=4

b = i < 10|| methodB(8);

19.static String str0=“0123456789”;
static String str1=“0123456789”;
String str2=str1.substring(5);
String str3=new String(str2);
String str4=new String(str3.toCharArray());
str0=null;
假定str0,…,str4后序代码都是只读引用。
Java 7中，以上述代码为基础，在发生过一次FullGC后，上述代码在Heap空间（不包括PermGen）保留的字符数为（）
正确答案: C 你的答案: C (正确)
5
10
15
20

解析：选C 方法区：主要存储结构信息的地方，比如方法体，同时也是存储静态变量，以及静态代码块的区域，构造函数，常量池，接口初始化等等 方法区物理上还是在堆中，是在堆的持久代里面。堆有年轻代 (由一个Eden区和俩个survivor区组成)，老年代，持久代。新创建的对象都在年轻代的Eden区，经过一次JC收集后，存活下来的会被复制到survivor区(一个满了，就全部移动到另外一个大的中，但要保证其中一个survivor为空)，经过多次JC后，还存活的对象就被移到老年代了。 持久代就是经常说的方法区里面存放类信息，常量池，方法等 static String str0=“0123456789”; static String str1=“0123456789”;是放在方法区里。也就是持久代，题目中已经说了，不包含持久代，所以剩余空间为5+5+5=15.

20.关于 Socket 通信编程，以下描述正确的是：（ ）

正确答案: C 你的答案: B (错误)
客户端通过new ServerSocket()创建TCP连接对象
客户端通过TCP连接对象调用accept()方法创建通信的Socket对象
客户端通过new Socket()方法创建通信的Socket对象
服务器端通过new ServerSocket()创建通信的Socket对象
解析：

A 错误
Client端通过new Socket()创建用于通信的Socket对象。
B 错误
Client端的Socket对象是直接new出来的。
C 正确
D 错误
Server端通过new ServerSocket()创建ServerSocket对象，ServerSocket对象的accept()方法产生阻塞，阻塞直到捕捉到一个来自Client端的请求。当Server端捕捉到一个来自Client端的请求时，会创建一个Socket对象，使用此Socket对象与Client端进行通信。

21.关于Java以下描述正确的有( )
正确答案: A 你的答案: A (正确)
native关键字表名修饰的方法是由其它非Java语言编写的
能够出现在import语句前的只有注释语句
接口中定义的方法只能是public
构造方法只能被修饰为public或者default
解析：A：native是由调用本地方法库（如操作系统底层函数），可以由C，C++实现，A正确
B：import是用于导包语句，其前面可以出现package，用来声明包的，B错误
C：接口方法的修饰符可以是：public，abstract，default，static（后两者需要有{}），C正确
D：构造方法可以用private，protected，default，private，D错误

22.list是一个ArrayList的对象，哪个选项的代码填到//todo delete处，可以在Iterator遍历的过程中正确并安全的删除一个list中保存的对象？（）

Iterator it = list.iterator();
int index = 0;
while (it.hasNext())
{
Object obj = it.next();
if (needDelete(obj)) //needDelete返回boolean，决定是否要删除
{
//todo delete
}
index ++;
}

正确答案: A 你的答案: C (错误)
it.remove();
list.remove(obj);
list.remove(index);
list.remove(obj,index);
解析：答案：A
如果在循环的过程中调用集合的remove()方法，就会导致循环出错，例如：
for(int i=0;i<list.size();i++){
list.remove(…);
}
循环过程中list.size()的大小变化了，就导致了错误。
所以，如果你想在循环语句中删除集合中的某个元素，就要用迭代器iterator的remove()方法，因为它的remove()方法不仅会删除元素，还会维护一个标志，用来记录目前是不是可删除状态，例如，你不能连续两次调用它的remove()方法，调用之前至少有一次next()方法的调用。

23.在Struts框架中如果要使用Validation作验证的话，需要使用以下哪个Form？
正确答案: D 你的答案: C (错误)
ActionForm
ValidatorActionForm
ValidatorForm
DynaValidatorActionForm
解析：在struts配置文件中配置具体的错误提示，再在FormBean中的validate()方法具体调用。

24.下列Java代码中的变量a、b、c分别在内存的____存储区存放。

class A {
private String a = “aa”;
public boolean methodB() {
String b = “bb”;
final String c = “cc”;
}
}
正确答案: C 你的答案: D (错误)
堆区、堆区、堆区
堆区、栈区、堆区
堆区、栈区、栈区
堆区、堆区、栈区
静态区、栈区、堆区
静态区、栈区、栈区
解析：堆区：只存放类对象，线程共享；
方法区：又叫静态存储区，存放class文件和静态数据，线程共享;
栈区：存放方法局部变量，基本类型变量区、执行环境上下文、操作指令区，线程不共享;

25.以下代码的输出结果是？

public class B
{
public static B t1 = new B();
public static B t2 = new B();
{
System.out.println(“构造块”);
}
static
{
System.out.println(“静态块”);
}
public static void main(String[] args)
{
B t = new B();
}
}

正确答案: C 你的答案: C (正确)
静态块 构造块 构造块 构造块
构造块 静态块 构造块 构造块
构造块 构造块 静态块 构造块
构造块 构造块 构造块 静态块
解析;开始时JVM加载B.class，对所有的静态成员进行声明，t1 t2被初始化为默认值，为null，又因为t1 t2需要被显式初始化，所以对t1进行显式初始化，初始化代码块→构造函数（没有就是调用默认的构造函数），咦！静态代码块咋不初始化？因为在开始时已经对static部分进行了初始化，虽然只对static变量进行了初始化，但在初始化t1时也不会再执行static块了，因为JVM认为这是第二次加载类B了，所以static会在t1初始化时被忽略掉，所以直接初始化非static部分，也就是构造块部分（输出’‘构造块’’）接着构造函数（无输出）。接着对t2进行初始化过程同t1相同（输出’构造块’），此时就对所有的static变量都完成了初始化，接着就执行static块部分（输出’静态块’），接着执行，main方法，同样也，new了对象，调用构造函数输出（‘构造块’）

26.servlet周期包含哪些：
正确答案: A B C 你的答案: A C (错误)
初始化
销毁
请求处理
开始
解析：ervlet生命周期分成3个阶段：

1）初始化阶段：调用init方法

2）响应客户请求：调用service

3）终止：调用destory方法

初始化阶段：在下列时刻servlet容器装载servlet

1 servlet容器启动时，自动装载某些servlet

2 在servlet容器启动后，客户首次向servlet发送请求

3 servlet类文件被更新之后，重新装载servlet

Servlet被装载之后，servlet容器创建一个servlet’对象并调用servlet的init方法，在servlet生命周期内，init方法只能被调用一次。servlet工作原理：客户端发起一个请求，servlet调用service方法时请求进行响应，service对请求的方式进行了匹配，选择调用dopost或者doget等这些方法，然后进入对应方法中调用逻辑层的方法，实现对客户的响应。

响应客户请求：对于用户到达servlet的请求，servlet容器会创建特定于该请求的servletrequest和servletresponse对象，然后调用servlet的service方法，service方法从servletrequest对象中获取客户请求的信息，处理该请求，并且通过servletresponse对象向客户端返回响应信息。

终止：当web应用终止或者servlet容器终止或servlet容器重新装载servlet新实例时，servlet容器会调用servlet对象的destory方法，在destory方法中可以释放servlet占用的资源

发表于 2018-12-18 15:49:20

27.下面有关java类加载器，说法正确的是？
正确答案: A B C D 你的答案: A D (错误)
引导类加载器（bootstrap class loader）：它用来加载 Java 的核心库，是用原生代码来实现的
扩展类加载器（extensions class loader）：它用来加载 Java 的扩展库。
系统类加载器（system class loader）：它根据 Java 应用的类路径（CLASSPATH）来加载 Java 类
tomcat为每个App创建一个Loader，里面保存着此WebApp的ClassLoader。需要加载WebApp下的类时，就取出ClassLoader来使用
解析：Java中的类加载器
Java 中的类加载器大致可以分成两类，一类是系统提供的，另外一类则是由Java 应用开发人员编写的。系统提供的类加载器主要有下面三个：

引导类加载器（bootstrap class loader）：
它用来加载 Java 的核心库，是用原生代码来实现的，并不继承自 java.lang.ClassLoader。主要负责jdk_home/lib目录下的核心api 或 -Xbootclasspath 选项指定的jar包装入工作（其中的jdk_home是指配置jdk环境变量是java_home的配置路径，一般是jdk/jre所在目录）。

扩展类加载器（extensions class loader）：
它用来加载 Java 的扩展库。Java虚拟机的实现会提供一个扩展库目录，扩展类加载器在此目录里面查找并加载 Java 类，主要负责jdk_home/lib/ext目录下的jar包或 -Djava.ext.dirs 指定目录下的jar包装入工作。

系统类加载器（system class loader）：
它根据 Java 应用的类路径（CLASSPATH）来加载 Java 类。一般来说，Java 应用的类都是由它来完成加载的。可以通过 ClassLoader.getSystemClassLoader()来获取它。主要负责CLASSPATH/-Djava.class.path所指的目录下的类与jar包装入工作.

除了系统提供的类加载器以外，开发人员可以通过继承java.lang.ClassLoader类的方式实现自己的类加载器，从而进行动态加载class文件，以满足一些特殊的需求，这体现java动态实时类装入特性。

除了引导类加载器之外，所有的类加载器都有一个父类加载器，通过getParent()方法可以得到。对于系统提供的类加载器来说，系统类加载器的父类加载器是扩展类加载器，而扩展类加载器的父类加载器是引导类加载器；对于开发人员编写的类加载器来说，其父类加载器是加载此类加载器 Java 类的类加载器。因为类加载器 Java 类如同其它的 Java 类一样，也是要由类加载器来加载的。一般来说，开发人员编写的类加载器的父类加载器是系统类加载器。类加载器通过这种方式组织起来，形成树状结构。树的根节点就是引导类加载器。下图中给出了一个典型的类加载器树状组织结构示意图，其中的箭头指向的是父类加载器。

28.Servlet的生命周期可以分为初始化阶段，运行阶段和销毁阶段三个阶段，以下过程属于初始化阶段是（）。
正确答案: A C D 你的答案: A B (错误)
加载Servlet类及.class对应的数据
创建servletRequest和servletResponse对象
创建ServletConfig对象
创建Servlet对象
解析：Servlet的生命周期可以分为初始化阶段，运行阶段和销毁阶段三个阶段，以下过程属于初始化阶段是（）。
正确答案: A C D 你的答案: A B (错误)
加载Servlet类及.class对应的数据
创建servletRequest和servletResponse对象
创建ServletConfig对象
创建Servlet对象

29.下面的switch语句中，x可以是哪些类型的数据：()

switch(x)
{
default:
System.out.println(“Hello”);
}

正确答案: B D 你的答案: B C E F (错误)
long
char
float
byte
double
Object
解析：以java8为准，switch支持10种类型 基本类型：byte char short int 对于包装类 ：Byte,Short,Character,Integer String enum 2、实际只支持int类型 Java实际只能支持int类型的switch语句，那其他的类型时如何支持的 a、基本类型byte char short 原因：这些基本数字类型可自动向上转为int, 实际还是用的int。 b、基本类型包装类Byte,Short,Character,Integer 原因：java的自动拆箱机制 可看这些对象自动转为基本类型 c、String 类型 原因：实际switch比较的string.hashCode值，它是一个int类型 如何实现的，网上例子很多。此处不表。 d、enum类型 原因 ：实际比较的是enum的ordinal值（表示枚举值的顺序），它也是一个int类型 所以也可以说 switch语句只支持int类型

30.下面有关 JAVA 异常类的描述,说法正确的有()
正确答案: A B C 你的答案: A D (错误)
异常的继承结构:基类为 Throwable,Error 和 Exception 。实现 Throwable, RuntimeException 和 IOException 等继承 Exception
非 RuntimeException 一般是外部错误(不考虑Error的情况下),其可以在当前类被 try{}catch 语句块所捕获
Error 类体系描述了 Java 运行系统中的内部错误以及资源耗尽的情形,Error 不需要捕捉
RuntimeException 体系包括错误的类型转换、数组越界访问和试图访问空指针等等,必须 被 try{}catch 语句块所捕获
解析：
都是Throwable的子类：
1.Exception（异常） :是程序本身可以处理的异常。
2.Error（错误）: 是程序无法处理的错误。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，一般不需要程序处理。
3.检查异常（编译器要求必须处置的异常） ： 除了Error，RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。

4.非检查异常(编译器不要求处置的异常): 包括运行时异常（RuntimeException与其子类）和错误（Error）。