java笔试

weixin_47187816

已于 2022-04-11 11:19:46 修改

阅读量152

点赞数

文章标签： java

于 2022-04-11 00:50:56 首次发布

本文链接：https://blog.csdn.net/weixin_47187816/article/details/124089527

版权

笔记2

Java专项

1、下列描述中，错误的是（）

答案：C. java要求编程者管理内存
解析：java与C***很大的一点区别就是java是不需要使用者关注内存分配以及管理的，Java的内存管理由Java虚拟机来完成对内存的管理。

2、执行下面的程序段，语句3的执行次数为（）

for (i = 0; i <= n-1; i++)   // (1)
    for (j = n; j > i; j--） // (2)
        state;               // (3)

答案：C. n(n+1)/2
解析：假设代入法：
设n=3，外层循环i的取值为0，1，2
当i=0时，内部循环j的取值为3，2，1，所以state执行3次；当i=1时，内部循环j的取值3，2，所以state执行2次；当i=2时，内部循环j的取值为3，所以 state执行1次。
综上所述：3+2+1=6次。将n=3带入选项中的出C符合结果。

3、在java中，下列对继承的说法，正确的是（）

答案：子类能继承父类的所有成员
解析：在一个子类被创建的时候，首先会在内存中创建一个父类对象，然后在父类对象外部放上子类独有的属性，两者合起来形成一个子类的对象。所以所谓的继承使子类拥有父类所有的属性和方法其实可以这样理解，子类对象确实拥有父类对象中所有的属性和方法，但是父类对象中的私有属性和方法，子类是无法访问到的，只是拥有，但不能使用。就像有些东西你可能拥有，但是你并不能使用。所以子类对象是绝对大于父类对象的，所谓的子类对象只能继承父类非私有的属性及方法的说法是错误的。可以继承，只是无法访问到而已。
使用反射可以看出子类是继承了父类的私有方法的(不管是否是final)，只是直接调用父类的私有方法是不可以的，但是利用反射的方式可以调用。

4、在Java中，关于HashMap类的描述，以下正确的是 ()

A、HashMap使用键/值得形式保存数据
B、HashMap 能够保证其中元素的顺序
C、HashMap允许将null用作键
D、HashMap允许将null用作值

答案：A C D
解析：HashMap 不按插入顺序排序，按照哈希值排序。所以无序。但是不增删改键的情况下，输出是按照一定顺序不变的

5、以下关于对象序列化描述正确的是

A、使用FileOutputStream可以将对象进行传输
B、使用PrintWriter可以将对象进行传输
C、使用transient修饰的变量不会被序列化
D、对象序列化的所属类需要实现Serializable接口

答案：C D
解析：使用ObjectOutputStream和ObjectInputStream可以将对象进行传输.
声明为static和transient类型的成员数据不能被串行化。因为static代表类的状态， transient代表对象的临时数据。

6、下面有关java类加载器，说法正确的是？

A、引导类加载器（bootstrap class loader）：它用来加载 Java 的核心库，是用原生代码来实现的
B、扩展类加载器（extensions class loader）：它用来加载 Java 的扩展库。
C、系统类加载器（system class loader）：它根据 Java 应用的类路径（CLASSPATH）来加载 Java 类
D、tomcat为每个App创建一个Loader，里面保存着此WebApp的ClassLoader。需要加载WebApp下的类时，就取出ClassLoader来使用

答案：A B C D
解析：a、Bootstrap ClassLoader/启动类加载器。
主要负责jdk_home/lib目录下的核心 api 或 -Xbootclasspath 选项指定的jar包装入工作.
B、Extension ClassLoader/扩展类加载器
主要负责jdk_home/lib/ext目录下的jar包或 -Djava.ext.dirs 指定目录下的jar包装入工作
C、System ClassLoader/系统类加载器
主要负责java -classpath/-Djava.class.path所指的目录下的类与jar包装入工作.
B、 User Custom ClassLoader/用户自定义类加载器(java.lang.ClassLoader的子类)
在程序运行期间, 通过java.lang.ClassLoader的子类动态加载class文件, 体现java动态实时类装入特性.

7、对于java类型变量char c,short s,float f,double d,表达式c*s+f+d的结果类型为（）

A、float
B、char
C、short
D、double

答案：D
解析：1.若参与运算的数据类型不同，则先转换成同一类型，然后进行运算。
2.转换按数据长度增加的方向进行，以保证精度不降低。例如int型和long型运算时，先把int量转成long型后再进行运算。
3.所有的浮点运算都是以双精度进行的，即使仅含float单精度量运算的表达式，也要先转换成double型，再作运算。
4.char型和short型参与运算时，必须先转换成int型。
5.在赋值运算中，赋值号两边的数据类型不同时，需要把右边表达式的类型将转换为左边变量的类型。
如果右边表达式的数据类型长度比左边长时，将丢失一部分数据，这样会降低精度。

**&&.**long与double在java中本身都是用64位存储的,但是他们的存储方式不同，导致double可储存的范围比long大很多

8、有变量int i = 0; int a = i++; int b = ++a; int c = a+b; int d = (a == 1)?b:c; 请问a和d的值分别是多少？( )。答案：D

A、2,4
B、1, 4
C、1, 2
D、1,1
解析：int i = 0; //i=0
int a = i++; //a=i,a=0,i++,i=1
int b = ++a; //a++,a=1,b=a,b=1
int c = a+b;//c=2
int d = (a == 1)?b:c;//a1,d=b,d=1
综上a1, d==1
三目运算符基本格式为: boolean表达式1 ? 有返回值的表达式2 : 有返回值的表达式3
计算表达式1的值，若值为true则执行表达式2并得到其值，否则则执行表达式3并得到其值。

9、面向对象方法的多态性是指（）答案：C

A、一个类可以派生出多个特殊类
B、一个对象在不同的运行环境中可以有不同的变体
C、针对一消息，不同的对象可以以适合自身的方式加以响应
D、一个对象可以是由多个其他对象组合而成的
解析：《疯狂java讲义》的标准解释是：相同类型的变量、调用同一个方法时呈现出多种不同的行为特征，这就是多态。

10、有以下程序段，则下面正确的选项是（）答案：B C D

public class MyThead extends Thread{
   
    public static void main(String[] args) {
   
        MyThead t=new MyThead();
        MyThead s=new MyThead();
        t.start();
        System.out.println("one.");
        s.start();
        System.out.println("two.");
    }
    public void run() {
   
        System.out.println("Thread");
    }
}

A、编译失败
B、

程序运行可能结果为：
one.
Thread
two.
Thread

C、

程序运行可能结果是：
one.
two.
Thread
Thread

D、程序运行结果不稳定
解析：单选题选D，多选题选BCD，都是套路！

11、下列选项中是正确的方法声明的是？（）答案： A B C D

A、protected abstract void f1();
B、public final void f1() {}
C、static final void fq(){}
D、private void f1() {}
解析：A：抽象方法只可以被public 和 protected修饰；
B：final可以修饰类、方法、变量，分别表示：该类不可继承、该方法不能重写、该变量是常量
C：static final 可以表达在一起来修饰方法，表示是该方法是静态的不可重写的方法
D：private 修饰方法（这太常见的）表示私有方法，本类可以访问，外界不能访问

12、类方法中可以直接调用对象变量？答案：B

A、正确
B、错误
解析：是不能静态方法中引用非静态的域。原因也很简单关于类初始化的过程中，静态域是随着类加载就完成了初始化，而非静态域此时都没有完成初始化，你引用它肯定就出错了。

13、BufferedReader的父类是以下哪个？答案：D

A、FilterReader
B、InputStreamReader
C、PipedReader
D、Reader
解析：

14、已知如下类说明：如下哪些使用是正确的（）答案：D

public class Test{
   
    private float f=1.0f;
    int m=12;
    static int n=1;
    public static void main(String args[]){
   
        Test t=new Test();
    }
}

A、t.f = 1.0
B、this.n
C、Test.m
D、Test.n
解析：A：编译不成功，因为float浮点类型默认是double类型所以float f=1.0f;（必须加上f 强调定义的是float）此处是精度由高(double)向低(float)转型所以会报错但是若是float f=1;这里是默认类型是Int 类型精度由低(int)向高转型(float)不丢失精度不会报错。
B：this的使用时针对在方法内部使局部变量等值于实例变量而使用的一个关键字，此处的n是静态变量而非实例变量所以this的调用会出错（试想一下，static本来是全类中可以使用的，是全局的，你非得this去调用，这不是区分局部变量和实例变量的分水线吗？但是此处是全局的，不需要区分）
C：m是实例变量，什么是实例变量：就是需要new 一个对象出来才能使用的，这里直接用类名就调用了，jvm怎么知道m是谁？
D：类变量可以通过类直接调用

15、下面哪些Java中的流对象是字节流? 答案：A B C D

A、FileInputStream
B、BufferedInputStream
C、PushbackInputStream
D、ByteArrayInputStream
解析：stream结尾都是字节流，reader和writer结尾都是字符流两者的区别就是读写的时候一个是按字节读写，一个是按字符。实际使用通常差不多。在读写文件需要对内容按行处理，比如比较特定字符，处理某一行数据的时候一般会选择字符流。只是读写文件，和文件内容无关的，一般选择字节流。

字节流：

InputStream
|-- FileInputStream (基本文件流）
|-- BufferedInputStream
|-- DataInputStream

|-- ObjectInputStream

字符流

16、jdk1.8版本之前的前提下，接口和抽象类描述正确的有（）答案：B C

A、抽象类没有构造函数
B、接口没有构造函数
C、抽象类不允许多继承
D、接口中的方法可以有方法体
解析：A,抽象类是一个类，所以有构造器
B,接口不是一个类，所以没有构造函数
C,抽象类是一个类，类不允许继承多个类,但是可以实现多个接口。而接口可以继承多个接口，接口不能实现接口。
D,jdk1.8之前，接口中的方法都是抽象方法，用public abstract修饰，jdk1.8新特性：可以有默认方法（用default修饰，不能缺省）和静态方法（static修饰），jdk1.9：接口中的默认方法还可以用private修饰

17、下列符号中可以在 java 程序里表示单行注释的是（）答案：C

A、–
B、/* ……/
C、//
D、/** ……/
解析：1、单行(single-line)–短注释：//……
注释格式：/* 注释内容 /
2、块(block)–块注释：/……/
/
* 注释内容
/
3、文档注释：/**……/
注释若干行，并写入javadoc文档。每个文档注释都会被置于注释定界符
/**…*/之中

18、下面代码运行结果是？答案：A

public class Test
{
   
    static boolean foo(char c)
    {
   
        System.out.print(c);
        return true;
    }
    public static void main( String[] argv )
    {
   
        int i = 0;
        for ( foo('A'); foo('B') && (i < 2); foo('C'))
        {
   
            i++ ;
            foo('D');
        }
    }
}

A、ABDCBDCB
B、ABCDABCD
C、Compilation fails.
D、An exception is thrown at runtime.
解析：for(条件1;条件2;条件3) {

	  //语句

}

执行顺序是条件1->条件2->语句->条件3->条件2->语句->条件3->条件2…

如果条件2为true，则一直执行。如果条件2位false，则for循环结束

19、下列代码执行结果为（）答案：A

public static void main(String args[])throws InterruptedException{
   
	    	Thread t=new Thread(new Runnable() {
   
				public void run() {
   
					try {
   
						Thread.sleep(2000);
					} catch (InterruptedException e) {
   
						throw new RuntimeException(e);
					}
					System.out.print("2");
				}
			});
	    	t.start();
	    	
	    	t.join();
	    	System.out.print("1");
	    }

A、21
B、12
C、可能为12，也可能为21
D、以上答案都不对
解析：thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的 Join()方法，直到线程A执行完毕后，才会继续执行线程B。

t.join(); //使调用线程 t 在此之前执行完毕。
t.join(1000); //等待 t 线程，等待时间是1000毫秒

20、尝试编译以下程序会产生怎么样的结果？（）答案：C

public class MyClass {
   
    long var;
    public void MyClass(long param) {
    var = param; }//(1)
    public static void main(String[] args) {
   
        MyClass a, b;
        a =new MyClass();//(2)
        b =new MyClass(5);//(3)
    }
}

A、编译错误将发生在（1），因为构造函数不能指定返回值
B、编译错误将发生在（2），因为该类没有默认构造函数
C、编译错误将在（3）处发生，因为该类没有构造函数，该构造函数接受一个int类型的参数
D、该程序将正确编译和执行
解析：这道题一定要看仔细了，MyClass方法并不是构造参数，而是返回类型为void的普通方法，普通方法自然需要实例化对象然后去调用它，所以124不对，第三个是正确的，因为没有带参数的构造器，所以自然不能传一个int进去。

构造方法就是：public 类名， 没有方法修饰符
 
所以 (1)  处就是一个普通方法
 
所以该类没有带参数构造方法 ，编译报错

（1）虽然方法名和类名相同，不过由于void的修饰，所以它并不是一个构造方法，只是一个普通方法。因此题类仍然只有默认的无参构造器，（3）向构造方法中传入一个参数故而有误。

21、下面代码在main()方法中第八行后可以正常使用的是（）答案：A D

public class Test
{
   
    private int a=10;
    int b=20;
    static int c=1;
    public static void main(String arg[])
    {
   
        Test t = new Test();
    }
 }

A、t.a
B、this.c
C、Test.b
D、t.c
解析：A : 在private 修饰不能在外部类中调用，main 方法属于Test类的方法，所以对象 t 可以在他自己的类方法中调用它的

private

B ： static 方法中没有this 这么一说

C: b不是static变量

D: 合理

22、以下关于继承的叙述正确的是答案：A

A、在Java中类只允许单一继承
B、在Java中一个类不能同时继承一个类和实现一个接口
C、在Java中接口只允许单一继承
D、在Java中一个类只能实现一个接口
解析：1）接口可以继承接口，而且可以继承多个接口，但是不能实现接口，因为接口中的方法全部是抽象的，无法实现；

另外，如果是Java 7以及以前的版本，那么接口中可以包含的内容有：1. 常量；2. 抽象方法
如果是Java 8，还可以额外包含有：3. 默认方法；4. 静态方法
如果是Java 9，还可以额外包含有：5. 私有方法

2）普通类可以实现接口，并且可以实现多个接口，但是只能继承一个类，这个类可以是抽象类也可以是普通类，如果继承抽象类，必须实现抽象类中的所有抽象方法，否则这个普通类必须设置为抽象类；

3）抽象类可以实现接口，可以继承具体类，可以继承抽象类，也可以继承有构造器的实体类。

抽象类中可以有静态main方法；抽象类里可以没有抽象方法，没有抽象方法的抽象类就是不想让别人实例化它；

另外，抽象类可以有构造方法，只是不能直接创建抽象类的实例对象而已。在继承了抽象类的子类中通过super(参数列表)调用抽象类中的构造方法，可以用于实例化抽象类的字段。

下面总结常见的抽象类与接口的区别：

1）抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象；

2）接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现（java8中接口可以有实现方法使用default修饰）；

3）接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量；

4）抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个类实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类；

5）抽象方法要被实现，所以不能是静态static的，也不能是私有private的，也不能被final修饰（试想一下，静态方法可以被类名直接调用，而类名直接调用一个没有实现的抽象方法没有意义）。

总结得比较杂乱，见谅！

23、以下程序的执行结果是：答案：

static boolean foo(char c){
   
     System.out.print(c);
     return true;
 }
 public static void main(String[] args) {
   
     int i =0;
     for(foo('A');foo('B')&&(i<2);foo('C')){
   
         i++;
         foo('D');
     }
 }

A、ABDCBDCB
B、ABCDABCD
C、编译时出错
D、运行时抛出异常
解析：1.其实foo(‘A’);就是初始化条件，只会执行一次，所以第一个打印的肯定是A
2.因为i=0;循环条件是i<2 （由此可知循环i等于2的时候就会停止循环，)所有0<2满足条件，接着会输出B，然后执行i++；i就变成1了，再输出D，再最后输出C，一次循环后的结果是：ABDC
3.第二次循环的开始是foo(‘A’);是初始条件所以不会执行，直接从foo(‘B’)开始，输出B，然后i为1，且小于2，此时循环体内再次执行i++；i的值为2了，再次输出D，最后输出C
第二次循环输出：BDC
4.*然后循环再次执行for(foo(‘A’);foo(‘B’)&&(i<2);foo(‘C’))
直接输出B，***i的值在第二轮循环后的值变成了2，2<2不成立，终止循环，输出B

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

24、有时为了避免某些未识别的异常抛给更高的上层应用，在某些接口实现中我们通常需要捕获编译运行期所有的异常， catch 下述哪个类的实例才能达到目的：（）答案：B

A、Error
B、Exception
C、RuntimeException
D、Throwable
解析：

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

2、既然是要捕获在 编译期 和 运行期

首先编译期在有些方法是必须要进行 try catch

而运行期可以手动添加 try catch

运行期间出现的异常都可以使用RuntimeException这个是运行期间所有异常的 “组长”

但是编译期就多了，他们没有这个所谓的 “组长”，但是它们上面还有个 “班长”（Exception）也就时 “组长” 的 “头儿”

*所以可以使用这个 “班长”**（Exception）*解决这两个组的异常

25、以下 json 格式数据，错误的是答案：A C

A、{company：4399}
B、{“company”:{“name”:[4399,4399,4399]}}
C、{[4399,4399,4399]}
D、{“company”:[4399,4399,4399]}
E、{“company”:{“name”:4399}}

解析：
A:错误 {company：4399} 首先，其为json对象。但json对象要求属性必须加双引号。

B:正确

C:错误 {[4399,4399,4399]} 。使用 {} 则为json对象。json对象必须由一组有序的键值对组成。

D:正确。

答案：AC.

另参考(摘自<<Javascript 高级程序设计(第三版)>>)：

JSON语法可以表示以下三种类型的值:

1.简单值：使用与JavaScript 相同的语法，可以在JSON中表示字符串，数值，布尔值和null。

2.对象：对象作为一种复杂数据类型，表示的是一组有序的键值对。而每组键值对中的值可以是简单值，也可以是复杂数据类型的值。

3.数组：数组也是一种复杂数据类型，表示一组有序的值的列表，可以通过数值索引来访问其中的值。数组的值也可以是任意类型–简单值，对象或数组。

26、以下哪种JAVA得变量声明方式可以避免程序在多线程竞争情况下读到不正确的值( ) 答案： A B

A、volatile
B、static volatile
C、synchronized
D、static
解析：1、synchronized不是修饰变量的它修饰方法或代码块或对象
2、线程安全性比较关键的两个点：内存可见性和操作原子性如果你不修改值，可以使用private static final int , final可以保证内存可见性语义。对于原生变量，final修饰后不可更改，从而也不存在操作原子性的问题。如果你只是想单纯地进行赋值，而不进行复合操作，那么可以使用volatile int. volatile可以确保内存可见性，但是无法确保原子性，所以不支持复合操作的线程安全性。如果你想进行复合操作，可以使用AtomicInteger这个原子类，支持CAS操作，可确保内存可见性和操作原子性。

27、下列程序段的输出结果是：（）答案：

public void complicatedexpression_r(){
   
    int x=20, y=30;
    boolean b;
    b = x > 50 && y > 60 || x > 50 && y < -60 || x < -50 && y > 60 || x < -50 && y < -60;
    System.out.println(b);
}

A、true
B、false
C、1
D、0
解析：

1、答：此题考查运算符优先级。

题中符号的优先级排序是：‘>’，‘<’，‘&&’，‘||’。

即 b=(x>50&&y>60)||(x>50&&y<-60)||(x<-50&&y>60)||(x<-50&&y<-60);

x>50结果为0，x<-50结果为0，所以括号中的表达式结果都为0，四个0或的结果0。

b为boolean类型，所以输出为false。

2、x>50为false，由于&&与操作，||或操作都是短路操作符，即与操作时一旦遇到false就停止执行后当前关系式中的后续代码，同理或操作时一旦遇到true也停止执行。

x>50&&y>60中x>50结果为false，所以就不需要判断y>60。继续判断第一个||或操作符后面的代码，结果为false || false || false || false。因此最终答案选择false。

28、默认RMI采用的是什么通信协议？答案：C

A、HTTP
B、UDP/IP
C、TCP/IP
D、Multicast
解析：RMI(Remote Method Invocation)远程方法调用是一种计算机之间利用远程对象互相调用实现双方通讯的一种通讯机制。使用这种机制，某一台计算机上的对象可以调用另外一台计算机上的对象来获取远程数据。RMI是Enterprise JavaBeans的支柱，是建立分布式Java应用程序的方便途径。在过去，TCP/IP套接字通讯是远程通讯的主要手段，但此开发方式没有使用面向对象的方式实现开发，在开发一个如此的通讯机制时往往令程序员感觉到乏味，对此RPC(Remote Procedure Call）应运而生，它使程序员更容易地调用远程程序，但在面对复杂的信息传讯时，RPC依然未能很好的支持，而且RPC未能做到面向对象调用的开发模式。针对RPC服务遗留的问题，RMI出现在世人面前，它被设计成一种面向对象的通讯方式，允许程序员使用远程对象来实现通信，并且支持多线程的服务，这是一次远程通讯的***，为远程通信开辟新的里程碑。

RMI的开发步骤

先创建远程接口及声明远程方法，注意这是实现双方通讯的接口，需要继承Remote

开发一个类来实现远程接口及远程方法，值得注意的是实现类需要继承UnicastRemoteObject

通过javac命令编译文件，通过java -server 命令注册服务，启动远程对象

最后客户端查找远程对象，并调用远程方法

所以选C

2、RMI采用的是TCP/IP协议

29、运行代码，结果正确的是：答案： B

Boolean flag = false;
if(flag = true){
   
System.out.println("true");
}else{
   
System.out.println("false");
}

A、编译错误
B、true
C、false
D、什么也没有输出
解析：if(flag = true)的时候flag已经是true了，所以输出true；

要是为if(flag == true)输出才为false

30、下面代码输出结果是？答案：C

int i = 5;
int j = 10;
System.out.println(i + ~j);

A、Compilation error because”~”doesn’t operate on integers
B、-5
C、-6
D、15
解析：1、公式-n=_n+1可推出n=-n-1，所以~10=-11再加5结果为-6

2、我认为应该是：

计算机本身储存的就是补码：

那么10的补码就是10的原码：0000 0000 0000 1010——这是补码，因为现在是计算机在计算

~10的补码就是：1111 1111 1111 0101

~10的反码就是：1111 1111 1111 0100——补码减1

~10的原码就是：1000 0000 0000 1011——反码取反：这个才是正常二进制数，换算为整数为-11

原码才可以对应为正常的整数，补码只有转换为原码才能被正常人类识别。

31、单例模式中，两个基本要点是答案： A D

A、构造函数私有
B、静态工厂方法
C、以上都不对
D、唯一实例
解析：

设计模式-单例模式
知识点
什么是单例模式？
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式有分为饿汉式和懒汉式

特点：

1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
应用实例：

1、一个班级只有一个班主任。
2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。
3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。
优点：

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例）。
2、避免对资源的多重占用（比如写文件操作）。
缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景：

1、要求生产唯一序列号。
2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。
注意事项：getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。

实例
单例模式-饿汉式
代码
//单例模式-饿汉式
public class SingletonDemo {
    public static void main(String[] args) {
        //编译错误：无法实例化
        // Singleton singleton = new Singleton();
 
        //正确获取对象的方法
        Singleton singleton = Singleton.getINSTANCE();
        singleton.hello();
    }
}
 
class Singleton{
    //创建一个本身对象
    private static final Singleton INSTANCE = new Singleton();
 
    //让构造方法为private，这样该类就不会被实例化
    private Singleton(){}
 
    //创建一个获取对象的方法
    public static Singleton getINSTANCE() {
        return INSTANCE;
    }
 
    public void hello(){
        System.out.println("Hello World! ——单例模式-饿汉式");
    }
}
结果

1
Hello World! ——单例模式-饿汉式
单例模式-懒汉式（线程不安全版）
这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。
这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。

代码
//单例模式-懒汉式
public class SingletonDemo2 {
    public static void main(String[] args) {
        Singleton2 singleton = Singleton2.getInstance();
        singleton.hello();
 
    }
 
}
 
class Singleton2{
    private static Singleton2 instance;
    private Singleton2(){}
 
    public static Singleton2 getInstance() {
        if (instance == null){
            instance = new Singleton2();
        }
        return instance;
    }
 
    public void hello(){
        System.out.println("Hello World! ——单例模式-懒汉式");
    }
}
结果

1
Hello World! ——单例模式-懒汉式
单例模式-懒汉式（线程安全版）
描述：这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。
优点：第一次调用才初始化，避免内存浪费。
缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。
getInstance() 的性能对应用程序不是很关键（该方法使用不太频繁）。

代码
//单例模式-懒汉式
public class SingletonDemo3 {
    public static void main(String[] args) {
        Singleton3 singleton = Singleton3.getInstance();
        singleton.hello();
 
    }
 
}
 
class Singleton3{
    private static Singleton3 instance;
    private Singleton3(){}
 
    public synchronized static Singleton3 getInstance() {
        if (instance == null){
            instance = new Singleton3();
        }
        return instance;
    }
 
    public void hello(){
        System.out.println("Hello World! ——单例模式-懒汉式");
    }
}
结果

复制代码
1
Hello World! ——单例模式-懒汉式

32、有以下代码: 请问输出的结果是: 答案： A

class A{
   
    public A(String str){
   
         
    }
}
public class Test{
   
    public static void main(String[] args) {
   
        A classa=new A("he");
        A classb=new A("he");
        System.out.println(classa==classb);
    }
}

A、false
B、true
C、报错
D、以上选项都不正确
解析：1、答案为 false 因为== 表示的是否指向的是同一个内存。

System.out.println(classa.equals(classb)); 如果这这样输出答案也是错误的因为子类没有覆盖Object

的equals()方法,而默认调用==的这个方法判断两个对象是否相等需要覆盖equals()方法和hashcaode()方法

2、这题不管是还是equals输出结果都为false因为equals没有被重写时默认调用进行比较。

3、object类――众类鼻祖 1.取得对象信息：toString():对象输出时，会默认调用Object类的toString()方法，将对象信息变为字符串返回。 2.对象相等判断方法：equals():两个对象进行比较时，实际上是比较两个对象的地址值（从程序看出两个对象内容完全相等，但是结果是不相等的，这是因为classa与classb的内容分别在不同的内存空间指向了不同的内存地址）。所以要对equals()进行覆写，判断equals()方法里面的Object类对象是否与调用equals()的类是同一个类的实例(用instanceof判断)，如果是，则进行向下转型，然后再调用String类中的equals方法对属性进行比较。 3.对象签名：hashCode():Object类有两种方法来推断对象的标识：equals()和hashCode()。如果根据equals()方法判断两个对象是相等的，那么对这两个对象中的每一个调用hashCode()方法都必然生成相同的整数结果。但是反过来，如果两个hashCode()返回的结果相等，两个对象的equals()方法却不一定相等。在默认情况下equals()方法用来比较两个对象的地址值，而原始的hashCode()方法用来返回其所在对象的物理地址（ps：对于非字符串变量而言，equals和比较的是地址，对于字符串变量而言equals()比较的是内容比较地址）

33、以下代码将打印出答案：B

public static void main(String args[]) {
   
      List  Listlist1 = new ArrayList();
      Listlist1.add(0);
      List Listlist2 = Listlist1;
      System.out.println(Listlist1.get(0) instanceof Integer);
      System.out.println(Listlist2.get(0) instanceof Integer);
}

A、编译错误
B、true true
C、true false
D、false false
解析：collection类型的集合（ArrayList,LinkedList）只能装入对象类型的数据，该题中装入了0，是一个基本类型，但是JDK5以后提供了自动装箱与自动拆箱，所以int类型自动装箱变为了Integer类型。编译能够正常通过。

将list1的引用赋值给了list2，那么list1和list2都将指向同一个堆内存空间。instanceof是Java中关键字，用于判断一个对象是否属于某个特定类的实例，并且返回boolean类型的返回值。显然，list1.get(0)和list2.get(0)都属于Integer的实例

2、答案B 不指定ArrayList类型，存入数据，再次取出时，默认是Object类型；但这个题的关键是instanceof关键字，instanceof执行时类似利用java反射机制，识别对象信息。

3、List集合中的元素必须是对象。

Listlist1.add(0);JDK1.5之后支持自动装箱(int类型自动装箱成Integer)，编译通过。

instanceof：前一个参数通常是一个引用类型变量，后一个操作数通常是一个类（也可以是一个接口， 它用于判断前面的对象是否是后面的类，或者其子类、实现类的实例。

List没有使用泛型，说明使用get(0)取出的元素的编译类型是Object型的， 但运行时类型是Integer。所以打印true。这边体现了多态。

而Listlist1把引用赋给了List list2，说明两个指向同一个对象。第二个打印的也是true。

34、下面代码运行结果是？答案：

class Value{
   
    public int i=15;
}
public class Test{
   
    public static void main(String argv[]){
   
        Test t=new Test( );
        t.first( );
    }
 
public void first( ){
   
    int i=5;
    Value v=new Value( );
    v.i=25;
    second(v,i);
    System.out.println(v.i);
}
 
public void second(Value v,int i){
   
    i = 0;
    v.i = 20;
    Value val = new Value( );
    v = val;
    System.out.println(v.i+" "+i);
   }
}

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

2、

3、可能有人会选择B，包括我刚开始也是。总以为v不是已经指向了val了吗？？为什么还是20呢？不应该是15吗？

其实，原因很简单。现在我们把second（）换一下

publicvoidsecond(Value tmp,inti){

i = 0;

tmp.i = 20;

Value val = newValue( );

tmp = val;

System.out.println(tmp.i+" "+i);

}

这个tmp其实相当于是一个指向原来first中的V这个对象的指针，也就是对v对象的引用而已。但是引用是会改变所指的地址的值的。

所以在second中当tmp.i= 20的时候，就把原来first中的v的i值改为20了。接下来，又把tmp指向了新建的一个对象，所以在second中的tmp

现在指的是新的对象val，i值为15.

当执行完毕second后，在first中在此输出v.i的时候，应为前面second中已经把该位置的i的值改为了20，所以输出的是20.

至于疑惑v指向了val，其实只是名字的问题，在second中的v实践也是另外的一个变量，名字相同了而已，这个估计也是纠结的重点。

简单的总结，不对希望可以提出来，谢谢！

35、有关线程的哪些叙述是对的（）答案：B C D

A、一旦一个线程被创建，它就立即开始运行。
B、使用start()方法可以使一个线程成为可运行的，但是它不一定立即开始运行。
C、当一个线程因为抢先机制而停止运行，它可能被放在可运行队列的前面。
D、一个线程可能因为不同的原因停止并进入就绪状态。
解析：1、我自己最开始的时候只选了BD没选C。看评论里面也对C存疑，通过书籍查证C是可以选的。

在抢先式系统下，由高优先级的线程参与调度。分为2种情况：

1.若多个线程都处于就绪状态，则具有高优先级的线程会在低优先级之前得到执行；

2.在当前线程的运行过程中，如果有较高级别的线程准备就绪，则正在运行的较低级别的线程将被挂起，转到较高级别的线程运行，直到结束后又会转到原来被挂起的线程。

第二种情况就描述了C所代表的情况，可以看到当较高级别的线程抢去运行权并运行完成之后，是先将权利转给原来的线程的，所以C是正确的。

2、一个新创建的线程并不是自动的开始运行的，必须调用它的start()方法使之将线程放入可运行态(runnable state)，这只是意味着该线程可被JVM的线程调度程序调度而不是意味着它可以立即运行。
线程的调度是抢先式的，而不是分时间片式的。
具有比当前运行线程高优先级的线程可以使当前线程停止运行而进入就绪状态。
不同优先级的线程间是抢先式的，而同级线程间是轮换式的。
一个线程停止运行可以是因为不同原因，可能是因为更高优先级线程的抢占，也可能是因为调用sleep()方法。
而即使是因为抢先而停止也不一定就进入可运行队列的前面，因为同级线程是轮换式的，它的运行可能就是因为轮换，而它因抢占而停止后只能在轮换队列中排队而不能排在前面。

36、下面哪些类可以被继承？ Java.lang.Thread、java.lang.Number、java.lang.Double、java.lang.Math、 java.lang.ClassLoad 答案：A B E

A、Thread
B、Number
C、Double
D、Math
E、ClassLoader
解析：答案：ABE

A，Thread可以被继承，用于创建新的线程

B，Number类可以被继承，Integer，Float，Double等都继承自Number类

C，Double类的声明为

public final class Doubleextends Numberimplements Comparable<Double>

final生明的类不能被继承

D，Math类的声明为

public final class Mathextends Object

不能被继承

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

2、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

37、下列类定义中哪些是合法的抽象类的定义？（）答案：C

A、abstract Animal{abstract void growl();}
B、class abstract Animal{abstract void growl();}
C、abstract class Animal{abstract void growl();}
D、abstract class Animal{abstract void growl(){System.out.println( “growl”);};}
解析：选C

1. 首先，类的修饰符，都应该在class关键字之前，AB错；

2. 抽象方法不能有方法体，D错。

2、自己总结的，有遗漏请私我指正，不知道为什么网上都说接口没有Main方法，然而我用IDEA和eclipse是可以的，不知道是不是我理解错了。

*jdk1.8之前*

*接口*

1.多实现

2.变量类型默认且只能为为public static final

3.函数类型默认且只能为public，只能有public类型的静态成员函数

4.非静态成员函数没有方法体，静态成员函数有方法体

5.子类必须实现所有接口函数

6.可以有main方法；可以new一个接口，需要在方法体中实现所有接口函数

7.没有构造器

*抽象类*

1.单继承

2.变量类型不限（静态变量+非静态变量）

3.函数类型不限（静态函数+非静态函数）

4.非静态函数包含没有方法体的抽象函数. 有方法体的普通函数

5.子类可以不覆写父类的抽象方法，但子类也要申明为抽象类；子类可以选择覆写父类的非抽象方法

6.可以有main方法；不可以new一个抽象类

7.可以有构造器

*Jdk1.8*

*接口中可以有default类型的方法，实现类可以选择实现该方法*

****意义：****默认方法的主要优势是提供一种拓展接口的方法，而不破坏现有代码。另一个优势为该方法是可选的，子类可以根据不同的需求Override或默认实现。

38、Java的Daemon线程，setDaemon( )设置必须要？答案：A

A、在start之前
B、在start之后
C、前后都可以
解析：1、答案是A

setDaemon()方法必须在线程启动之前调用，当线程正在运行时调用会产生异常。

2、java线程基础知识----java daemon线程

java线程是一个运用很广泛的重点知识,我们很有必要了解java的daemon线程.

1.首先我们必须清楚的认识到java的线程分为两类: 用户线程和daemon线程

A.　　用户线程: 用户线程可以简单的理解为用户定义的线程,当然包括main线程(以前我错误的认为main线程也是一个daemon线程,但是慢慢的发现原来main线程不是,因为如果我再main线程中创建一个用户线程,并且打出日志,我们会发现这样一个问题,main线程运行结束了,但是我们的线程任然在运行).

B.　　daemon线程: daemon线程是为我们创建的用户线程提供服务的线程,比如说jvm的GC等等,这样的线程有一个非常明显的特征: 当用户线程运行结束的时候,daemon线程将会自动退出.(由此我们可以推出下面关于daemon线程的几条基本特点)

2.　daemon 线程的特点:

A.　　守护线程创建的过程中需要先调用setDaemon方法进行设置,然后再启动线程.否则会报出IllegalThreadStateException异常.(个人在想一个问题,为什么不能动态更改线程为daemon线程?有时间一个补上这个内容,现在给出一个猜测: 是因为jvm判断线程状态的时候,如果当前只存在一个线程Thread1,如果我们把这个线程动态更改为daemon线程,jvm会认为当前已经不存在用户线程而退出,稍后将会给出正确结论,抱歉!如果有哪位大牛看到,希望给出指点,谢谢!)

B.　　由于daemon线程的终止条件是当前是否存在用户线程,所以我们不能指派daemon线程来进行一些业务操作,而只能服务用户线程.

C.　　daemon线程创建的子线程任然是daemon线程.

3、A

java中线程分为两种类型：

1：用户线程。通过Thread.setDaemon(false)设置为用户线程；

2：守护线程。通过Thread.setDaemon(true)设置为守护线程，如果不设置，默认用户线程；

守护线程是服务用户线程的线程，在它启动之前必须先set。

39、当你编译和运行下面的代码时，会出现下面选项中的哪种情况？答案：B

public class Pvf{
   
    static boolean Paddy;
    public static void main(String args[]){
   
        System.out.println(Paddy);
    }
}

A、编译时错误
B、编译通过并输出结果false
C、编译通过并输出结果true
D、编译通过并输出结果null
解析：类中声明的变量有默认初始值；方法中声明的变量没有默认初始值，必须在定义时初始化，否则在访问该变量时会出错。

boolean类型默认值是false

40、能单独和finally语句一起使用的块是( ) 答案：

A、try
B、catch
C、throw
D、throws
解析：解析：处理异常常用的两种方式：
1、try…catch(捕获处理机制)；
2、throws(冒泡处理机制).
注意细节：使用try…catch块捕获时可以没有catch块,但当没用catch块的时候必须得有finally块.故选A）

40、以下代码段执行后的输出结果为答案：D

public class Test {
   
    public static void main(String[] args) {
   
        System.out.println(test());
 
    }
    private static int test() {
   
        int temp = 1;
        try {
   
            System.out.println(temp);
            return ++temp;
        } catch (Exception e) {
   
            System.out.println(temp);
            return ++temp;
        } finally {
   
            ++temp;
            System.out.println(temp);
        }
    }
}

A、1,2,2
B、1,2,3
C、1,3,3
D、1,3,2
解析：执行顺序为：

输出try里面的初始temp：1；

temp=2；

保存return里面temp的值：2；

执行finally的语句temp：3，输出temp：3；

返回try中的return语句，返回存在里面的temp的值：2；

输出temp：2。

2、finally代码块在return中间执行。return的值会被放入临时空间，然后执行finally代码块，如果finally中有return，会刷新临时空间的值，方法结束返回临时空间值。

41、以下哪项不是java基础类型（）答案： C

A、int
B、boolean
C、String
D、float
解析：C是正确答案

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

2、数据类型包括基本数据类型和引用数据类型

基本数据类型：byte,short,int,long,char,float,double,boolean

引用数据类型：数组，接口，枚举，类，空类

3、java的基本数据类型有八种： 1）四种整数类型(byte、short、int、long)： byte：8 位，用于表示最小数据单位，如文件中数据，-128~127 short：16 位，很少用，-32768 ~ 32767 int：32 位、最常用，-2^31-1~231 （21 亿） long：64 位、次常用注意事项： int i=5; // 5 叫直接量（或字面量），即直接写出的常数。整数字面量默认都为 int 类型，所以在定义的 long 型数据后面加 L或 l。小于 32 位数的变量，都按 int 结果计算。强转符比数算符优先级高。见常量与变量中的例子。 2）两种浮点数类型(float、double)： float：32 位，后缀 F 或 f，1 位符号位，8 位指数，23 位有效尾数。 double：64 位，最常用，后缀 D 或 d，1 位符号位，11 位指数，52 位有效尾注意事项：二进制浮点数： 1010100010=101010001.02=10101000.102^{10（2次方)=1010100.010*2}11(3次方)= . 10101000102^1010(10次方) 尾数： . 1010100010 指数： 1010 基数：2 浮点数字面量默认都为 double 类型，所以在定义的 float 型数据后面加F 或 f；double 类型可不写后缀，但在小数计算中一定要写 D 或 X.X float 的精度没有 long 高，有效位数（尾数）短。 float 的范围大于 long 指数可以很大。浮点数是不精确的，不能对浮点数进行精确比较。 3）一种字符类型(char)： char：16 位，是整数类型，用单引号括起来的 1 个字符（可以是一个中文字符），使用 Unicode 码代表字符，0~2^16-1（65535）。注意事项：不能为 0个字符。转义字符：\n 换行 \r 回车 \t Tab 字符 " 双引号 \ 表示一个\ 两字符 char 中间用“+”连接，内部先把字符转成 int 类型，再进行加法运算，char 本质就是个数！二进制的，显示的时候，经过“处理”显示为字符。 4）一种布尔类型(boolean)：true 真和 false 假。 5）类型转换： char–> 自动转换：byte–>short–>int–>long–>float–>double 强制转换：①会损失精度，产生误差，小数点以后的数字全部舍弃。②容易超过取值范围。 6）记忆：8位：Byte（字节型） 16位：short（短整型）、char（字符型） 32位：int（整型）、float（单精度型/浮点型） 64位：long（长整型）、double（双精度型）最后一个：boolean(布尔类型

42、执行语句“int a= ’ 2 ’ ”后，a的值是（）答案：B

A、2
B、50
C、49
D、0
解析：1、常用ASCII码值：空格为32；数字0为48；“A”为65；“a”值为97。

2、一个简便的记忆法：0：48 A:65 a:97，数字连起来是486597 -> 486 597 -> 486 (486 + 111)

3、常见字符的ASCII码值如下：空格的ASCII码值为32；数字0到9的ASCII码值分别为48到57；大写字母“A”到“Z”的ASCII码值分别为65到90；小写字母“a”到“z”的ASCII码值分别为97到到122。

43、Which lines of the following will produce an error? 答案：A

byte a1 = 2, a2 = 4, a3;
short s = 16;
a2 = s;
a3 = a1 * a2;

A、Line 3 and Line 4
B、Line 1 only
C、Line 3 only
D、Line 4 only
解析：答案:A

short类型转为byte类型出错

a1*a2结果为int类型，转为byte类型出错

2、数值型变量在默认情况下为Int型，byte和short型在计算时会自动转换为int型计算，结果也是int 型。所以a1*a2的结果是int 型的。

44、以下代码结果是什么？答案： 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;
    }
}

A、代码可以编译运行，输出“AB.AB”。
B、代码可以编译运行，输出“A.A”。
C、代码可以编译运行，输出“AB.B”。
D、代码可以编译运行，输出“A.B”。
解析：这里简单地说,a,b,x,y就是四个指针。y本来指向的是b所指向的对象，但是一个“=”，y就指向了x所指向的目标即是a指向的对象，因此原来b所指向的目标并没有发生任何改变。与y不同的是，x进行的是对象操作,此时此对象在内存中是真正的本质上的改变。有点绕，但是手机打字，没发画图，不然其实很容易理解。

2、引用a指向对象A

引用b指向对象B

引用x指向对象A

引用y指向对象B

在operate方法中，引用x指向的对象A被连接了B，对象A也就被改变为AB

然后又把引用y指向了x所指向的对象地址，也就是此时引用a,x,y指向同一个对象AB

而引用b没有发生任何变化，依旧指向对象B。

45、在J2EE中，使用Servlet过滤器，需要在web.xml中配置（）元素答案：A B

A、
B、
C、
D、
解析：答案：AB
Servlet过滤器的配置包括两部分：
第一部分是过滤器在Web应用中的定义，由元素表示，包括和两个必需的子元素
第二部分是过滤器映射的定义，由元素表示,可以将一个过滤器映射到一个或者多个Servlet或JSP文件，也可以采用url-pattern将过滤器映射到任意特征的URL。

46、如下的Java程序答案：B

public class Test {
    
     public static void main(String[] args) {
    
     System.out.println(args[0]); 
     } 
} 
 若采用命令行“java Test one two three”调用，则程序输出的结果为：

A、Test
B、one
C、two
D、java
解析：采用命令行“ java Test one two three ”调用

其中Test为调用的方法，而one two three则为Test方法里面main函数的参数；

System.out.println(args[0]);表示输出第一个元素，故为one；

47、事务隔离级别是由谁实现的？答案：C

A、Java应用程序
B、Hibernate
C、数据库系统
D、JDBC驱动程序
解析：答案：C

A，我们写java程序的时候只是设定事物的隔离级别，而不是去实现它

B，Hibernate是一个java的数据持久化框架，方便数据库的访问

C，事物隔离级别由数据库系统实现，是数据库系统本身的一个功能

D，JDBC是java database connector，也就是java访问数据库的驱动

2、C

数据库事务的隔离级别有4个，由低到高依次为Read uncommitted、Read committed、Repeatable read、Serializable，这四个级别可以逐个解决脏读、不可重复读、幻读这几类问题。

√: 可能出现 ×: 不会出现

	脏读	不可重复读	幻读
Read uncommitted	√	√	√
Read committed	×	√	√
Repeatable read	×	×	√
Serializable	×	×	×

48、上述代码返回结果为：答案：B

Integer a = 1;
Integer b = 1;
Integer c = 500;
Integer d = 500;
System.out.print(a == b);
System.out.print(c == d);

A、true、true
B、true、false
C、false、true
D、false、false
解析：1、

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

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

49、执行语句“int a= ’ 2 ’ ”后，a的值是（）答案：B

A、2
B、50
C、49
D、0
解析：1、常用ASCII码值：空格为32；数字0为48；“A”为65；“a”值为97。

2、一个简便的记忆法：0：48 A:65 a:97，数字连起来是486597 -> 486 597 -> 486 (486 + 111)

50、从以下哪一个选项中可以获得Servlet的初始化参数? 答案：C

A、Servlet
B、ServletContext
C、ServletConfig
D、GenericServlet
解析：C

通过ServletConfig接口的getInitParameter(java.lang.String name)方法

2、ServletContext对象：servlet容器在启动时会加载web应用，并为每个web应用创建唯一的servlet context对象，可以把ServletContext看成是一个Web应用的服务器端组件的共享内存，在ServletContext中可以存放共享数据。ServletContext对象是真正的一个全局对象，凡是web容器中的Servlet都可以访问。

整个web应用只有唯一的一个ServletContext对象

servletConfig对象：用于封装servlet的配置信息。从一个servlet被实例化后，对任何客户端在任何时候访问有效，但仅对servlet自身有效，一个servlet的ServletConfig对象不能被另一个servlet访问

51、下列类在多重catch中同时出现时，哪一个异常类应最后一个列出（）答案：C

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

2、ArithmeticException 是算数异常

NumberFormatException 是数据格式异常

Exception 异常

ArrayIndexOutOfBoundException 数组索引超过界限异常

先处理具体的异常，如果没有则放到一个大的范围之中Exception

52、下面有关java实例变量,局部变量,类变量和final变量的说法，错误的是？答案：B

A、实例变量指的是类中定义的变量，即成员变量，如果没有初始化，会有默认值。
B、局部变量指的是在方法中定义的变量，如果没有初始化，会有默认值
C、类变量指的是用static修饰的属性
D、final变量指的是用final 修饰的变量
解析：B，局部变量必须有初始值。

2、定义在类中的变量是类的成员变量，可以不进行初始化，Java会自动进行初始化，如果是引用类型默认初始化为null,如果是基本类型例如int则会默认初始化为0

局部变量是定义在方法中的变量，必须要进行初始化，否则不同通过编译

被static关键字修饰的变量是静态的，静态变量随着类的加载而加载，所以也被称为类变量

被final修饰发变量是常量

53、答案：C

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）保留的字符数为（）

A、5
B、10
C、15
D、20
解析：substring实际是new，5字符

str3和4也都是new，每个5字符

分别都会创建新的对象

常量池是PermGen的

因此应该是一共15字符

2、解析：这是一个关于java的垃圾回收机制的题目。垃圾回收主要针对的是堆区的回收，因为栈区的内存是随着线程而释放的。堆区分为三个区：年轻代（Young Generation）、年老代（Old Generation）、永久代（Permanent Generation，也就是方法区）。

年轻代：对象被创建时（new）的对象通常被放在Young（除了一些占据内存比较大的对象）,经过一定的Minor GC（针对年轻代的内存回收）还活着的对象会被移动到年老代（一些具体的移动细节省略）。

年老代：就是上述年轻代移动过来的和一些比较大的对象。Minor GC(FullGC)是针对年老代的回收

永久代：存储的是final常量，static变量，常量池。

str3,str4都是直接new的对象，而substring的源代码其实也是new一个string对象返回，如下图：

经过fullgc之后，年老区的内存回收，则年轻区的占了15个，不算PermGen。所以答案选C

54、下面哪些情况会引发异常：答案：A B C

A、数组越界
B、指定URL不存在
C、使用throw语句抛出
D、使用throws语句
解析：1、throws出现在方法头，throw出现在方法体 2、throws表示出现异常的一种可能性，并不一定会发生异常；throw则是抛出了异常，执行throw则一定抛出了某种异常。 3、两者都是消极的异常处理方式，只是抛出或者可能抛出异常，是不会由函数处理，真正的处理异常由它的上层调用处理。

55、下面哪些描述是正确的：（）答案：B C

public class Test {
   
    public static class A {
   
        private B ref;
        public void setB(B b) {
   
            ref = b;
        }
    }
    public static Class B {
   
        private A ref;
        public void setA(A a) {
   
            ref = a;
        }
    }
    public static void main(String args[]) {
   
    …
        start();
    ….
    }
    public static void start() {
    A a = new A();
        B b = new B();
        a.setB(b);
        b = null; //
        a = null;
    …
    }
}

A、b = null执行后b可以被垃圾回收
B、a = null执行后b可以被垃圾回收
C、a = null执行后a可以被垃圾回收
D、a,b必须在整个程序结束后才能被垃圾回收
解析：

2、内存如下：

a -> “a(b)”
b -> “b”

a引用指向一块空间，这块空间里面包含着b对象

b引用指向一块空间，这块空间是b对象

A选项，b = null执行后b可以被垃圾回收。这里"b可以被垃圾回收"中的b指的是引用b指向的内存。这块内存即使不被引用b指向，还是被引用a指向着，不会被回收。
B选项，a = null执行后b可以被垃圾回收。从代码中可以看到，a = null是在b = null后执行的，该行执行后，引用a和b都没有指向对象，对象会被回收。

C选项，同理。

56、只有实现了()接口的类，其对象才能序列化。答案：A

A、Serializable
B、Cloneable
C、Comparable
D、Writeable
解析：Serializable要实现序列化对象必须要实现的接口

2、答案是A:Serializable接口是专门提供给类实现序列化用的。要实现序列化对象必须要实现 Serializable 接口

3、B、可进行复制

C、比较器

D、hadoop中的接口

57、的输出是？答案：D

class Foo {
   
    final int i;
    int j;
    public void doSomething() {
   
        System.out.println(++j + i);
    }
}

A、0
B、1
C、2
D、不能执行，因为编译有错
解析：D。final类型的变量一定要初始化，因为final的变量不可更改。

final作为对象成员存在时，必须初始化；但是，如果不初始化，也可以在类的构造函数中初始

因为java允许将数据成员声明为final，却不赋初值。但是，blank finals必须在使用之前初始化，且必须在构造函数中初始化

58、下列代码编译和运行的结果是：（）答案：C

public class Threads4{
   
     public static void main(String[] args){
   
         new Threads4().go();
     }
     public void go(){
   
         Runnable r=new Runnable(){
   
             public void run(){
   
                 System.out.print("foo");
             }
         };
     Thread t=new Thread(r);
     t.start();
     }
 }

A、编译错误
B、抛出运行时异常
C、输出：foo
D、代码正常运行，但是无输出
解析：在java多线程中实现多线程的方式有两种①extends Thread ②implements Runnable。这两种情况是我们最常见的，还有一种是由第二种变形而来的直接new Runnable(){}，我们都知道java的接口是不可以实例化的，但代码中的new Runnable(){xxx}确是实例化了，为什么？接口和抽象类不可以实例化是对的，这个是java语法规范来的，而new Runnable(){}其实不是实例化Runnable接口来的，实际上一种内部类的一种简写 在这里：

①首先构造了一个”implements Runnable “的无名local内部类(方法内的内部类)

②然后构造了这个无名local内部类的一个实例

③然后用Runnable来表示这个无名local内部类的type(OO多态)。例如上面这段代码编译后你会看到其实是编译了两个类来的，如下：

其中Text2$1就是无名local内部内类，这个也就很好地解释了为什么在ma