1️⃣ 综合测试二

下面( )不属于面向对象的特点。
A. 封装
B. 转型
C. 继承
D. 多态
下面关于类与对象的描述正确的是( )。
A. 任何情况下必须先有类再有对象，对象只能够调用类中定义的方法，不能够调用属性
B. “class”关键字可以定义类，并且要求文件名称与类名称完全一致，否则程序将无法编译通过
C. 一个类可以产生多个对象，通过关键字 new 实例化的每个对象都将拥有属于自己的堆内存空间
D. 对象一旦开辟之后即使不再使用了，也会一直占据内存空间不释放
下面 ( ) 权限定义不属于Java。
A. public
B. private
C. friend
D. protected
关于构造方法的描述正确的是( )。
A. 构造方法在使用关键字 new 实例化对象时会自动进行调用
B. 一个类中可以没有任何构造方法的定义
C. 构造方法不会有返回值，所以需要使用 void 进行声明
D. 构造方法在进行重载时，方法名称可以不同
下面关于String类的特点描述正确的一项是( )。
A. String 类在需要时可以定义子类
B. String 类的对象内容一旦声明则不可改变
C. String 类可以直接利用“==”进行字符串内容的比较
D. String 类对象实例化后都会自动存入字符串对象池
下列 ( ) 不属于面向对象程序设计的基本要素。
A. 类
B. 对象
C. 方法
D. 安全

下列程序的执行结果是( )。

public class TestDemo {
	public void fun(){
		static int i=0;
		i++;
		System.out.println();
	}
	public static void main(String args[]){
		Demo d =new Demo();
		d.fun();
	}
}

A. 编译错误
B. 0
C. 1
D. 运行成功，但不输出

顺序执行下列程序语句后，则 b 的值是( )。
```
String  str  ="Hello";
String  b  =  str.substring(0,2);
```
A. Hello
B. hello
C. He
D. null
不能直接使用 new 创建对象的类是( )。
A. 静态类
B. 抽象类
C. 最终类
D. 公有类
为类定义多个名称相同、但参数的类型或个数不同的方法的做法称为( )。
A. 方法重载
B. 方法覆写
C. 方法继承
D. 方法重用
定义接口的关键字是( )。
A. extends
B. class
C. interface
D. public
现在有两个类A、B, 以下描述中表示B 继承自A 的是( )。
A. class A extends B
B. class B implements A
C. class A implements
D. class B extends A
下面关于子类调用父类构造方法的描述正确的是( )。
A. 子类定义了自己的构造方法，就不会调用父类的构造方法
B. 子类必须通过 super关键字调用父类有参的构造方法
C. 如果子类的构造方法没有通过 super 调用父类的构造方法，那么子类会先调用父类中无参构造方法，之后再调用子类自己的构造方法
D. 创建子类对象时，先调用子类自己的构造方法，让后再调用父类的构造方法
假设类X 是类Y 的父类，下列声明对象x 的语句中不正确的是( )。
A. X x = new X();
B. X x = new Y();
C. Y x = new Y();
D. Y x = new X();

编译并运行下面的程序，程序的执行结果是( )。

public class A {
	public static void main(String args[]){
		B b = new B();
		b.test();
	}
	void test(){
		System.out.print("A");
	}
}
class B extends A{
	void test(){
		super.test();
		System.out.println("B");
	}
}

A. 产生编译错误
B. 代码可以编译运行，并输出结果： AB
C. 代码可以编译运行，但没有输出
D. 编译没有错误，但会运行时会产生异常

编译运行下面的程序，程序的运行结果是( )。
```
public class A{
	public static void main(String args[]){
		B b=new B();
		b.test();
	}
	public void test(){
		System.out.print("A");
	}
}
class B extends A{
	void test(){
		super.test();
		System.out.println("B");
	}
}
```
A. 产生编译错误，因为类B 覆盖类A 的方法test)时，降低了其访问控制的级别
B. 代码可以编译运行，并输出结果：AB
C. 代码可以编译运行，但没有输出
D. 代码可以编译运行，并输出结果：A
下面( ) 修饰符所定义的方法必须被子类所覆写。
A. final
B. abstract
C. static
D. interface
下面( )修饰符所定义的方法不能被子类所覆写。
A. final
B. abstract
C. static
D. interface

下面的程序编译运行的结果是( ) 。

public class A implements B{
	public static void main(String args[]){
		int m,n;
		A a = new A();
		m = a.K;
		n = B.K;
		System.out.println(m+","+n);
	}	
}

interface B{
	int K=5;
}

A. 5,5
B. 0,5
C. 0,0
D. 编译程序产生编译结果

下面关于接口的说法中不正确的是( )。
A. 接口所有的方法都是抽象的
B. 接口所有的方法一定都是 public类型
C. 用于定义接口的关键字是 implements
D. 接口是Java 中的特殊类，包含全局常量和抽象方法
下面关于Java 的说法不正确的是( )。
A. abstract和 final能同时修饰一个类
B. 抽象类不光可以做父类，也可以做子类
C. 抽象方法不一定声明在抽象类中，也可以在接口中
D. 声明为 final的方法不能在子类中覆写
下面关于 this与 super 的区别描述错误的是( )。
A. this和 super 都可以调用类中的属性、方法、构造方法
B. this表示本类实例化对象，而 super 表示父类实例化对象
C. 使用 “this.属性”或者 “this.方法() ”时都会先从本类查找方法，如果本类没有定义，则通过父类查找
D. 子类可以利用 “super.方法()”调用父类方法，这样可以避免覆写父类方法时所产生的递归调用问题
使用 ( )关键字可以在程序中手工抛出异常。
A. throws
B. throw
C. assert
D. class
下面 ( )关键字可以用在方法的声明处。
A. throws
B. assert
C. class
D. interface
为了捕获一个异常，代码必须放在下面( )语句块中。
A. try
B. catch
C. throws
D. finally
下面关于try 块的描述正确的一项是( )。
A. try块后至少应有一个catch 块
B. try 块后必须有 finally 块
C. 可能抛出异常的方法应放在try块中
D. 对抛出的异常的处理应放在try 块中
下面关于 finally块中的代码的执行，描述正确的是( )。
A. 总是被执行
B. 如果 try 块后面没有 catch块时， finally块中的代码才会执行
C. 异常发生时才被执行
D. 异常没有发生时才执行
一个异常将终止( )。
A. 整个程序
B. 只终止抛出异常的方法
C. 产生异常的 try块
D. 上面的说法都不对
所有程序可处理异常的共同父类是( )。
A. Error
B. Exception
C. Throwable
D. RuntimeException
String 和 Object 类在 ( )包中定义的。
A. java.lang
B. java.util
C. java.net
D. java.sql
下面 ( ) 权限是同一包可以访问，不同包的子类可以访问，不同包的非子类不可以访问。
A. private
B. default
C. protected
D. public
下列说法正确的一项是( )。
A. java.lang.Integer 是接口
B. String 定义在java.util包中
C. Double 类在 java.lang 包中
D. Double类在java.lang.Object 包中
下列关于包、类和源文件的描述中，不正确的一项是( )。
A. 一个包可以包含多个类
B. 一个源文件中，只能有一个 public class
C. 属于同一个包的类在默认情况不可以互相访问，必须使用 import 导入
D. 系统不会为源文件创建默认的包
定义类时不可能用到的关键字是( )。
A. final
B. public
C. protected
D. static
下面关于泛型的描述中错误的一项是( )。
A. “? extends 类” 表示设置泛型上限
B. “? super 类” 表示设置泛型下限
C. 利用“?”通配符可以接收全部的泛型类型实例，但却不可修改泛型属性内容
D. 如果类在定义时使用了泛型，则在实例化类对象时需要设置相应的泛型类型，否则程序将无法编译通过
下面关于枚举的描述正确的一项是( )。
A. 枚举中定义的每一个枚举项其类型都是String
B. 在 Java 中可以直接继承 java.util.Enum类实现枚举类的定义
C. 利用枚举类中的 values()方法可以取得全部的枚举项
D. 枚举中定义的构造方法只能够使用private权限声明
下面( ) Annotation 不是Java 内建的 Annotation。
A. @Override
B. @Deprecated
C. @SuppressWarning
D. @Functionallnterface
关于Java8 中提供的四个核心函数式接口的描述，正确的一项是( )。
A. Predicate 接口中的方法不能够返回数据，只能够接收并操作数据
B. Consumer 接口中的方法可以对数据进行判断，并且可以返回判断结果
C. Function 接口中的方法可以接收参数，并且将数据处理后返回
D. Supplier 接口中的方法可以接收基本数据类型参数，但是没有返回值
关于Java 的异常处理中，错误的是( )。
A. Java 中用户可以处理的异常都是Exception 的子类
B. Java 中出现异常时，可以利用 try 进行捕获
C. Java 中产生异常代码时，如果没有异常处理，则会由系统处理异常，而后让程序正常执行完毕
D. 一个 try语句后面可以跟多个 catch块，也可以只跟一个 finally 语句块
下面对于多态性的描述，错误的一项是( )。
A. 面向对象多态性描述的就是对象转型的操作
B. 对象可以自动实现向上转型
C. 对象的向下转型需要强制转型
D. 可以利用 instanceOf 方法判断某一个对象是否属于某个类的实例
为 Demo 类的一个无形式参数无返回值的方法 method 书写方法头，使得使用类名 Demo 作为前缀就可以调用它，该方法头的形式为( )。
A. static void method()
B. public void method()
C. final void method()
D. abstract void method()

下面代码会存在什么问题? ( )

public class MyClass {
	public static void main(String arguments[]){
		amethod(arguments);
	}
	public void amethod(String[] arguments){
		System.out.println(arguments);
		System.out.println(arguments[1]);
	}
}

A. 错误， void amethod()不是static类型
B. 错误，main() 方法不正确
C. 错误，数组必须导入参数
D. 方法 amethod () 必须用String 类型描述

当编译下列代码可能会输出( )。

class TestDemo{
	static int i;
	public static void main(String args[]){
		System.out.println(i);
	}
}

A. Error Variable i may not have been initialized
B. null
C. 1
D. 0

如果试图编译并运行下列代码可能会打印输出( )。

...
int i=9;
switch(i){
	default:
		System.out.println("'default");
	case 0:
		System.out.println("zero");
		break;
	case 1:
		System.out.println("one");
	case 2:
		System.out.println("two");
...

A. default
B. default, zero
C. error default clause not defined
D. no output displayed

在一个类文件中，导入包、类和打包的排列顺序是( )。
A. package 、import 、class
B. class 、import 、package
C. import 、package 、class
D. package 、class 、import

现在有如下一段程序：

class Demo{
	public static void main(String args[]){
		float [][] f1 = {{1.2f,2.3f},{4.5f,5.6f}};
		Object oo =f1;
		f1[1]=oo;
		System.out.printIn("Best Wishes "+f1[1);
	}
}

该程序会出现的效果是( )。
A. {4.5,5.6}
B. 4.5
C. compilation error in line NO.5
D. exception

现在有如下一段程序：

class super  {
	String name;
	public super(String name){
		this.name = name;
	}
	public void fun1(){
		System.out.println("this is class super !"+name);
	}
}

class sub extends super  {
	public void fun1(){
		System.out.println("this is class sub !"+name);
	}
}

class Test {
	public static void main(String args[]){
		super s = new sub();
	}
}

运行上面的程序可能会出现的结果是( )。

A. this is class super !
B. this is class sub !
C. 编译时出错
D. 运行时出错

当试图编译和运行下面代码可能会发生( )。

class Base  {
	private void amethod(int iBase){
		System.out.println("Base.amethod");
	}
}

class Over extends Base  {
	public static void main(String args[]){
		Over o = new Over();
		int iBase=0;
		o.amethod(iBase);
	}
	public void amethod(int iOver)(
		System.out.println("Over.amethod");
	}
}

A. Compile time error complaining that Base.amethod is private
B. Runntime error complaining that Base.amethod is private
C. Output of Base.amethod
D. Output of Over.amethod

如要在字符串s ( 内容为 “welcome to mldn!!”),中，发现字符’t 的位置，应该使用下面 ( )方法。
A. mid(2,s)
B. charAt(2)
C. s.indexOf(‘t’)
D. indexOf(s,‘v’)

现在有如下一段代码：

public class Test {
	public int aMethod(){
		static int i=0;
		j++;
		return i;
	}
	public static void main(String args[]){
		Test test = new Test();
		test.aMethod();
		int j = test.aMethod();
		System.out.println(j);
	}
}

将产生的结果是( )。
A. Compilation will fail
B. Compilation will succeed and the program will print“0”
C. Compilation will succeed and the program will print“1”
D. Compilation will succeed and the program will print“2”