第一阶段学习测试

逐梦

一、单选题

1、对于下列代码，结果正确的是：

public class Text {
	public static void main(String[] args) {
		System.out.println(m());
	}
	@SuppressWarnings("finally")
	public static Person m() {
		Person p = new Person();
		try {
			p.setName("Amy");
			p.setAge(15);
		} catch (Exception e) {
			p.setName("Sam");
			p.setAge(12);
			return p;
		} finally {
			p = new Person();
			p.setName("Tom");
			p.setAge(13);
		}
	}
}
class Person {
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return name + " " + age;
	}
}

A.Tom 13
B.Sam 12
C.运行错误
D.编译错误
【正确答案】D
【答案解析】方法需要返回值，但是try块以及finally块里都没有return，如果try块没有异常那就不会·走catch块里，就有可能没有返回值
2、关于下列代码说法正确的是？

byte b1 = 1, b2 = 2, b3, b6;
		final byte b4 = 4, b5 = 6;
		b6 = b4 + b5;
		b3 = (b1 + b2);
		System.out.println(b3 + b6);

A.运行期抛出异常
B.输出结果：13
C.语句：b6=b4+b5编译出错
D.语句：b3=b1+b2编译出错
【正确答案】D
【答案解析】b4和b5都是最终值，值一直都是byte类型值所以求和之后仍然还是byte类型值所以可以直接赋值给b6
3、以下代码的运行结果正确的是（）

public static void main(String[] args) {
	byte a;
	int b, c, d;
	a = 5;
	b = a += a -= a *= a++;
	c = b *= b += b += --b;
	d = c + 2;
	System.out.println(d > b ? a : c);
}

A.-15
B.15
C.100
D.35
【正确答案】A
【答案解析】进行连等赋值时需要进行展开先把最右边值计算才能传值给左边，a++的值是5和左边的5进行相乘为25，再和左边的5进行求差为-20，再和左边的5进行求和最后b的值为-15。同理可得–b为-16和左边的-15进行求和为-31，再和左边的-15进行求和为-46再和左边的-15进行相乘最后c的值为690再加上2为d的值。d比b大最后三目返回的是a的值为-15
4、对于代码的运行结果是：

 `public class Test {
  public static void main(String[] args) { 
  String str = new String("abc");
   twice(str);
    System.out.println(str);
     } 
     pubilc static String twice(String str) {
      return str += new StringBuilder(str).reverse(); 
      }
}`

A.abc
B.abcabc
C.cba
D.abccba
E.cbaabc
【正确答案】A
【答案解析】实参是引用数据类型传递的是地址值的拷贝，所以方法执行完之后不会原结果
5、一下程序的输出结果是：

public class CodeDemo {
	public static void main(String[] args) {
		new SB();
	}
}
class SA {
	D d;
	static {
		System.out.println("D2");
	}
	{
		System.out.println("C3");
		d = new D();
	}
	public SA() {
		System.out.println("D1");
	}
}
class SB extends SA {
	static C c = new C();
	static {
		System.out.println("A1");
	}
	{
		System.out.println("B2");
	}
	public SB() {
		System.out.println("D");
	}
}
class C {
	public C() {
		System.out.println("A2");
	}
}
class D extends C {
	public D() {
		System.out.println("A3");
	}
}

A.A1 C B1 A2 C D A3 B2 B3
B.D2 A2 A1 C3 A2 A3 D1 B2 D
C.D2 A2 A1 C3 D D1 A3 B2 A2
D.D2 A2 A1 C3 A3 A2 D1 B2 D
【正确答案】B
【答案解析】当创建子类对象时，需要先加载父类静态信息、子类静态信息、父类对象级别信息、子类对象级别信息。父类静态信息只有静态代码块所有输出D2，子类静态信息包括静态属性和静态代码块依次加载所以输出A2、A1。子类对象级别信息包括构造代码块和构造方法依次执行（构造代码块要输出C3之后需要再雄黄酒D类对象，还要接着输出A2，A3）C3 A2 A3 D1，之后再执行子类对象级别输出B2 D
6、下列Java代码输出的结果是 ：

public class T14 {
	public static void main(String[] args) {
		int[] ary1 = { 3, 4, 5 };
		int[] ary2 = { 3, 4 };
		int[] ary3 = f(ary1, ary2);
		System.out.println(Arrays.toString(ary3));
	}
	public static int[] f(int[] ary1, int[] ary2) {
		int[] ary = Arrays.copyOf(ary1, ary1.length + ary2.length);
		System.arraycopy(ary2, 0, ary, ary1.length, ary2.length);
		return ary;
	}
}

A.[3, 4, 5]
B.[3, 4, 5, 0, 0]
C.[3, 4, 5, 3, 4]
D.[3, 4, 3, 4, 5]
【正确答案】C
【答案解析】第一次数组扩容是让ary指向前面数值是ary1的值长度为5的新数组。第二次扩容是把ary2里的值从ary1值后继续赋值
7、下列语句的输出结果是:（）

System.out.println(5+7+'I'+"tarena"+5+7);

A.84tarena57
B.57tarena12
C.57tarena57
D.85tarena57
【正确答案】D
【答案解析】代码从右往左依次执行，5和7进行求和，遇见字符需要把字符转成对应的编码值进行求和最后的结果是85，再和字符串直接量以及后面的所有内容进行拼接
8、对于代码:

public class Test {
	public static void main(String[] args) {
		Person p = new Person();
		p.name = "Sam";
		p.age = 16;
		m(p);
		System.out.println(p);
	}
	public static Person m(Person p) {
		try {
			p.name = "Amy";
			p.age = 18;
			throw new NullPointerException();
		} catch (Exception e) {
			p.name = "Tom";
			p.age = 20;
			return p;
		} finally {
			p = new Person();
			p.name = "Jack";
			p.age = 22;
		}
	}
}
class Person {
	String name;
	int age;
	@Override
	public String toString() {
		return "Person [name = " + name + ", age = " + age + "]";
	}
}

的输出结果是
A.Person[name = Sam, age = 16]
B.Person[name = Amy, age = 18]
C.Person[name = Tom, age = 20]
D.Person[name = Jack, age = 22]
【正确答案】C
【答案解析】执行try块里内容抛出异常被catch块捕获此时执行到return语句，检测到有finally块需要把p的地址值进行挂起，执行finally块里内容，这个里内容执行完没有影响原p对象的内容，所以最后返回时还是返回的catch块里的对象以及属性值
9、当下面程序运行到第五行的时候i和j分别是多少

public class test{ 
	public static void main (String args[]){ 
		int i＝0×FFFFFFF1; 
		int j＝~i; 
	} 
}

A.i为-15 j为14
B.i为-14 j为15
C.编译异常
D.运行异常
【正确答案】A
【答案解析】0xfffffff1是十六进制的补码形式，每个f转变成二进制都是4个1，所以转成二进制的形式就是前面28位都是1中间3位是0最后1位是1，想要得到i的值需要把补码转成原码，最后就是-15。j按位取反就是前28位都是0中间3位是1最后一位是0最后结果就是14
10、下列各项关于抽象类的说法正确的是
A.含有抽象方法的类必须声明为抽象类
B.抽象类中必然含有抽象方法
C.抽象类可以被实例化
D.抽象类中没有构造方法
【正确答案】A
【答案解析】抽象类中不一定含有抽象方法，含有构造方法但是不能创建对象
11、对于代码：

package cn.tedu.test1 ;
public class A{
	int age;
}
package cn.tedu.test2  ;
public  class  C{
public static void main(String[] args) {
	B b=new B();
	b.clone();  //1
}
}
class B extends A{
	int age;
	public void test1(){
		A a=new B();
		a.clone();  //2
		B b=new B();
		b.clone(); //3
	}
}

编译报错的行号是？
A.1,2,3
B.2,3
C.1,2
D.1,3
【正确答案】C
【答案解析】Clone方法被protected修饰在Object类中与ABC三个类不在一个包但是有父子关系，如果想要调用到clone方法需要保证子类对象在子类的本类中使用，1和2都不是
12、对于代码：

public class Text { 
public static void main(String[] args) { 
	System.out.println(m()); 
} 
public static Person m() {
 Person p = new Person(); 
	try {
	  p.setName("Amy"); p.setAge(15); return p; 
	 } catch (Exception e) { 
	  p.setName("Sam"); 
	  p.setAge(12); return p; 
	 } finally { 
	  p.setName("Tom"); 
	  p.setAge(13); 
	 throw new NullPointerException(); 
	  } 
	} 
} 
class Person { 
private String name; 
private int age; 
public String getName() {
 return name; 
 } 
 public void setName(String name) {
  this.name = name; 
  } public int getAge() {
   return age; 
   } 
public void setAge(int age) {
   this.age = age; 
} 
@Override 
public String toString() {
 return name + " " + age; 
   } 
}

A.Amy 15
B.Sam 12
C.Tom 13
D.编译错误
E.运行错误
【正确答案】E
【答案解析】finally是在try以及catch的后面执行而且必须执行，当在finally里抛出异常就没有catch能够捕获
13、ArrayList list = new ArrayList(20);中的list扩充几次？
A.0
B.1
C.2
D.3
【正确答案】A
【答案解析】可以指定Arraylist初始容量，所以没有扩容
14、下列关于File的说法正确的是
A.File file=new File(“D:\a.txt”);是在D盘下创建一个a.txt文件
B.可以通过mkdirs()方法创建多个文件
C.当调用getPath()方法的时候，会去计算机中检查 该文件是否存在
D.可以通过isFile()方法判断该File对象是否是一个文件对象
【正确答案】D
【答案解析】创建File对象只是指明有一个路径但是不会去检查路径是否存在。mkdirs方法是可以创建多个目录。getPath方法返回的是路径名
15、关于final关键字，下面说法正确的是？
A.final关键字如果用于修饰成员变量，那么该成员变量必须初始化
B.final关键字修饰的类只能被继承一次
C.final关键字修饰的方法可以被重写
D.final关键字如果用于修饰方法，该方法所在的类不能被继承
【正确答案】A
【答案解析】final修饰的方法不能被重写不会影响所在的类。修饰类时不能被继承
16、关于以下程序的说明，正确的是（）

1．class   StaticStuff 2．{ 
	3．static  int  x=10； 
	4．static  { x+=5；} 
	5．public  static  void  main（String  args[ ]） 6．{
	7．	System.out.println("x=" + x); 
	8．}
	9．static{ 
		x/=3;
	} 
10.}

A.4行与9行不能通过编译，因为缺少方法名和返回类型
B.9行不能通过编译，因为只能有一个静态初始化器
C.编译通过，执行结果为：x=5
D.编译通过，执行结果为：x=3
【正确答案】C
【答案解析】按照静态信息出现先后顺序依次进行加载执行，先加载静态属性为10，在执行静态代码块加5为15，最后再执行一个静态代码块进行除3最后结果为5
17、下列的运行结果为( )

public class StaticExam {
	public static void main(String[] args) {
		System.out.println(SEDemo.i);
		System.out.println(new SEDemo().j);
	}
}
class SEDemo {
	public static int i = 6;
	public static SEDemo s = new SEDemo();
	public int j;

	public SEDemo() {
		i--;
		j--;
	}
}

A.6，0
B.6，-1
C.5，0
D.5，-1
【正确答案】D
【答案解析】当SEDemo.i时，需要加载整个类，类的静态信息也需要加载，静态属性i赋值为6，静态属性s也需要进行赋值就需要创建本类对象一次所以需要去执行构造方法i–为5。当new SEDemo().j时静态信息以及加载完成直接执行属性j初始值为0，再去调用构造方法j–为-1
18、下面的方法将返回？

public static int func() {
		int i = 2;
		try {
			return i++;
		} catch (Exception e) {
			return i++;
		} finally {
			i++;
		}
	}

A.1
B.2
C.3
D.编译错误
【正确答案】B
【答案解析】try块里在执行return 2时发现有finally就会把值和状态都要挂起，所以执行完finally接着执行挂起的内容所以最后返回2
19、下列关于增强for循环说法不正确的是
A.增强for循环只能遍历，不能修改
B.增强for循环底层是用迭代器实现的
C.增强for循环不能遍历数组
D.增强for循环可以遍历集合
【正确答案】C
【答案解析】可以遍历数组
20、以下关于static的说法正确的是？
A.static不能修饰类的构造函数
B.static修饰类的时候，该类不可以被继承
C.static修饰类方法的时候，该方法可以访问类中的final变量
D.static变量可以和成员变量同名
【正确答案】A
【答案解析】Static修饰的类是内部类也可以被继承。静态方法不能使用final不同级。Static修饰的变量就是之前的成员变量
21、下列选项中关于 java 中 super 关键字的说法错误的是。
A.super 关键字是在子类对象内部指代其父类对象的引用
B.super 关键字不仅可以指代子类的直接父类，还可以指代父类的父类
C.子类可以通过 super 关键字调用父类的方法
D.子类可以通过 super 关键字调用父类的属性
【正确答案】B
【答案解析】Super只能指代父类对象
22、下列程序中出现了几处错误

abstract class A{ 
	abstract void f(){}; 
	public abstract void k(); 
} 
class B extends A{ 
	@Override protected void f() { 
	// TODO Auto-generated method stub
	 } 
	 @Override void k() { 
	 // TODO Auto-generated method stub 
	 } 
	 public static void main(String[] args){
		  A a=new A(); 
		  a.f(); 
		  a.k();
	 }
}

A.1
B.2
C.3
D.4
【正确答案】C
【答案解析】f()抽象方法不能有方法体。k()方法进行重写是修饰符需要是public。A类是抽象类没有对象
23、对于代码：

public class StaticExam { 
	public static void main(String[] args) { 
		System.out.println(new SE().i); 
		System.out.println(SEDemo.i); 
		System.out.println(SEDemo.j); 
	} 
} 
class SEDemo{ 
	public static SEDemo s=new SEDemo(); 
	public static int i=0; 
	public static int j; 
	public SEDemo(){ 
		i++; j++; 
	} 
} 
class SE{ 
{ 
	i=5; 
} 
	int i=1; 
	} 
}

输出结果依次为
A.5,0,1
B.5,1,1
C.1,0,1
D.1,1,1
【正确答案】C
【答案解析】笔记有详细解释
24、下列程序运行的结果是（ ）

interface InterfaceA {
	int MAX = 10;
}
class ClassA implements InterfaceA {
	int a = 1;
}
class ClassB extends ClassA {
	int b = 2;
}
public class E {
	public static void main(String[] args) {
		ClassB b = new ClassB();
		System.out.print(b.MAX);
		System.out.print(" " + ClassB.MAX);
		System.out.print(" " + ClassA.MAX);
		System.out.print(" " + InterfaceA.MAX);
	}
}

A.编译错误：MAX在类ClassB没有定义
B.编译错误：MAX不能通过对象名b来访问
C.编译错误：MAX不能通过接口名InterfaceA来访问
D.10 10 10 10
【正确答案】D
【答案解析】接口中的属性默认是被public、static、final共同修饰，而且A是接口实现类，B是A的子类，所以A类或者B类都可以直接类名点调用接口属性
25、给出以下代码运行结果

Collection<String> c = new ArrayList<>();
		c.add("ac");
		c.add("bdc");
		c.add("cac");
		c.add("dad");
		Stream<String> s = c.stream();
		s.filter(str -> str.matches(".*a.*")).filter(str -> str.endsWith("c")).forEach(str -> {
			c.remove(str);
			System.out.println(str);
			System.out.println(c);
			try {
				Thread.sleep(500);
			} catch (Exception e) {
				e.printStackTrace();
			}
		});

A.ac [bdc,cac,dad] cac [bdc,dad] NullPointerException
B.ac dbc cac [dbc]
C.ac [bdc,cac,dad] cac [bdc,dad]
D.NullPointerException
【正确答案】A
【答案解析】把包含a的元素进行筛选出来再根据以c结尾来进行过滤，剩下了ac和cac，根据ac和cac进行删除接着输出删除内容再输出新的剩下的元素，要删除2个所以要输出2次最后结果是ac [bdc,cac,dad] cac [bdc,dad]，最后又执行了一次删除但是此时没有元素了c的对象就是null再调用remove方法就出来空指针异常
26、对于Java中的集合类java.util.ArrayList，以下说法正确的是（）。
A.这个集合中的元素是无序的
B.可以通过键来获取这个集合中的元素
C.在对这个集合的元素执行遍历操作时，效率比较高
D.可以通过addFirst()方法，在列表的首部插入元素
【正确答案】C
【答案解析】Arraylist的底层依赖数组实现所以有序、没有键，addFirst是属于链表里的方法
27、下面程序的输出结果

public class TestLlan {
	static int test() {
		int x = 1;
		try {
			return x;
		} finally {
			++x;
		}
	}
	public static void main(String[] args) throws FileNotFoundException {
		System.out.println(TestLlan.test());
	}
}

A.1
B.0
C.编译异常
D.运行异常
【正确答案】A
【答案解析】finally块里内容一定会执行而且需要执行完毕，所有return 1一定能完整的执行结束就会把1的值进行返回
28、下面程序的输出结果

public class TestLlan {
	static int test() {
		int x = 1;
		try {
			return x;
		} finally {
			++x;
		}
	}
	public static void main(String[] args) throws FileNotFoundException {
		System.out.println(TestLlan.test());
	}
}

A.0
B.1
C.运行异常
D.编译异常
【正确答案】B
【答案解析】代码从上往下编译与执行,执行到x— return 1;代码执行到return语句时检测到了finally的存在就一定要执行会对return这个语句进行挂起（return 1 把值和返回的状态一起挂起）去执行finally，执行i+±–i=3，finally执行完毕把原来挂起的return语句再次执行
29、对于代码：

 public class Test {
	public static void main(String[] args) {
		int[] a = { 12, 20, 5, 16, 15, 1, 30, 45, 23, 9 };
		int start = 0;
		int end = a.length - 1;
		sort(a, start, end);
		for (int i = 0; i < a.length; i++) {
			System.out.println(a[i]);
		}
	}
	public static void sort(int[] a, int low, int high) {
		int start = low;
		int end = high;
		int key = a[low];
		while (end > start) {
			while (end > start && a[end] >= key)
				end--;
			if (a[end] <= key) {
				int temp = a[end];
				a[end] = a[start];
				a[start] = temp;
			}
			while (end > start && a[start] <= key)
				start++;
			if (a[start] >= key) {
				int temp = a[start];
				a[start] = a[end];
				a[end] = temp;
			}
		}
		if (start > low)
			sort(a, low, start - 1);
		if (end < high)
			sort(a, end + 1, high);
	}
}

实现的效果是
A.获取数组的最大值
B.获取数组的最小值
C.将数组降序排序
D.将数组升序排序
E.将数组扩为两倍
【正确答案】D
【答案解析】如果数组后面小于前面的就交换，前面大于了后面的也交换，最后就是按照升序进行排序
30、对于代码：

public void test(int[] arr) {
		int i, j, note;
		for (i = 1; i < arr.length; i++) {
			note = arr[i];
			j = i - 1;
			while (j >= 0 && note < arr[j]) {
				arr[j + 1] = arr[j];
				j--;
			}
			arr[j + 1] = note;
		}
	}

所实现的功能是
A.获取最大值
B.获取最小值
C.升序排序
D.降序排序
E.反转数组
【正确答案】C
【答案解析】如果后面的值比前面的小就把前面的值赋值给后面

二、多选题

31、对于代码：

package cn.tedu.test;
public class Demo{ 
	public static void main(String[] args){ 
		System.out.println("Test~~");
 	}
 }

下列说法正确的是：
A.可以通过javac Demo.java来编译这个java文件
B.可以通过javac -d . Demo.java来编译这个文件
C.可以通过java cn.tedu.test.Demo 来运行这段代码
D.可以通过java Demo.class来运行对应的class文件
E.可以通过javadoc Demo来运行这段代码
【正确答案】A,B,C
【答案解析】.class文件不能直接运行。Javadoc不是运行的命令
32、下列关于Lambda表达式说法正确的是
A.当一个接口中有多个抽象方法的时候，可以通过Lambda表达式来重写其中的方法
B.可以通过::来传递Arrays.sort()
C.由于Lambda表达式是表示重写某个抽象方法，因此参数列表不可省略
D.当Lambda表达式的函数体只有一句的时候，可以省略return不写
【正确答案】B,D
【答案解析】接口中只有一个抽象方法时才能使用Lambda表达式。::可以传递静态方法。只有一个参数而且全局只操作这一个参数时可以省略。只有一句时可以省略
33、给出以下代码，请问该程序的运行结果是什么？

class A{
	 private int x=0; 
	 static int y=1;
	 protected int z=2; 
} 
class B extends A{
	 void method(){
		 System.out.println(x); 
		 System.out.println(y); 
		 System.out.println(z); 
	} 
} 

下列说法正确的是（ ）
A.程序编译错误，因为类B不能访问变量x
B.程序编译成功，打印输出012。
C.程序编译错误，如果移走System.out.println(x)这条语句，可使编译程序通过。
D.程序编译错误,因为变量x未在类B中定义。
【正确答案】A,C,D
【答案解析】Private在父类中是私有属性子类访问不到
34、关于代码

public class Demo {
	int value;
	public static void main(String[] args) {
		Animal a = new Dog(); // 1
	}
}
interface tiger {
}
class Animal {
}
class Dog extends Animal {
}
class Cat extends Animal{}}}

可以填在1处编译没错运行有错的选项是？
A.Dog d=(Dog)a;
B.Cat c=(Cat)a;
C.Animal e=(Animal)a;
D.tiger t=(tiger)a;
【正确答案】B,C,D
【答案解析】给类传值时要求运行有错就是检测实际创建类不是一个。给接口传值运行报错不是实现类就行
35、在使用super和this关键字是，以下描述错误的是
A.在子类构造方法中使用super( )显式调用父类的构造方法，super( )必须写在子类构造方法的第一行，否则编译不通过
B.super( )和this( )不一定要放在构造方法内第一行
C.this( )和super( )可以同时出现在一个构造函数中
D.this( )和super( )可以在static环境中使用，包括static方法和static语句块
【正确答案】B,C,D
【答案解析】super语句和this语句均需放在构造方法首行，所以不能同时出现。两个语句都是对象级别的不能在静态信息里使用
36、下列各项中可以正确赋值的是：
A.byte=0b01111111;
B.short s=‘测’
C.float f=3000;
D.double d=0x3p2
E.int i=2e4;
【正确答案】A,B,C,D
【答案解析】2e4是属于科学计数法，只能小数是这样表示
37、下列方法中能和方法int max(int a, int b, double c)构成重载关系的是( )
A.private double max(int a, int b, double c)
B.void max(int a, double c, int b)
C.int max(double a, int b)
D.int max(int x, int y, double z)
【正确答案】B,C
【答案解析】方法名一致，参数列表不一致
38、下列各项中能正确编译运行的是
A.byte b=120+8;
B.char c=’d’;c++;
C.byte b=3;b*=2;
D.short s=’a’;s=s+5;
E.short s1=3,s2=6;short s=s1+s2;
【正确答案】B,C
【答案解析】扩展赋值运算符默认含有强制类型转换，BC两个选项都是
39、关于定义构造方法，下列说法正确的是
A.在类中声明构造函数时，名称应该与类名相同
B.具有重载特性，可以建立多个相同的名称
C.使用类建立新对象时，会自动执行构造函数，因此可以在构造函数内设定变量的初值或进行内存分配
D.构造函数没有返回值
【正确答案】A,B,C,D
【答案解析】构造方法是一个没有返回值、与类同名且可以支持重载的方法。创建对象必须调用构造方法所以可以进行属性初始化的操作
40、下列各项中对于正确赋值的是
A.byte b =‘a’;
B.short s = 2 << 5;
C.float f = -5;
D.float f = 3.2f / 1;
【正确答案】A,B,C,D
【答案解析】上述四种赋值都是正确赋值
41、下列关于java中的方法描述正确的是
A.Java中定义方法的格式是，修饰符 返回值类型 方法名(参数列表){方法体}
B.Java中的方法，如果有返回值，方法中必须有return语句
C.Java中定义方法，参数列表中必须有形参变量
D.Java中的方法，可以无限的被反复调用
【正确答案】A,B,D
【答案解析】方法可以没有参数
42、下列选项中 ，哪个可以使下列代码成功编译（）

class Super{ private int a; 
	//第2行 
	protected Super(int a) { 
	this.a=a; 
	} 
} 
public class Sub extends Super{ 
	public Sub(int a) {
	 super(a); 
	} 
	public Sub() {
	 this.a=5; 
	//第7行 
	} 
}

A.将第2行改为public int a
B.将第7行改为super(a)
C.将第2行改为int a
D.将第7行改为super(5)
E.将第7行改为this(5);
【正确答案】D,E
【答案解析】每个子类构造方法中都要默认调用父类的构造方法，此时父类只有有参构造，所以只有DE符合要求
43、下列判断结果为true的是（）
A.String str1=new String(“abc”); String str2=new String(“abc”); str1str2;
B.String str1=“abc”; String str2=“abc”; str1str2;
C.Integer i1=127; Integer i2=127; i1i2;
D.String str1=“a”; String str2=“b”; str2+=str1; String str3=“ab”; str2str3
【正确答案】B,C
【答案解析】字符串会共享对象，B选项两个引用指向同一个区域。C选项的整数值包装类进行自动封箱时会存在共享区域
44、下列各项中可以用作java的标识符的是：
A.测试
B.T2T
C.KaTeX parse error: Expected group after '_' at position 1: _̲
D.cn.tedu
E.202
【正确答案】A,B,C
【答案解析】标识符不包括.这个符号。标识符不能以数字开头
45、java异常描述错误的是
A.抛出异常意味着发生了运行时错误，需要调试修改
B.如果try块没有出现异常，则finally块里的内容不会执行
C.java中的运行时异常，可能来自RuntimeException类及其子类
D.用throws定义了方法可能抛出异常，那么调用此方法一定会抛出异常
【正确答案】A,B,D
【答案解析】抛出异常有可能是编译时异常。无论try里有无异常都要执行finnaly。如果抛出的是运行时异常就可能不抛出
46、在下列代码的//insert code here 处，加上下列哪行代码运行时会抛出

java.lang.ClassCastException? interface foo {
}
class Alpha implements foo {
}
class Beta extends Alpha {
}
pulic class Delta extends Beta {
	public static void main(String[] args){ 
		Beta x = new Beta();
     //insert code here
		}
}

A.Alpha a = x;
B.foo f = (Delta) x;
C.foo f = (Alpha) x
D.Beta b = (Beta)(Alpha)x;
E.Delta d = (Delta)(Alpha)x;
【正确答案】B,E
【答案解析】如果进行和接口进行值的转换只要对象类型和接口不是实现类关系就会报错。如果要和类进行值的转换先要保证两个对象之间有继承关系这个能保证编译没错，再保证两个对象的实际创建类不是同一个运行就会报错。
47、下列各项中可以正确编译运行的是:
A.byte b = 3 + 5；
B.char c = 98; c++;
C.float f = ‘a’;
D.double d = 123456789012;
E.byte b = ‘a’;
【正确答案】A,B,C,E
【答案解析】A选项是只有直接量计算会进行编译优化直接计算结果进行赋值。B选项++会默认进行强制类型转换。D选项的值超过了int范围
48、对于代码：

class A { private static void m(){} } 
public class B extends A {
// 1 
} 

下列各项中添加到// 1处不会出错的是：
A.public static int m(){return 0;}
B.private void m() throws Exception {}
C.void m(){}
D.public final double m(double i){return i *= 3;}
E.public abstract void m();
【正确答案】A,B,C,D
【答案解析】父类私有方法对子类不可见，所以子类可以定义任意方法只要符合语法即可，因为B类不是抽象类所以不能定义抽象方法
49、下列关于Java中的类和对象的说法正确的是
A.类和对象一样，只是说法不一样
B.对象是具有属性和行为的实体
C.类规定类对象所拥有的特征和行为
D.类是对一类对象的概括
【正确答案】B,C,D
【答案解析】类和对象不一样，类是一段描述，对象是具体表现
50、对于代码

public class Test { 
	public double add(int a, double b){
	 return a + b; 
	 } 
	 // 1 
 }

下列各项中添加在// 1处编译不会出错的是：
A.pubic void add(double i ,double j){return i + j;}
B.public static double add(int i, double j){return i + j;}
C.public final double adds(int a, double b){return a + b;}
D.public double add(double b, int a){return a + b;}
E.public abstract double add(double a,double b);
【正确答案】C,D