8月25号复盘

1：下列命令中，用来运行java程序的是（A）
A,java
B,javadoc
C,jar
D,javac
2,下列程序的运行结果(A)

public void getCustomerInfo() {
   try {
      // do something that may cause an Exception
    } catch (java.io.FileNotFoundException ex) {
      System.out.print("FileNotFoundException!");
      } catch (java.io.IOException ex) {
      System.out.print("IOException!");
          } catch (java.lang.Exception ex) {
               System.out.print("Exception!");
          }
}

A.IOException!
B.IOException!Exception!
C.FileNotFoundException!IOException!
D.FileNotFoundException!IOException!Exception!

3,下面程序段的时间复杂度是（B）

i = k = 0;
while( k < n ){
   i ++ ;
k += i ;
}

A.O(n)
B.O(n^1/2)
C.O(n*i)
D.O(n+i)

4、在Java中，HashMap中是用哪些方法来解决哈希冲突的？©
A.开放地址法
B.二次哈希法
C.链地址法
D.建立一个公共溢出区

解析：链接：
以上方法都是解决哈希填冲突的策略，但是在java.util.HashMap中，总体来说是使用的链地址法来解决冲突的。
当然了，使用链地址法会导致get的效率从o（1）降至o（n），所以在Java8中，使用的是平衡树来解决提高效率的。

5，下列说法正确的有：（C）

A.class中的constructor不可省略
B.constructor必须与class同名，但方法不能与class同名
C.constructor在一个对象被new 时执行
D.一个class只能定义一个constructor

解析：B错：方法是可以和class同名的；方法可以和类名同名的，和构造方法唯一的区别就是，构造方法没有返回值。一个类必须有 constructor 方法，如果没有显式定义，一个默认的 consructor 方法会被默认添加。所以即使你没有添加构造函数，也是会有一个默认的构造函数的。一般 constructor 方法返回实例对象 this ，但是也可以指定 constructor 方法返回一个全新的对象，让返回的实例对象不是该类的实例。

6.下面有关java实例变量,局部变量,类变量和final变量的说法，错误的是？（B）

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

解析：B,局部变量：定义在方法中，使用之前必须进行初始化，且生命周期仅仅在该方法中有效。 C，在程序中仅加载一次，分配独立的存储空间（静态区），所有实例化的对象共享类变量。D，表示该变量为常量，显示初始化之后不可以被修改，类似于C++里面的全局变量。

7，关于static说法不正确的是（D ）

A.可以直接用类名来访问类中静态方法(public权限)
B.静态块仅在类加载时执行一次
C.static方法中不能有用this调用的方法
D.不可以用对象名来访问类中的静态方法(public权限)

解析：
静态方法可以不用创建对象就调用，非静态方法必须有了对象的实例才能调用.因此想在静态方法中引用非静态方法是不可能的,因为它究竟引用的是哪个对象的非静态方法呢?

8，顺序执行下列程序语句后，则b的值是（C）

String a=“Hello”;
String b=a.substring(0,2);
A.Hello
B.Hel
C.He
D.null

解析：substring 是截取字符串的，substring(0,2) 的 ,substring括号里面的 数值 都代表的是 ，Index (下标) 的意思,substring(0,2) 的(0,2) 是 ,包括 0 下标值 而不包括 2 下标的值，也就是 substring 会 截取 下标为 0跟 1的值 ,而不包括 2的值!

9,JAVA语言的下面几种数组复制方法中，哪个效率最高？(B)
A.for循环逐一复制
B.System.arraycopy
C.Arrays.copyOf
D.使用clone方法

解析：Arrays.copyOf：深拷贝： 两个对象地址不一样，内容一样。
System.arraycopy：两个对象指向同一个地址，所以两个对象的内容共享。

10，下列关于java并发的说法中正确的是：(B)

A.copyonwritearraylist适用于写多读少的并发场景
B.readwritelock适用于读多写少的并发场景
C.concurrenthashmap的写操作不需要加锁，读操作需要加锁
D.只要在定义int类型的成员变量i的时候加上volatile关键字，那么多线程并发执行i++这样的操作的时候就是线程安全的了

解析：A：CopyOnWirteArrayList 适用于写少读多的并发场景
B: ReadWriteLock 即为读写锁，要求写与写之间互斥，读与写之间互斥，读与读之间可以并发执行，在读多写少的情况下可以提高效率。
C.ConcurrentHashMap是同步的HashMap，读写都加锁
D.volatile只保证多线程操作的可见性，不保证原子性

11,以下代码段执行后的输出结果为(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

12,关于Java语言描述正确的是？ (B )

A.java和C++都保留了指针
B.java和C++都有三个特征：封装、继承和多态
C.java的垃圾回收机制是指程序结束时系统自动回收内存
D.以上说法都不正确

13,类的声明是正确的？(B)
A.protected private number;
B.public abstract class Car{}
C.abstract private move(){}
D.abstract final class HI{}

解析：
在使用类之前，必须先声明它，然后才可以声明变量，并创建对象。

类声明的语法如下:

[标识符] class 类名称
  {
      //类的成员变量
      //类的方法
  }

在上面的语法格式中，[标识符] 可以是public、private、protected或者完全省略这个修饰符。

类名称遵循标识符命名规则与规范，这里不再赘述，有兴趣的可以去标识符命名规则与规范看看。

Java提供了一系列的访问控制符来设置基于类（class）、变量（variable）、方法（method）及构造方法（constructor）等不同等级的访问权限。

Java的访问权限主要有4类：

1、default（默认）
在默认模式下，不需为某个类、方法等不加任何访问修饰符。这类方式声明的方法和类，只允许在同一个包（package）内是可访问的。

2、 private（私有）
这是Java语言中对访问权限控制最严格的修饰符。如果一个方法、变量和构造方法被声明为“私有”访问，那么它仅能在当前声明它的类内部访问。

类和接口（interface）的访问方式是不能被声明为私有的。

3、public（公有）
这是Java语言中访问权限控制最宽松的修饰符。如果一个类、方法、构造方法和接口等被声明为“公有”访问，那么它不仅可以被跨类访问，而且允许跨包访问。

如果需要访问其他包里的公有成员，则需要事先导入（import）那个包含所需公有类、变量和方法等的那个包。

4、protected（保护）
介于public 和 private 之间的一种访问修饰符。如果一个变量、方法和构造方法在父类中被声明为“保护”访问类型，只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。

类和接口（interface）的访问方式是不能声明为保护类型的。

5、final
类的标识符除了上述的4个访问控制符，还可以是final。

关键字“final”有“无法改变的”或者“终态的”含义。

一个类一旦被声明为final，那这个final类不能被继承，因此final类的成员方法没有机会被覆盖，默认情况下类都是default的。

在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会再被扩展，那么就设计为final类。
【示例】

class Person
{
   String name;
   int age;
   void talk()
   {
   System.out.println("我是："+name+"，今年："+age+"岁");
  }
}

14：下列说法正确的是©

A.java中包的主要作用是实现跨平台功能
B.package语句只能放在import语句后面
C.包（package）由一组类（class）和接口（interface）组成
D.可以用#include关键词来标明来自其它包中的类

[解析] Java中的包是为了能够使用户可以方便地重复利用已经创建的类，Java提供了一个名为包的机制，包实际上是一组相关的类和接口的集合。所以选项A错误；选项C正确；package语句将源文件存入指定的包中，该部分至多只有一句，必须放在源程序的第一句，如果没有该语句，则源文件存入当前目录下。import语句导入需要的包或类，该部分可以有若干import语句或者没有，必须放在所有的类定义前。所以选项B、D错误；

15，给定以下JAVA代码，这段代码运行后输出的结果是（B）

public class Test
{
    public static int aMethod(int i)throws Exception
    {
        try{
            return i / 10;
        }
        catch (Exception ex)
        {
            throw new Exception("exception in a Method");
        } finally{
            System.out.printf("finally");
        }
    }
 
    public static void main(String [] args)
    {
        try
        {
            aMethod(0);
        }
        catch (Exception ex)
        {
            System.out.printf("exception in main");
        }
        System.out.printf("finished");
    }
}
 
    

A.exception in main finished
B.finally finished
C.exception in main finally
D.finally exception in main finished

16，抽象类方法的访问权限默认都是public。（B ）

A.正确
B.错误

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

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

17：Java的跨平台特性是指它的源代码可以在多个平台运行。(B)

A.对
B.错

解析：Java代码是字节代码，就像楼上所说的Java是运行在虚拟机上的，虚拟机将Java字节代码和具体的平台给隔开，不同平台上面运行的虚拟机是不一样的，而这些虚拟机对Java代码要求是一样的，所以Java可以在多个平台运行

18：下列java程序的输出结果为__B_。

public class Example{
    String str=new String("hello");
    char[]ch={'a','b'};
    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]='c';
    }
}

A.hello and ab
B.hello and cb
C.hello and a
D.test ok and ab
E.test ok and cb
F.test ok and c

19：下面代码的输出是什么？(A)

public class Base
{
    private String baseName = "base";
    public Base()
    {
        callName();
    }
 
    public void callName()
    {
        System. out. println(baseName);
    }
 
    static class Sub extends Base
    {
        private String baseName = "sub";
        public void callName()
        {
            System. out. println (baseName) ;
        }
    }
    public static void main(String[] args)
    {
        Base b = new Sub();
    }
}

A.null
B.sub
C.base

20假设一个 list初始化为{2，9，5，4，8，1}。 在第一次冒泡排序后，list变成了（D）?

A.2, 9, 5, 4, 8, 1
B.2, 9, 5, 4, 1, 8
C.2, 5, 9, 4, 8, 1
D.2, 5, 4, 8, 1, 9‘’

21：在java的一个异常处理中，可以包含多个的语句块是 （ D）。

A.try
B.finally
C.throws
D.catch

解析：

异常处理一般格式：
捕获异常：
try{
    //代码块
}catch(异常类型，例如：Exception e){
    //需要抛出的异常，例如：e.printStackTrace();
}catch(异常类型){
    //需要抛出的异常
}finally{
    //必定执行的代码块
}
所以说在一个异常处理中catch语句块是可以多个的，也就是可以抛出多个异常！

22：若有下列定义，下列哪个表达式返回false？(B)

String s = “hello”;
String t = “hello”;
char c[] = {‘h’,‘e’,‘l’,‘l’,‘o’} ;
A.s.equals(t);
B.t.equals©;
C.s==t;
D.t.equals(new String(“hello”));

解析

：Java中equals和==的区别
java中的数据类型，可分为两类：

1.基本数据类型，也称原始数据类型。byte,short,char,int,long,float,double,boolean
他们之间的比较，应用双等号（==）,比较的是他们的值。

2.复合数据类型(类)
当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。 JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地 址，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。

对于复合数据类型之间进行equals比较，在没有覆写equals方法的情况下，他们之间的比较还是基于他们在内存中的存放位置的地址值的，因为Object的equals方法也是用双等号（==）进行比较的，所以比较后的结果跟双等号（==）的结果相同。

23：从以下哪一个选项中可以获得Servlet的初始化参数?©

A.Servlet
B.ServletContext
C.ServletConfig
D.GenericServlet

解析：ServletContext作用

1.  是一个域对象
   

2.  可以读取全局配置参数
   

3.  可以搜索当前工程目录下面的资源文件
   

4.  可以获取当前工程名字（了解）作用
   

GenericServlet：
是实现了Servlet接口和ServletConfig接口的实现类，是一个抽象类，里面的service方法为抽象方法。

23：对于下面这段代码，以下说法正确的是：©

public class Test
{
    public int x;
    public static void main(String []args)
    {
        System. out. println("Value is" + x);
    }
}

A.程序会打出 “Value is 0”
B.程序会抛出 NullPointerException
C.非静态变量不能够被静态方法引用
D.编译器会抛出 "possible reference before assignment"的错误

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

A.在创建自己的Servlet时候，应该在初始化方法init()方法中创建Servlet实例
B.在Servlet生命周期的服务阶段，执行service()方法，根据用户请求的方法，执行相应的doGet()或是doPost()方法
C.在销毁阶段，执行destroy()方法后会释放Servlet 占用的资源
D.destroy()方法仅执行一次，即在服务器停止且卸载Servlet时执行该方法

解析：
Servlet的生命周期分为5个阶段：加载、创建、初始化、处理客户请求、卸载。
(1)加载：Servlet容器（Tomcat）通过类加载器加载servlet文件（.class）
(2)创建：通过调用servlet构造函数创建一个servlet对象
(3)初始化：调用init方法初始化
(4)处理客户请求：每当有一个客户请求，容器会创建一个线程来处理客户请求
(5)卸载：调用destroy方法让servlet自己释放其占用的资源
servlet是由Servlet容器负责加载Servlet类，创建Servlet对象并实例化，然后调用Servlet的init方法，进行初始化，之后调用Service方法。实例化和初始化不同。先实例化，再初始化。

serlvet是单实例多线程
默认第一次访问的时候,服务器创建servlet,并调用init实现初始化操作.并调用一次service方法
每当请求来的时候,服务器创建一个线程,调用service方法执行自己的业务逻辑
当serlvet被移除的时候服务器正常关闭的时候,服务器调用servlet的destroy方法实现销毁操作.

25：下列关于java抽象类的说法哪个正确?D
A.某个抽象类的父类是抽象类，则这个子类必须重载父类的所有抽象方法
B.接口和抽象类是同一回事
C.可以用抽象类直接去实例化创建对象
D.一个类只能继承一个抽象类

解析：
A.非抽象类继承抽象类，必须将抽象类中的方法重写，否则需将方法再次申明为抽象。所以这个方法还可再次声明为抽象，而不用重写。而用重载也错了，重载是在同一个类中，重写、覆盖才是在父子类中。

B.抽象类可以没有抽象方法，接口是完全的抽象，只能出现抽象方法。

C.抽象类无法实例化，无法创建对象。现实生活中也有抽象类的类子，比如说人类是一个抽象类，无法创建一个叫人类的对象，人继承人类来创建对象。况且抽象类中的抽象方法只有声明，没有主体，如果实例化了，又如何去实现调用呢？

D因为类是单继承的，类继承了一个抽象类以后，就不能再继承其他类了。

26：关于protected 修饰的成员变量，以下说法正确的是B

A.可以被该类自身、与它在同一个包中的其它类、在其它包中的该类的子类所访问
B.只能被该类本身和该类的所有的子类访问
C.只能被该类自身所访问
D.只能被同一个包中的类访问

26：根据以下代码段,执行new Child(“John”, 10); 要使数据域data得到10，则子类空白处应该填写D

1.class Parent {  
2.  
3.    private int data;  
4.  
5.    public Parent(int d){ data = d; }  
6.  
7.}  
8.  
9.class Child extends Parent{  
10.  
11.    String name;  
12.  
13.    public Child(String s, int d){  
14.  
15.        ___________________  
16.  
17.        name = s;  
18.  
19.    }  
20.  
21.}  

A.data = d;
B.super.data = d;
C.Parent(d);
D.super(d);

27：执行下列代码的输出结果是C

1.public class Demo{  
2.　public static void main(String args[]){  
3.　　　int num = 10;  
4.　　　System.out.println(test(num));  
5.}  
6.public static int test(int b){  
7.　　　try  
8.　　　{  
9.　　　　b += 10;  
10.　　　　return b;  
11.　　　}  
12.　　　catch(RuntimeException e)  
13.　　　{  
14.　　　}  
15.　　　catch(Exception e2)  
16.　　　{  
17.　　　}  
18.　　　finally  
19.　　　{  
20.　　　　b += 10;  
21.　　　　return b;  
22.　　　}  
23.　　}  
24.}  

A.10
B.20
C.30
D.40

28：下列关于容器集合类的说法正确的是？C

A.LinkedList继承自List
B.AbstractSet继承自Set
C.HashSet继承自AbstractSet
D.WeakMap继承自HashMap

解析：
List,Set,Map在java.util包下都是接口
List有两个实现类：ArrayList和LinkedList
Set有两个实现类：HashSet和LinkedHashSet
AbstractSet实现了Set

29：Hashtable 和 HashMap 的区别是：EDBC

A.Hashtable 是一个哈希表，该类继承了 AbstractMap，实现了 Map 接口
B.HashMap 是内部基于哈希表实现，该类继承AbstractMap，实现Map接口
C.Hashtable 线程安全的，而 HashMap 是线程不安全的
D.Properties 类 继承了 Hashtable 类，而 Hashtable 类则继承Dictionary 类
E.HashMap允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许。

30：.与InputStream流相对应的Java系统的“标准输入对象”是A

A.System.in
B.System.out
C.System.err
D.System.exit()

31：执行如下代码后输出结果为C

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

A.return value of getValue(): 1
B.return value of getValue(): 4
C.return value of getValue(): 5
D.其他几项都不对

32：关于抽象类的叙述正确的是？A

A.抽象类不可以实例化
B.抽象类就是一种特殊的接口
C.抽象类的方法都是抽象方法
D.抽象类的导出类一定不是抽象类

解析：

A选项中，抽象类不能实例化，这句是正确的。后面，抽象类不能申明为对象，是错误的。java中，接口和抽象类，都可以声明为对象，只需要在实例化的时候，用一个该接口/抽象类的实现类实例化就行了。即：
interface / abstract class obj = new class();其中，new后面的class是前面接口/抽象类的实现类。
B选项中，接口是一种特殊的抽象类。其中，成员变量都是默认public static final修饰的，方法都是public abstract修饰的，并且除了default和static的以外，只有声明，没有方法体。
C选项中，抽象类的方法，可以是抽象abstract的，也可以是普通的。就算全部是普通方法，也可以用abstract修饰。
D选项中，导出类，及子类，抽象类的子类可以是抽象的，也可以是普通的。

33：以下运行结果:B

1.for(var i = 0; i < 10; i++) {  
2.    setTimeout(function() {  
3.        console.log(i);  
4.    }, 1000);  
5.}  

A.0–9
B.10个10
C.10个9
无限循环

34：如果希望监听TCP端口9000，服务器端应该怎样创建socket?B

A.new Socket(“localhost”,9000);
B.new ServerSocket(9000);
C.new Socket(9000);
D.new ServerSocket(“localhost”,9000);

35：多选)关于 java 的异常处理机制的叙述哪些正确？BA

A.不论程序是否发生错误及捕捉到异常情况，都会执行finally部分
B.当try区段的程序发生异常时，才会执行catch区段的程序
C.catch部分捕捉到异常情况时，才会执行finally部分
D.其它选项都不正确

36：(多选)关于java集合下列说法不正确的有哪些D,B,A

A.HashSet 它是线程安全的，不允许存储相同的对象
B.ConcurrentHashMap 它是线程安全的，其中存储的键对象可以重复，值对象不能重复
C.Collection接口是List接口和Set接口的父接口，通常情况下不被直接使用
D.ArrayList线程安全的，允许存放重复对象

37：Math.round(11.5) 等于:C
A.11
B.11.5
C.12
D.12.5

解析：将括号内的数+0.5之后，向下取值。

38：下列叙述中，错误的是B

A.File类能够存储文件属性
B.File类能够读写文件
C.File类能够建立文件
D.File类能够获取文件目录信息

39：下列关于Java中类的构造方法的描述，正确的是B，A

A.构造方法的返回类型为void
B.可以定义一个类而在代码中不写构造方法。
C.在同一个类中定义的重载构造方法不可以相互调用。
D.子类不允许调用父类的构造方法。

40：下列描述中，错误的是C

A.SQL语言又称为结构化查询语言
B.java中”static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问
C.面向对象开发中，引用传递意味着传递的并不是实际的对象，而是对象的引用，因此，外部对引用对象所做的改变不会反映到所引用的对象上
D.java是强类型语言，javascript是弱类型语言
E.面向对象的三大特性包括：封装，继承，多态

解析：

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

41：抽象类和接口的区别，一下说法错误的是D

A.接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的。
B.abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface，实现多重继承。接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面的变量全是常量）的作用。
C.在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是 static final的，不过在 interface中一般不定义数据成员），所有的成员方法默认都是 public abstract 类型的。
D.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"has-a"关系，interface表示的是"is-a"关系。

解析：

Java 抽象类

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

Java 接口

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口与类相似点：

一个接口可以有多个方法。

接口文件保存在 .java 结尾的文件中，文件名使用接口名。

接口的字节码文件保存在 .class 结尾的文件中。

接口相应的字节码文件必须在与包名称相匹配的目录结构中。

接口与类的区别：

接口不能用于实例化对象。

接口没有构造方法。

接口中所有的方法必须是抽象方法。

接口不能包含成员变量，除了 static 和 final 变量。

接口不是被类继承了，而是要被类实现。

接口支持多继承。

接口特性

接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。

接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。

接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

抽象类和接口的区别

1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。

2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。

3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。

4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

42下列关于构造函数说法正确的是C

A.构造函数的返回值为void
B.构造函数不可以被重载
C.构造函数可以是内联函数
D.构造函数可以没有参数

解析：构造函数（默认内联函数）：能够给反复重载,可带参数（不能有返回值，也不能void
析构函数：不能有返回值和参数，只能有一个析构函数，销毁一个对象

43：(多选)java中Hashtable, Vector, TreeSet, LinkedList哪些线程是安全的？AB

A.Hashtable
B.Vector
C.TreeSet
D.LinkedList

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

A.Serializable
B.Cloneable
C.Comparable
D.Writeable

解析：
A:Serializable接口是专门提供给类实现序列化用的。要实现序列化对象必须要实现 Serializable 接口

43：对于Java中异常的描述正确的是D

A.用throws定义了方法可能抛出的异常，那么调用此方法时一定会抛出此异常。
B.如果try块中没有抛出异常，finally块中的语句将不会被执行。
C.抛出异常意味着程序发生运行时错误，需要调试修改
D.Java中的可不检测（unchecked）异常可能来自RuntimeException类或其子类。

44：关于sleep()和wait()，以下描述错误的一项是D

A.sleep是线程类（Thread）的方法，wait是Object类的方法；
B.sleep不释放对象锁，wait放弃对象锁
C.sleep暂停线程、但监控状态仍然保持，结束后会自动恢复
D.wait后进入等待锁定池，只有针对此对象发出notify方法后获得对象锁进入运行状态

解析： sleep：Thread类中定义的方法，表示线程休眠，会自动唤醒；

wait：Object中定义的方法，需要手工调用notify()或者notifyAll()方法。

sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。 wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

sleep就是正在执行的线程主动让出cpu，cpu去执行其他线程，在sleep指定的时间过后，cpu才会回到这个线程上继续往下执行，如果当前线程进入了同步锁，sleep方法并不会释放锁，即使当前线程使用sleep方法让出了cpu，但其他被同步锁挡住了的线程也无法得到执行。wait是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行，只有其他线程调用了notify方法（notify并不释放锁，只是告诉调用过wait方法的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为锁还在别人手里，别人还没释放。如果notify方法后面的代码还有很多，需要这些代码执行完后才会释放锁，可以在notfiy方法后增加一个等待和一些代码，看看效果），调用wait方法的线程就会解除wait状态和程序可以再次得到锁后继续向下运行。对于wait的讲解一定要配合例子代码来说明，才显得自己真明白。

45：多选) 对Collection和Collections描述正确的是BD

A.Collection是java.util下的类，它包含有各种有关集合操作的静态方法
B.Collection是java.util下的接口，它是各种集合结构的父接口
C.Collections是java.util下的接口，它是各种集合结构的父接口
Collections是java.util下的类，它包含有各种有关集合操作的静态方法

46：.局部内部类可以用哪些修饰符修饰?CD

A.public
B.private
C.abstract
D.final

47：(多选)下面有关forward和redirect的描述，正确的是(B,C,D) ？

A.forward是服务器将控制权转交给另外一个内部服务器对象，由新的对象来全权负责响应用户的请求
B.执行forward时，浏览器不知道服务器发送的内容是从何处来，浏览器地址栏中还是原来的地址
C.执行redirect时，服务器端告诉浏览器重新去请求地址
D.forward是内部重定向，redirect是外部重定向
E.redirect默认将产生301 Permanently moved的HTTP响应

48：.ArrayLists和LinkedList的区别，下述说法正确的有？ABCD

A.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
B.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
C.对于新增和删除操作add和remove，LinkedList比较占优势，因为ArrayList要移动数据。
D.ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间。

49：关于访问权限说法正确的是 ？B

A.外部类前面可以修饰public,protected和private
B.成员内部类前面可以修饰public,protected和private
C.局部内部类前面可以修饰public,protected和private
D.以上说法都不正确

50：下面说法正确的是C

A.构造函数先调用自己的构造函数然后初始化成员变量最后调用基类构造函数
B.构造函数先调用基类构造函数然后调用自己的构造函数最后初始化成员变量
C.构造函数先调用基类构造函数然后初始化成员变量最后调用自己的构造函数
D.构造函数先调用自己的构造函数然后调用基类构造函数最后初始化成员变量

51：Which of the following can be applied to constructors:E

A.final
B.static
C.synchronized
D.native
E.None of these.