牛客java错题整理

牛客Java错题

8.6
1.java如何返回request范围内存在的对象
request.getAttribute()方法返回request范围内存在的对象，而request.getParameter()方法是获取http提交过来的数据。getAttribute是返回对象，getParameter是返回字符串。

2.下列不属于算法结构的是
算法包括0个或多个输入，1个或多个输出，中间有穷个处理过程。而存储结构是属于数据结构，不属于算法结构。

3.在Java图形用户界面编程中，如果需要提示信息，一般用什么类的对象来实现
JTextField单行文本
JTextArea多行文本
JButton按键显示
JLable显示标签 信息

4.java8中，忽略内部接口的情况，不能用来修饰interface里的方法的有？
在JDK1.7的时候，接口里面就只能有静态常量(public static final)和抽象方法(public abstract)而在java 1.8开始支持接口定义静态方法static和default方法。

5.以下哪些jvm的垃圾回收方式采用的是复制算法回收
总结一下两个最基本的java回收算法：复制算法和标记清理算法。
复制算法：两个区域A和B，初始对象在A，继续存活的对象被转移到B。此为新生代最常用的算法。（复制算法要想使用，最起码对象的存活率要非常低才行）

标记—清除：一块区域，标记可达对象（可达性分析），然后回收不可达对象，会出现碎片，那么引出。

标记—整理：多了碎片整理，整理出更大的内存存放更大的对象。

新生代：初始对象，生命周期短的。

永久代：长时间存在的对象。

综上：新生代基本采用复制算法，老年代采用标记整理算法。Cms采用标记清理。

8.7
1.关于单例模式

单例模式中的恶汉式单例：第一步，不让外部调用创建对象，所以把构造器私有化，用private来修饰。第二步，怎么让外部获取本类的实例对象？通过本类提供一个方法，供外部调用获取实例。由于没有对象调用，所以此方法为类方法，用static来修饰。第三步，通过方法返回实例对象，由于类方法（静态方法）只能调用静态方法，所以存放该实例的变量改为类变量，用static来修饰。最后，类变量，类方法是在类加载时初始化的，只加载一次。所以由于外部不能创建对象，而且本来实例只在类加载时创建一次，因此叫做单例模式。所以该题选true(注意JAVA中的真是小写)。

2.HashMap保存数据的过程为
首先判断key是否为null，若为null，则直接调用putForNullKey方法。若不为空则先计算key的hash值，然后根据hash值搜索在table数组中的索引位置，如果table数组在该位置处有元素，则通过比较是否存在相同的key，若存在则覆盖原来key的value，否则将该元素保存在链头（最先保存的元素放在链尾）。若table在该处没有元素，则直接保存。

3.下列哪些操作会使线程释放锁资源？
（1）sleep（）方法
在指定时间内让当前正在执行的线程暂停执行，但不会释放“锁标志”。不推荐使用。sleep（）使当前线程进入阻塞状态，在指定时间内不会执行。
（2）wait（）方法
wait（）线程会释放掉它所占有的“锁标志”，从而使别的线程有机会抢占该锁。
（3）join（）方法
join（）方法底层调用的是wait（）方法
（4）yield（）方法
实际上是不释放锁，但是放弃了CPU时间片，让可运行状态变成了就绪状态。

4.关于JAVA中的ClassLoader下面的哪些描述是错误的：
JAVA中类的加载有五个过程：加载、验证、准备、解析、初始化；类加载器的任务是根据一个类的全限定名来读取此类的二进制字节流到JVM中，然后转换为一个与目标类对应的java.lang.Class对象实例，在虚拟机提供了3种加载器，分别是引导（Bootsteap）、扩展（Exception）、系统（System）加载器。其中Bootsteap加载器加载核心库类，Exception加载器加载jre/lib下的类，System加载器加载classpath环境指定路径的类。其中类（接口）相同的条件是：全限定名相同+使用相同类加载器加载。

8.9
1.若有下列定义，下列哪个表达式返回false？
String s=“hello”；
String t=“hello”；
char c []={“h”，“e”，“l”，“l”，“o”}；

char数组是一种对象类型不是String类型的实例，直接跳过比较返回false

2.下面关于webservice的描述，错误的是？
Webservice是跨平台，跨语言的远程调用技术；它的通信机制实质就是xml数据交换；它采用了soap协议（简单对象协议）进行通信。

3.String s=new String（“xyz”）创建了几个StringObject？
（1）String对象的两种创建方式：
第一种方式：String str1=“aaa”；是在常量池中获取对象（“aaa”属于字符串字面量，因此编译时期会在常量池中创建一个字符串对象）
第二种方式：String str2=new String（“aaa”）；一共会创建两个字符串对象，一个在堆中，一个在常量池中（前提是常量池中还没有“aaa”字符串对象）。

System.out.println（str1==str2）；// false

4.关于Java线程切换
https://blog.csdn.net/weixin_44741522/article/details/107892332

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

Thread可以被继承，创建新的线程。Number类可以被继承，integer，Float，Double类都继承自Number类，但他们都是final修饰，Math也是final修饰，类加载器可以被继承。

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

7.下列有关JAVA异常类的描述，说法错误的是？
https://blog.csdn.net/weixin_44741522/article/details/107894977

8.下列方法中哪个是线程执行的方法？
run（）方法用来执行线程体中具体的内容。start（）方法用来启动线程对象，使其进入就绪状态。sleep（）方法用来使线程进入睡眠状态。suspend（）方法用来使线程挂起，要通过resume（）使其重新启动。

8.10

这道题的答案就是good and gbc
首先说下String确实是个不可变对象，这个不可变是JDK特有的，写JAVA的人特意针对的。

但是这与本题无关，题目中的形参str只是原引用ex.str的一个引用副本，传的是一个副本地址值，这个值与ex.str地址值是不一样的,但是它们同时指向了堆中的对象new String(“good”)，当你在函数中改变形参也就是地址的副本值也就是这句str=“test ok"只是将副本地址指向常量"test ok”，并没有改变原ex.str的指向方向，它还是指向对象new String(“good”)的 。

char数组与String一样传的也是地址的副本，但是关键是形参ch它没有新的指向 ch[0]只是ch在指向原对象时改变了对象的内部结构, 所以在ex.ch指向与它是同一个对象的情况下当然也会随之变化 。

2.下面的程序输出的结果是( )

public class A implements B{
public static void main(String args[]){
int i;
A a1=new A();
i =a1.k;
System.out.println(“i=”+i);
}
}
interface B{
int k=10；
}

正确答案是i=10
分析：java接口中变量的默认修饰符为public static final，接口中的变量可不写修饰符
而java局部变量不是必须要初始化的，只是要使用的话才需要赋值。

3.下列运行结果为

Thread.join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的join（）方法，直到线程A执行完毕后，才会继续执行线程B。

t.join（）；//使调用线程t在此之前执行完毕。对于本题代码，因为子线程休眠时间太长，因此主线程很有可能在子线程之前结束也就是输出1 ，2.但是子线程用了join函数，因此主线程必须等待子线程执行完毕才结束因此输出结果只能是2,1.

4.以下哪些继承自Collection接口

8.12

这道题考察了类初始化步骤。正常的类加载顺序：静态变量/静态代码块—>main方法—>非静态变量/代码块—>构造方法。

其中静态代码块与静态变量的执行顺序同代码定义的顺序；非静态变量和代码块的执行顺序同代码执行顺序。注意：一个类中可以有多个静态代码块，按声明顺序来执行，如题中即先x=10，然后x=10+5=15；x=15/3=5。

2.关于方法重载和重写的描述正确的是
方法重载的返回值类型可以不同，因为判断方法重载的方法主要是根据方法的参数不同来判定；方法重写的返回值类型小于等于父类的。重载是在一个类中定义多个方法名相同但参数列表不同的方法，重写是在子类中定义与父类完全相同的方法。重写应该遵循两同-两小-一大的规则。两同：方法名和参数列表相同；两小：子类返回值类型小于等于父类的，异常抛出小于等于父类的；一大：访问权限修饰符大于等于父类。

3.关于Java反射的理解
反射指的是在运行时能够分析类的能力的程序。具体参考如下博客：
https://blog.csdn.net/weixin_44741522/article/details/107953152

A、Class类在java.lang包下，错；B、动态代理可以通过接口与类实现，通过反射形成新的代理类；C、反射可以强制访问private类型的成员，它可以破除封装；D、反射可以动态的调用类和对象的任意方法，反射是用来访问类和实例化，并不能进行修剪字节码；F、反射的效率比调用类的方法低。

4.一般有两种用于创建线程的方法
（1）从Java.lang.Thread类派生一个新的线程类，重写它的run（）方法
（2）实现一个runnable接口，重写runnable接口中的run（）方法

5.方法的声明
（1）抽象方法只能定义在抽象类中，抽象方法和抽象类必须由abstract修饰，abstract关键字只能描述类和方法，不能描述变量。抽象方法只定义方法声明，不定义方法实现。抽象类不可以被实例化（创建对象），只有通过子类继承抽象类并覆盖抽象类中的所有抽象方法后，该子类才可以被实例化，否则该子类还是一个抽象类。抽象类中有构造函数用于给子类对象进行初始化，同时抽象类中可以含有非抽象方法。abstract关键字不可以与final，private,static关键字共存，因为被final修饰的方法不可以被重写，意味着子类不可以重写该方法，如果abstract和final共同修饰父类中的方法，子类要实现抽象方法（abstract的作用），而final又不让该方法重写，这相互矛盾。如果private和abstract共同修饰父类中的方法，private修饰则该方法不可以被子类访问，但是abstract修饰需要子类去实现，两者产生矛盾。如果static和abstract共同修饰父类中的方法，static表示是静态的方法，随着类的加载而加载，则该方法不需要在子类中去实现，这与abstract关键字矛盾。
（2）static用于修饰成员变量和成员函数，想要实现对象中的共性数据的对象共享，可以将这个数据进行静态修饰，被静态修饰的成员可以直接被类名调用，静态随着类的加载而加载，而且优先于对象存在。静态方法只能访问静态成员（静态方法和静态变量），不可以访问非静态成员，这是因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。静态方法中不能使用this和super关键字，因为this代表本类对象，super代表父类对象，而静态时，有可能没有对象存在，所以this和super无法使用。
（3）final关键字可以修饰类，方法，变量（成员变量内，局部变量，静态变量），被final修饰的类是一个最终类，不可以被继承，被final修饰的方法是一个最终方法，不可以被覆盖，但是可以被继承。被final修饰的变量只能是一个常量，只能赋值一次。内部类被定义在类中的局部位置上时，只能访问局部被final修饰的局部变量。

8.13
1.以下代码输出的正确结果是
public class Test{
public static void main(String[] args){
String s=“祝你考出好成绩！”;
SyStem.out.println(s.length());
}
}
这题被坑了，答案就是8，这个就是问字符串的长度，没有问占多少个字节

2.关于HashMap和HashTable正确的说法有
（1）Hashmap和HashTable都实现了map接口，主要区别在于Hashmap允许空（null）键值（key），而HashTable是不允许的。其中要注意的是Hashmap允许至多有一个null的key值，null值的value则是几个都随意，但是Hashtable则是不允许null键或者null的value出现。TreeMap的key不允许为null，value可以为null。
（2）HashTable的方法是线程安全的，而HashMap不是线程安全的。

3.有关线程的叙述哪些是对的
一个新创建的线程并不是自动运行，必须调用它的start（）方法使之将线程放入可运行态，然后可以被调度，并不意味着可以立即被运行。线程的调度是抢先式的，而不是分时间片式的。具有比当前运行线程高优先级的线程可以使当前线程停止运行而进入就绪状态。Java线程中的yield（）方法，即为线程让步，它不释放锁，它是直接把自己的cpu让掉，它没有经过阻塞状态，直接变成可运行状态，注意这不是单纯让给其他线程，有可能自己又再次抢到。

4.对Map的用法，正确的有：
new java.util.Map().put(“key”,“value”);

new java.util.SortedMap().put(“key”，“value”);

New java.util.HashMap().put(null,null);

New java.util.TreeMap().put(0,null);

这个选后面两项，考察的是Map接口实现类的创建对象以及对象类型包含的方法。

对于第一个来说，Map属于接口类型，不可以实例化，所以错误。
对于第二个来说，SortedMap属于接口类型，不可实例化所以错误。
对于第三个来说，HashMap基于哈希表实现Map接口的类，并允许null的键值对。
对于第四个来说，TreeMap通过红黑树实现Map接口的类，key不可以null，value可以为null。

8.14
1.一个以.java为后缀的源文件
统一答案：只能有一个与文件名相同的类，可以包含其他类。

2.多重继承的概念在Java中实现是通过如下哪些？
A.扩展两个或多个类
B.扩展一个类并实现一个或多个接口
C.实现两个或更多接口

这题答案选BC，其实拓展的意思即extend，就是我们常说的继承，而在JAVA
中是单继承的，即只可以继承一个类。

3.关键字super的作用是
（1）可以调用父类的构造方法
（2）用来调用父类中被重写的方法
（3）用来访问父类被隐藏的非私有成员变量

4.有关JSP内置对象描述，说法错误的是
（1）request对象：客户端的请求信息封装在request对象中，通过它才能了解到客户的需求，然后做出相应。
（2）Response对象：response对象包含了响应客户请求的有关信息，但在JSP中很少直接用到它。
（3）Session对象：Session对象指的客户端与服务器的一次会话
（4）Application对象：application对象实现了用户间数据的共享，可存放全局变量，注意application对象是共享的，所以是多个用户共享一个，以此实现数据共享和通信。

5.判断对错
Integer i=42;
Long l=42l;
Double d=42.0;

A(il) B(id) C(l==d) D(i.equals(d)) E(d.equals(l)) F(i.equals(l))
G(i.equals(42L))

总结一下：
“==”使用如下所示：

（1）基本类型间的比较：

“==”在基本类型中比较的是值
（2）同个类型的基本类型与包装类型的比较

看下面一个例子

这样是无法编译成功，因为27是int类型，自动装箱后是integer类型，不对应与double，因此错误。
（3）同一种类型的包装类型比较

其中这里我们要弄清楚的是，包装类即相当于一个引用，其中除了Double和Float都有常量池，即取值在[-128,127]之间，都会放入到常量池，所以返回true，而不在这个区间内，相当于两个对象，返回true，而Double和Float全部的数都是两个不同的对象。

（4）不同的类型的包装类型对比

由图可知，如果是不同包装类型比较，直接编译不通过
但是如果是包装型比较其他的基本数据类型，却是可以通过。

同类型的进行比较，如Integer 与int，Long与long进行==比较时，会自动拆箱；不同类型之间进行比较，如果有一方为非包装类，则会自动拆箱。如果两方都为包装类，则不会拆箱，且不能比较，编译会报错。

equals的比较：

6.ArrayList list=new ArrayList(20)中的list扩充几次？
！！！这种是直接定好了大小初始化好了大小为20，并没有进行扩充。

7.下面将会输出什么

！注意审题，首先一直向下进行类的加载，x=5，随后x=0，y=0，接下来进行静态方法的加载，x=-1，接下来调用myMethod()方法，在该方法中对x和y进行计算，由于他们是静态变量，所以是在整个类中都是同一个。接下来y=x++ ++x,即y=-1+1=0,此时x=1，最后1+0+2=3

8.下列不是Java关键字的是

1）48个关键字：abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while。

2）2个保留字（现在没用以后可能用到作为关键字）：goto、const。

3）3个特殊直接量：true、false、null。

8.17
1.下面代码的运行结果是
public static void main(String []args){
String s;
System.out.println(“s=”+s);
}
方法内的变量必须初始化，否则编译不通过。

2.下列对访问修饰符作用范围由大到小排列正确的是？
public>protected>default>private
public可以被当前类，子类，包，其他包访问；protected可以被当前类，子类和包访问；default可以被当前类，包内访问；private只可以被当前类访问。

3.变量a是一个64位有符号的整数，初始值用16进制表示为：0x7FFFFFFFFFFFFFFF；变量b是一个64位有符号的整数，初始值用16机制表示为：0x8000000000000000.则a+b的结果用10进制表示为多少？

首先两数相加得到的是0xFFFFFFFFFFFFFFFF，其中要注意的是，计算机中是以补码存储并参与运算，所以题目中的初始值均是补码，题目要求十进制，而进制的转换使用的是原码。而原码又等于反码反转。因此我们先求反码，反码即等于补码-1，二进制即表示为111…1111（63个1）最后一位为0，原码即等于最后一位是1，

4.

i++ 先赋值在计算结果；

++i 先计算结果再赋值。

int i = 0;
i = i ++; // 左边这个i其实是障眼法，就是一个中间变量，可以和下行的i合并；
System.out.println(i); 这里等价于: int i = 0;

System.out.println(i++); 这下再看，先赋值(先将i传给println函数打印出来,在计算表达式结果)

所以打印出来的是0，实际上整个表达式的结果已经是1了，只是没有打印出整个表达式的结果。

所以我们知道如下结论：

1、无论怎么变，i++和++i的整个表达式的结果都是1.

2、有时我们打印的是表达式的结果(System.out.println(++i)),

有时我们打印的只是一个中间变量(System.out.println(i++))。

Ps:

int i = 0;

i++;

System.out.println(i); //值为1 打印的是表达式的结果

int i = 0;

++i;

System.out.println(i); //值为1 打印的是表达式的结果

int i = 0;

i = i++;

System.out.println(i); //值为0 打印的是中间变量(JVM中间缓存变量机制)

int i = 0;

i = ++i;

System.out.println(i); //值为1 打印的是表达式的结果

5.jdk1.8版本之前的前提下，接口和抽象类描述正确的是

接口没有构造函数，抽象类不允许多继承（其中抽象类可以有构造函数，只是不能实现），而在JDK8以后的默认方法和静态方法可以有方法体。

9.4

1.正则表达式

正则表达式：写在两个/之间，然后#号开头，（）括号里面是需要匹配的串的描述，[]里0-9表示数字的允许范围，a-f表示允许小写字母的范围，A-F表示允许大写字母的范围，{6}表示6个连续的字符，| 表示的是条件或，g表示全局搜索。

2.关于Java编译和运行命令错误的说法是
（1）运行命令是 java + 你的 Java 程序的名字但是不加后缀
（2）javac 是编译命令，后跟 你的 Java 程序名字加后缀，例如Scut.class
（3）JVM （Java 虚拟机）运行的是编译后的字节码文件（以.class为后缀的文件）

3.
short类型转为byte类型出错
a1*a2结果为int类型，转为byte类型出错
所以本题3和4都会出错

java中如果碰到char、byte和short参与运算时，会自动将这些值转换为int类型然后再进行运算。

4.
这道题选c，一般注入sessionFactory的是hibernate

5.关于数组的说法正确的是

其中数组长度一旦定下长度就不变了，不可以动态调整，一个固定长度的数组应该是这样定义：
int[] array=new int [100]; int array[]=new int [100];

9.8

1、f 虽然是 Test 类的私有成员属性，但因为 main 方法就在 Test 类内，因此可以通过 “对象名.属性名” 的方式调用，所以 A 对。
2、static 静态成员属性不能使用 this 关键字调用，B 错
3、m 和 f 都是普通成员属性，而 “类名.” 方式只能调用 静态成员属性，因此 C 和 D 都错。

2.
A，“任何对象”锁定，太绝对了，你能锁住你没有权限访问的对象吗？
B，前半句话讲的是创建线程的方式，后半句讲的是锁定，驴头不对马嘴。
C，正确。
D，线程调度分为协同式调度和抢占式调度，Java使用的是抢占式调度，也就是每个线程将由操作系统来分配执行时间，线程的切换不由线程本身来决定（协同式调度）。这就是平台独立的原因。
以上，选CD

11.16
1.


2.

对于c选项
只要int类型的数没有超出（byte，short，char）的表述范围也就是127，可以直接byte a=23

这题考察的就两个知识点：一、强制转换（主要涉及各个类型占几个字节，这里我只简单说一下byte型占一个字节，也就是8位，int型4个字节，32位）；二、在计算机系统中，数值一律用补码来表示（存储）
正数：补码=反码=原码（当然以二进制形式表达）
129 int类型（4个字节）二进制： 00000000 00000000 00000000 10000001
强制转换byte型后，只有一个字节即 10000001（注意这里从二进制角度看，第一位是符号位，即求负数的补码接下来）

只要求出上面原码对应的补码就行了，然后再转换对应的int型数值（因为题干所给的答案都是比较int型）
10000001（原码） 对应的反码为1111 1110
又补码等于反码+1
即1111 1111 该二进制转换int型刚好是-127（1+2+4+8+16+32+64）

普及一下：正数原码，反码，补码相同
负数反码除了符号位不变，其他位取反，补码=反码+1；

4.

关于重写：
两同:方法名、形参列表相同；
两小:返回值类型、抛出异常更小，这里的“小”指的是继承关系的子父类，不是像高赞所谓的float和int的大小之分；
一大:访问修饰符。

以下程序的输出结果是编译错误：

在调用子类构造器之前，会先调用父类构造器，当子类构造器中没有使用"super(参数或无参数)"指定调用父类构造器时，是默认调用父类的无参构造器，如果父类中包含有参构造器，却没有无参构造器，则在子类构造器中一定要使用“super(参数)”指定调用父类的有参构造器，不然就会报错。

答案 ： C D
1.HashMap,TreeMap 未进行同步考虑，是线程不安全的。
2. HashTable 和 ConcurrentHashMap 都是线程安全的。区别在于他们对加锁的范围不同，HashTable 对整张Hash表进行加锁，而ConcurrentHashMap将Hash表分为16桶(segment)，每次只对需要的桶进行加锁。
3. Collections 类提供了synchronizedXxx()方法，可以将指定的集合包装成线程同步的集合。比如，
List list = Collections.synchronizedList(new ArrayList());
Set set = Collections.synchronizedSet(new HashSet());

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 类一样，也是要由类加载器来加载的。一般来说，开发人员编写的类加载器的父类加载器是系统类加载器。类加载器通过这种方式组织起来，形成树状结构。树的根节点就是引导类加载器。下图中给出了一个典型的类加载器树状组织结构示意图，其中的箭头指向的是父类加载器。

选AB
A，D考的一个知识点，final修饰变量，变量的引用（也就是指向的地址）不可变，但是引用的内容可以变（地址中的内容可变）。
B，finally表示总是执行。但是其实finally也有不执行的时候，但是这个题不要扣字眼。
1.在try中调用System.exit(0)，强制退出了程序，finally块不执行。
2.在进入try块前，出现了异常，finally块不执行。
C，finalize方法，这个选项错就错在，这个方法一个对象只能执行一次，只能在第一次进入被回收的队列，而且对象所属于的类重写了finalize方法才会被执行。第二次进入回收队列的时候，不会再执行其finalize方法，而是直接被二次标记，在下一次GC的时候被GC。

A.类的成员变量包括实例变量和类变量（静态变量）,成员方法包括实例方法和类方法（静态方法）。 A正确
B.类变量（静态变量）用关键字static声明，B错误
C.方法中的局部变量在方法被调用加载时开始入栈时创建，方法入栈创建栈帧包括局部变量表操作数栈，局部变量表存放局部变量，并非在执行该方法时被创建，C错误
D.局部变量被使用前必须初始化，否则程序报错。D正确

解析：比较的是变量的内存中的地址值，equals没有重写的话和一样，也是比较内存中的地址值。显然Test类没有重写equals方法。语句：private String name = “abc”;是在常量池创建"abc"常量，test.name和testB.name指向的都是常量池的"abc"。

ABC在java中会报错，D可以正常运行, 所以答案是ABC.

A. ‘a’是字符,’ a’这个是空格和a，必须要用" a"才可以;
B.String有length()方法
C.int 无法直接转成String类型
D.尾部添加字符串”100“

11.17
1.

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

编译时异常必须显示处理，运行时异常交给虚拟机。
运行时异常可以不处理。当出现这样的异常时，总是由虚拟机接管。比如我们从来没有人去处理过Null Pointer Exception异常，它就是运行时异常，并且这种异常还是最常见的异常之一。出现运行时异常后，系统会把异常一直往上层抛，一直遇到处理代码。如果没有处理块，到最上层，如果是多线程就由Thread.run()抛出，如果是单线程就被main()抛出。抛出之后，如果是线程，这个线程也就退出了。如果是主程序抛出的异常，整个程序也就退出了。运行时异常是Exception的子类，也有一般异常的特点，是可以被Catch块处理的。只不过往往不对它处理罢了。也就是说，如果不对运行时异常进行处理，那么出现运行时异常之后，要么是线程中止，要么是主程序终止。

父类静态代码块–>子类静态代码块–>父类初始化块–>父类构造方法–>子类初始化块–>子类构造方法

拓展一下，在类中定义的{}之间被称为构造块，构造块相对于构造方法先执行，构造块之间按照代码编译顺序执行

A、Semaphore：类，控制某个资源可被同时访问的个数;
B、ReentrantLock：类，具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大；
C、 Future：接口，表示异步计算的结果；
D、 CountDownLatch： 类，可以用来在一个线程中等待多个线程完成任务的类。

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

每个线程输出0，1，2，3，4，’空格， 输出空格前必有线程输出了0-4，所以选C

8.

因为Test类的hello方法是静态的，所以是属于类的，当实例化该类的时候，静态会被优先加载而且只加载一次，所以不受实例化new Test();影响，只要是使用到了Test类，都会加载静态hello方法！

另外，在其他类的静态方法中也是可以调用公开的静态方法，此题hello方法是使用public修饰的所以在MyApplication中调用hello也是可以的。
总结：即使Test test=null;这里也会加载静态方法，所以test数据中包含Test类的初始化数据。（静态的，构造的，成员属性）

因此test.hello是会调用到hello方法的

A，java是强类型语言，所有的方法必须放在类里面，包括main
B ,java中可以有多个重载的main方法，只有public static void main(String[] args){}是函数入口
C，内部类的类名一般与文件名不同
D，函数都必须用{}括起来，不管是一条语句还是多条语句

静态初始化块在类加载时完成，无法人为调用

A Class类在java.lang包
B 动态代理技术可以动态创建一个代理对象，反射不行
C 反射访问私有成员时，Field调用setAccessible可解除访问符限制
D CGLIB实现了字节码修改，反射不行， 反射的本质就是从字节码中查找，动态获取类的整容结构，包括属性，构造器，动态调用对象的方法，而不是修剪类
E 反射会动态创建额外的对象，比如每个成员方法只有一个Method对象作为root，他不胡直接暴露给用户。调用时会返回一个Method的包装类
F 反射带来的效率问题主要是动态解析类，JVM没法对反射代码优化。

11.18
1.

1、抽象类中的抽象方法（其前有abstract修饰）不能用private、static、synchronized、native访问修饰符修饰。原因如下：抽象方法没有方法体，是用来被继承的，所以不能用private修饰；static修饰的方法可以通过类名来访问该方法（即该方法的方法体），抽象方法用static修饰没有意义；使用synchronized关键字是为该方法加一个锁。。而如果该关键字修饰的方法是static方法。则使用的锁就是class变量的锁。如果是修饰 类方法。则用this变量锁。但是抽象类不能实例化对象，因为该方法不是在该抽象类中实现的。是在其子类实现的。所以。锁应该归其子类所有。所以。抽象方 法也就不能用synchronized关键字修饰了；native，这个东西本身就和abstract冲突，他们都是方法的声明，只是一个吧方法实现移交给子类，另一个是移交给本地操作系统。如果同时出现，就相当于即把实现移交给子类，又把实现移交给本地操作系统，那到底谁来实现具体方法呢？

2、接口是一种特殊的抽象类，接口中的方法全部是抽象方法（但其前的abstract可以省略），所以抽象类中的抽象方法不能用的访问修饰符这里也不能用。而且protected访问修饰符也不能使用，因为接口可以让所有的类去 实现（非继承） ，不只是其子类，但是要用public去修饰。接口可以去继承一个已有的接口。但是抽象类可以用protected。

在接口里面的变量默认都是public static final 的，它们是公共的,静态的,最终的常量.相当于全局常量，可以直接省略修饰符。
实现类可以直接访问接口中的变量

不加break的话，switch会从第一次进入case语句的地方，一直向下执行完。因为x=4，所以它会从case = 4的时候开始执行，执行完j++之后，j=2;然后继续执行，case =5 时，j=3;case = default时，j=4;所以结果为8。

第一步，func(1)，if条件不成立，不抛出异常，catch不运行，final运行，拼串得到“1”，程序继续往下走，拼串得到“12”。 第二步，fun(2)，if条件成立，抛出异常，catch捕获异常，运行catch里面代码，拼串得到“120”，虽然有return，但是不管出不出异常，final里代码必须执行，执行final，拼串得到“1201”，然后return结束。所以最终结果“1201”。

A，只有在不显示声明构造方法时，系统才提供默认无参构造方法，当我们显示的提供一个无参或带参的构造方法时，Java都不会在提供构造方法了。

ArrayList list=new ArrayList();
这种是默认创建大小为10的数组，每次扩容大小为1.5倍

ArrayList list=new ArrayList(20);
这种是指定数组大小的创建，创建时直接分配其大小，没有扩充。
一次性为创建了传入的数字的长度的数组
所以，扩充为0次

jdk1.8后接口中用static或default修饰的方法可以有方法体

Java8的接口方法可以有如下定义
only public, abstract, default, static and strictfp are permitted，抽象类可以用protected

1.final修饰变量，则等同于常量
2.final修饰方法中的参数，称为最终参数。
3.final修饰类，则类不能被继承
4.final修饰方法，则方法不能被重写。

final 不能修饰抽象类和接口

final修饰的方法可以被重载 但不能被重写