牛客刷题笔记--(java基础151-200)_在java中,下列关于常量的说法错误的是?a.常量的值被赋值后,在程序运行过程中

151 以下哪种JAVA的变量表达式使得变量a和变量b具有相同的内存引用地址( AB )

String a = "hello"; String b = "hello";

Integer a; Integer b = a;

int a = 1; Integer b = new Integer(1);

int a = 1; Integer b = 1;
1
2
3
4
5
6
7

内存引用地址，是指栈中存放的地址，来指向堆中的某个位置。
int 是基本类型，数据直接存放在栈中，不存在内存引用地址的说法

A对 指向常量池里的"hello"。
B对 题中没说声明的a是局部变量。
C错 int a =1;并不指向堆中，它只有值，没有引用地址，Integer b =new Integer(1);指向堆中地址为1的位置。
D错 原因同C

152 Java是一门支持反射的语言,基于反射为Java提供了丰富的动态性支持，下面关于Java反射的描述，哪些是错误的：( ADF )

Java反射主要涉及的类如Class, Method, Filed,等，他们都在java.lang.reflet包下

通过反射可以动态的实现一个接口，形成一个新的类，并可以用这个类创建对象，调用对象方法

通过反射，可以突破Java语言提供的对象成员、类成员的保护机制，访问一般方式不能访问的成员

Java反射机制提供了字节码修改的技术，可以动态的修剪一个类

Java的反射机制会给内存带来额外的开销。例如对永生堆的要求比不通过反射要求的更多

Java反射机制一般会带来效率问题，效率问题主要发生在查找类的方法和字段对象，因此通过缓存需要反射类的字段和方法就能达到与之间调用类的方法和访问类的字段一样的效率 
1
2
3
4
5
6
7
8
9
10
11
12
13

射指的是在运行时能够分析类的能力的程序。
反射机制可以用来：
1.在运行时分析类的能力–检查类的结构–所用到的就是java.lang.reflect包中的Field、Method、Constructor，分别用于描述类的与、方法和构造器。A中的Class类在java.lang中。
2.在运行时查看对象。
3.实现通用的数组操作代码。
反射机制的功能：
在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态***。
反射机制常见作用：
动态加载类、动态获取类的信息（属性、方法、构造器）；动态构造对象；动态调用类和对象的任意方法、构造器；动态调用和处理属性；获取泛型信息（新增类型：ParameterizedType,GenericArrayType等）；处理注解（反射API:getAnnotationsdeng等）。
反射机制性能问题：
反射会降低效率。
void setAccessible(boolean flag):是否启用访问安全检查的开关，true屏蔽Java语言的访问检查，使得对象的私有属性也可以被查询和设置。禁止安全检查，可以提高反射的运行速度。

A ：Filed、Method Constructor分别分别用与描述类的与、方法和构造器。 在Java.lang.reflet包中而Class而是在Java.lang中
B：是对的 ，动态代理就是通过实现接口的 ，然后我们可以通过类的路径可以的到类的全部信息。（可以看下动态代理的原理：
C：反射的概念中提到过 反射可以通过类的路径来得到该类的全部信息。
D：反射可以动态的调用类和对象的任意方法
E：反射的缺点是对性能有影响
F：反射会降低效率，可是设置禁止安全检查，来提高反射的运行速度；
反射常见的作用有：动态加载类、动态获取类的信息（属性、方法、构造器）；
动态构造对象；动态调用类和对象的任意方法、构造器；
动态调用和处理属性；
获取泛型信息 ,处理注解

153 下面关于Applet的说法是正确的是(ABCD)

Applet可以在带有Java解释器的浏览器中运行

Applet类必须继承java.applet.Applet

Applet可以访问本地文件

Applet是Object类的子类

154 从以下哪一个选项中可以获得Servlet的初始化参数?（C）
Servlet
ServletContext
ServletConfig
GenericServlet

ServletContext对象：servlet容器在启动时会加载web应用，并为每个web应用创建唯一的servlet context对象，可以把ServletContext看成是一个Web应用的服务器端组件的共享内存，在ServletContext中可以存放共享数据。ServletContext对象是真正的一个全局对象，凡是web容器中的Servlet都可以访问。
整个web应用只有唯一的一个ServletContext对象
servletConfig对象：用于封装servlet的配置信息。从一个servlet被实例化后，对任何客户端在任何时候访问有效，但仅对servlet自身有效，一个servlet的ServletConfig对象不能被另一个servlet访问。

155What is displayed when the following is executed; （A）

double d1=-0.5;
System.out.println("Ceil d1="+Math.ceil(d1));
System.out.println("floor d1="+Math.floor(d1));
1
2
3

Ceil d1=-0.0
floor d1=-1.0

Ceil d1=0.0
floor d1=-1.0

Ceil d1=-0.0
floor d1=-0.0

Ceil d1=0.0
floor d1=0.0

Ceil d1=0
floor d1=-1
1
2
3
4
5
6
7
8
9
10
11
12
13
14

ceil：大于等于 x，并且与它最接近的整数。
floor：小于等于 x，且与 x 最接近的整数。

ceil：天花板数，向上取整。
floor：地板数，向下取整

这里主要是有一点：

Math.ceil(d1) 
1

ceil 方法上有这么一段注释：If the argument value is less than zero but greater than -1.0, then the result is negative zero
如果参数小于0且大于-1.0，结果为 -0

Math.floor(d1)
1

ceil 和 floor 方法 上都有一句话：If the argument is NaN or an infinity or positive zero or negative zero, then the result is the same as the argument，意思为：如果参数是 NaN、无穷、正 0、负 0，那么结果与参数相同，
如果是 -0.0，那么其结果是 -0.0

156 下列哪个选项是合法的标识符？（BD）
123
_name
class
first

Java标识符由 数字、字母、下划线(_)、美元符号($) 组成， 首位不能是数字 。并且 Java关键字不能作为标识符 。

标识符：
1. 只能由数字，字母，符号（有且仅有_和$两个）组成。
2. 数字不能作为标识符的开头。
3. 不能和关键字，保留字，显式常量一样。关键字都是小写的。
4. null，true，false都不是关键字，属于显式常量。goto，const都是保留关键字。

java的关键字不能作为标识符，java中的关键字如下：
访问控制
private protected public

类,方法和变量修饰符
abstract class extends final implements interface native new
static strictfp synchronized transient volatile

程序控制
break continue return do while if else for instanceof switch
case default

异常处理
try cathc throw throws

包相关
import package

基本类型
boolean byte char double float int long short null true false

变量引用
super this void

保留字
goto const

157 下述有关c++的虚类和java接口的描述，说法错误的是？(CD)

c++虚类相当与java里面的抽象类

c++中没有接口的概念，与之对应的是纯虚类，对应的是java的接口

纯虚函数和虚函数的区别在于前者只包含定义，而后者还可以包含函数体。

一个抽象类和接口中的方法必须是抽象方法

158 在使用 interface 声明一个外部接口时，只可以使用（ D）修饰符修饰该接口。

private

protected

private protected

public

jdk8之后，接口可以定义 static方法 与 default方法。 static方法只能通过接口调用，不能通过实现类调用。default只能通过接口实现类调用，不能通过接口名调用。
接口的方法都是 public abstract 变量都是public static final的

159 在第16行插入哪段代码可以获得一个Point对象的坐标?(D )

class Line {
11. public class Point { public int x,y;}
12. public Point getPoint() { return new Point(); }
13. }
14. class Triangle {
15. public Triangle() {
16. // insert code here
17. }
18. }
1
2
3
4
5
6
7
8
9

Point p = Line.getPoint();

Line.Point p = Line.getPoint();

Point p = (new Line()).getPoint();

Line.Point p = (new Line()).getPoint();


1
2
3
4
5
6
7
8
9
10
11

(1)把类定义在另一个类的内部，该类就被称为内部类。
举例：把类B定义在类A中，类B就被称为内部类。
(2)内部类的访问规则
A:可以直接访问外部类的成员，包括私有
B:外部类要想访问内部类成员，必须创建对象
(3)内部类的分类
A:成员内部类
B:局部内部类
C:匿名内部类
(4)成员内部类访问规则
成员内部类不是静态的：
外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
成员内部类是静态的：
外部类名.内部类名 对象名 = new 外部类名.内部类名();
(5)局部内部类
A:局部内部类访问局部变量必须加final修饰。
B:为什么呢?
因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。
所以，堆内存还是用该变量，而改变量已经没有了。
为了让该值还存在，就加final修饰。
通过反编译工具我们看到了，加入final后，堆内存直接存储的是值，而不是变量名。
(6)匿名内部类(掌握)
A:是局部内部类的简化形式
B:前提
存在一个类或者接口
C:格式:
new 类名或者接口名() {
重写方法;
}
D:本质：
其实是继承该类或者实现接口的子类匿名对象

160 以下哪项陈述是正确的？（E）

垃圾回收线程的优先级很高，以保证不再 使用的内存将被及时回收

垃圾收集允许程序开发者明确指定释放 哪一个对象

垃圾回收机制保证了JAVA程序不会出现 内存溢出

进入”Dead”状态的线程将被垃圾回收器回收

以上都不对
1
2
3
4
5
6
7
8
9

A: 垃圾回收在jvm中优先级相当相当低。
B：垃圾收集器（GC）程序开发者只能推荐JVM进行回收，但何时回收，回收哪些，程序员不能控制。
C：垃圾回收机制只是回收不再使用的JVM内存，如果程序有严重BUG，照样内存溢出。
D：进入DEAD的线程，它还可以恢复，GC不会回收

真正宣布一个对象死亡，至少需要经历2次标记过程。当第一次标记时会同时进行一次筛选(判断此对象是否有必要执行finalize方法)。如果对象没有覆盖该方法，就面临死亡，所以说这个方法是对象逃脱死亡命运的最后一次机会。

当程序运行时，至少会有两个线程开启启动，一个是我们的主线程，一个时垃圾回收线程，垃圾回收线程的priority（优先级）较低
垃圾回收器会对我们使用的对象进行监视，当一个对象长时间不使用时，垃圾回收器会在空闲的时候（不定时）对对象进行回收，释放内存空间，程序员是不可以显示的调用垃圾回收器回收内存的，但是可以使用System.gc()方法建议垃圾回收器进行回收，但是垃圾回收器不一定会执行。
Java的垃圾回收机制可以有效的防止内存溢出问题，但是它并不能完全保证不会出现内存溢出。例如当程序出现严重的问题时，也可能出现内存溢出问题。

161 在JAVA中，假设A有构造方法A(int a)，则在类A的其他构造方法中调用该构造方法和语句格式应该为（B）

this.A(x)

this(x)

super(x)

A(x)
1
2
3
4
5
6
7

this的作用其中一个就是在一个构造方法中调用另一个构造方法，格式为this(参数)；
super是调用父类的方法；
A(a)这种形式是在new一个类时使用。

A.这是调用普通方法的写法

C.这时显示调用父类构造方法

D.调用静态方法

162 根据下面这个程序的内容，判断哪些描述是正确的：（CD ）

public class Test {
public static void main(String args[]) {
String s = "tommy";
Object o = s;
sayHello(o); //语句1
sayHello(s); //语句2
}
public static void sayHello(String to) {
System.out.println(String.format("Hello, %s", to));
}
public static void sayHello(Object to) {
System.out.println(String.format("Welcome, %s", to));
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

没意思没意思 上边是s o顺序 调用方法就变成o s了 真的没意思

163 String str = new String(“abc”)，“abc”在内存中是怎么分配的？(AC)

堆
栈
字符串常量区
寄存器
1
2
3
4

什么是字符串常量池
JVM为了减少字符串对象的重复创建，其维护了一个特殊的内存，这段内存称为字符串常量池或者字符串字面量池

工作原理
当代码中出现字面量形式创建字符串对象时，JVM首先会对这个字面量进行检查，如果字符串常量池中存在相同内容的字符串对象的引用，则将这个引用返回，否则新的字符串对象被创建，然后将这个引用放入字符串常量池，并返回该引用。

实现前提
字符串常量池实现的前提条件就是Java中String对象是不可变的，这样可以安全保证多个变量共享同一个对象。如果Java中的String对象可变的话，一个引用操作改变了对象的值，那么其他的变量也会受到影响，显然这样是不合理的。

关于堆和栈
Java中所有由类实例化的对象和数组都存放在堆内存中，无论是成员变量，局部变量，还是类变量，它们指向的对象都存储在堆内存中。而栈内存用来存储局部变量和方法调用。

关于寄存器
Java中运行时数据区有一个程序寄存器（又称程序计数器），该寄存器为线程私有。Java中的程序计数器用来记录当前线程中正在执行的指令。如果当前正在执行的方法是本地方法，那么此刻程序计数器的值为undefined

“abc”保存在常量池，str引用的对象保存在堆里，而java7中又把常量池移到了堆中

当你new String(“abc”)时，其实会先在字符串常量区生成一个abc的对象，然后new String()时会在堆中分配空间，然后此时会把字符串常量区中abc复制一个给堆中的String，故abc应该在堆中和字符串常量区
164 在异常处理中，以下描述不正确的有（D）

try块不可以省略

可以使用多重catch块

finally块可以省略

catch块和finally块可以同时省略
解释：
用try-catch 捕获异常;
用try-finally 清除异常;
用try-catch-finally 处理所有的异常. 三者选一种即可
1.try块中放置可能引发异常的代码 故不可被省略
2.Jdk1.7中新增了多个catch块的功能，用以捕获多异常， 捕获顺序为先小后大
3.finally块用作回收无法被JVM回收的物理资源 例如数据库链接 网络链接等 Jdk1.7中虽增强了try()的功能，使得其中的代码在程序执行完毕后自动关闭代码 相当与隐含finally块
4.catch块用作捕获异常
总结
异常处理语法结构中只有try块是必须的，但不能只有try块，1.7中的增强try除外 因为其中的try()已经隐含了finally了

165关于Float，下列说法错误的是©

Float是一个类

Float在java.lang包中

Float a=1.0是正确的赋值方法

Float a= new Float(1.0)是正确的赋值方法

解释:
Float是类，float不是类.
查看JDK源码就可以发现Byte，Character，Short，Integer，Long，Float，Double，Boolean都在java.lang包中.
Float正确复制方式是Float f=1.0f,若不加f会被识别成double型,double无法向float隐式转换.
Float a= new Float(1.0)是正确的赋值方法，但是在1.5及以上版本引入自动装箱拆箱后，会提示这是不必要的装箱的警告，通常直接使用Float f=1.0f.

Float a = new Float(1.0); 这个的东西能存在，是因为Float类中有形参是float和double的两个构造器。
Double d = new Double(1.0F);这个能成立的原因是float向上转型了。
Float a = 1.0；这个东西不成立是因为浮点型的默认类型是double，而double不会自动转成float，然后再装箱。
Double d = 1.0f；不成立的原因是因为Double类中的装箱方法，只有valueOf(String s)和valueOf(double d)；装箱本身可不会自动向上转型啊。

166 下面有关webservice的描述，错误的是？(B)

Webservice是跨平台，跨语言的远程调用技术

Webservice通信机制实质就是json数据交换

Webservice采用了soap协议（简单对象协议）进行通信

WSDL是用于描述 Web Services 以及如何对它们进行访问

解析:Webservice是跨平台，跨语言的远程调用技术;
它的通信机制实质就是xml数据交换;
它采用了soap协议（简单对象协议）进行通信
WSDL 指网络服务描述语言 (Web Services Description Language)。
WSDL 是一种使用 XML 编写的文档。这种文档可描述某个 Web service。它可规定服务的位置，以及此服务提供的操作（或方法）

Web service顾名思义是基于web的服务，它是一种跨平台，跨语言的服务。
我们可以这样理解它，比如说我们可以调用互联网上查询天气信息的web服务，把它嵌入到我们的B/S程序中，当用户从我们的网点看到天气信息时，会认为我们为他提供很多的服务，但其实我们什么也没做，只是简单的调用了一下服务器上的一端代码而已。Web service 可以将你的服务发布到互联网上让别人去调用，也可以调用别人发布的web service，和使用自己的代码一样。
它是采用XML传输格式化的数据，它的通信协议是SOAP(简单对象访问协议).

167 java运行时内存分为“线程共享”和“线程私有”两部分，以下哪些属于“线程共享”部分(BD)

程序计算器

方法区

java虚拟机栈

java堆

解释
私有:java虚拟机栈，程序计数器，本地方法栈 共享:java堆，方法区

共享的资源有：
a. 堆 由于堆是在进程空间中开辟出来的，所以它是理所当然地被共享的；因此new出来的都是共享的（16位平台上分全局堆和局部堆，局部堆是独享的）
b. 全局变量 它是与具体某一函数无关的，所以也与特定线程无关；因此也是共享的
c. 静态变量 虽然对于局部变量来说，它在代码中是“放”在某一函数中的，但是其存放位置和全局变量一样，存于堆中开辟的.bss和.data段，是共享的
d. 文件等公用资源 这个是共享的，使用这些公共资源的线程必须同步。Win32 提供了几种同步资源的方式，包括信号、临界区、事件和互斥体。
独享的资源有
a. 栈 栈是独享的
b. 寄存器 这个可能会误解，因为电脑的寄存器是物理的，每个线程去取值难道不一样吗？其实线程里存放的是副本，包括程序计数器PC

168 下面哪些类可以被继承？ Java.lang.Thread、java.lang.Number、java.lang.Double、java.lang.Math、 java.lang.ClassLoader（ABE）

Thread

Number

Double

Math

ClassLoader

解释
java.lang包中不能被继承的类：
public final class Byte
public final class Character
public static final class Character.UnicodeBlock
public final class Class
public final class Compile
public final class Double
public final class Float
public final class Integer
public final class Long
public final class Math
public final class ProcessBuilder
public final class RuntimePermission
public final class Short
public final class StackTraceElement
public final class StrictMath
public final class String
public final class StringBuffer
public final class StringBuilder
public final class System
public final class Void

A，Thread可以被继承，用于创建新的线程
B，Number类可以被继承，Integer，Float，Double等都继承自Number类
C，Double类的声明为

public final class Doubleextends Numberimplements Comparable<Double>
1

final生明的类不能被继承
D，Math类的声明为

public final class Mathextends Object
1

不能被继承
E，ClassLoader可以被继承，用户可以自定义类加载器

169 若有下列定义，下列哪个表达式返回false？（B）
String s = “hello”;
String t = “hello”;
char c[] = {‘h’,‘e’,‘l’,‘l’,‘o’} ;

s.equals(t);
t.equals(c);
s==t;
t.equals(new String("hello"));
1
2
3
4

常量池中的字符串，只有变量名不同是可以用双等号判断是否相等的，内存都是常量池中的字符串。但是new出来的字符串，只能用equals，用双等号是不相等的，因为是两个内存对象。

170 对于如下代码段，可以放入到横线位置，使程序正确编译运行，而且不产生错误的选项是（ C）

 class A{
    public A foo(){return this;}
}
class B extends A{
    public A foo(){
        return this;
    }
}

class C extends B
{
    _______

} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

public void foo(){}

public int foo(){return 1;}

public A foo(B b){return b;}

public A foo(){return A;}


1
2
3
4
5
6
7
8
9
10
11

public void foo(){}      方法名相同，返回值不同-->不是重写；而参数列表与父类相同，那么也不是重载。

public int foo(){return 1;}    方法名相同，返回值不同-->不是重写；而参数列表与父类相同，那么也不是重载。

public A foo(B b){return b;}    方法名相同，返回值（无所谓），而参数列表与父类不相同，那么是重载。另：B是A的子类，根据里氏替换原则/自动向上转型，可以这个选项正确。

public A foo(){return A;}    方法名相同，返回值相同，而参数列表也与父类相同，那么也不是重载。


1
2
3
4
5
6
7
8
9
10
11

171 下面有关SPRING的事务传播特性，说法错误的是？（B）

PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行

PROPAGATION_REQUIRED：支持当前事务，如果当前没有事务，就抛出异常

PROPAGATION_REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起

PROPAGATION_NESTED：支持当前事务，新增Savepoint点，与当前事务同步提交或回滚
1
2
3
4
5
6
7

172 设有下面两个赋值语句：下述说法正确的是（D）

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

a是整数类型变量，b是整数类对象。

a是整数类对象，b是整数类型变量。

a和b都是整数类对象并且它们的值相等。

a和b都是整数类型变量并且它们的值相等。

intValue()是把Integer对象类型变成int的基础数据类型；
parseInt()是把String 变成int的基础数据类型；
Valueof()是把String 转化成Integer对象类型；（现在JDK版本支持自动装箱拆箱了。）
本题：parseInt得到的是基础数据类型int，valueof得到的是装箱数据类型Integer，然后再通过Intvalue转换成int，所以选择D

Integer对象的方法
Integer.parseInt("");是将字符串类型转换为int的基础数据类型
Integer.valueOf("")是将字符串类型数据转换为Integer对象
Integer.intValue();是将Integer对象中的数据取出，返回一个基础数据类型int

173 下面有关java classloader说法正确的是（ACD）？

ClassLoader就是用来动态加载class文件到内存当中用的

JVM在判定两个class是否相同时，只用判断类名相同即可，和类加载器无关

ClassLoader使用的是双亲委托模型来搜索类的

Java默认提供的三个ClassLoader是Boostrap ClassLoader，Extension ClassLoader，App ClassLoader

以上都不正确
1
2
3
4
5
6
7
8
9

JDK中提供了三个ClassLoader，根据层级从高到低为：

Bootstrap ClassLoader，主要加载JVM自身工作需要的类。
Extension ClassLoader，主要加载%JAVA_HOME%\lib\ext目录下的库类。
Application ClassLoader，主要加载Classpath指定的库类，一般情况下这是程序中的默认类加载器，也是ClassLoader.getSystemClassLoader() 的返回值。（这里的Classpath默认指的是环境变量中配置的Classpath，但是可以在执行Java命令的时候使用-cp 参数来修改当前程序使用的Classpath） 
1
2
3

JVM加载类的实现方式，我们称为 双亲委托模型：
如果一个类加载器收到了类加载的请求，他首先不会自己去尝试加载这个类，而是把这个请求委托给自己的父加载器，每一层的类加载器都是如此，因此所有的类加载请求最终都应该传送到顶层的Bootstrap ClassLoader中，只有当父加载器反馈自己无法完成加载请求时，子加载器才会尝试自己加载。

双亲委托模型的重要用途是为了解决类载入过程中的安全性问题。

假设有一个开发者自己编写了一个名为Java.lang.Object的类，想借此欺骗JVM。现在他要使用自定义ClassLoader来加载自己编写的java.lang.Object类。然而幸运的是，双亲委托模型不会让他成功。因为JVM会优先在Bootstrap ClassLoader的路径下找到java.lang.Object类，并载入它

174 有关hashMap跟hashTable的区别，说法正确的是？(ABCD)

HashMap和Hashtable都实现了Map接口

HashMap是非synchronized，而Hashtable是synchronized

HashTable使用Enumeration，HashMap使用Iterator

HashMap允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许。
1
2
3
4
5
6
7

A正确。Map是一个接口，hashtable,hashmap都是它的实现。
B正确。由于Hashtable是线程安全的也是synchronized，所以在单线程环境下它比HashMap要慢。如果你不需要同步，只需要单一线程，那么使用HashMap性能要好过Hashtable。
C正确。 HashMap的迭代器(Iterator)是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。所以当有其它线程改变了HashMap的结构（增加或者移除元素），将会抛出ConcurrentModificationException，但迭代器本身的remove()方法移除元素则不会抛出ConcurrentModificationException异常。但这并不是一个一定发生的行为，要看JVM。这条同样也是Enumeration和Iterator的区别。
D正确。 哈希值的使用不同，HashTable直接使用对象的hashCode，代码是这样的：
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
而HashMap重新计算hash值，而且用与代替求模：
int hash = hash(k);
int i = indexFor(hash, table.length);

174 以下代码结果是什么？（C）

 public class foo {

public static void main(String sgf[]) {

StringBuffer a=new StringBuffer(“A”);

StringBuffer b=new StringBuffer(“B”);

operate(a,b);
System.out.println(a+”.”+b);
}
static void operate(StringBuffer x,StringBuffer y) {
x.append(y);
y=x;
}
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

代码可以编译运行，输出“AB.AB”。

代码可以编译运行，输出“A.A”。

代码可以编译运行，输出“AB.B”。

代码可以编译运行，输出“A.B”。
1
2
3
4
5
6
7

这里简单地说,a,b,x,y就是四个指针。y本来指向的是b所指向的对象，但是一个“=”，y就指向了x所指向的目标即是a指向的对象，因此原来b所指向的目标并没有发生任何改变。与y不同的是，x进行的是对象操作,此时此对象在内存中是真正的本质上的改变。
往方法中传参，传的仅仅只是地址，而不是实际内存，所以不要以为y=x程序的执行，是 b=a的执行。这两者是不相等的

引用a指向对象A
引用b指向对象B
引用x指向对象A
引用y指向对象B
在operate方法中，引用x指向的对象A被连接了B，对象A也就被改变为AB
然后又把引用y指向了x所指向的对象地址，也就是此时引用a,x,y指向同一个对象AB
而引用b没有发生任何变化，依旧指向对象B。
175关于String、StringBuffer、StringBuilder以下说法错误的是（C）

StringBuilder运行速度最快

StringBuffer是线程安全的

String的值是可变的

StringBuffer运行速度比String快

String是final修饰的，不可变
运行速度StringBuilder>StringBuffer>String
StringBuffer是线程安全的
关于String、StringBuffer、StringBuilder的区别

176 上述代码返回结果为：（B）

Integer a = 1;
Integer b = 1;
Integer c = 500;
Integer d = 500;
System.out.print(a == b);
System.out.print(c == d);
1
2
3
4
5
6

true、true

true、false

false、true

false、false
解释：
Integer类型在-128–>127范围之间是被缓存了的，也就是每个对象的内存地址是相同的，赋值就直接从缓存中取，不会有新的对象产生，而大于这个范围，将会重新创建一个Integer对象，也就是new一个对象出来，当然地址就不同了，也就！=；

Interger的范围时[-128,127]，在这个范围内比较大小，相等为true，超过范围为false

Integer a = 1;是自动装箱会调用Interger.valueOf(int)方法；该方法注释如下：
This method will always *** values in the range -128 to 127 inclusive, and may *** other values outside of this range.
也就是说IntegerCache类缓存了-128到127的Integer实例，在这个区间内调用valueOf不会创建新的实例。

177ServletConfig接口默认是哪里实现的？（B）

Servlet

GenericServlet

HttpServlet

用户自定义servlet
GenericServlet类的实现接口中包括了ServletConfig接口，但是它自身的init(ServletConfig config)方法又需要外界给它传递一个实现ServletConfig的对象，就是说GenericServlet和ServletConfig的依赖关系既是继承关系，也是一种关联关系。

178 已知String a=“a”,String b=“b”,String c=a+b,String d=new String(“ab”) 以下操作结果为true的是（AD）
(a+b).equals©

a+b==c

c==d

c.equals(d)

        String a="a";
        String b="b";
        String c=a+b;
        String d=new String("ab");
        System.out.println((a+b).equals(c));
        System.out.println(a+b==c);
        System.out.println(c==d);
        System.out.println(c.equals(d));
1
2
3
4
5
6
7
8

true
false
false
true
1
2
3
4

B中左方和右方实质上都是new出来的新String，“==”比较地址，故B不对；C同理，而D中equals在String中被重载，相当于只比较值。

2.String对象的两种创建方式:
(1)第一种方式: String str1 = "aaa";  是在常量池中获取对象("aaa" 属于字符串字面量，因此编译时期会在
常量池中创建一个字符串对象，如果常量池中已经存在该字符串对象则直接引用)
(2)第二种方式: String str2 = new String("aaa") ;
 一共会创建两个字符串对象一个在堆中，一个在常量池中（前提是常量池中还没有 "aaa" 象）。
        System.out.println(str1==str2);//false

3.String类型的常量池比较特殊。它的主要使用方法有两种：
(1)直接使用双引号声明出来的String对象会直接存储在常量池中。
(2)如果不是用双引号声明的String对象,可以使用 String 提供的 intern 方法。 String.intern() 是一个
 Native 方法，它的作用是： 如果运行时常量池中已经包含一个等于此 String 对象内容的字符串，则返回常量
 池中该字符串的引用； 如果没有，则在常量池中创建与此 String 内容相同的字符串，并返回常量池中创建的字
 符串的引用。
    String s1 = new String("AAA");
    String s2 = s1.intern();
    String s3 = "AAA";
    System.out.println(s2);//AAA
    System.out.println(s1 == s2);//false，因为一个是堆内存中的String对象一个是常量池中的String对象，
    System.out.println(s2 == s3);//true， s1,s2指向常量池中的”AAA“
4字符串拼接：
    String a = "a";
    String b = "b";
         
    String str1 = "a" + "b";//常量池中的对象
    String str2 = a + b; //在堆上创建的新的对象     
    String str3 = "ab";//常量池中的对象
    System.out.println(str1 == str2);//false
    System.out.println(str1 == str3);//true 
    System.out.println(str2 == str3);//false
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

179 关于OutOfMemoryError，下面说法正确的是（ABC）？

java.lang.OutOfMemoryError: PermGen space 增加-XX:MaxPermSize这个参数的值的话，
这个问题通常会得到解决。

java.lang.OutOfMemoryError: Requested array size exceeds VM limit当你正准备创建一个超过虚拟机
允许的大小的数组时，这条错误将会出现

java.lang.OutOfMemoryError: Java heap space 一般情况下解决这个问题最快的方法就是通过-Xmx参数来增
加堆的大小

java.lang.OutOfMemoryError: nativeGetNewTLA这个异常只有在jRockit虚拟机时才会碰到
1
2
3
4
5
6
7
8
9
10

关于此题，《深入理解java虚拟机》有关于OOM（OutOfMemory）问题的解释
A：属于运行时常量池导致的溢出，设置-XX：MaxPermSize可以解决这个问题，
B：属于堆空间不足导致的错误，问题比较少见，解决方式和C相同，
C：属于java堆内存问题，一般的手段是通过内存映像分析工具，对Dump出来的堆转储存快照进行分析，重点是确认内存中的对象是否是有必要的，也就是要判断是出现了内存泄漏，还是出现了内存溢出，如果是内存列楼，通过工具检查泄露对象打GC Roots的引用链信息，可以准确的确定出泄露代码的位置，不存在泄露，就应该检查虚拟机的堆参数，如果可以继续调大，可以设置-Xmx解决问题
D：java.lang.OutOfMemoryError: nativeGetNewTLA指当虚拟机不能分配新的线程本地空间(Thread Local Area）的时候错误信息，此错误是线程申请一个新的TLA时产生的，这个异常一般只会发生在jRockit虚拟机，只有过于绝对。

180 Consider the following code: Which test would return true? (CDE)

Integer s=new Integer(9);
Integer t=new Integer(9);
Long u=new Long(9);
1
2
3

(s==u)

(s==t)

(s.equals(t))

(s.equals(9))

(s.equals(new Integer(9))
1
2
3
4
5
6
7
8
9

    int和int之间，用==比较，肯定为true。基本数据类型没有equals方法
    int和Integer比较，Integer会自动拆箱，== 和 equals都肯定为true
    int和new Integer比较，Integer会自动拆箱，调用intValue方法, 所以 == 和 equals都肯定为true

    Integer和Integer比较的时候，由于直接赋值的话会进行自动的装箱。所以当值在[-128,127]中的时候，由
    于值缓存在IntegerCache中，那么当赋值在这个区间的时候，不会创建新的Integer对象，而是直接从缓存中
    获取已经创建好的Integer对象。而当大于这个区间的时候，会直接new Integer。
    当Integer和Integer进行==比较的时候，在[-128,127]区间的时候，为true。不在这个区间，则为false
    
    当Integer和Integer进行equals比较的时候，由于Integer的equals方法进行了重写，比较的是内容，所以
    为true

    Integer和new Integer ： new Integer会创建对象，存储在堆中。而Integer在[-128,127]中，从缓存
    中取，否则会new Integer.
    所以 Integer和new Integer 进行==比较的话，肯定为false ; Integer和new Integer 进行equals比
    较的话，肯定为true

    new Integer和new Integer进行==比较的时候，肯定为false ; 进行equals比较的时候，肯定为true
    原因是new的时候，会在堆中创建对象，分配的地址不同，==比较的是内存地址，所以肯定不同

    装箱过程是通过调用包装器的valueOf方法实现的
    拆箱过程是通过调用包装器的xxxValue方法实现的（xxx表示对应的基本数据类型）

    总结：Byte、Short、Integer、Long这几个类的valueOf方法实现类似的。所以在[-128,127]区间内，==比
    较的时候，值总是相等的（指向的是同一对象），在这个区间外是不等的。
    而Float和Double则不相等， Boolean的值总是相等的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

181 下列程序执行后结果为(A )

 class A {
     public int func1(int a, int b) {
         return a - b;
     }
 }
 class B extends A {
     public int func1(int a, int b) {
         return a + b;
     }
 }
 public class ChildClass {
     public static void main(String[] args) {
     A a = new B();
     B b = new B();
     System.out.println("Result=" + a.func1(100, 50));
     System.out.println("Result=" + b.func1(100, 50));
     }
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Result=150Result=150

Result=100Result=100

Result=100Result=150

Result=150Result=100
1
2
3
4
5
6
7

涉及转型的题目，分为向上或者向下转型。
关键的来了，不论向上或者向下转型，都是一句话，“编译看左边，运行看右边”。也就是编译时候，会看左边引用类型是否能正确编译通过，运行的时候是调用右边的对象的方法。
就本题来说，编译时候会发现左边满足条件所以编译通过，运行时候又会调用右边也就是 class B 的方法，所以答案都是150。

对于多态，可以总结它为：

 一、使用父类类型的引用指向子类的对象；

二、该引用只能调用父类中定义的方法和变量；

三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）

四、变量不能被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写“了父类中的变量，那么在编译时会报错。
1
2
3
4
5
6
7

多态的3个必要条件：
1.继承 2.重写 3.父类引用指向子类对象。

向上转型： Person p = new Man() ; //向上转型不需要强制类型转化
向下转型： Man man = (Man)new Person() ; //必须强制类型转化

182以下哪项不是java基础类型（C）

int

boolean

String

float
1
2
3
4
5
6
7

Java中基本数据类型大体分为两类 数字类型（byte,short,int,long,float,double,char）,布尔类型（boolean）; 备注：由于char可以和数字间转换，也可认为大的范围是数字类型的。

数据类型包括基本数据类型和引用数据类型
基本数据类型：byte,short,int,long,char,float,double,boolean
引用数据类型：数组，接口，枚举，类，空类

183 下面关于静态方法说明正确的是（B）

在静态方法中可用this来调用本类的类方法

在静态方法中调用本类的静态方法时可直接调用

在静态方法中只能调用本类中的静态方法

在静态方法中绝对不能调用实例方法
1
2
3
4
5
6
7

A.静态成员随类的加载而加载，这个时候对象都还没有，this代表当前对象，所以this不能用于static方法中
C还可以调用静态变量 D.可以通过对象.进行调用
C:在静态方法中，不只可以调用本类的静态方法，也可以使用【类名.静态方法名】调用其他类的静态方法
D:可以调用实例方法，使用【new 类名().实例方法名】调用

静态方法中，可以调用其他类的静态方法

静态方法中可以调用实例方法，但是必须要new一个对象

静态方法中不能用this.实例方法，因为此时对象还没有

184 Which of the following can be applied to constructors:（E）

final

static

synchronized

native

None of these.
1
2
3
4
5
6
7
8
9

识别合法的构造方法；
1：构造方法可以被重载，一个构造方法可以通过this关键字调用另一个构造方法，this语句必须位于构造方法的第一行；
重载：方法的重载(overload)：重载构成的条件：方法的名称相同，但参数类型或参数个数不同，才能构成方法的重载。

2 当一个类中没有定义任何构造方法，Java将自动提供一个缺省构造方法；
3 子类通过super关键字调用父类的一个构造方法；
4 当子类的某个构造方法没有通过super关键字调用父类的构造方法，通过这个构造方法创建子类对象时，会自动先调用父类的缺省构造方法
5 构造方法不能被(非访问性质的修饰)static、final、synchronized、abstract、native修饰，但可以被public、private、protected修饰；
6 构造方法不是类的成员方法；
7 构造方法不能被继承。

185 java用（A）机制实现了进程之间的同步执行

监视器

虚拟机

多个CPU

异步调用
1
2
3
4
5
6
7

同步的两种方式：同步块和同步方法
对于同步来说都是使用synchronized方法
每一个对象都有一个监视器，或者叫做锁。

package ticket; class Tickets { public static void main(String[] args)
    {
        sellTickets st = new sellTickets(); //四个线程同时卖这100张票，注意是同一个对象创建四个线程，他们共享同一个变量ticket new Thread(st).start(); new Thread(st).start(); new Thread(st).start(); new Thread(st).start();
    }
} class sellTickets implements Runnable { int ticket = 100;
    Object o = new Object();
    @Override public void run() { while(true)
        { //每一个对象都有一个监视器，或者叫做锁。同步块示例 synchronized (o) { if(ticket > 0)
                { //存在的隐藏的问题当ticket=1，它的时间片到期了进入到if语句中，第二个线程进入到if语句然后时间片到期 try { //线程睡眠,该方法需要写异常 Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();                    
                    } //第几个线程卖出了第多少张票 System.out.println(Thread.currentThread().getName() + "sell tickets" + ticket);
                    ticket--;
                }
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

186 Math.floor(-8.5)=( D)

(float)-8.0

(long)-9

(long)-8

(double)-9.0

Math.floor(x) 返回小于等于x的最接近整数，类型为double

Math.floor() 表示向下取整，返回double类型 （floor—地板）
Math.ceil() 表示向上取整，返回double类型 （ceil—天花板）
Math.round() 四舍五入，返回int类型

187 以下代码将打印出 ©

 public static void main (String[] args) { 
    String classFile = "com.jd.". replaceAll(".", "/") + "MyClass.class";
    System.out.println(classFile);
}
1
2
3
4

com. jd

com/jd/MyClass.class

///MyClass.class

com.jd.MyClass
1
2
3
4
5
6
7

由于replaceAll方法的第一个参数是一个正则表达式，而".“在正则表达式中表示任何字符，所以会把前面字符串的所有字符都替换成”/"。如果想替换的只是"."，那么就要写成"\.".

188 下面哪些接口直接继承自Collection接口（AC）

List

Map

Set

Iterator
1
2
3
4
5
6
7

189 面向对象程序设计方法的优点包含：(ABC)

可重用性

可扩展性

易于管理和维护

简单易懂
1
2
3
4
5
6
7

190 关于运行时常量池，下列哪个说法是正确的(BCD)

运行时常量池大小受栈区大小的影响

运行时常量池大小受方法区大小的影响

存放了编译时期生成的各种字面量

存放编译时期生成的符号引用
1
2
3
4
5
6
7

运行时常量池（Runtime Constant Pool）是方法区的一部分。Class文件中除了有类的版本、字段、方法、接口等描述信息外，还有一项信息是常量池（Constant Pool Table），用于存放编译器生成的各种字面量和符号引用，这部分内容将在类加载后进入方法区的运行时常量池中存放。

191 以下代码的输出的正确结果是（D）

public class Test {
public static void main(String args[]) {
String s = "祝你考出好成绩！";
System.out.println(s.length());
}
}
1
2
3
4
5
6

24

16

15

8
1
2
3
4
5
6
7

一个汉字等于一个字符　　 字符 是char
一个汉字也等于二个字节，字节 是byte
java的String底层是char数组，它的length()返回数组大小，而unicode中一个汉字是可以用一个char表示的

192 以下会产生信息丢失的类型转换是(B ）

float  a=10

int a=（int）8846.0

byte  a=10； int b=-a

double d=100
1
2
3
4
5
6
7

会产生信息丢失不如说丢失精度，这样可能更容易明白，而精度丢失只会发生在从大范围到小范围的转换
上面四个选项，只有 B 是从 double 到 int ，也就是从大范围到小范围。

对于c选项
只要int类型的数没有超出（byte，short，char）的表述范围也就是127，可以直接byte a=23
A: float a=10; 可以. 它可以自動把 int 的10 轉成 float.
float a=10.0; 反而是把 double 轉成 float. 這是損失精度. 在 C/C++可以, 但在 java 是錯誤.
最正確的寫法是 float=10.0f;
B: double变为int损失了精度。

193 指出下列程序运行的结果： (B)

public class Example{
    String str=new String("tarena");
    char[]ch={'a','b','c'};
    public static void main(String args[]){
        Example ex=new Example();
        ex.change(ex.str,ex.ch);
        System.out.print(ex.str+" and ");
        System.out.print(ex.ch);
    }
    public void change(String str,char ch[]){
   //引用类型变量，传递的是地址，属于引用传递。
        str="test ok";
        ch[0]='g';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

tarena and abc

tarena and gbc

test ok and abc

test ok and gbc

string和char数组都是引用类型，引用类型是传地址的，会影响原变量的值，但是string是特殊引用类型，为什么呢？因为string类型的值是不可变的，为了考虑一些内存，安全等综合原因，把它设置成不可变的; 不可变是怎么实现的？Java在内存中专门为string开辟了一个字符串常量池，用来锁定数据不被篡改，所以题目中函数中的str变量和原来的str已经不是一个东西了，它是一个局部引用，指向一个testok的字符串，随着函数结束，它也就什么都没了，但是char数组是会改变原值的

1.java中只有值传递。 2.方法exchange接收的参数是引用的副本。即都是地址的复制值。 3.方法中str副本指向了一个新的字符串，但是并没有改变原本的str指向的字符串。 4.方法中ch虽然也是一个副本，但方法利用它修改了它所指向的字符数组中的第一个元素。 5.方法结束后，所有副本弹出结束，但是我们的成员变量str和ch还存在，它们依然是之前的地址。所以str的内容不变，ch第一个元素被改变。

194 以下代码执行的结果显示是多少（D ）？

true,false,true
false,true,false
true,true,false
false,false,true
1
2
3
4

其实当我们在为Integer赋值的时候，java编译器会将其翻译成调用valueOf()方法。比如Integer i=127翻译为Integer i=Integer.valueOf(127)
然后我们来看看valueOf()函数的源码：

public static Integer valueOf(int i)
    {
        //high为127
        if(i >= -128 && i <= IntegerCache.high)
            return IntegerCache.***[i + 128];
        else
            return new Integer(i);
    }
1
2
3
4
5
6
7
8

可以看出，对于-128到127之间的数，Java会对其进行缓存。而超出这个范围则新建一个对象。
所以现在回到这道问题
i1和i2为128，超出范围，所以都需要新建对象，对象比较为false；
i5和i6为100，在范围之内，在执行Integer i5=100时，就会直接缓存到内存中，但执行执行Integer i6=100时，就直接从缓存里取，而不需要新建对象，所以为true。

关于字符串的解释（摘自：https://www.cnblogs.com/huajiezh/p/6565301.html）：String str1=”java”; //指向字符串池
String str2=”blog”; //指向字符串池

String s=str1+str2; //s是指向堆中值为"javablog"的对象，+运算符会在堆中建立来两个String对象，这两个对象的值分别是"java" “blog”. 也就是说从字符串池中复制这两个值，然后在堆中创建两个对象，然后再建立对象s,然后将"javablog"的堆地址赋给s. 这句共创建了?个String 对象！

System.out.println(s==”javablog”); //结果是false。
Jvm确实对型如String str1=”java”;的String对象放在常量池里，但是它是在编译时那么做的，而String s=str1+str2;是在运行时刻才能知道，也就是说str1+str2是在堆里创建的，所以结果为false了

195 对于文件的描述正确的是（D ）

文本文件是以“.txt”为后缀名的文件，其他后缀名的文件是二进制文件。

File类是Java中对文件进行读写操作的基本类。

无论文本文件还是二进制文件，读到文件末尾都会抛出EOFException异常。

Java中对于文本文件和二进制文件，都可以当作二进制文件进行操作。
1
2
3
4
5
6
7

A.文件分为文本文件和二进制文件，计算机只认识二进制，所以实际上都是二进制的不同解释方式。文本文件是以不同编码格式显示的字符，例如Ascii、Unicode等，window中文本文件的后缀名有".txt",".log",各种编程语言的源码文件等；二进制文件就是用文本文档打开是看不懂乱码，只要能用文本打开的文件都可以算是文本文件，只是显示的结果不是你想要的，二进制文件只有用特殊的应用才能读懂的文件，例如".png",".bmp"等，计算机中大部分的文件还是二进制文件。
B.File类是对文件整体或者文件属性操作的类，例如创建文件、删除文件、查看文件是否存在等功能，不能操作文件内容；文件内容是用IO流操作的。
C.当输入过程中意外到达文件或流的末尾时，抛出EOFException异常,正常情况下读取到文件末尾时，返回一个特殊值表示文件读取完成，例如read()返回-1表示文件读取完成。
D.上面A选项已经说了，不论是文本文件还是二进制文件，在计算机中都是以二进制形式存储的，所以都当做二进制文件读取

196 下列有关Servlet的生命周期，说法不正确的是？(A)

在创建自己的Servlet时候，应该在初始化方法init()方法中创建Servlet实例

在Servlet生命周期的服务阶段，执行service()方法，根据用户请求的方法，执行相应的doGet()或是doPost()方法

在销毁阶段，执行destroy()方法后会释放Servlet 占用的资源

destroy()方法仅执行一次，即在服务器停止且卸载Servlet时执行该方法
解释：
创建Servlet的实例是由Servlet容器来完成的，且创建Servlet实例是在初始化方法init()之前

Servlet的生命周期
1.加载：容器通过类加载器使用Servlet类对应的文件来加载Servlet
2.创建：通过调用Servlet的构造函数来创建一个Servlet实例
3.初始化：通过调用Servlet的init()方法来完成初始化工作，这个方法是在Servlet已经被创建，但在向客户端提供服务之前调用。
4.处理客户请求：Servlet创建后就可以处理请求，当有新的客户端请求时，Web容器都会创建一个新的线程来处理该请求。接着调用Servlet的
Service()方法来响应客户端请求（Service方***根据请求的method属性来调用doGet（）和doPost（））
5.卸载：容器在卸载Servlet之前需要调用destroy()方法，让Servlet释放其占用的资源。

197下列描述正确的是（ AC）？

类不可以多继承而接口可以多实现

抽象类自身可以定义成员而接口不可以

抽象类和接口都不能被实例化

一个类可以有多个基类和多个基接口
1.java支持单继承，却可以实现多个接口。a对d错
2.接口没有构造方法，所以不能实例化，抽象类有构造方法，但是不是用来实例化的，是用来初始化的。c对
3.抽象类可以定义普通成员变量而接口不可以，但是抽象类和接口都可以定义静态成员变量，只是接口的静态成员变量要用static final public 来修饰。b错

198 以下JSP代码定义了一个变量，如何输出这个变量的值？(BCD)

<bean:define id="stringBean" value="helloWorld"/> 
1

<bean:write name="helloWorld"/>
<%=stringBean%>
<bean:write name="stringBean"/>

<%String myBean=(String)pageContext.getAttribute("stringBean",PageContext.PAGE_SCOPE);%>
<%=myBean%>
1
2
3
4
5
6

199 执行如下代码后输出结果为（C ）

public class Test {
 public static void main(String[] args) {
     System.out.println("return value of getValue(): " + getValue());
 }
 public static int getValue() {
     int i = 1;
     try {
         i = 4;
     } finally{
         i++;
         return i;
     }
     }
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

return value of getValue(): 1

return value of getValue(): 4

return value of getValue(): 5

其他几项都不对
1
2
3
4
5
6
7

更为严格的说法其实是：try只适合处理运行时异常，try+catch适合处理运行时异常+普通异常。也就是说，如果你只用try去处理普通异常却不加以catch处理，编译是通不过的，因为编译器硬性规定，普通异常如果选择捕获，则必须用catch显示声明以便进一步处理。而运行时异常在编译时没有如此规定，所以catch可以省略，你加上catch编译器也觉得无可厚非。

try里面的句子没有异常正常执行，i=4，然后执行finally里面的程序，return i++,i=5,所以输出5

200 关于下面程序，哪些描述是正确的: (B )

public class While {
public void loop() {
int x= 10;
while ( x )  {
System.out.print("x minus one is " + (x - 1));
x -= 1;
}
}
}
1
2
3
4
5
6
7
8
9

行1有语法错误
行4有语法错误
行5有语法错误
行6有语法错误
行2有语法错误,loop是关键字
程序能够正常编译和运行
1
2
3
4
5
6
7
8

这个题主要考while（）中表达式的判断，在C语言中大于0的int值都会被认为是true，而java中没有这个机制，必须是boolean类型的
while()括号里参数必须是布尔类型，要么true要么false

loop 不是java 的关键字
问题出在 wile( boolean ) x 是一个int 形的变量 不是Boolean 值 所有编译不通过