【牛客网练习题】Java专项练习（50题）含解析

1.运行结果：（3,5,6,7）

void main(void) {
    char *s = "1314520";
    int v1 = 0, v2 = 0, v3 = 0, v4 =0;
    for (int i = 0; s[i]; i++) {
        switch(s[i]) {
            default: v4++;
            case '1': v1++;
            case '2': v2++;
            cas3 '3': v3++;
        }
    }
    printf("%d, %d, %d, %d", v4,v1,v2,v3)
}

解析：
default意思是缺省情况，只有任何条件都不匹配的情况下才会执行，故会匹配到s[i]为‘4’，‘5’，‘0’ 的情况。于是v4++三次，v4=3。并且这个default后没有使用break语句，于是case‘1’、‘2’、‘3’都会执行三次。注意到所以语句都没有加break，则语句执行过之后会继续下面的case语句，另外由于s[i]中有两个1，故v1,v2,v3此时为5.另外有一个2，v2,v3++后为6，还有一个case3 于是v3++，最终v3为7。

2.jdk1.8中，下面有关java 抽象类和接口的区别，说法错误的是？（ B D ）

A . 抽象类可以有构造方法，接口中不能有构造方法
B . 抽象类中可以包含非抽象的普通方法，接口中的方法必须是抽象的，不能有非抽象的普通方法
C . 一个类可以实现多个接口，但只能继承一个抽象类
D . 接口中可以有普通成员变量，抽象类中没有普通成员变量

解析：

抽象类和接口知识点

3.在 applet 的方法中 , 可关闭小应用程序并释放其占用资源的是（ D ）

A . stop()
B . paint()
C . init()
D . destroy()

解析：
Applet 的生命周期涉及 init() 、 start() 、 stop() 和 destroy() 四种方法，这 4 种方法都是 Applet 类的成员，可以继承这些方法，也可以重写这些方法，覆盖原来定义的这些方法。除此之外，为了在 Applet 程序中实现输出功能，每个 Applet 程序中还需要重载 paint() 方法：
（1）init()方法是 Applet 运行的起点。当启动 Applet 程序时，系统首先调用此方法，以执行初始化任务。
（2）start()方法是表明 Applet 程序开始执行的方法。当含有此 Applet 程序的 Web 页被再次访问时调用此方法。因此，如果每次访问 Web 页都需要执行一些操作的话，就需要在 Applet 程序中重载该方法。在 Applet 程序中，系统总是先调用 init() 方法，后调用 start() 方法。
（3）stop()方法使 Applet 停止执行，当含有该 Applet 的 Web 页被其他页代替时也要调用该方法。
（4）destroy()方法收回 Applet 程序的所有资源，即释放已分配给它的所有资源。在 Applet 程序中，系统总是先调用 stop() 方法，后调用 destroy() 方法。
（5）paint(Graphics g)方法可以使 Applet 程序在屏幕上显示某些信息，如文字、色彩、背景或图像等。参数 g 是 Graphics 类的一个对象实例，实际上可以把 g 理解为一个画笔。对象 g 中包含了许多绘制方法，如 drawstring() 方法就是输出字符串。

4.对于构造方法，下列叙述正确的是（A C D）。

A . 构造方法的优先级一般比代码块低。
B . 构造方法的返回类型只能是void型。
C . 构造方法的主要作用是完成对类的对象的初始化工作。
D . 一般在创建新对象时，系统会自动调用构造方法。

解析：
java程序初始化顺序
父类静态变量，父类静态代码块（只执行一次），子类静态变量，子类静态代码块（只执行一次），父类非静态变量，父类非静态代码块，父类构造函数，子类非静态变量，子类非静态代码块，子类构造函数。
构造方法没有返回值。

5.关于Java语言中的final关键字的使用，下列说法正确的是（C）

A . 在使用final关键字定义的方法里面使用final关键字定义变量。
B . 使用final关键字定义变量，必须在变量定义的同时给定变量的具体数值，完成变量初始化。
C . final关键字可以用来修饰方法，表明此方法不可以被子类重写。
D . 使用final关键字定义变量，必须同时使用static关键字。

解析：
A ：在 final 定义的方法里，不是必须要用 final 定义变量。
B： final 定义的变量，可以在不是必须要在定义的同时完成初始化，也可以在构造方法中完成初始化。
C ：final修饰方法，不能被子类重写，但是可以被重载。
D final 定义变量，可以用 static 也可以不用。

6.关于Java中参数传递的说法，哪个是错误的？（D）

A . 在方法中，修改一个基础类型的参数不会影响原始参数值
B . 在方法中，改变一个对象参数的引用不会影响到原始引用
C . 在方法中，修改一个对象的属性会影响原始对象参数
D . 在方法中，修改集合和Maps的元素不会影响原始集合参数

解析：
A选项：在方法中，修改一个基础类型的参数永远不会影响原始参数值。
B选项：在方法中，改变一个对象参数的引用永远不会影响到原始引用。然而，它会在堆中创建了一个全新的对象。（译者注：指的是包装类和immutable对象）
C选项：在方法中，修改一个对象的属性会影响原始对象参数。
D选项：在方法中，修改集合和Maps会影响原始集合参数。

7.关于类的叙述正确的是（B）。

A . 在类中定义的变量称为类的成员变量，在别的类中可以直接使用
B . 局部变量的作用范围仅仅在定义它的方法内，或者是在定义它的控制流块中
C . 使用别的类的方法仅仅需要引用方法的名字即可
D . 只要没有定义不带参数的构造函数，JVM都会为类生成一个默认构造函数

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

8.针对下面的代码块,哪个equal为true:（A）

1 String s1 = “xiaopeng” ;
2 String s2 = “xiaopeng” ;
3 String s3 =new String (s1);
A . s1 == s2
B . s1 = s2
C . s2 == s3
D . 都不正确

解析：
string是final修饰的，会将创建的变量放入字符串常量池，当再创建同样的字符串时，发现常量池中有则直接使用。
String有两种实例化方式：
（1）直接赋值
（2）使用new关键字

9.下面哪几个语句正确的声明一个整型的二维数组（C D）

A . int a[][]=new int[][]
B . int b[10][10]=new int[][]
C . int c[][]=new int[10][10]
D . int []d[]=new int[10][10]

10.servlet周期包含哪些：(A B C)

A . 初始化
B . 销毁
C . 请求处理
D. 开始

解析：
Servlet生命周期分成3个阶段：
（1）初始化阶段：调用init方法
（2）响应客户请求：调用service
（3）终止：调用destory方法

11.以下代码可以使用的修饰符是：（A B D）

public interface Status {
 /*INSERT CODE HERE*/  int MY_VALUE=10;
}

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

解析：
接口中字段的修饰符：public static final（默认不写）
接口中方法的修饰符：public abstract（默认不写）

12.以下关于 abstract 关键字的说法，正确的是（D）

A . abstract 可以与final 并列修饰同一个类。
B . abstract 类中不可以有private的成员。
C . abstract 类中必须全部是abstract方法。
D . abstract 方法必须在abstract类或接口中。

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

13.在socket编程中，可以使用方法（B）获取本机的ip地址。

A . getInetAddress()
B . getLocalAddress()
C . getReuseAddress()
D . getLocalPort()

解析：
getInetAddress获取主机名和IP地址
getLocalAddress()顾名思义，获取本地IP地址
getReuseAddress()返回布尔类型，表示复用地址
getLocalPort()API 的说明：“Returns the Internet Protocol (IP) port number of the interface on which the request was received. ”

14.Servlet的生命周期可以分为初始化阶段，运行阶段和销毁阶段三个阶段，以下过程属于初始化阶段是（ A C D）。

A . 加载Servlet类及.class对应的数据
B . 创建servletRequest和servletResponse对象
C . 创建ServletConfig对象
D . 创建Servlet对象

解析：

15.Java Application 源程序的主类是指包含有（ A）方法的类。

A . public static void main方法
B . toString方法
C . init方法
D . actionPerfromed方法

16.观察以下代码：

class Car extends Vehicle
{
    public static void main (String[] args)
    {
        new  Car(). run();
    }
    private final void run()
    {
        System. out. println ("Car");
    }
}
class Vehicle
{
    private final void run()
    {
        System. out. println("Vehicle");
    }
}

上述哪些针对代码运行结果的描述是正确的？
A . Car
B . Vehicle
C . Compiler error at line 3
D . Compiler error at line 5
E . Exception thrown at runtime

解析：
因为方法是private的，也就是子类没有继承父类的run方法，因此子类的run方法跟父类的run方法无关，并不是覆盖。new Car().run()也是调用子类的run方法。

17.下列说法正确的是（B）

A . 在类方法中可用this来调用本类的类方法
B . 在类方法中调用本类的类方法时可直接调用
C . 在类方法中只能调用本类中的类方法
D . 在类方法中绝对不能调用实例方法

18.列表(List)和集合(Set)下面说法正确的是？ (A)

A . Set中至多只能有一个空元素
B . List中至多只能有一个空元素
C . List和Set都可以包含重复元素的有序集合
D . List和Set都是有序集合

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

19.Web客户端的编程语言JavaScript源自Java，其功能是Java SE的子集。(×)。

20./…/中可以嵌套//注释，也能嵌套/…/注释。（×）。

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

21.对于JVM内存配置参数：其最小内存值和Survivor区总大小分别是（D）

-Xmx10240m -Xms10240m -Xmn5120m -XXSurvivorRatio=3

A . 5120m，1024m
B . 5120m，2048m
C . 10240m，1024m
D . 10240m，2048m

解析：
-Xmx：最大堆大小
-Xms：初始堆大小
-Xmn：年轻代大小
-XXSurvivorRatio：年轻代中Eden区与Survivor区的大小比值。
年轻代5120m， Eden：Survivor=3，Survivor区大小=1024m（Survivor区有两个，即将年轻代分为5份，每个Survivor区占一份），总大小为2048m。
-Xms初始堆大小即最小内存值为10240m。

22.局部变量能否和成员变量重名？（A）

A . 可以，局部变量可以与成员变量重名，这时可用“this”来指向成员变量
B . 可以，这时可用“local”关键字来指向局部变量
C . 不能，局部变量不能与成员变量重名
D . 不能，在一个类中不能有重名变量，不管是成员变量还是函数中的局部变量

解析：
例：如下

public class TestA {
	private String a = "成员变量 (类变量)中的a";
	public void useA(){
		String a = "成员变量(方法)中的a";
		System. out. print1n(this.a);
		System. out.print1n(a);|
	public static void main(String[] args) {
		TestA t = new TestA( );
		t.useA( );
	}
}
/*
打印结果：
成员变量(类变量)中的a
成员变量(方法)中的a
*/

23.以下哪些类是线程安全的（A D E）

A . Vector
B . HashMap
C . ArrayList
D . StringBuffer
E . Properties

解析：
A选项：Vector相当于一个线程安全的List
B选项：HashMap是非线程安全的，其对应的线程安全类是HashTable
C选项：Arraylist是非线程安全的，其对应的线程安全类是Vector
D选项：StringBuffer是线程安全的，相当于一个线程安全的StringBuilder
E选项：Properties实现了Map接口，是线程安全的

24.给出下面的代码段:在代码说明// assignment x=a, y=b处写入如下哪几个代码是正确的？（）

public class Base{
	int w, x, y ,z;
	public Base(int a,int b)
	{
		x=a; y=b;
	}
	public Base(int a, int b, int c, int d)
	{
		// assignment x=a, y=b
		w=d;z=c;
	}
}

解析：
A选项：调用Base这个构造方法应该这样 new Base(a,b)
B选项：和C相比应该是分号不是逗号，帅的一塌糊涂
C选项：正常赋值操作
D选项：调用本类的构造方法

25.在java中，无论在何处调用，使用静态属性必须以类名做前缀。（×）

解析：
如果是本类使用，可以直接就用静态变量名。
如果是其他类使用，可以使用类名来调用，也可以创建一个实例对象来调用。
如果静态变量所在的类是静态类，那么不管在本类里或者在其他外部类，都可以直接使用静态变量名。

26.关于Java以下描述正确的有(A)

A . native关键字表名修饰的方法是由其它非Java语言编写的
B . 能够出现在import语句前的只有注释语句
C . 接口中定义的方法只能是public
D . 构造方法只能被修饰为public或者default

解析：
A：native是由调用本地方法库（如操作系统底层函数），可以由C，C++实现。
B：import是用于导包语句，其前面可以出现package，用来声明包的。
C：接口方法的修饰符可以是：public，abstract，default，static（后两者需要有{}。
D：构造方法可以用private，protected，default，private。

27.以下哪些方法是Object类中的方法（A B C D）

A . clone()
B . toString()
C . wait()
D . finalize()

解析：

28.character流和byte流的区别不包括（A B D）

A . 每次读入的字节数不同
B . 前者带有缓冲，后者没有。
C . 前者是字符读入，后者是字节读入。
D . 二者没有区别，可以互换。

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

29.下列关于Java并发的说法中正确的是（B）

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

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

30.以下代码段执行后的输出结果为（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);
		}
	}
}

解析：
执行顺序为：
输出try里面的初始temp：1；
temp=2；
保存return里面temp的值：2；
执行finally的语句temp：3，输出temp：3；
返回try中的return语句，返回存在里面的temp的值：2；
输出temp：2。

31.下面哪些具体实现类可以用于存储键，值对，并且方法调用提供了基本的多线程安全支持：(A E)

A . java.util.ConcurrentHashMap
B . java.util.Map
C . java.util.TreeMap
D . java.util.SortMap
E . java.util.Hashtable
F . java.util.HashMap

解析：
线程安全的类有Hashtable，concurrentHashMap，synchronizedMap。

32.下列程序执行后结果为( )

class A {
    public int func1(int a, int b) {
        return a - b;
    }
}
class B extends A {
    public int func1(int a, int b) {
        return a + b;
    }
}
public class ChildClass {
    public static void main(String[] args) {
    A a = new B();
    B b = new B();
    System.out.println("Result=" + a.func1(100, 50));
    System.out.println("Result=" + b.func1(100, 50));
    }
}

A . Result=150Result=150
B . Result=100Result=100
C . Result=100Result=150
D . Result=150Result=100

解析：
不论向上或者向下转型，都是一句话，“编译看左边，运行看右边”。也就是编译时候，会看左边引用类型是否能正确编译通过，运行的时候是调用右边的对象的方法。

33.Java中基本的编程单元为：（A）

A . 类
B . 函数
C . 变量
D . 数据

解析：
java的基本编程单元是类，基本存储单元是变量。

34.Java 的屏幕坐标是以像素为单位，容器的左下角被确定为坐标的起点。（×）

解析：容器的左上角被确定为坐标的起点

35.关于java中的数组，下面的一些描述，哪些描述是准确的：（A C F）

A . 数组是一个对象，不同类型的数组具有不同的类
B . 数组长度是可以动态调整的
C . 数组是一个连续的存储结构
D . 一个固定长度的数组可类似这样定义：int array[100]
E . 两个数组用equals方法比较时，会逐个便利其中的元素，对每个元素进行比较
F . 可以二维数组，且可以有多维数组，都是在java中合法的。

解析：
D：在java 中，声明一个数组时，不能直接限定数组长度，只有在创建实例化对象时，才能对给定数组长度。
E：数组没有重写equals，所以还是使用的object的equals。相当于“==”。

36.变量a是一个64位有符号的整数，初始值用16进制表示为：0Xf000000000000000； 变量b是一个64位有符号的整数，初始值用16进制表示为：0x7FFFFFFFFFFFFFFF。 则a-b的结果用10进制表示为多少？（C）

A . 1
B . -(2^62 + 2^61 + 2^60 + 1)
C . 2^62 + 2^61 + 2^60 + 1
D . 2^59 + (2^55 + 2^54 + … + 2^2 + 2^1 + 2^0)

解析：
0Xf000000000000000补码为1111000000000000000000000000000000000000000000000000000000000000
0x7FFFFFFFFFFFFFFF补码为0111111111111111111111111111111111111111111111111111111111111111
a-b=a+(-b)=
1111000000000000000000000000000000000000000000000000000000000000+1000000000000000000000000000000000000000000000000000000000000001=10111000000000000000000000000000000000000000000000000000000000001(高位溢出舍去)
则结果为0111000000000000000000000000000000000000000000000000000000000001=2^62 + 2^61 + 2^60 + 1
答案为C

37.抽象类方法的访问权限默认都是public。（×）

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

38.下面哪个行为被打断不会导致InterruptedException：（E）？

A . Thread.join
B . Thread.sleep
C . Object.wait
D . CyclicBarrier.await
E . Thread.suspend

39.关于异常的编程，以下描述错误的是：（A）

A . 在有除法存在的代码处，为了防止分母为零，必须抛出并捕获异常
B . int i=Integer.parseInt(”123a”);将产生NumberFormatException
C . int a[]=null; a[0]=1; 将产生NullPointerException
D . 输入输出流编程中，读和写时都要抛出IOException

解析：
异常分为运行时异常，非运行时异常和error，其中error是系统异常，只能重启系统解决。非运行时异常需要我们自己补获，而运行异常是程序运行时由虚拟机帮助我们补获，运行时异常包括数组的溢出，内存的溢出空指针，分母为0等。

40.下面有关java基本类型的默认值和取值范围，说法错误的是？（C）

A . 字节型的类型默认值是0，取值范围是-2^7— 2^7-1
B . boolean类型默认值是false，取值范围是true\false
C . 字符型类型默认是0，取值范围是-2^15 —2^15-1
D . long类型默认是0，取值范围是-2^63— 2^63-1

字符型类型默认是‘ \u0000′ ，取值范围是 0—2^16-1

41.根据以下代码段，下列说法中正确的是©。

public class Parent {
    private void m1(){}
    void m2(){}
    protected void m3(){}
    public static void m4(){}
}

A . 子类中一定能够继承和覆盖Parent类的m1方法
B . 子类中一定能够继承和覆盖Parent类的m2方法
C . 子类中一定能够继承和覆盖Parent类的m3方法
D . 子类中一定能够继承和覆盖Parent类的m4方法

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

42.以下哪个区域不属于新生代？（C)

A . eden区
B . from区
C . 元数据区
D . to区

解析：
在 Java 中，堆被划分成两个不同的区域：新生代 ( Young )、老年代 ( Old )。新生代 ( Young ) 又被划分为三个区域：Eden、From Survivor、To Survivor。

43.关于Java以下描述正确的有(CD)

A . Class类是Object类的超类
B . Object类是一个final类
C . String类是一个final类
D . Class类可以装载其它类

解析：
A：
class类是Object的派生类
B：每个类都使用Object类作为超类，而final修饰的类不能被继承
C：
D：Class类中的forName()方法返回与带有给定字符串名的类或接口相关联的Class对象（装载其他类）

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

A . (float)-8.0
B . (long)-9
C . (long)-8
D . (double)-9.0

解析：

floor: 求小于参数的最大整数。返回double类型
例如：Math.floor(-4.2) = -5.0
ceil: 求大于参数的最小整数。返回double类型
例如：Math.ceil(5.6) = 6.0
round: 对小数进行四舍五入后的结果。返回int类型
例如：Math.round(-4.6) = -5

45.已知如下类定义：如下哪句可以正确地加入子类中？（D）

class Base {  
 public Base (){ 
 //... 
 }  
 public Base ( int m ){ 
 //... 
 }  
 public void fun( int n ){ 
 //... 
 } 
}  
public class Child extends Base{  
 // member methods  
}  

A . private void fun( int n ){ //…}
B . void fun ( int n ){ //… }
C . protected void fun ( int n ) { //… }
D . public void fun ( int n ) { //… }

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

46.下列关于异常处理的描述中，错误的是(D)。

A . 程序运行时异常由Java虚拟机自动进行处理
B . 使用try-catch-finally语句捕获异常
C . 可使用throw语句抛出异常
D . 捕获到的异常只能在当前方法中处理，不能在其他方法中处理

解析：
捕获到的异常不仅可以在当前方法中处理，还可以将异常抛给调用它的上一级方法来处理。

47.JAVA中，下列语句哪一个正确（C）

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

解析：
A：省略构造函数,编译器会自动生成。
D：构造函数可以重载
B：方法是可以和类名同名的，和构造方法唯一的区别就是，构造方法没有返回值。

48.下面哪些情况下需要使用抽象类？（A B D）

A . 当一个类的一个或多个方法是抽象方法时
B . 当类是一个抽象类的子类，并且不能为任何抽象方法提供任何实现细节或方法体时
C . 当一个类实现多个接口时
D . 当一个类实现一个接口，并且不能为任何抽象方法提供实现细节或方法体时

解析：
A项 一个类中有抽象方法则必须申明为抽象类
B项 抽象类中的抽象方法必须由其子类实现，若子类不能实现则子类也必须定义为抽象类
D项 一个类实现一个接口就必须实现其中所有的抽象方法，若该实现类不能实现接口中的所有方法则实现类定义为抽象类

49.下面的类哪些可以处理Unicode字符?（A B C）

A . InputStreamReader
B . BufferedReader
C . Writer
D . PipedInputStream

解析：
字符流是字节流根据字节流所要求的编码集解析获得的
可以理解为字符流=字节流+编码集
所以本题中和字符流有关的类都拥有操作编码集(unicode)的能力。
字节流：
InputStream
|-- FileInputStream (基本文件流）
|-- BufferedInputStream
|-- DataInputStream
|-- ObjectInputStream
字符流：
Reader
|-- InputStreamReader (byte->char 桥梁）
|-- BufferedReader (常用）
Writer
|-- OutputStreamWriter (char->byte 桥梁）
|-- BufferedWriter
|-- PrintWriter （常用）

50.下列描述正确的是（A C）？

A . 类不可以多继承而接口可以多实现
B . 抽象类自身可以定义成员而接口不可以
C . 抽象类和接口都不能被实例化
D . 一个类可以有多个基类和多个基接口

解析：
java支持单继承，却可以实现多个接口。A对D错
接口没有构造方法，所以不能实例化，抽象类有构造方法，但是不是用来实例化的，是用来初始化的。C对
抽象类可以定义普通成员变量而接口不可以，但是抽象类和接口都可以定义静态成员变量，只是接口的静态成员变量要用static final public 来修饰。B错