java练习题

java题1

解析：
编译不会编译注释中的内容。javac编译后的字节码文件中也不会出现自己手打的注释。

解析：
Java中类是单继承，但接口可以多继承

解析：
先要理解什么是类的方法，所谓类的方法就是指类中用static 修饰的方法（非static 为实例方法），比如main 方法，那么可以以main 方法为例，可直接调用其他类方法，必须通过实例调用实例方法，this 关键字不是这么用的

解析：
解决哈希冲突常用的两种方法是：开放定址法和链地址法

解析：
接口方法默认是public abstract的，且实现该接口的类中对应的方法的可见性不能小于接口方法的可见性，因此也只能是public的。

解析：
选C
父类没有无参的构造函数，所以子类需要在自己的构造函数中显式调用父类的构造函数，会编译报错

解析：
A不用解释，B中JVM将字节码转换成不同平台(OS)下可执行的机器码指令。D中说的与硬件交互是JVM机器指令与硬件的交互。

解析：
A.函数中定义的变量是局部变量，作用域为当前函数或循环等
B.局部变量在函数内部或循环内部，随函数的退出或循环退出就不存在了

解析：


解析：
字节流必是一个接点流，字符流就是一个操作流

解析：
这道题，首先没有初始化对象根本没有输出。
其次，即使初始化了对象，也该是输出
我是父类
我是父类
我是子类

解析：
导包关键词import

解析：
值传递，传递的是原来值的副本。
引用传递，除了一些特殊的（String，包装类属于不可变类），一般的引用类型在进行传递的时候，一开始形参和实参都是指向同一个地址的，这个时候形参对对象的改变会影响到实参

解析：
类中声明的变量有默认初始值；方法中声明的变量没有默认初始值，必须在定义时初始化，否则在访问该变量时会出错。boolean类型默认值是false

解析：
this表示当前类的对象，由static修饰的方法是由类直接调用，不需要创建对象，所以在static里不能用this.

解析：
关于抽象类
JDK 1.8以前，抽象类的方法默认访问权限为protected
JDK 1.8时，抽象类的方法默认访问权限变为default

关于接口
JDK 1.8以前，接口中的方法必须是public的
JDK 1.8时，接口中的方法可以是public的，也可以是default的

解析：
第一，记住wait必须要进行异常捕获
第二，记住调用wait或者notify方法必须采用当前锁调用，即必须采用synchronized中的对象

解析：
newSupper().get()和newSub().get()只调用了get()方法，又没有打印输出get()返回的数值，所以肯定没有5

解析：
Collection
-----List
-----LinkedList 非同步
----ArrayList 非同步，实现了可变大小的元素数组
----Vector 同步
-----Set 不允许有相同的元素
Map
-----HashTable 同步，实现一个key–value映射的哈希表，key和value都不允许出现nul值
-----HashMap 非同步，
-----WeakHashMap 改进的HashMap，实现了“弱引用”，如果一个key不被引用，则被GC收
注：
List接口中的对象按一定顺序排列，允许重复
Set接口中的对象没有顺序，但是不允许重复
Map接口中的对象是key、value的映射关系，key不允许重复

解析：
A、LinkedBlockingQueue是一个基于节点链接的可选是否有界的阻塞队列，不允许null值。
B、LinkedBlockingQueue是一个线程安全的阻塞队列，实现了先进先出等特性。
C、PriorityQueue是一个队列，不允许null值，入队和出队的时间复杂度是O（log(n)）。
D、PriorityQueue是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。ConcurrentLinkedQueue是一个基于链接节点的线程安全队列，该队列的元素遵循FIFO原则。

解析：
continue是跳出本次循环

解析：
A：一个类里面多个内部类，构造方法名是与和.java文件同名的public类名。内部类也是类，构造方法名和内部类名不同。
B:构造方法不返回任何值，也没有返回类型。无异议。
C：子类在构造方法里面调用父类的构造方法时，会在第一行使用“super(参数列表)”显示调用父类的构造方法。这里是显示地直接调用，而且没有创建新对象。
D：每一个和.java文件同名的public类可以有多个构造方法，构造方法允许重载。内部类也可以有多个构造方法，而匿名内部类一个构造方法都没有。

解析：
基类是抽象类，子类继承父类，但是没有实现基类的抽象方法，那么子类也是抽象类。抽象类不能创建对象，所以在主函数中创建对象编译不会通过。

解析：

1. 在类的其他构造方法中可以用this()的方式调用其他构造方法；
2. 在类的子类中则可以通过super调用父类中指定的构造方法；
3. 在反射中可以使用newInstance()的方式调用。

解析：

解析：
a++ 先把10赋值给a 再+1 所以左边是10 但此时a=11。右边a-- 也是先赋值 a=11，再-1。10+11=21 此时a=10。

解析：
公式-n=_n+1可推出n=-n-1，所以~10=-11再加5结果为-6

解析：
抛InterruptedException的代表方法有：
java.lang.Object 类的 wait 方法
java.lang.Thread 类的 sleep 方法
java.lang.Thread 类的 join 方法

解析：
JVM内存区：程序计数器、虚拟机栈、本地方法栈、堆、方法区（包括常量池）。
不属于JVM内存区：直接内存（Direct Memory），用户I/O操作

解析：
1、abstract类不能用来创建abstract类的对象；
2、final类不能用来派生子类，因为用final修饰的类不能被继承；
3、如2所述，final不能与abstract同时修饰一个类，abstract类就是被用来继承的；
4、类中有abstract方法必须用abstract修饰，但abstract类中可以没有抽象方法，接口中也可以有abstract方法。

java题2

解析：
A、一旦执行到return，就不再执行后续的代码。
B、类的封装性可不是这么体现的，数据域和方法都可以被封装。数据域可以是基本数据类型也可以是引用类型。
C、方法的返回值可以是引用类型。
D、重载，判定方法只有方法名一致，形参列表不同。

解析：
Java是一门面向对象编程语言，属于计算机语言。故正确答案为D选项。

解析：
instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例，而Object是所有类的父类。

解析：
+号两边如果有一边为字符类型 则为字符串连接。

解析：
A，类是一个封装，类的成员只能在类内部使用，外部需要 “对象名.变量名” 来引用。
B，正确，局部变量只在定义它的代码块或者函数内部可见
C，跟类的成员变量一样，需要指定对象才能引用
D，如果类没有构造方法，JVM会生成一个默认构造方法，如果定义了任意类型的构造方法，编译器都不会自动生成构造方法。

解析：
在同一个java原文件中，可以有多个class类，但是只有有一个公共的 public class

解析：
覆盖是发生在子类与基类中，重载发生在一个类中重载要求方法名一样，形参类型、顺序和个数不能完全一样，返回值类型不能作为判断的标准覆盖要求 方法名、形参类型、顺序和个数都完全一样。

解析：
try:可能发生异常的语句
catch:捕获，并处理异常（printStackTrace()用来跟踪异常事件发生时执行堆栈的内容）
throw:方法内部抛异常
throws:声明方法异常
finaly：代码中无论是否有异常都会执行，清除资源

解析：
内部类可以是静态static的，也可用public，default，protected和private修饰，外部类的修饰符只能是public，abstract，final。

解析：
Set 不能有重复的元素，且是无序的，要有空值也就只能有一个。因为它不允许重复。 L ist 可以有重复元素，且是有序的，要有空值也可以有多个，因为它可重复。

解析：
++i就是先赋值 再计算 当到9的时候直接+1超过了10直接输出。

解析：
此题的父类方法有private修饰，所以对子类不可见，子类不能覆盖。所以子类方法和父类是两个方法。

解析：
package语句只能放在第一行。

解析：
&& 运算时出现false时运算结果就判断为false
a != 3 && a != 4 && a != 5 && a != 6
a = 4;
因为a != 4 false 所以 结果false；
a = 6;
因为a != 6 false 所以 结果false；
a = 8;
因为a != 3 a != 4 a != 5 a != 6都为 ture 所以 结果true
所以
答案D

解析：
结果中数组的第一个元素 0 是 原数组中的第二个0。
这个程序就是在删除数组中的0 ，但是会有个小问题，就是连续的0会只删除一个。
原因：当执行remove的时候，ArrayList 数组的 size 会变小一个，原本的位置上的 0 会被后面的 0 给替代；而在执行完remove后执行了k++;所以跳过了第二个0

解析：
y是2，返回的结果是2+（z–/++x），再来看z–/++x，结果应该是3/2，但是因为x,y,z都是int型的，所以最后的返回值只能是int，这时候z–/++x的值就是1，那么最终的结果就是2+1=3。

解析：
\D 匹配一个非数字字符。

解析：
Step 1: new B()构造一个B类的实例
此时super(5)语句调用显示调用父类A带参的构造函数，该构造函数调用setValue(v)，这里有两个注意点一是虽然构造函数是A类的构造函数，但此刻正在初始化的对象是B的一个实例，因此这里调用的实际是B类的setValue方法，于是调用B类中的setValue方法 ==> 而B类中setValue方法显示调用父类的setValue方法，将B实例的value值设置为2 x 5 = 10。
紧接着，B类的构造函数还没执行完成，继续执行setValue(getValue()- 3) // 备注1语句。

先执行getValue方法，B类中没有重写getValue方法，因此调用父类A的getValue方法。这个方法比较复杂，需要分步说清楚：

调用getValue方法之前，B的成员变量value值为10。
value++ 执行后， B的成员变量value值为11，此时开始执行到return语句，将11这个值作为getValue方法的返回值返回出去
但是由于getValue块被try finally块包围，因此finally中的语句无论如何都将被执行，所以步骤2中11这个返回值会先暂存起来，到finally语句块执行完毕后再真正返回出去。
这里有很重要的一点：finally语句块中 this.setValue(value)方法调用的是B类的setValue方法。因为此刻正在初始化的是B类的一个对象（运行时多态），就像最开始第一步提到的一样(而且这里用了使用了this关键词显式指明了调用当前对象的方法)。因此，此处会再次调用B类的setValue方法，同上，super.关键词显式调用A的setValue方法，将B的value值设置成为了2 * 11 = 22。
因此第一个打印项为22。
finally语句执行完毕 会把刚刚暂存起来的11 返回出去，也就是说这么经历了这么一长串的处理，getValue方法最终的返回值是11。
回到前面标注了 //备注1 的代码语句，其最终结果为setValue(11-3)=>setValue(8)
这里执行的setValue方法，将会是B的setValue方法。 之后B的value值再次变成了2*8 = 16;

Step2: new B().getValue()
B类中没有独有的getValue方法，此处调用A的getValue方法。同Step 1，

调用getValue方法之前，B的成员变量value值为16。
value++ 执行后， B的成员变量value值为17，此时执行到return语句，会将17这个值作为getValue方法的返回值返回出去
但是由于getValue块被try finally块包围而finally中的语句无论如何都一定会被执行，所以步骤2中17这个返回值会先暂存起来，到finally语句块执行完毕后再真正返回出去。
finally语句块中继续和上面说的一样: this.setValue(value)方法调用的是B类的setValue()方法将B的value值设置成为了2 * 17 = 34。
因此第二个打印项为34。
finally语句执行完毕 会把刚刚暂存起来的17返回出去。
因此new B().getValue()最终的返回值是17.

Step3: main函数中的System.out.println
将刚刚返回的值打印出来，也就是第三个打印项：17

最终结果为 22 34 17。

解析：
插入排序：最佳O（N）
快速排序：最佳O（NlogN）
堆 排序：最佳O（NlogN）
归并排序：最佳O（NlogN）
因此选择插入排序。

解析：
A.很明显是赋值符号
B.<<=左移赋值
C.不是
D.>>>= 右移赋值，左边空出的位以0填充

解析：
ArrayList 是线程不安全的， Vector 是线程安全的，这两个类底层都是由数组实现的
LinkedList 是线程不安全的，底层是由链表实现的
HashTable 是线程安全的，不能存储 null 值
HashMap 不是线程安全的，可以存储 null 值

解析：


解析：
1、一个类可以实现多个接口
2、抽象类可以没有抽象方法；
3、有抽象方法的类必须定义为抽象类

解析：
Jsp只会在客户端第一次发请求的时候被编译，之后的请求不会再编译，同时tomcat能自动检测jsp变更与否，变更则再进行编译。
第一次编译并初始化时调用： init() ；销毁调用： destroy() 。在整个jsp生命周期中均只调用一次。
service()方法是接收请求，返回响应的方法。每次请求都执行一次，该方法被HttpServlet封装为doGet和doPost方法

解析：
HttpSessionAttributeListener：可以实现此侦听器接口获取此web应用程序中会话属性列表更改的通知；
HttpSessionBindingListener：当该对象从一个会话中被绑定或者解绑时通知该对象，这个对象由HttpSessionBindingEvent对象通知。这可能是servlet程序显式地从会话中解绑定属性的结果，可能是由于会话无效，也可能是由于会话超时；
HttpSessionObjectListener：没有该接口API；
HttpSessionListener：当web应用程序中的活动会话列表发生更改时通知该接口的实现类，为了接收该通知事件，必须在web应用程序的部署描述符中配置实现类；
HttpSessionActivationListener：绑定到会话的对象可以侦听容器事件，通知它们会话将被钝化，会话将被激活。需要一个在虚拟机之间迁移会话或持久会话的容器来通知所有绑定到实现该接口会话的属性

解析：
java中只有byte, boolean是一个字节, char是两个字节, 所以对于java来说127不会发生溢出, 输出328
但是对于c/c++语言来说, char是一个字节, 会发生溢出, 对127加一发生溢出, 0111 1111 --> 1000 0000, 1000 0000为补码-128, 所以结果为200-128=72

解析：
静态内部类：不可以访问外部非静态资源；
成员内部类:可以访问外部所有资源，但本身内部不可以有静态属性(需要被外部实例化)
局部内部类:不可被访问符合和static修饰，只能访问final变量和形参
匿名内部类：a没有构造器,没有静态资源，无法被访问符修饰 b只能在匿名内部类中创建一个实。

解析：
byte类型的变量在做运算时被会转换为int类型的值，故A、B左为byte，右为int，会报错；而C、D语句中用的是a+=b的语句，此语句会将被赋值的变量自动强制转化为相对应的类型。

解析：
A、错，Hashtable 是一个哈希表，该类继承自Dictionary类，实现了 Map 接口
B、错，HashMap是基于哈希表实现的，每一个元素是一个key-value对，其内部通过单链表解决冲突问题，容量不足（超过了阀值）时，同样会自动增长。该类继承AbstractMap，实现Map接口
C、 对，Hashtable 线程安全的，而 HashMap 是线程不安全的。Hashtable 中的方法是Synchronize的，而HashMap中的方法在缺省情况下是非Synchronize的。
D、讲的没错，但是不符合题意
E、对。

解析：

1. 只看尖括号里边的！！明确点和范围两个概念
2. 如果尖括号里的是一个类，那么尖括号里的就是一个点，比如List<A>,List<B>,List<Object>
3. 如果尖括号里面带有问号，那么代表一个范围，<? extends A> 代表小于等于A的范围，<? super A>代表大于等于A的范围，<?>代表全部范围
4. 尖括号里的所有点之间互相赋值都是错，除非是俩相同的点
5. 尖括号小范围赋值给大范围，对，大范围赋值给小范围，错。如果某点包含在某个范围里，那么可以赋值，否则，不能赋值
6. List<?>和List 是相等的，都代表最大范围
7. List既是点也是范围，当表示范围时，表示最大范围

public static void main(String[] args) {
		List<A> a;
		List list;
		list = a;   //A对，因为List就是List<?>，代表最大的范围，A只是其中的一个点，肯定被包含在内
		List<B> b;
		a = b;      //B错，点之间不能相互赋值
		List<?> qm;
		List<Object> o;
		qm = o;     //C对，List<?>代表最大的范围，List<Object>只是一个点，肯定被包含在内
		List<D> d;
		List<? extends B> downB;
		downB = d;  //D对，List<? extends B>代表小于等于B的范围，List<D>是一个点，在其中
		List<?extends A> downA;
		a = downA;  //E错，范围不能赋值给点
		a = o;      //F错，List<Object>只是一个点
		downA = downB;  //G对，小于等于A的范围包含小于等于B的范围，因为B本来就比A小，B时A的子类嘛
	}

java题3

解析：
构造方法用于对象属性的实例化

解析：
类除了无参构造方法，还有有参构造方法，有参构造方法还可以通过重载写出多参的构造方法（2参，3参，4参）

解析：
子类调用父类的构造器使用super(),放在子类构造函数的首行

解析：
m++ ，这里m输出12后，m=13.
++n, 这里n输出35， n依旧=35.
n++, 这里n输出35, n=36.
++m,这里m输出14,m=14,

解析：
java采用局部优先的思想。局部变量可以和成员变量相同，使用标识符调用时，优先使用局部变量。在实例方法中出现变量名相同时，可以使用this关键字来调用。

解析：
通俗的讲，就是基本数据类型和包装类之间的转换。如： int 类型和 Integer 类的转换
基本数据类型转化成包装类是装箱 (如： int --> Integer)。
包装类转化成基本数据类型就是拆箱 (如：Integer --> int)。
包装类就是引用类型，基本数据类型就是值类型。所以选C

解析：
局部变量：方法定义中或者方法声明上。
局部变量：在内存的栈中。
局部变量：随方法的调用而存在，随着方法的调用完毕而消失。
局部变量：没有默认值，必须定义，赋值，然后才能使用

解析：
重复题

解析：
Java中数组是对象，不是基本数据类型（原生类），大小不可变且连续存储，因为是对象所以存在堆中。

解析：
&& 和 || 为短路与 短路或
&&若前面的表达式为false,整个逻辑表达式为false,所以后面的表达式无论true和false都无法影响整个表达式的逻辑结果，所以为了提高代码执行速率，这里后面的表达式就不会执行。
同理，若前面表达式为true,则后面的表达式无需计算。

& 和 | 为不短路与 不短路或
无论什么情况，前面的和后面的都要执行。
因此：
++i先自增再运算，i++先运算在自增，所以i=1。||短路前一部分不正确就不会继续执行，所以j=0.

解析：
substring 方法将返回一个包含从 start 到最后（不包含 end ）的子字符串的字符串。

解析：
final的作用：
1. 修饰变量，变量的引用地址不可变，但是地址中的内容可以变。
2. 修饰方法，方法不可被重写，但是还是可以重载
3. 修饰类，类不可继承。

解析：
服务器端：ServerSocket提供的实例 ServerSocket server = new ServerSocket(端口号)
客户端：Socket提供的实例 Socket client = new Socket(IP地址，端口号)

解析：
log4j在运行期间是不可以重新设置日志级别的

解析：
若调用start，则先执行主线程的，后执行子线程的，即结果为pingpong
若调用run，相当于函数调用，顺序执行，即结果为pongping

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

解析：
写写数字, 观察规律
i= 1, 2, 3, 4, 5, 6, 7, 8
k=1, 3, 6, 10, 15, 21, 28, 36
把k的数字两个两个一起看的话, 也就是(1,3), (6,10), (15, 21), (7,8), 求和后可以发现规律(1+3=4), (6+10=16), (15+21=36), (28+36=64)
也就是2^2, 4^2, 6^2, 8^2…偶数的平方
循环在x^2>=n时终止, 可得x等于根号n,也就是n^(1/2)
循环的次数是x/2, 时间复杂度为O((1/2)n^(1/2)), 一般而言时间复杂度认为常系数为1, 所以答案就是O(n^(1/2))

解析：
Java中静态变量只能在类主体中定义，不能在方法中定义。 静态变量属于类所有而不属于方法。

解析：
关于抽象类
JDK 1.8以前，抽象类的方法默认访问权限为protected
JDK 1.8时，抽象类的方法默认访问权限变为default

关于接口
JDK 1.8以前，接口中的方法必须是public的
JDK 1.8时，接口中的方法可以是public的，也可以是default的

解析：
静态方法先行执行，导致变量x还未被初始化，所以编译出错

解析：
子类的构造方法总是先调用父类的构造方法，如果子类的构造方法没有明显地指明使用父类的哪个构造方法，子类就调用父类不带参数的构造方法。而父类没有无参的构造函数，所以子类需要在自己的构造函数中显示的调用父类的构造函数。
否则报错：
Implicit super constructor Person() is undefined. Must explicitly invoke another constructor

解析：
AWT，抽象窗口工具包，是Java提供的建立图形用户界面的工具集，可用于生成现代的、鼠标控制的图形应用接口，且无需修改，就可以在各种软硬件平台上运行。
而swing是Java语言在编写图形用户界面方面的新技术，Swing采用模型-视图-控制设计范式，Swing可以使Java程序在同一个平台上运行时能够有不同外观以供用户选择。
两者不同在于一个是初代工具集，一个是进化版的工具集，用户不会再满足于初始的功能，而是更加注重于附加价值，明显从这点上，Swing是比AWT要好很多。
写法上，Swing的头文件引用包需要用到Javax，组件调用时也需要在AWT的基础上加上“J”。

解析：
创建线程的方法：1）从Java.lang.Thread类派生一个新的线程类，重写它的run()方法；2） 实现Runnable接口，重写Runnable接口中的run()方法。

解析：


解析：
方法重写
1.参数列表必须完全与被重写方法的相同；
2.返回类型必须完全与被重写方法的返回类型相同；
3.访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
4.父类的成员方法只能被它的子类重写。
5.声明为final的方法不能被重写。
6.声明为static的方法不能被重写，但是能够被再次声明。
7.子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
8.子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
9.重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
10.构造方法不能被重写。
11.如果不能继承一个方法，则不能重写这个方法。

解析：
A:Java中所有错误和异常的父类是java.lang.Throwable
B：基本数据类型不是对象，不能用new的方法获取，但是每个基本数据类型都对应着封装类型，这些封装类型为了解决基本数据类型面向对象用的。
C:Java垃圾回收器负责回收无用对象占据的内存资源,但对象没有使用new获取了一块特殊区域，这块特殊区域的回收使用finallize（）
D：Java跨平台是因为有JVM的存在，Java的三个版本的运行需要各自不同的环境。

解析：
搞不懂

解析：
resume与suspended一起使用
wait与notify(notifyAll)一起使用
sleep会让线程暂时不执行

解析：
1、 PreparedStatement 继承 Statement ， PreparedStatement 实例包含已编译的 SQL 语句， 所以其执行速度要快于 Statement 对象。
2、作为 Statement 的子类，PreparedStatement 继承了 Statement 的所有功能。三种方法
execute、 executeQuery 和 executeUpdate 已被更改以使之不再需要参数
3. PreparedStatement尽最大可能提高性能. 最重要的一点是极大地提高了安全性.

解析：
字符流和字节流每次读入的字节数是不确定的，可能相同也可能不相同；字符流和字节流都有缓冲流

java题4

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

解析：
abstract 关键字，这个关键字声明了以后该类不能被实例化，之能让其子类继承它，这个类中必须声明有抽象方法才能被称为抽象类如果其中没有抽象方法则该类无法被称为抽象类。

解析：
a++很好记的，表示先用后+，而++a表示先+后用。看+在前在后，也决定第一步。

解析：
String x=“fmn”; “fmn”是在常量池里的不可变对象。
x.toUpperCase(); 在堆中new一个"FMN"对象，但无任何引用指向它。
String y=x.replace(‘f’,‘F’); 在堆中 new一个"Fmn"对象，y指向它。
y=y+“wxy”; 在堆中 重新new一个"Fmnwxy"对象， 修改y指向，现在y指向它。

解析：
静态成员和静态方法，可以直接通过类名进行调用；其他的成员和方法则需要进行实例化成对象之后，通过对象来调用。

解析：

1. 静态内部类：
   1. 静态内部类本身可以访问外部的静态资源，包括静态私有资源。但是不能访问非静态资源，可以不依赖外部类实例而实例化。
2. 成员内部类：
   1. 成员内部类本身可以访问外部的所有资源，但是自身不能定义静态资源，因为其实例化本身就还依赖着外部类。
3. 局部内部类：
   1. 局部内部类就像一个局部方法，不能被访问修饰符修饰，也不能被static修饰。
   2. 局部内部类只能访问所在代码块或者方法中被定义为final的局部变量。
4. 匿名内部类：
   1. 没有类名的内部类，不能使用class，extends和implements，没有构造方法。
   2. 多用于GUI中的事件处理。
   3. 不能定义静态资源
   4. 只能创建一个匿名内部类实例。
   5. 一个匿名内部类一定是在new后面的，这个匿名类必须继承一个父类或者实现一个接口。
   6. 匿名内部类是局部内部类的特殊形式，所以局部内部类的所有限制对匿名内部类也有效。

解析：
通常一个类实现序列化方式是实现序列化接口 Serializable

序列化的作用：把数据长久的保存在磁盘中，磁盘和内存是不同的，内存一般在程序运行时占用，数据保存周期短，随程序结束而结束，磁盘可以长久保存数据

transient关键字的作用，在已实现序列化的类中，有的变量不需要保存在磁盘中，就要transient关键字修饰，如银行卡密码等，就这个作用------在已序列化的类中使变量不序列化

解析：
就把内部类理解成类的成员，成员有4种访问权限吧，内部类也是！分别为private、protected、public以及默认的访问权限

解析：
Java中的四类八种基本数据类型
第一类：整数类型 byte short int long
第二类：浮点型 float double
第三类：逻辑型 boolean(它只有两个值可取true false)
第四类：字符型 char

解析：
final修饰的成员变量在赋值时可以有三种方式。1、在声明时直接赋值。2、在构造器中赋值。3、在初始代码块中进行赋值。

解析：
首先执行try，遇到算术异常，抛出，执行catch，打印1，然后抛出RuntimeException，缓存异常，执行finally，打印2，然后抛出RuntimeException。
如果catch中没有抛出RuntimeException，则执行结果为123。

解析：
总页数=总记录数/每页显示的条数（每页显示的条数是人为规定的）
因此总页数要根据总记录数确定，因此要首先获取总记录数

解析：
CountDownLatch 是等待一组线程执行完，才执行后面的代码。此时这组线程已经执行完。
CyclicBarrier 是等待一组线程至某个状态后再同时全部继续执行线程。此时这组线程还未执行完。

解析：
ArrayList内部是动态数组实现，在增加空间时会复制全部数据到新的容量大一些的数组中。而LinkedList内部为双向链表，可以按需分配空间，扩展容量简单，因此LinkedList用时少。

解析：
Servlet的生命周期分为5个阶段：加载、创建、初始化、处理客户请求、卸载。
(1)加载：容器通过类加载器使用servlet类对应的文件加载servlet
(2)创建：通过调用servlet构造函数创建一个servlet对象
(3)初始化：调用init方法初始化
(4)处理客户请求：每当有一个客户请求，容器会创建一个线程来处理客户请求
(5)卸载：调用destroy方法让servlet自己释放其占用的资源

解析：
首先不能两个public类，其次child类中无法访问父类的私有变量

解析：
在接口中，属性都是默认public static final修饰的，所以：
A（错误）：不能用private修饰；
B（正确）：在接口中，属性默认public static final，这三个关键字可以省略；
C（错误）：没写属性的类型；
D（错误）：final修饰的属性必须赋值；

解析：
考察的是值传递与引用传递，Java中原始数据类型都是值传递，传递的是值得副本，形参的改变不会影响实际参数的值， 引用传递传递的是引用类型数据，包括String,数组，列表, map,类对象等类型，形参与实参指向的是同一内存地址，因此形参改变会影响实参的值。

解析：
java在运行时才进行翻译指令

解析：
list,set,vector 是基本的集合

解析：
boolean类型只有两个直接量值:true和false.

解析：
继承只能有一个，接口可以有多个

解析：
init() --> 初始化
service() --> 处理请求
destory () --> 销毁（停止）

解析：
&不短路，&&短路。

解析：
is-a 表示继承：Gadget is-a Widget就表示Gadget 继承 Widget；
has-a表示从属：Gadget has-a Sprocket就表示Gadget中有Sprocket的引用，Sprocket是Gadget的组成部分；
like-a表示组合：如果A like-a B，那么B就是A的接

解析：

解析：
在初次标记，重新标志的时候，要求我们暂停其它应用程序，那么这两个阶段用户线程是不会参与的

解析：
str += ‘a’ 和 str +="a"都是对的，但是如果a前面加一个空格，那么只能用双引号了。代表字符串

解析：
A:Java中所有错误和异常的父类是java.lang.Throwable
B：基本数据类型不是对象，不能用new的方法获取，但是每个基本数据类型都对应着封装类型，这些封装类型为了解决基本数据类型面向对象用的。
C:Java垃圾回收器负责回收无用对象占据的内存资源,但对象没有使用new获取了一块特殊区域，这块特殊区域的回收使用finallize（）
D：Java跨平台是因为有JVM的存在，Java的三个版本的运行需要各自不同的环境。

解析：（英文看不太懂）
翻译：
MVC是一种在web应用中常用的架构，下列说法正确的是（）

A. 模型通常代表应用程序中的数据以及用于操纵数据的业务逻辑；

B. 视图是其对应的模型的可视化呈现，视图 将模型渲染成适合于交互的形式（通常为用户界面元素）；

C. 控制器是用户与系统之间的纽带，它接受用户输入，并指示模型和视图基于用户输入执行操作（处理数据、展示数据）；

D. MVC模式在web应用中的常见实践是：模型接受来自于用户的GET或POST请求数据并决定如何处理，模型将用户数据转交给控制器，控制器将控制权转交给视图（视图由HTML生成）；

E. 以上全不是。

1.模型(model)它是应用程序的主体部分，主要包括业务逻辑模块（web项目中的Action,dao类）和数据模块（pojo类）。模型与数据格式无关，这样一个模型能为多个视图提供数据。由于应用于模型的代码只需写一次就可以被多个视图重用，所以减少了代码的重复性

2.视图(view) 用户与之交互的界面、在web中视图一般由jsp,html组成

3.控制器(controller)接收来自界面的请求 并交给模型进行处理 在这个过程中控制器不做任何处理只是起到了一个连接的作用。 本题中显然D错误，应该是控制器接收请求，并将其交给模型进行处理，正确答案为A,B,C.

java题5

解析：
java.lang：java的语言包，是核心包，默认导入到用户程序，包中有object类，数据类型包装类，数学类，字符串类，系统和运行时类，操作类，线程类，错误和异常处理类，过程类。

解析：
静态方法用static修饰

解析：
interface 接口

解析：
public static void的main方法才是主类

解析：
主函数默认返回为void

解析：
A，接口中方法的默认修饰符时public abstract，抽象方法可是没有方法体的，没有大括号{}
B，JDK8中，接口中的方法可以被default和static修饰，但是！！！被修饰的方法必须有方法体。
C，注意一下，接口是可以多继承的。整个没毛病，和A选项一样，抽象方法不能有方法体

解析：
final修饰变量，则等同于常量

解析：
思路：
首先排除include和最后一个
其次：
1.PrintWriter
2.OutputStreamWriter
注意：
在创建OutputStreamWriter的时候，使用的是类的全名称。所以不需要使用import
故：选择A

解析：
nums.add(6);//把6添加到list中，变为｛5,3,1,6｝
nums.add(0,4);//在list的第0个位置添加4，list变为｛4,5,3,1,6｝
nums.remove(1);//移除list的第一个元素，list变为｛4,3,1,6｝

解析：
构造方法不能被static、final、synchronized、abstract、native修饰，但可以被public、private、protected修饰；

解析：
元数据区是用来替换永久代的

解析：
JVM如何理解泛型概念 —— 类型擦除。事实上，JVM并不知道泛型，所有的泛型在编译阶段就已经被处理成了普通类和方法。 处理方法很简单，我们叫做类型变量T的擦除(erased) 。 总结：泛型代码与JVM ① 虚拟机中没有泛型，只有普通类和方法。 ② 在编译阶段，所有泛型类的类型参数都会被Object或者它们的限定边界来替换。(类型擦除) ③ 在继承泛型类型的时候，桥方法的合成是为了避免类型变量擦除所带来的多态灾难。 无论我们如何定义一个泛型类型，相应的都会有一个原始类型被自动提供。原始类型的名字就是擦除类型参数的泛型类型的名字。

解析：
异常抛出基本形式

解析：

for(1;2;3){
    4;
}

这题考察的应该是for循环的执行顺序：
1只在开头执行一次便不再执行；然后是2->4->3->2->4->3这样循环下去；等到满足终止条件时到2就停止了

解析：
1、如果两个对象相等，那么他们一定有相同的哈希值（hash code）。

2、如果两个对象的哈希值相等，那么这两个对象有可能相等也有可能不相等。（需要再通过equals来判断）

解析：

sout split(6) = {
    sout split(3) = {
        sout split(2) = {
            sout split(1)
            return 2
        }
        sout split(1)
        return 3;
    }
    return 6
}

解析：
i1和i2为128，超出范围，所以都需要新建对象，对象比较为false；
i5和i6为100，在范围之内，在执行Integer i5=100时，就会直接缓存到内存中，但执行执行Integer i6=100时，就直接从缓存里取，而不需要新建对象，所以为true。
Jvm确实对型如String str1=”java”;的String对象放在常量池里，但是它是在编译时那么做的，而String s=str1+str2;是在运行时刻才能知道，也就是说str1+str2是在堆里创建的，所以结果为false了

解析：
通常可以使用继承来实现功能的拓展,如果这些需要拓展的功能的种类很繁多,那么势必生成很多子类,增加系统的复杂性,同时,使用继承实现功能拓展,我们必须可预见这些拓展功能,这些功能是编译时就确定了,是静态的。

解析：
for关键字

解析：
lable显示标签

解析：
桥接模式：
定义 ：将抽象部分与它的实现部分分离，使它们都可以独立地变化。
JDBC提供两套接口，一个面向数据库厂商，一个面向JDBC使用者。

解析：
静态块：用static申明，JVM加载类时执行，仅执行一次
构造块：类中直接用{}定义，每一次创建对象时执行
执行顺序优先级：静态块>main()>构造块>构造方法
静态块按照申明顺序执行，先执行Test t1 = new Test();
所有先输出blockA，然后执行静态块，输出blockB，最后执行main
方法中的Test t2 = new Test();输出blockA。

解析：
编译看左边，运行看右边。意思编译时候，看左边有没有该方法，运行的时候结果看 new 的对象是谁，就调用的谁。

解析：
子类可以继承父类的全部数据域和方法

解析：
isErrorPage为true才表示这是错误页面，才能使用exception对象

解析：
实现多线程的方法：
1.继承Thread类
2.实现Runnable接口
3.实现Callable接口

解析：
序列化：将数据结构转换称为二进制数据流或者文本流的过程。序列化后的数据方便在网络上传输和在硬盘上存储。
反序列化：与序列化相反，是将二进制数据流或者文本流转换称为易于处理和阅读的数据结构的过程。

解析：
在java中，子类构造器会默认调用super()(无论构造器中是否写有super（）),用于初始化父类成员，同时当父类中存在有参构造器时，必须提供无参构造器，子类构造器中并不会自动继承有参构造器，仍然默认调用super()，使用无参构造器。因此，一个类想要被继承必须提供无参构造器。

解析：
Hashtable：
（1）Hashtable 是一个散列表，它存储的内容是键值对(key-value)映射。
（2）Hashtable 的函数都是同步的，这意味着它是线程安全的。它的key、value都不可以为null。
（3）HashTable直接使用对象的hashCode。
HashMap：
（1）由数组+链表组成的，基于哈希表的Map实现，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的。
（2）不是线程安全的，HashMap可以接受为null的键(key)和值(value)。
（3）HashMap重新计算hash值

解析：
A 显然是错误的，Java一律采用Unicode编码方式，每个字符无论中文还是英文字符都占用2个字节。
B 也是不正确的，不同的编码之间是可以转换的，通常流程如下：
将字符串S以其自身编码方式分解为字节数组，再将字节数组以你想要输出的编码方式重新编码为字符串。
例：String newUTF8Str = new String(oldGBKStr.getBytes(“GBK”), “UTF8”);
C 是正确的。Java虚拟机中通常使用UTF-16的方式保存一个字符
D 也是正确的。ResourceBundle能够依据Local的不同，选择性的读取与Local对应后缀的properties文件，以达到国际化的目的。

java题6（1）

解析：
A 接口与抽象类是不同的概念。抽象类是用于捕捉子类的通用特性，接口是抽象方法的集合；
B 实现接口必须实现接口的所有方法；
C 接口可以继承一个或多个接口，抽象类只能继承一个类或者实现多个接口；
D 一个类只能继承一个类，但是可以实现多个接口。

解析：
二维数组的遍历，即每个元素之和

解析：
非静态方法只能通过实例对象来调用，不能直接通过类名调用。静态方法（static）才能通过类名直接调用.

解析：
定义的数组长度为10，角标即为0-9
访问数组角标10会出现数组角标越界异常

解析：
在空闲时间以不定时的方式动态回收无任何引用的对象占据的内存空间

解析：
每次循环都是减二，i一直不为0，所以循环为无限执行

解析：
内部类可以是静态static的，也可用public，default，protected和private修饰，外部类的修饰符只能是public，abstract，final

解析：
运行异常，可以通过java虚拟机来自行处理。非运行异常，我们应该捕获或者抛出

解析：
答案是 A foobar 这道题是考线程的调用情况，线程的启动方式只能通过start这种方式启动才能真正的实现多线程的效果，如果是手动调用run方法和普通方法调用没有区别，所以这个还是按照顺序执行首先执行run方法之后，执行输出语句所以最终得到结果foobar.

解析：
根据官方的JVM规范：
如果try语句里有return，返回的是try语句块中变量值。
详细执行过程如下：

1. 如果有返回值，就把返回值保存到局部变量中；
2. 执行jsr指令跳到finally语句里执行；
3. 执行完finally语句后，返回之前保存在局部变量表里的值。
   如果try，finally语句里均有return，忽略try的return，而使用finally的return.

解析：
Java中静态变量只能在类主体中定义，不能在方法中定义。 静态变量属于类所有而不属于方法。

解析：
A：java的访问权限有public、protected、private和default的，default不能修饰变量
C：普通变量不能用abstract修饰，abstract一般修饰方法和类
D：被定义为abstract的类需要被子类继承，但是被修饰为final的类是不能被继承和改写的

解析：

解析：
重写 要求两同两小一大原则， 方法名相同，参数类型相同，子类返回类型小于等于父类方法返回类型， 子类抛出异常小于等于父类方法抛出异常， 子类访问权限大于等于父类方法访问权限。［注意：这里的返回类型必须要在有继承关系的前提下比较］

重载 方法名必须相同，参数类型必须不同，包括但不限于一项，参数数目，参数类型，参数顺序
再来说说这道题 A B 都是方法名和参数相同，是重写，但是返回类型没与父类返回类型有继承关系，错误 D 返回一个类错误 c的参数类型与父类不同，所以不是重写，可以理解为广义上的重载访问权限小于父类，都会显示错误
虽然题目没点明一定要重载或者重写，但是当你的方法名与参数类型与父类相同时，已经是重写了，这时候如果返回类型或者异常类型比父类大，或者访问权限比父类小都会编译错误

解析：
A 错误 运行命令是 java + 你的 Java 程序的名字但是不加后缀 所以这道题错在多了 .class这个后缀
C javac 是编译命令，后跟 你的 Java 程序名字加后缀，也就是 YourClassName.java 所以答案正确
D JVM （Java 虚拟机）运行的是编译后的字节码文件（以.class为后缀的文件），也就是 YourClassName.class 所以答案正确

解析：

解析：
if(flag = true)的时候flag已经是true了，所以输出true；
要是为if(flag == true)输出才为false

解析：
操作步骤就是先解码再编码
用new String(src，“GBK”)解码得到字符串
用getBytes(“UTF-8”)得到UTF8编码字节数组

解析：
好吧 首字母大写没有注意到

解析：
线程安全的map:HashTable,SynchronizedMap,ConcurrentHashMap

解析：
is-a 表示继承：Gadget is-a Widget就表示Gadget 继承 Widget；
has-a表示从属：Gadget has-a Sprocket就表示Gadget中有Sprocket的引用，Sprocket是Gadget的组成部分；
like-a表示组合：如果A like-a B，那么B就是A的接口

解析：
题目的四个选项是构造方法new，序列化对象，反射，克隆分别创建一个对象的方法，，只有new和反射用到了构造方法

解析：
A选项正确，Java中一般通过interrupt方法中断线程
B选项正确，线程使用了wait方法，会强行打断当前操作，进入阻塞（暂停）状态，然后需要notify方法或notifyAll方法才能进入就绪状态
C选项错误，新创建的线程不会抢占时间片，只有等当前线程把时间片用完，其他线程才有资格拿到时间片去执行。
D选项错误，调度算法未必是剥夺式的，而准备就绪但是还没有获得CPU，它的权限更高只能说明它获得CPU被执行的几率更大而已

解析：
Java有5种方式来创建对象：

1. 使用 new 关键字（最常用）： ObjectName obj = new ObjectName();
2. 使用反 射的Class类的newInstance()方法： ObjectName obj = ObjectName.class.newInstance();
3. 使用反射的Constructor类的newInstance()方法： ObjectName obj = ObjectName.class.getConstructor.newInstance();
4. 使用对象克隆clone()方法： ObjectName obj = obj.clone();
5. 使用反序列化（ObjectInputStream）的readObject()方法： try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_NAME))) { ObjectName obj = ois.readObject(); }
   
   解析：
   
   解析：
   D中说的与硬件交互是JVM机器指令与硬件的交互
   
   解析：
   
   解析：
   
   解析：

java题7（2）

解析：
类支持单继承，接口支持多继承

解析：
1、本类的方法可以访问
2、反射也可以访问

解析：

解析：
this()和super()都是构造器，this()调用本类构造器，super()调用父类构造器


解析：
javac将源程序编译成.class文件，字节码；java将字节码转为机器码，.exe程序

解析：


解析：
java 中String是 引用数据类型的，也就是不可变，一旦初始化，其引用指向的内容是不可变的。

也就是说，String str = “aa”；str=“bb”；第二句不是改变“aa”所存储地址的内容，而是另外开辟了一个空间用来存储“bb”；同时由str指向

原来的“aa”，现在已经不可达，GC时会自动回收。

因此String作为参数传进来时候，str= “test ok”; 实际给副本引用str指向了新分配的地址，该地址存储“test ok”。

因此，原先的str仍然指向“good”

解析：
example调用run(),而不是启动线程的start(),所以该程序会依次执行，先打印run,再打印main,所以选A


解析：
在类方法中不能有this关键字，直接调用类方法即可，A错误，B正确，在类方法中可以通过创建实例对象调用类的实例方法，C\D错误

解析：
hashcode和equals的约定关系如下：

1、如果两个对象相等，那么他们一定有相同的哈希值（hash code）。

2、如果两个对象的哈希值相等，那么这两个对象有可能相等也有可能不相等。（需要再通过equals来判断）

解析：
1.start方法
用 start方法来启动线程，是真正实现了多线程， 通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法。但要注意的是，此时无需等待run()方法执行完毕，即可继续执行下面的代码。所以run()方法并没有实现多线程。
2.run方法
run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码。

解析：
继承是根源，重写是表现形式

解析：

解析：
枚举类是一种特殊对的类，既然是类。那他就不是原始数据类型了

解析：

1. 构造方法可以被重载，一个构造方法可以通过this关键字调用另一个构造方法，this语句必须位于构造方法的第一行；
   重载：方法的重载(overload)：重载构成的条件：方法的名称相同，但参数类型或参数个数不同，才能构成方法的重载。
2. 当一个类中没有定义任何构造方法，Java将自动提供一个缺省构造方法；
3. 子类通过super关键字调用父类的一个构造方法；
4. 当子类的某个构造方法没有通过super关键字调用父类的构造方法，通过这个构造方法创建子类对象时，会自动先调用父类的缺省构造方法
5. 构造方法不能被static、final、synchronized、abstract、native修饰，但可以被public、private、protected修饰；
6. 构造方法不是类的成员方法；
7. 构造方法不能被继承。
   
   
   解析：
   位异运算符号。
   运算规则是：两个数转为二进制，然后从高位开始比较，如果相同则为0，不相同则为1。
   17：0001 0001
   5： 0000 0101
   结果：0001 0100 转10进制：20
   
   解析：
   方法区在JVM中也是一个非常重要的区域，它与堆一样，是被 线程共享 的区域。 在方法区中，存储了每个类的信息（包括类的名称、方法信息、字段信息）、静态变量、常量以及编译器编译后的代码等。
   
   
   解析：
   因为byte是有符号单字节整形，所以存储数字范围是[-128·127]
   
   解析：
   Iterator接口是Collection接口的父接口。
   
   解析：
   线程安全的类有hashtable concurrentHashMap synchronizedMap
   

解析：
s为null，因此只要调用了s.length()都会抛出空指针异常。因此这个题目就是考察if语句的后半部分会不会执行。
A，单个与操作的符号& 用在整数上是按位与，用在布尔型变量上跟&&功能类似，但是区别是无论前面是否为真，后面必定执行，因此抛出异常
B，与操作，前半部分判断为假，后面不再执行
C，这里跟 & 和&& 的区别类似，后面必定执行，因此抛出异常
D，或语句，前面为真，整个结果必定为真，后面不执行


解析：
1、不管有木有出现异常，finally块中代码都会执行；
2、当try和catch中有return时，finally仍然会执行；
3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；
4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

java题8（3）

解析：
被sataic声明的为静态方法，可以直接通过类名调用而不需要通过对象调用


解析：
这是多重catch块的顺序问题，由于异常处理系统就近寻找匹配异常处理程序，应先子类后父类。

解析：

解析：
ArrayIndexOutOfBoundsException


解析：
一轮排序之后，最大值在最后面，选D




解析：
定义在类中的变量是类的成员变量，可以不进行初始化，Java会自动进行初始化，如果是引用类型默认初始化为null,如果是基本类型例如int则会默认初始化为0
局部变量是定义在方法中的变量，必须要进行初始化，否则不同通过编译
被static关键字修饰的变量是静态的，静态变量随着类的加载而加载，所以也被称为类变量
被final修饰发变量是常量


解析：
一般关系数据模型和对象数据模型之间有以下对应关系：表对应类，记录对应对象，表的字段对应类的属性

解析：
get()采用立即加载方式,而load()采用 延迟加载

解析：
导入java.util.*不能读取其子目录的类，因为如果java.util里面有个a类，java.util.regex里面也有个a类，我们若是要调用a类的方法或属性时，应该使用哪个a类呢

解析：
i==j ，这个是基本类型与 Integer 的比较， j 会自动拆箱成 int 类型，然后比较的是值。因此返回真。
j.equals(i) ，调用 equals 方法后，这个 i 会自动装箱成 Integer 类型，然后再比较值，所以也返回真。

解析：
"|"是按位或：先判断条件1，不管条件1是否可以决定结果（这里决定结果为true)，都会执行条件2
"||"是逻辑或：先判断条件1，如果条件1可以决定结果（这里决定结果为true)，那么就不会执行条件2

解析：
C中，应该是Arrays.asList()，其将一个数组转化为一个List对象，这个方法返回一个ArrayList类型的对象， 这个ArrayList类并非java.util.ArrayList类，而是Arrays类的内部类

解析：



解析：
考察点1：重载静态多分派——根据传入重载方法的参数类型，选择更加合适的一个重载方法
考察点2：static方法不能被子类覆写，在子类中定义了和父类完全相同的static方法，则父类的static方法被隐藏，Son.staticmethod()或new Son().staticmethod()都是调用的子类的static方法，如果是Father.staticmethod()或者Father f = new Son(); f.staticmethod()调用的都是父类的static方法。
考察点3：此题如果都不是static方法，则最终的结果是A. 调用子类的getType，输出collection


解析：
调用getName()方法而getName()是：包名+类名


解析：
case 1和case 2后都没有break语句，故都会执行到打印Test2的语句

解析：
局部变量，没有像成员变量那样类加载时会有初始化赋值，所以要使用局部变量时，一定要显式的给它赋值，也就是定义时就给它数值。


解析：
USES-A：依赖关系，A类会用到B类，这种关系具有偶然性，临时性。但B类的变化会影响A类。这种在代码中的体现为：A类方法中的参数包含了B类。
关联关系：A类会用到B类，这是一种强依赖关系，是长期的并非偶然。在代码中的表现为：A类的成员变量中含有B类。
HAS-A：聚合关系，拥有关系，是关联关系的一种特例，是整体和部分的关系。比如鸟群和鸟的关系是聚合关系，鸟群中每个部分都是鸟。
IS-A：表示继承。父类与子类，这个就不解释了。

解析：
通过阅读源码可以知道，string与stringbuffer都是通过字符数组实现的。
其中string的字符数组是final修饰的，所以字符数组不可以修改。
stringbuffer的字符数组没有final修饰，所以字符数组可以修改。
string与stringbuffer都是final修饰，只是限制他们所存储的引用地址不可修改。
至于地址所指内容能不能修改，则需要看字符数组可不可以修改。

java题9（2.21）

解析：
成员变量为int类型可以不初始化，默认值为0
局部变量为int类型必须初始化，没有默认值

解析：
封装主要是隐藏内部代码；
继承主要是复用现有代码；
多态主要是改写对象行为。


解析：
synchronized 关键字 : 用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这个段代码。

解析：
导包关键词import。

解析：
有默认的无参构造方法

解析：
public>protected>默认(包访问权限)>private

解析：
面板容器组件

解析：
子类重写父类方法时，方法的访问权限不能小于原访问权限，在接口中，方法的默认权限就是public，所以子类重写后只能是public

解析：
==用来判断两个变量是否相等时，如果两个变量是基本类型变量，且都是数值类型(不要求数据类型严格相同)，则只要两个变量的值相等，就返回true；对于两个引用类型变量，必须指向同一个对象，==才会返回true。

解析：
if()语句括号中为比较表达式，返回值要么是true，要么是false，if(x=y)是将y赋值给x，但是数据类型是int类型的，编译不能通过


解析：
Java在序列化时不会实例化static变量和transient修饰的变量，因为static代表类的成员，transient代表对象的临时数据，被声明这两种类型的数据成员不能被序列化

解析：
运行java命令,没有t f a b c对应的类,会报找不到或者无法加载主类。

解析：
通过继承，子类可以拥有所有父类对其可见的方法和域
A.私有方法只能在本类中可见，故不能继承，A错误
B.缺省访问修饰符只在本包中可见，在外包中不可见，B错误
C.保护修饰符凡是继承自该类的子类都能访问，当然可被继承覆盖；C正确
D.static修饰的成员属于类成员，父类字段或方法只能被子类同名字段或方法遮蔽，不能被继承覆盖，D错误

解析：
①调用func(1),if不符合，直接进入finally，sRet=“1"
②finally语句中没有返回值，故继续向下执行，sRet=“12”
③调用func(2),if符合，sRet=“120”，此时有返回值!!!
④调用finally语句，sRet=“1201”
⑤因为已经有返回值了，finally之后的语句也不再执行，sRet=“1201”。

解析：
在执行main之前先执行之前的带有static的内容
1.执行public static B t1 = new B();(这时忽略其他带有static的部分)打印"构造块"
2.执行 public static B t2 = new B();同1打印"构造块"
3.执行static{syso(“静态块”)}打印"静态块"
4.执行main打印"构造块"

解析：
new Sub();在创造派生类的过程中首先创建基类对象，然后才能创建派生类。
创建基类即默认调用Base()方法，在方法中调用callName()方法，由于派生类中存在此方法，则被调用的callName（）方法是派生类中的方法，此时派生类还未构造，所以变量baseName的值为null

解析：
[ ] 里面是不重复的，所以等价于[😕]
如果[ ]后面没有带+号的话，是不会贪婪匹配的，就只能匹配到://中的其中一个

解析：
private方法是可以继承的，只是不能调用



解析：
e3若先出栈说明1、2被压，那么4进栈后会先于1、2出栈

解析：
记住标识符只有英文，数字，下划线和$，而且数字不能做开头




解析：
1.方法重写时， 方法名与形参列表必须一致。
2.方法重写时，子类的权限修饰符必须要大于或者等于父类的权限修饰符。
3.方法重写时，子类的返回值类型必须要小于或者等于父类的返回值类型。
4.方法重写时， 子类抛出的异常类型要小于或者等于父类抛出的异常类型。


解析：
其中string的字符数组是final修饰的，所以字符数组不可以修改。
stringbuffer的字符数组没有final修饰，所以字符数组可以修改。
string与stringbuffer都是final修饰，只是限制他们所存储的引用地址不可修改。
至于地址所指内容能不能修改，则需要看字符数组可不可以修改。

java题10（2.24）

解析：
Java文件经过JVM编译成字节码文件，即.class文件

解析：
接口的方法都是 public abstract 变量都是public static final的


解析：
类静态成员和静态初始化块，按在代码中出现的顺序依次执行。

解析：
for循环执行开始
首先执行out(‘A’) 输出A；
然后执行out(‘B’)&&(i<2)此时输出B，i=0，判断条件为真，执行for循环的循环体；
执行i++，out(‘D’)，输出D i=1；
执行out(‘C’),输出C
然后执行out(‘B’)&&(i<2) 此时输出B，i=1 判断条件为真 ，执行for循环的循环体；
执行i++，out(‘D’)，输出D i=2；
执行out(‘C’),输出C
然后执行out(‘B’)&&(i<2) 此时输出B，i=2，不满足i<2 判断条件为假 ，跳出循环；
所以结果为ABDCBDCB


解析：
如果finally块中有return语句的话，它将覆盖掉函数中其他return语句。

解析：
final类型的变量一定要初始化，因为final的变量不可更改。


解析：
SessionFactory接口：初始化Hibernate，充当数据存储源的，创建session对象，SessionFactory是线程安全的，意味着它的同一个实例可以被应用的多个线程共享，是重量级二级缓存；

解析：
在java源码中被@Deprecated修饰的类、方法、变量等表示不建议使用的

解析：
CountDownLatch 是等待一组线程执行完，才执行后面的代码。此时这组线程已经执行完。

解析：
java中引用类型的实参向形参的传递，只是传递的引用，而不是传递的对象本身。


解析：
threadlocalmap使用开放定址法解决haah冲突，hashmap使用链地址法解决hash冲突

解析：
Java集合框架主要由Collection和Map两个根接口及其子接口、实现类组成。 collection 的子接口包括List,set,queue。而Map包括三个实现类HashMap，HashTable，LinkeHashMap

(1)== 用于比较基本数据类型时比较的是值，用于比较引用类型时比较的是引用指向的地址。
(2)Object 中的equals() 与 ==的作用相同，但String类重写了equals()方法，比较的是对象中的内容。

A、java为单继承，多实现。可以实现多个接口。
B、接口允许定义成员，但必须是常量。
C、抽象类和接口类的无法实例化，任何编译器中直接使用new会报错。
D、同A，单继承，多实现。


解析：
ThreadLocal继承Object，相当于没继承任何特殊的。
ThreadLocal没有实现任何接口。
ThreadLocal并不是一个Thread，而是Thread的局部变量。

java题11（3.6）

解析：
java中为单继承

解析：
队列为先进先出

解析：
private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用

解析：
1abstract类不能与final,static使用。final修饰方法，子类可以调用，但不能覆盖。
2最好不要有private因为私有和抽象放在一起，子类如果想重写父类的私有方法根本继承不过来，也就无法重写
3抽象类中可以有非抽象方法
4抽象类中可以都是非抽象的，但是抽象方法一定要在类和接口中

解析：
抽象类不可以实例化

解析：
Java一个源程序只能有一个public类存在，且类名与文件名相同

解析：
TreeSet自然排序，LinkedHashSet按添加顺序排序

解析：
异常触发后，不执行后续语句，直接跳出try，执行catch
Console.WriteLine(“error2”);
如果有finally，则执行finally后程序结束；如果没有，执行catch外部后程序结束 Console.WriteLine(“error3”);

解析：
在Java中规定，多行注释可以嵌套单行注释，但是不能嵌套多行注释。

解析：
计算机是由硬件和软件组成，操作系统是软件部分。

解析：
依赖注入的动机就是减少组件之间的耦合度，使开发更为简洁

解析：
main线程会等待其他线程的run方法执行完成后再结束

解析：


解析：
switch支持 int及以下（char， short， byte），String， Enum

解析：
往方法中传参，传的仅仅只是地址，而不是实际内存，所以不要以为y=x程序的执行，是 b=a的执行。这两者是不相等的

解析：
Webservice是跨平台，跨语言的远程调用技术;
它的通信机制实质就是xml数据交换;
它采用了soap协议（简单对象协议）进行通信


解析：
java中整型默认的是int,浮点默认的是double.
B: double类型的11.1 转成 float，是需要强制转换的
C: double类型的0.0 转成 int，也是需要强制转换的
D: int 转为 封装类型Double，是无法编译的

解析：
关于子类继承父类中方法的调用，只要不是用super调用，调用的都是子类中覆写父类的方法。

解析：
既然是字符流，那么一般是reader和writer结尾，那么就选BC了

解析：
&和|为非短路逻辑运算符，无论两个语句为什么，一定会执行完毕，所以A、C两个是会报出异常的。

解析：
lx第一次赋值之后，把它的值赋给nb，这个时候nb的值已经确定，lx再次赋值，也是无法改变nb的值的。




解析：
数组是一种引用数据类型 那么他肯定是继承Object类的 所以里面有equals() 方法 但是肯定没有重写过 因为他并不是比较数组内的内容
使用Arrays.equals() 是比较两个数组中的内容。
数组的长度是固定的，int[] array =new int[100]就对了

解析：
C：是使用unicode表示的字符。

java题12（3.13）

解析：
被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；

解析：
rivate方法只可以在类的内部使用，在类外根本访问不到， 而final方法可以在类外访问，但是不可以重写该方法

解析：
类支持单根继承，接口支持多继承

解析：
==比较的是地址和值。
equals比较的是值。
s1==s2，比较的是地址，s1,s2两个引用指向的是同一个地址，所以返回true.
s3 == s4，比较的是两个new出来开辟的空间对象地址，所以值相同，但地址不同，返回false.
s1.equals(s3)，比较的是内容,返回true。

解析：
%和*是同一个优先级，从左到右运算

解析：
String是final修饰的，不可变
运行速度StringBuilder>StringBuffer>String
StringBuffer是线程安全的

解析：
构造函数，名称与类相同，没有返回类型的

解析：
final变量，如果是基本数据类型，则其数值一旦初始化后就不能被改变。如果是引用类型的变量，则对其初始化后，便不能再指向另一个对象，但是其里面的值是可以改变的。引用变量所指向的对象中的内容是可以改变的。

解析：
1、不管有木有出现异常，finally块中代码都会执行；
2、当try和catch中有return时，finally仍然会执行；
3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；
4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

解析：
javac -d 指定放置生成的类文件的位置

解析：
重写了object 的equals 的方法，使他怎么输出都是tue


解析：
out是java.lang.System类中的一个字段，out是“标准“”输出流，public static final PrintStream out，
out是PrintStream类型，PrintStream是包装流，你传入什么，他就输出什么

解析：
javadoc 它从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档。

解析：
1、jps：查看本机java进程信息。

2、jstack：打印线程的栈信息，制作线程dump文件。

3、jmap：打印内存映射，制作堆dump文件

4、jstat：性能监控工具

5、jhat：内存分析工具

6、jconsole：简易的可视化控制台

7、jvisualvm：功能强大的控制台

解析：

考察的是for循环三条语句的执行顺序 for(第一条语句；第二条语句；第三条语句；) 首次循环时先执行前两句。以后的每次循环结束，都是执行最后一条语句，然后执行判断语句（也就是第二条语句）条件成立进入下一次循环。 第一条语句只会被执行一次

解析：
floor: 求小于参数的最大整数。返回double类型

解析：
volatile用于限定变量只能从内存中读取，保证对所有线程而言，值都是一致的。但是volatile不能保证原子性，也就不能保证线程安全。

解析：
成员内部类访问规则
成员内部类不是静态的：
外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
成员内部类是静态的：
外部类名.内部类名 对象名 = new 外部类名.内部类名();



解析：
分母为0 为运行时异常，jvm帮我们补货，无需代码里面显式捕获


解析：
c是面向过程，c++面向对象，JAVA面向对象，汇编是面向机器


解析：
A选项Map属于接口类型，不可以new的方式创建对象。所以A错误。
B选项SortedMap属于接口类型，不可以new的方式创建对象。所以B错误。
C选项HashMap基于哈希表实现Map接口的类，并允许null的值和null键。
D选项TreeMap通过红黑树实现Map接口的类，key不可以为null，会报NullPointerException异常,value可以为null。

java对象初始化顺序
结论：

父类静态代码块，父类静态成员变量（同级，按代码顺序执行）
子类静态代码块，子类静态成员变量（同级，按代码顺序执行）
父类普通代码块，父类普通成员变量（同级，按代码顺序执行）
父类构造方法
子类普通代码块，子类普通成员变量（同级，按代码顺序执行）
子类构造方法
注意点：

1. 静态内容只在类加载时执行一次，之后不再执行。
2. 默认调用父类的无参构造方法，可以在子类构造方法中利用super指定调用父类的哪个构造方法。

java题13（3.20）

解析：
1.不能以数字开头
2.不能是关键字
3.不能包含除了$和_以外的其他字符

解析：
比较对象相等时也是要最好同时重写这两个方法。一直记着hashcode用来找桶，equals用来在桶里找相同那一个。


解析：
==是验证两个对象是否是一个（内存地址是否相同）

解析：

父类静态代码块，父类静态成员变量（同级，按代码顺序执行）
子类静态代码块，子类静态成员变量（同级，按代码顺序执行）
父类普通代码块，父类普通成员变量（同级，按代码顺序执行）
父类构造方法
子类普通代码块，子类普通成员变量（同级，按代码顺序执行）
子类构造方法
注意点：

1. 静态内容只在类加载时执行一次，之后不再执行。
2. 默认调用父类的无参构造方法，可以在子类构造方法中利用super指定调用父类的哪个构造方法。
   
   解析：
   重载的概念是：
   方法名称相同，参数个数、次序、类型不同
   因此重载对返回值没有要求，可以相同，也可以不同
   但是如果参数的个数、类型、次序都相同，方法名也相同，仅返回值不同，则无法构成重载。
   
   
   
   解析：
   对象赋值时，比如A=B，只是把A对象的地址指向了B对象的地址，所以其实对象只有一个
   
   解析：
   Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11而不是-12。
   
   
   解析：
   基本数据类型是值传递，修改形参的值实参也改变
   引用数据类型是对地址的应用，赋值会重新指向新的地址
   
   
   解析：
   append()，方法是对指向的对象进行操作
   引用数据类型是对地址的应用，赋值会重新指向新的地址
   
   
   解析：
   类的加载包括：加载，验证，准备，解析，初始化。
   选项A：生成java.lang.Class对象是在加载时进行的。生成Class对象作为方法区这个类的各种数据的访问入口。
   选项B：既然是对象成员，那么肯定在实例化对象后才有。在类加载的时候会赋予初值的是类变量，而非对象成员。
   选项C：这个会调用。可以用反射试验。
   选项D：类方法解析发生在解析过程。
   
   解析：
   解决冲突主要有三种方法：定址法，拉链法，再散列法。
   
   
   
   
   
   解析：
   count=count++就是先把局部变量表中count的值0放入操作数栈中，然后直接对局部变量表中的count加1，然后再把操作数栈中的0出栈赋值给局部变量表中的count，最终局部变量表中的count值仍为0
   
   
   
   解析：
   1.抽象类可以有构造方法，接口中不能有构造方法。
   2.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
   3.抽象类中可以有普通成员变量，接口中没有普通成员变量
3. 抽象类中的抽象方法的访问类型可以是public，protected和默认类型
4. 抽象类中可以包含静态方法，接口中不能包含静态方法
5. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型
   
   
   解析：
   A : 在private 修饰不能在外部类中调用，main 方法属于Test类的方法， 所以 对象 t 可以在他自己的类方法中调用它的private
   B ： static 方法中没有this 这么一说
   C: b不是static变量
   D: 合理
   
   

java题14（3.27）

解析：
没有break，会产生穿透，从满足条件的case开始执行到底

解析：
list 存放的元素可重复， set 不可以。 map 使用的是键值对存放，可一对多，key不重复，value可重复

解析：
反射破坏代码的封装性，破坏原有的访问修饰符访问限制

解析：
功能性注释嵌在源程序中，用于说明程序段或语句的功能以及数据的状态。
可使用空行或缩进，以便很容易区分注释和程序。
修改程序也应修改注释。

解析：
执行1次，5
执行2次，3
执行3次，1
执行4次，-1
永远执行不到0

解析：

1. 首先，类的修饰符，都应该在class关键字之前，AB错；
2. 抽象方法不能有方法体，D错。
   
   解析：
   
   
   解析：
   1、abstract不能与final并列修饰同一个类 对的。
   2、abstract类中不应该有private的成员 对的 ：abstract类中可以有private 但是不应该有。
   3、abstract方法必须在abstract类或接口中 对的 ： 若类中方法有abstract修饰的，该类必须abstract修改。接口方法默认public abstract。
   4、static方法中能处理非static的属性 错误 ：在JVM中static方法在静态区，静态区无法调用非静态区属性。
   
   解析：
   A 选项在 final 定义的方法里，不是必须要用 final 定义变量。
   B final 定义的变量，可以在不是必须要在定义的同时完成初始化，也可以在构造方法中完成初始化。
   C 正确，final修饰方法，不能被子类重写，但是可以被重载。
   D final 定义变量，可以用 static 也可以不用。
   
   
   解析：
   接口中的变量默认是public static final 的，方法默认是public abstract 的
   
   解析：
   方法重载（overload）：
   1.必须是同一个类
   2方法名（也可以叫函数）一样
   3参数类型不一样或参数数量不一样

方法的重写（override）两同两小一大原则：
方法名相同，参数类型相同
子类返回类型小于等于父类方法返回类型，
子类抛出异常小于等于父类方法抛出异常，
子类访问权限大于等于父类方法访问权限。

解析：
try的形式有三种：
try-catch
try-finally
try-catch-finally
但catch和finally语句不能同时省略！


解析：
因为x的 修饰符为 static 所以x为类变量，即对于所有的实例来说，他们访问的x为同一个x，类变量存储在方法区，不属于每个实例的私有，
刚开始x=100
调用hs1.x++ x为101;
调用hs2.x++ x为102;
调用hs1.x++ x为103 (此时hs1指向了一个新的HasStatic实例，但是依然访问的是同一个X)
调用HasStatic.x-- x为102
所以结果为D

解析：
int a=‘2’；将字符"2"取ASCII码赋给a。'2’的ASCII码是50。ASCII码记忆：空格是32，'0’是48，'A’是65，'a’是97。



解析：
1，字符串在java中存储在字符串常量区中
2，==判断的是对象引用是否是同一个引用，判断字符串相等要用equals方法
首先判断a==MESSAGE 同一份字符串常量在内存中只有一份，因此是同一地址，返回true
再次比较(b+c)==MESSAGE 这相当于 new String(b+c)==MESSAGE 这里new了一个String对象，所以返回false


解析：
运行时异常，编译器没有强制对其进行捕捉和处理。一般都会把异常向上抛出，直到遇到处理代码位置，若没有处理块就会抛到最上层，多线程用thread。run（）抛出，单线程用main（）抛出。

解析：

String test="javaandpython"; 
String str1="java"; 
String str2="and"; 
String str3="python"; 
System. out. println(test=="java"+"and"+"python"): 
System. out. println(test ==str1 + str2 + str3);

对于上面这段代码，结果是true false
这是因为字符串字面量拼接操作是在Java编译器编译期间就执行了，也就是说编译器编译时，直接把"java"、“and"和"python"这三个字面量进行”+“操作得到一个"javaandpython” 常量，并且直接将这个常量放入字符串池中，这样做实际上是一种优化，将3个字面量合成一个，避免了创建多余的字符串对象（只有一个对象"javaandpython"，在字符串常量池中）。而字符串引用的"+“运算是在Java运行期间执行的，即str1 + str2 + str3在程序执行期间才会进行计算，它会在堆内存中重新创建一个拼接后的字符串对象。且在字符串常量池中也会有str1,str2与str3，这里创建多少个新的对象与原来字符串常量池中有没有str1\str2\str3有关，如果之前存在就不会创建新的对象。
总结来说就是：字面量”+“拼接是在编译期间进行的，拼接后的字符串存放在字符串池中；而字符串引用的”+"拼接运算实在运行时进行的，新创建的字符串存放在堆中。
那么再来看这题，很明显只在编译期间在字符串常量池中创建了"welcometo360"一个字符串

解析：
DBMS中事务有四个特性，持久性，一致性，原子性，隔离性，持久性实现恢复管理子系统，一致性实现并发控制子系统，原子性实现完整性管理子系统，隔离性实现安全控制管理子系统 个人理解，有错请指正



解析：


解析：
两个数值进行二元操作时，会有如下的转换操作：
如果两个操作数其中有一个是double类型，另一个操作就会转换为double类型。
否则，如果其中一个操作数是float类型，另一个将会转换为float类型。
否则，如果其中一个操作数是long类型，另一个会转换为long类型。
否则，两个操作数都转换为int类型。
故，x==f1[0]中，x将会转换为float类型。

java题15（4.10）

解析：
抽象类可以包括抽象方法和非抽象方法


解析：
方法的重写（override）两同两小一大原则：
方法名相同，参数类型相同
子类返回类型小于等于父类方法返回类型，
子类抛出异常小于等于父类方法抛出异常，
子类访问权限大于等于父类方法访问权限。



解析：
Java 重载的规则：

1、必须具有不同的参数列表；

2、可以有不同的返回类型，只要参数列表不同就可以；

3、可以有不同的访问修饰符；

4、可以抛出不同的异常；

5、方法能够在一个类中或者在一个子类中被重载。


解析：
1、子类构造函数调用父类构造函数用super
2、子类重写父类方法后，若想调用父类中被重写的方法，用super
3、未被重写的方法可以直接调用。

解析：
没有break，发生case穿透现象，程序会继续向下执行，直到遇到break或者结束switch语句的大括号为止。

解析：
Java的跨平台特性是因为JVM的存在， 它可以执行.class字节码文件，而不是.java源代码


解析：
Java是纯粹的面向对象语言，所有的方法都必须存在于类中。类才有封装，继承，多态的特性。

解析：
&和&&都是逻辑运算符，都是判断两边同时真则为真，否则为假；但是&&当第一个条件不成之后，后面的条件都不执行了，而&则还是继续执行，直到整个条件语句执行完为止

解析：
5的二进制是0101。
x=5>>2 （>>带符号右移）

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

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

所以得出答案0

解析：
A：缺少必要的整型类型声明
B：缺少常量关键字final
D：定义一个浮点常量

解析：
初始化为{5,3,1}
nums.add(6)后list为{5,3,1,6}
nums.add(0,4)是在0号索引上添加数字4得到list为{4,5,3,1,6}
nums.remove(1)是将1号索引上的5进行remove得到list为{4,3,1,6}

解析
引用类型作为函数的参数时，复制的是引用的地址，不会产生一个新的T；而如果T是值类型，其作为函数实参时会复制其值，也就是产生了一个新的T。所以D选项正确


解析：
因为原字符串不包含分隔符，所以直接返回原字符串，分割出来只有一个空的字符串数组，所以结果是1.（注意，虽然原字符串为空，存到字符串数组为空，但是这个空也会算一个元素。）

解析：
假设两线程为A、B，设有3种情况：
1.AB不并发：此时相当于两个方法顺序执行。A执行完后a=-1，B使用-1作为a的初值，B执行完后a=-2
2.AB完全并发：此时读写冲突，相当于只有一个线程对a的读写最终生效。相同于方法只执行了一次。此时a=-1
3.AB部分并发：假设A先进行第一次读写，得到a=1;之后A的读写被B覆盖了。B使用用1作为a的初值，B执行完后a=0


解析：
先执行：
static int x = 10；
再执行两个静态块：
static { x+=5; }
static { x/=3; }
最后执行main()：
System.out.println(“x=” + x);
所以x = 10 -> x = x +5 = 15 -> x = x / 3 = 5
打印x=5

java题16（4.17）

解析：

1. 用try-catch 捕获异常;
2. 用try-finally 清除异常;
3. 用try-catch-finally 处理所有的异常. 三者选一种即可

解析：
string是final修饰的，会将创建的变量放入字符串常量池，当再创建同样的字符串时，发现常量池中有则直接使用

解析：
如果是本类使用，可以直接就用静态变量名

解析：

A错误，类的实例方法是与该类的实例对象相关联的，不能直接调用，只能通过创建超类的一个实例对象，再进行调用
B错误，当父类的类方法定义为private时，对子类是不可见的，所以子类无法调用
C错误，子类具体的实例方法对父类是不可见的，所以无法直接调用， 只能通过创建子类的一个实例对象，再进行调用
D正确，实例方法可以调用自己类中的实例方法

解析：

正解：0.5
x/y= （float）1.0/（float）2.0=0.5 （float类型的）

解析：

subset(form，true，to，true)是Treeset的非静态方法，该方法返回从form元素到to元素的一个set集合，两个boolean类型是确认是否包含边境值用的。

解析：

正确答案是B，因为error是系统出错，catch是无法处理的，难以修复的，RuntimeException不需要程序员进行捕获处理，error和exception都是throwable的子类，我们只需要对exception的实例进行捕获即可

解析：

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

解析：

java的“一次编写，到处运行”的跨平台性是独有的特点~

解析：

java多态有两种情况：重载和覆写
在覆写中，运用的是动态单分配，是根据new的类型确定对象，从而确定调用的方法；
在重载中，运用的是静态多分派，即根据静态类型确定对象，因此不是根据new的类型确定调用的方法

解析：

泛型只是提高了数据传输安全性，并没有改变程序运行的性能

解析：

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

解析：

Java表达式转型规则由低到高转换：
1、所有的byte,short,char型的值将被提升为int型；
2、如果有一个操作数是long型，计算结果是long型；

3、如果有一个操作数是float型，计算结果是float型；

4、如果有一个操作数是double型，计算结果是double型；
5、被fianl修饰的变量不会自动改变类型，当2个final修饰相操作时，结果会根据左边变量的类型而转化。
--------------解析--------------
语句1错误：b3=(b1+b2);自动转为int，所以正确写法为b3=(byte)(b1+b2);或者将b3定义为int；
语句2正确：b6=b4+b5;b4、b5为final类型，不会自动提升，所以和的类型视左边变量类型而定，即b6可以是任意数值类型；
语句3错误：b8=(b1+b4);虽然b4不会自动提升，但b1仍会自动提升，所以结果需要强转，b8=(byte)(b1+b4);
语句4错误：b7=(b2+b5); 同上。同时注意b7是final修饰，即只可赋值一次，便不可再改变。

解析：

synchronized不是修饰变量的 它修饰方法或代码块或对象

解析：

确实ABDE都可以。也就是说数组命名时名称与[]可以随意排列，但声明的二维数组中第一个中括号中必须要有值，它代表的是在该二维数组中有多少个一维数组。