1、在类的继承关系中，需要遵循以下哪个继承原则（）
A、 多重
B、 单一
C、 双重
D、 不能继承
答案： B
2、类中的一个成员方法被下面哪个修饰符修饰，该方法只能在本类被访问（）
A、 public
B、 private
C、 protected
D、 default
答案： B
3、已知类的继承关系如下：
A、 ass Employee;
B、 ass Manager extends Employee;
C、 ass Director extends Employee;
下语句能通过编译的是（）
A、 Employee e = new Manager();
B、 Director d = new Manager();
C、 Director d = new Employee ();
D、 Manager m = new Director();
答案： A
笔记：
1.父类 xx = new 子类（）定义的对象只能调用继承来的方法。
2.父类 xx = new 子类（）定义的对象调用的是子类的方法，而不是父类的。
简单的说，就是自己用自己的，儿子有父亲一样的，就用儿子的。
4、请阅读下面代码：
class A {
public int i = 10;
}
class B extends A{
public int i = 20;
}
public class Test{
public static void main(String args[]){
B b = new B();
A a = b;
System.out.println(b.i);
System.out.println(a.i);
}
}
以上程序的输出结果是 ()
A、 10 10
B、 10 20
C、 20 10
D、 20 20
答案： C
笔记： 没new的对象 只能访问该类中的静态方法或静态成员变量
5、下列关于类的继承的描述，正确的是（）。
A、 一个类可以继承多个父类
B、 一个类可以具有多个子类
C、 子类可以使用父类的所有方法
D、 子类一定比父类有更多的成员方法
答案： B
解析：A、一个类只能继承一个父类｜C、子类可以使用父类的非私有方法｜D、子类不一定比父类有更多的成员方法
6、Java中，如果类C是类B的子类，类B是类A的子类，那么下面描述正确的是（）。
A、 C可以继承B中的公有成员，同样也可以继承A中的公有成员
B、 C只继承了B中的成员
C、 C只继承了A中的成员
D、 C不能继承A或B中的成员
答案： A
7、阅读下面代码：
class Parent{
public String name;
public Parent(String pName){
this.name = pName;
}
}
public class Test extends Parent { //第1行
public Test(String Name){ //第2行
name="hello"; //第3行
super("kitty"); //第4行
}
}
下列选项说法正确的是（ ）。
A、第2行错误，Test类的构造函数中参数名称应与其父类构造函数中的参数名相同
B、第3行错误，应使用super关键字调用父类的name属性，改为super.name="hello";
C、第4行错误，调用父类构造方法的语句必须放在子类构造方法中的第一行
D、程序编译通过，无错误
答案： C
8、阅读下面代码：
public static void main (String [] args){
String s;
System.out.println(“s=”+s);
}
编译运行以上程序，结果是（）
A、 编译错误
B、 编译通过，但出现运行时错误
C、正常运行，输出s=null
D、 正常运行，输出s=
答案： A
9、阅读下面代码：
class Parent {
public int count() { // 第1行
return 0;
}
}
public class Test extends Parent {
public float count() { // 第2行
return 9; // 第3行
}
}
编译时，会出现以下（ ）情况。
A、 编译通过
B、 在第1行引发编译错误
C、在第2行引发编译错误
D、在第3行引发编译错误
答案： C
10、阅读下面代码：
class Parent1 {
Parent1(String s){
System.out.println(s);
}
}
class Parent2 extends Parent1{
Parent2(){
System.out.println("parent2");
}
}
public class Child extends Parent2 {
public static void main(String[] args) {
Child child = new Child();
}
}
编译并运行Child.java，以上代码运行结果为（ ）。
A、 编译错误：没有找到构造器Child()
B、编译错误：没有找到构造器Parent1()
C、正确运行，没有输出值
D、正确运行，输出结果为：parent2
答案： B
解析：C选项是因为当我们给出了构造方法，系统将不再提供默认的无参构造函数
11、阅读下面代码：
class Parent {
Parent() {
System.out.println("parent");
}
}
public class Child extends Parent {
Child(String s) {
System.out.println(s);
}
public static void main(String[] args) {
Child child = new Child("child");
}
}
上述代码的运行结果为（）
A、 child
B、 child parent
C、parent child
D、编译错误
答案： C
12、阅读下面代码：
class Parent {
public void count() {
System.out.println(10%3);
}
}
public class Child extends Parent{
public void count() {
System.out.println(10/3);
}
public static void main(String args[]) {
Parent p = new Child();
p.count();
}
}
下列选项中的输出结果正确的是（ ）。
A、 1
B、 1.0
C、 3
D、 3.3333333333333335
答案： C
13、阅读下面代码：
class Base {
public void method(){
System.out.print ("Base method");
}
}
class Child extends Base{
public void methodB(){
System.out.print ("Child methodB");
}
}
class Sample {
public static void main(String[] args) {
Base base= new Child();
base.methodB();
}
}
下列选项中的输出结果正确的是（）
A、 Base method
B、 Child methodB
C、 Base method Child MethodB
D、 编译错误
答案： D
14、阅读下面代码：
interface Parent{
public int count(int i);
}
public class Test implements Parent {
public int count(int i){
return i % 9;
}
public static void main(String[] args){
________________
int i = p.count(20);
}
}
在_____横线处加入（ ）语句，可以使这段代码编译通过。
A、 Test p = new Test();
B、 Parent p;
C、 Parent p = new Parent();
D、 Test p = new Parent();
答案： A
15、下列选项中关于Java中super关键字的说法，错误的是（ ）。
A、 当子类和父类中成员变量重名的时候,在子类方法中想输出父类成员变量的值,可以用super区分子父类成员变量
B、 super语句可以放在构造函数的任意一行
C、 子类可以通过super关键字调用父类的方法
D、 子类可以通过super关键字调用父类的属性
答案： B
16、下面关于匿名内部类、接口、抽象类和局部内部类的说法，正确的是( )
A、 匿名内部类编译后不会生成.class文件
B、 接口编译后不会生成.class文件
C、 抽象类中没有构造方法
D、 局部内部类只能访问被final修饰的局部变量
答案： D
17、阅读下面代码：
public class Test{
private static final int counter=10;
public static void main(String [] args){
System.out.println(++counter);
}
}
编译运行Test.java，结果是 （）
A、 10
B、 11
C、 编译错误
D、 运行时出现异常
答案： C
解析：
final修饰的变量不可以被改变。
18、在Java中，如果父类中的某些方法不包含任何逻辑，并且需要有子类重写，应该使用（）关键字来声明父类的这些方法
A、 final
B、 static
C、 abstract
D、 void
答案： C
19、阅读下面代码：
public interface Face{
int counter = 40;
}
public class Test implements Face{
private static int counter;
public static void main(String[]args){
System.out.println(++counter);
}
}
Test.java 的编译运行结果是（）。
A、 40
B、 41
C、 0
D、 1
答案： D
20、在Java中，多态的实现不仅能减少编码的工作量，还能大大提高程序的可维护性及可扩展性，下面哪一个选项不属于多态的条件（）。
A、 子类重写父类的方法
B、 子类重载同一个方法
C、 要有继承或实现
D、 父类引用指向子类对象
答案： B
21、在Java中，要想让一个类继承另一个类，可以使用以下哪个关键字（）
A、 inherits
B、 extends
C、 implements
D、 modifies
答案： B
22、下面说法中错误的是（）
A、 静态代码块只在类加载后执行一次,以后再创建对象的时候不执行
B、 局部代码块的作用是为了限制变量的生命周期
C、 构造代码块在每创建一次对象就执行一次
D、 以上都不对
答案： D
笔记：
1.随着类的加载而执行，只执行一次，并优先于主函数。
2.普通代码块（局部代码快）是在方法名后面用 {} 括起来的代码段，不能够单独存在，必须要紧跟在方法名后面且必须使用方法名调用它，作用是限定变量的生命周期和提高效率。
3.每当实例化一个XX类对象，都会在执行构造方法之前执行构造代码块。
23、分析如下Java代码，如果想在控制台上输出“B类的test()方法”，则在主函数应填入（）。
class A {
public void test() {
System.out.println("A类的test()方法");
}
}
class B extends A {
public void test() {
System.out.println("B类的test()方法");
}
public static void main(String args[]) {
}
}
A、A a = new B(); a.test();
B、 A a = new A(); a.test();
C、 B b = new A(); b.test();
D、 new B().test();
答案： AD
笔记：多态成员方法：编译看左边，运行看右边
24、关于super关键字以下说法哪些是正确的（）
A、 super关键字可以调用父类的构造方法
B、 super关键字可以调用父类的普通方法
C、 super与this不能同时存在于同一个构造方法中
D、 super与this可以同时存在于同一个构造方法中
答案： ABC
25、阅读下面代码：
public class Parent{
int change(){
…
}
}
Class Child extends Parent{
_______ (此处可以放入下面哪个选项)
}
下面选项中可以加入Child类中的方法是（）
A、 public int change(){}
B、int show(int i){}
C、private int change(){}
D、 abstract int change(){}
答案： AB
解析：C选项private的权限低于默认修饰符
26、阅读下面代码：
abstract class Shape {
abstract void draw( );
}
要创建Shape类的子类Circle，以下代码正确的是（）。
A、class Circle extends Shape{ int draw( ){} }
B、abstract class Circle extends Shape{ }
C、class Circle extends Shape{ void draw( ); }
D、class Circle extends Shape{ void draw( ){} }
答案： BD
笔记：
1.抽象方法的定义格式如下：abstract void 方法名称(参数);
2.抽象类和抽象方法都要使用abstract关键字声明。
3.抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；
4.子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。
27、在Java中，下面关于抽象类的描述正确的是（）。
A、 抽象类可以被实例化
B、 如果一个类中有一个方法被声明为抽象的，那么这个类必须是抽象类
C、 抽象类中的方法必须都是抽象的
D、 声明抽象类必须带有关键字abstract
答案： BD
28、下面选项中不能和abstract关键字共用的是()
A、 abstract不可以和private共用
B、 abstract不可以和static共用
C、 abstract不可以和final共用
D、 abstract不可以和public共用
答案： ABC
29、在java中，已定义了两个接口B和C，下面继承语句正确的是（）
A、 interface A extends B,C
B、 interface A implements B,C
C、 class A implements B,C
D、 class A implements B,implements C
答案： AC
30、下面关于Java接口的说法正确的是（）
A、 Java接口中定义的是扩展功能
B、 Java接口中可以被多个子类实现,一个类也可以同时实现多个接口
C、 Java接口中可以声明私有成员
D、 Java接口不能被实例化
答案： ABD
31、在Java接口中定义常量，下面语法正确的是（）。
A、 static int MALE = 1;
B、 final int MALE = 1;
C、 int MALE = 1;
D、 private int MALE = 1;
答案： ABC
笔记：
1.接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰。
2.接口当中的常量，可以省略public static final，注意：不写也照样是这样。
32、不存在继承关系的情况下，也可以实现重写。
答案： 错误
解析：不存在继承关系的情况下，不可以实现重写。
33、Java中，子类可以覆盖父类中的任意方法。
答案： 错误
34、Java中被final关键字修饰的变量，不能被重新赋值。
答案： 正确
解析：Java中被final关键字修饰的变量，称为常量，他只能被赋值一次。
35、super调用父类构造方法的代码必须位于子类构造方法的第一行。
答案： 正确
解析：super调用父类构造方法的代码必须位于子类构造方法的第一行。
36、抽象方法必须定义在抽象类中，所以抽象类中的方法都是抽象方法。
答案： 错误
解析：抽象类可以不包含任何抽象方法
37、如果一个类继承了一个抽象类，但是没有完全复写父类的所有的抽象方法那么这个类也是抽象类。
答案： 正确
38、Throwable有两个直接子类Error和Exception，其中Error代表程序中产生的异常，Exception代表程序中产生的错误。
答案： 错误
39、使用【】关键字修饰的类不可以被继承。
答案： final；
40、一个类如果实现一个接口，那么他就需要实现接口定义的全部【】，否则该类就必须定义成【】。
答案： 抽象方法；抽象类；
解析：当一个类实现接口时，如果这个类是抽象类，只需要实现接口中的部分抽象方法即可，否则需要实现接口中的所有抽象方法。
41、一个类可以从其他的类中派生出来，派生出来的类称为【】，用于派生的类称为【】或者【】。
答案： 子类；基类；父类；
42、在继承关系中，子类会自动继承父类中的方法，但有时在子类中需要对继承的方法进行一些修改，即对父类的方法进行【】。
答案： 重写；
43、在定义方法时不写方法体，这种不包含方法体的方法为【】方法。
答案： 抽象；
44、在Java语言中，所有的类都直接或间接继承自【】类。
答案： Object；
45、Object类中的equals方法的参数是【】类型的参数。
答案： Object；
46、RuntimeException类及其子类都是【】异常。
答案： 运行时；
47、Java中提供了大量的异常类，这些类都继承自【】类。
答案： java.lang.Throwable；
48、【】关键字用于在方法中声明抛出异常的实例对象。
答案： throws；
49、请阅读下面代码：
class A {
public int i = 10;
}
class B extends A{
public int i = 20;
}
public class Test{
public static void main(String args[]){
B b = new B();
A a = b;
System.out.println(b.i);
System.out.println(a.i);
}
}
以上程序的输出结果是 ()
A、 10 10
B、 10 20
C、 20 10
D、 20 20
答案： C
50、阅读下面代码：
class Parent{
public String name;
public Parent(String pName){
this.name = pName;
}
}
public class Test extends Parent { //第1行
public Test(String Name){ //第2行
name="hello"; //第3行
super("kitty"); //第4行
}
}
下列选项说法正确的是（ ）。
A、第2行错误，Test类的构造函数中参数名称应与其父类构造函数中的参数名相同
B、第3行错误，应使用super关键字调用父类的name属性，改为super.name="hello";
C、第4行错误，调用父类构造方法的语句必须放在子类构造方法中的第一行
D、程序编译通过，无错误
答案： C
51、阅读下面代码：
public static void main (String [] args){
String s;
System.out.println(“s=”+s);
}
编译运行以上程序，结果是（）
A、 编译错误
B、 编译通过，但出现运行时错误
C、
正常运行，输出s=null
D、 正常运行，输出s=
答案： A
52、阅读下面代码：
class Parent {
public int count() { // 第1行
return 0;
}
}
public class Test extends Parent {
public float count() { // 第2行
return 9; // 第3行
}
}
编译时，会出现以下（ ）情况。
A、 编译通过
B、 在第1行引发编译错误
C、
在第2行引发编译错误
D、
在第3行引发编译错误
答案： C
53、阅读下面代码：
class Parent1 {
Parent1(String s){
System.out.println(s);
}
}
class Parent2 extends Parent1{
Parent2(){
System.out.println("parent2");
}
}
public class Child extends Parent2 {
public static void main(String[] args) {
Child child = new Child();
}
}
编译并运行Child.java，以上代码运行结果为（ ）。
A、 编译错误：没有找到构造器Child()
B、
编译错误：没有找到构造器Parent1()
C、
正确运行，没有输出值
D、
正确运行，输出结果为：parent2
答案： B
解析：C选项是因为当我们给出了构造方法，系统将不再提供默认的无参构造函数
54、阅读下面代码：
class Parent {
Parent() {
System.out.println("parent");
}
}
public class Child extends Parent {
Child(String s) {
System.out.println(s);
}
public static void main(String[] args) {
Child child = new Child("child");
}
}
上述代码的运行结果为（）
A、 child
B、 child parent
C、
parent child
D、
编译错误
答案： C
55、阅读下面代码：
class Parent {
public void count() {
System.out.println(10%3);
}
}
public class Child extends Parent{
public void count() {
System.out.println(10/3);
}
public static void main(String args[]) {
Parent p = new Child();
p.count();
}
}
下列选项中的输出结果正确的是（ ）。
A、 1
B、 1.0
C、 3
D、
3.3333333333333335
答案： C
56、阅读下面代码：
class Base {
public void method(){
System.out.print ("Base method");
}
}
class Child extends Base{
public void methodB(){
System.out.print ("Child methodB");
}
}
class Sample {
public static void main(String[] args) {
Base base= new Child();
base.methodB();
}
}
下列选项中的输出结果正确的是（）
A、
Base method
B、
Child methodB
C、
Base method Child MethodB
D、 编译错误
答案： D
57、阅读下面代码：
interface Parent{
public int count(int i);
}
public class Test implements Parent {
public int count(int i){
return i % 9;
}
public static void main(String[] args){
________________
int i = p.count(20);
}
}
在_____横线处加入（ ）语句，可以使这段代码编译通过。
A、 Test p = new Test();
B、
Parent p;
C、 Parent p = new Parent();
D、
Test p = new Parent();
答案： A
58、阅读下面代码：
public class Test{
private static final int counter=10;
public static void main(String [] args){
System.out.println(++counter);
}
}
编译运行Test.java，结果是 （）
A、 10
B、 11
C、
编译错误
D、
运行时出现异常
答案： C
解析：
final修饰的变量不可以被改变。
59、阅读下面代码：
public interface Face{
int counter = 40;
}
public class Test implements Face{
private static int counter;
public static void main(String[]args){
System.out.println(++counter);
}
}
Test.java 的编译运行结果是（）。
A、 40
B、 41
C、 0
D、 1
答案： D
60、分析如下Java代码，如果想在控制台上输出“B类的test()方法”，则在主函数应填入（）。
class A {
public void test() {
System.out.println("A类的test()方法");
}
}
class B extends A {
public void test() {
System.out.println("B类的test()方法");
}
public static void main(String args[]) {
}
}
A、
A a = new B(); a.test();
B、 A a = new A(); a.test();
C、 B b = new A(); b.test();
D、 new B().test();
答案： AD
61、阅读下面代码：
public class Parent{
int change(){
…
}
}
Class Child extends Parent{
_______ (此处可以放入下面哪个选项)
}
下面选项中可以加入Child类中的方法是（）
A、 public int change(){}
B、
int show(int i){}
C、
private int change(){}
D、 abstract int change(){}
答案： AB
解析：C选项private的权限低于默认修饰符
62、阅读下面代码：
abstract class Shape {
abstract void draw( );
}
要创建Shape类的子类Circle，以下代码正确的是（）。
A、
class Circle extends Shape{ int draw( ){} }
B、
abstract class Circle extends Shape{ }
C、
class Circle extends Shape{ void draw( ); }
D、
class Circle extends Shape{ void draw( ){} }
答案： BD
63、
Throwable类中的printStackTrace(PrintStream s)方法用于将此throwable及其追踪输出至标准错误流。
答案： 正确
64、
Throwable类中的printStackTrace ()方法用于将此throwable及其追踪输出至标准错误流。
答案： 正确
65、
Throwable类中的getMessage()方法用于返回此throwable 的详细消息字符串。
答案： 正确
66、
【】类及其子类用于表示运行时异常。
答案：
RuntimeException
；
67、
Exception类称为异常类，它表示程序本身可以处理的错误，在开发Java程序中进行的异常处理，都是针对Exception类及其子类。
答案： 正确
68、
Error类称为错误类，它表示Java运行时产生的系统内部错误或资源耗尽的错误，是比较严重的，仅靠修改程序本身是不能恢复执行的。
答案： 正确
69、
Throwable有两个直接子类是？（ ）
A、 Error
B、 Exception
C、 ArithmeticException
D、 以上说法都不对
答案： AB
70、
Throwable有两个直接子类Error和Exception，其中Error代表程序中产生的异常，Exception代表程序中产生的错误。
答案： 错误
71、
Java中的异常类都继承自java.lang.Throwable类。
答案： 正确
72、
Java中提供了大量的异常类，这些类都继承自【】类
答案：
java.lang.Throwable
；
73、
下列符号中，哪个用于分隔throws关键字抛出的多个异常（）
A、 ；
B、 ，
C、 &
D、 |
答案： B
解析：方法中如果有多个异常，他们之间使用逗号隔开。
74、
若有父类Animal及其两个子类Cat、Dog，则以下类型转换正确的有（ ）
A、 Cat cat = (Cat)new Animal();
B、 Animal a = new Cat(); Cat cat = (Cat) a;
C、 Animal animal = new Cat();
D、 Animal a = new Dog(); Cat cat = (Cat) a;
答案： BC
解析：无论是向上还是向下转型，最终都是子类对象做着类型的转换。
75、
若Animal 是Cat,Dog的父类，则下列选项中，正确的是（）
A、 Animal animal = new Cat();
B、 Cat cat = (Cat)new Animal();
C、 Animal animal = new Dog();
D、 Cat cat = (Cat)new Dog();
答案： AC
解析：将子类对象当做父类使用时不需要任何显式地声明，需要注意的是，此时不能通过父类变量去调用子类中某些方法。
76、
下面选项中哪一行代码能正确赋值（）
A、 final int num1 = 10;
B、 static int num2 = 20;
C、 abstract int num3 = 30;
D、 private int num4 = 40;
答案： A
解析：final可以修饰局部变量。
77、
已知类的继承关系如下：
class A
class B extends A
class C extends A
则以下语句能通过编译的是（ ）
A、 A a=new B();
B、 C c=new B();
C、 C c=new A();
D、 B b=new C();
答案： A
解析：假设A为犬类，B为狗，C为狼，那么狗当然属于犬类对象。
78、
下列关于自定义异常的说法中，错误的是（ ）
A、 自定义异常要继承Exception类
B、 自定义异常继承Exception类后，具有可抛性
C、 自定义异常可以在构造方法中用super关键字传递异常信息给父类
D、 自定义异常必须继承Error类
答案： D
解析：自定义异常的特点。
79、
如果类的成员被（ ）访问控制符来修饰，则这个成员只能被该类的其它成员访问，其它类无法直接访问。
A、 private
B、 default
C、 protected
D、 public
答案： A
解析：如果类的成员被private访问控制符来修饰，则这个成员只能被该类的其它成员访问，其它类无法直接访问。类的良好封装就是通过private关键字来实现的
80、
开发中，编译时期产生的异常，可以不进行处理，依然可以通过编译。
答案： 正确
解析：在实际开发中，经常会在程序编译时期产生一些异常，而这些异常必须要进行处理，这种异常被称为编译时期异常。
81、
以下关于编译异常说法正确的是（ ）
A、 编译异常就是指Exception以及其子类
B、 编译异常如果产生，可以不用处理
C、 编译异常如果产生，必须处理，要么捕获，要么抛出
D、 编译异常指的就是Error
答案： C
解析：编译异常如果产生，必须处理，要么捕获，要么抛出。
82、在类的继承关系中，需要遵循以下哪个继承原则（）
A、 多重
B、 单一
C、 双重
D、 不能继承
答案： B
83、类中的一个成员方法被下面哪个修饰符修饰，该方法只能在本类被访问（）
A、 public
B、 private
C、 protected
D、 default
答案： B
84、下列关于类的继承的描述，正确的是（）。
A、 一个类可以继承多个父类
B、 一个类可以具有多个子类
C、 子类可以使用父类的所有方法
D、 子类一定比父类有更多的成员方法
答案： B
解析：A、一个类只能继承一个父类｜C、子类可以使用父类的非私有方法｜D、子类不一定比父类有更多的成员方法
85、Java中，如果类C是类B的子类，类B是类A的子类，那么下面描述正确的是（）。
A、 C可以继承B中的公有成员，同样也可以继承A中的公有成员
B、 C只继承了B中的成员
C、 C只继承了A中的成员
D、 C不能继承A或B中的成员
答案： A
86、下列选项中关于Java中super关键字的说法，错误的是（ ）。
A、 当子类和父类中成员变量重名的时候,在子类方法中想输出父类成员变量的值,可以用super区分子父类成员变量
B、 super语句可以放在构造函数的任意一行
C、 子类可以通过super关键字调用父类的方法
D、 子类可以通过super关键字调用父类的属性
答案： B
87、下面关于匿名内部类、接口、抽象类和局部内部类的说法，正确的是( )
A、 匿名内部类编译后不会生成.class文件
B、 接口编译后不会生成.class文件
C、 抽象类中没有构造方法
D、 局部内部类只能访问被final修饰的局部变量
答案： D
88、在Java中，如果父类中的某些方法不包含任何逻辑，并且需要有子类重写，应该使用（）关键字来声明父类的这些方法
A、 final
B、 static
C、 abstract
D、 void
答案： C
89、在Java中，多态的实现不仅能减少编码的工作量，还能大大提高程序的可维护性及可扩展性，下面哪一个选项不属于多态的条件（）。
A、 子类重写父类的方法
B、 子类重载同一个方法
C、 要有继承或实现
D、 父类引用指向子类对象
答案： B
90、在Java中，要想让一个类继承另一个类，可以使用以下哪个关键字（）
A、 inherits
B、 extends
C、 implements
D、 modifies
答案： B
91、下面说法中错误的是（）
A、 静态代码块只在类加载后执行一次,以后再创建对象的时候不执行
B、 局部代码块的作用是为了限制变量的生命周期
C、 构造代码块在每创建一次对象就执行一次
D、 以上都不对
答案： D
92、关于super关键字以下说法哪些是正确的（）
A、 super关键字可以调用父类的构造方法
B、 super关键字可以调用父类的普通方法
C、 super与this不能同时存在于同一个构造方法中
D、 super与this可以同时存在于同一个构造方法中
答案： ABC
93、在Java中，下面关于抽象类的描述正确的是（）。
A、 抽象类可以被实例化
B、 如果一个类中有一个方法被声明为抽象的，那么这个类必须是抽象类
C、 抽象类中的方法必须都是抽象的
D、 声明抽象类必须带有关键字abstract
答案： BD
94、下面选项中不能和abstract关键字共用的是()
A、 abstract不可以和private共用
B、 abstract不可以和static共用
C、 abstract不可以和final共用
D、 abstract不可以和public共用
答案： ABC
95、在java中，已定义了两个接口B和C，下面继承语句正确的是（）
A、 interface A extends B,C
B、 interface A implements B,C
C、 class A implements B,C
D、 class A implements B,implements C
答案： AC
96、下面关于Java接口的说法正确的是（）
A、 Java接口中定义的是扩展功能
B、 Java接口中可以被多个子类实现,一个类也可以同时实现多个接口
C、 Java接口中可以声明私有成员
D、 Java接口不能被实例化
答案： ABD
97、在Java接口中定义常量，下面语法正确的是（）。
A、 static int MALE = 1;
B、 final int MALE = 1;
C、 int MALE = 1;
D、 private int MALE = 1;
答案： ABC
98、不存在继承关系的情况下，也可以实现重写。
答案： 错误
解析：不存在继承关系的情况下，不可以实现重写。
99、Java中，子类可以覆盖父类中的任意方法。
答案： 错误
100、Java中被final关键字修饰的变量，不能被重新赋值。
答案： 正确
解析：Java中被final关键字修饰的变量，称为常量，他只能被赋值一次。
101、super调用父类构造方法的代码必须位于子类构造方法的第一行。
答案： 正确
解析：super调用父类构造方法的代码必须位于子类构造方法的第一行。
102、抽象方法必须定义在抽象类中，所以抽象类中的方法都是抽象方法。
答案： 错误
解析：抽象类可以不包含任何抽象方法
103、如果一个类继承了一个抽象类，但是没有完全复写父类的所有的抽象方法那么这个类也是抽象类。
答案： 正确
104、Throwable有两个直接子类Error和Exception，其中Error代表程序中产生的异常，Exception代表程序中产生的错误。
答案： 错误
105、使用【】关键字修饰的类不可以被继承。
答案：
final
；
106、一个类如果实现一个接口，那么他就需要实现接口定义的全部【】，否则该类就必须定义成【】。
答案：
抽象方法；
抽象类；
解析：当一个类实现接口时，如果这个类是抽象类，只需要实现接口中的部分抽象方法即可，否则需要实现接口中的所有抽象方法。
107、一个类可以从其他的类中派生出来，派生出来的类称为【】，用于派生的类称为【】或者【】。
答案：
子类；
基类
；
父类
；
108、在继承关系中，子类会自动继承父类中的方法，但有时在子类中需要对继承的方法进行一些修改，即对父类的方法进行【】。
答案：
重写
；
109、在定义方法时不写方法体，这种不包含方法体的方法为【】方法。
答案：
抽象
；
110、在Java语言中，所有的类都直接或间接继承自【】类。
答案：
Object
；
111、Object类中的equals方法的参数是【】类型的参数。
答案：
Object
；
112、RuntimeException类及其子类都是【】异常。
答案：
运行时
；
113、Java中提供了大量的异常类，这些类都继承自【】类。
答案：
java.lang.Throwable
；
114、【】关键字用于在方法中声明抛出异常的实例对象。
答案：
throws
；
115、
下面程序的运行结果是（ ）
public class Demo {
public static void main(String[] args) {
try {
System.out.println(10 / 0);
} catch (RuntimeException e) {
System.out.println("RuntimeException");
} catch (ArithmeticException e) {
System.out.println("ArithmeticException");
}
}
}
A、 编译失败
B、 编译通过，没有结果输出
C、 输出：RuntimeException
D、 输出：ArithmeticException
答案： A
解析：在用try…catch处理异常的时候，子类异常一定要先catch，父类异常最后catch。
116、
【】关键字用于在方法中声明抛出异常的实例对象。
答案：
throw
；
解析：这时就需要用到throw关键字，throw关键字用于在方法中声明抛出异常的实例对象。
117、
编译时异常的处理方案有几种?分别是什么?
答案：
有两种。
方式1：使用try…catch语句对异常进行捕获
方式2：使用throws关键字声明抛出异常","调用者对其处理。
解析：在Java中，Exception类中除了RuntimeException类及其的子类都是编译时异常。编译时异常的特点是Java编译器会对其进行检查，如果出现异常就必须对异常进行处理，否则程序无法通过编译。
处理编译时期的异常有两种方式，具体如下：
使用try…catch语句对异常进行捕获
118、
如果一个方法要抛出多个异常，则需要使用多个throws进行抛出。
答案： 错误
解析：如果一个方法要抛出多个异常，使用一个throws就可以了，但多个异常之间需要用逗号隔开。
119、
throw关键字后面必须写异常对象。
答案： 正确
解析：throw关键字用在方法内部，后面必须写异常对象。
120、
请阅读下面的程序，在空白处填写正确的代码。
class Demo{
public static void main(String[] args){
try{
System.out.println(getArea(6.1,4.1));
}catch(【】 e){}
}
public static double getArea (double d1,double d2)throws Exception{
if(d1 <0|| d2 < 0)
throw new Exception();
return d1*d2;
}
}
答案：
Exception
；
解析：try...catch语句,Exception。
121、
定义一个方法，只想被不同包下的子类使用，需要使用访问修饰符【】。
答案：
protected
；
解析：protected受保护权限。
122、
在try…catch语句中，try语句块存放可能发生异常的语句。
答案： 正确
解析：try语句块中存放可能发生异常的语句，一旦发生异常，通过catch语句块进行捕获。
123、
Java中的异常分为两种,一种是【】另外一种是运行时异常。
答案：
编译时异常
；
解析：Java中的异常分为两种,一种是编译时异常另外一种是运行时异常。
124、
编译异常如果产生，可以处理，也可以不用处理。
答案： 错误
解析：编译异常如果产生了，要求我们在必须处理，要么捕获，要么抛出。
125、
请阅读下面的程序，在空白处填写正确的代码，使程序可以编译通过
class Demo{
public static void main(String[] args){
try{
System.out.println(getArea(6.1,4.1));
}catch(Exception e){}
}
public static double getArea (double d1,double d2)throws Exception{
if(d1 <0|| d2 < 0)
【】 Exception();
return d1*d2;
}
}
答案：
throw
；
解析：throw用法，异常对象。
126、
下列异常中，属于编译时异常的是（ ）
A、 NumberFormatException
B、 ArithmeticException
C、 ClassNotFoundException
D、 RuntimeException
答案： C
127、
下列关于throws的描述中，正确的是（ ）
A、 throws是用来声明一个方法可能抛出的异常信息
B、 throws语句用在方法声明后面
C、 方法中没有使用catch处理的异常必须使用throws抛出
D、 throws关键字对外声明该方法有可能发生的异常，调用者在调用方法时必须在程序中对异常进行处理
答案： ABCD
解析：针对这种情况，Java中允许在方法的后面使用throws关键字对外声明该方法有可能发生的异常，这样调用者在调用方法时，就明确地知道该方法有异常，并且必须在程序中对异常进行处理，否则编译无法通过。
128、
下面程序的运行结果是（ ）
public class Demo {
public static void main(String[] args) {
try {
System.out.println(10 / 0);
System.out.println("除法正常运行");
} catch (ArithmeticException e) {
System.out.println("除数不能为0");
}
}
}
A、 编译失败
B、 编译通过，没有结果输出
C、 输出：除法正常运行
D、 输出：除数不能为0
答案： D
解析：虽然是运行时期异常，但是也可以使用try…catch语句进行处理。一旦进入处理语句就不会再回去执行。
129、
下列关于自定义异常的描述中，正确的是（ ）
A、 自定义的异常类需继承Exception类，在构造方法中使用super()语句调用Exception的构造方法
B、 自定义异常类需要用throw关键字在方法中声明抛出异常的实例对象
C、 如果想要调用者捕获throw抛出的异常，需要在抛出异常的方法中使用throws关键字指明异常
D、 抛出的异常对象可以使用try…catch语句对其进行处理
答案： ABCD
130、
运行时异常是必须进行处理的异常，否则程序编译不能通过。
答案： 错误
解析：运行时异常的特点是Java编译器不会对其进行检查，也就是说，当程序中出现这类异常时，即使没有使用try..catch语句捕获或使用throws关键字声明抛出，程序也能编译通过。
131、
自定义一个运行时异常,要求如下：
1） 类名为MyRuntimeException
2） 将异常描述信息传递给父类
答案：
public class MyRuntimeException extends RuntimeException{
public MyRuntimeException(String message){
super(message);
}
}
解析：继承RuntimeException，super传递异常信息。
132、
下列关于throws关键字的描述中，正确的是（ ）
A、 thorws可以声明在方法上也可以声明在方法体中
B、 方法上使用throws抛出一个异常则这个方法中一定有trycatch代码块
C、 使用throws抛出多个异常时各个异常之间必须使用逗号隔开
D、 throws必须和throw配合使用
答案： C
解析：throws关键字声明抛出异常的语法格式如下：
修饰符 返回值类型 方法名([参数1，参数2.....])throws ExceptionType1[,ExceptionType2.....]{
}
133、
下面程序运行的结果是（ ）
class Demo{
public static void main(String[] args){
int x = div(1,2);
try{
}catch(Exception e){
System.out.println(e);
}
System.out.println(x);
}
public static int div(int a,int b){
return a / b ;
}
}
A、 输出1
B、 输出0
C、 输出0.5
D、 编译失败
答案： B
134、
throw关键字用于在方法中声明抛出异常的【】。
答案：
实例对象
；
解析：throw关键字用于在方法中声明抛出异常的实例对象。
135、
编译异常如果产生了，要求我们在必须处理，要么捕获，要么抛出。
答案： 正确
解析：编译异常如果产生了，要求我们在必须处理，要么捕获，要么抛出
136、
protected修饰的类，类中的所有方法只能给子类使用。
答案： 错误
解析：protecetd不能修饰类。
137、
throw关键字用于在方法上声明抛出异常的实例对象。
答案： 错误
解析：throw关键字用于在方法中声明抛出异常的实例对象
throws关键字需要写在方法声明的后面，throws后面需要声明方法中发生异常的类型。
138、
protected修饰的方法，只能给子类使用。
答案： 错误
解析：同一包下的类也可以使用。
139、
RuntimeException类及其子类都是【】异常。
答案：
运行时
；
解析：RuntimeException类及其子类都是运行时异常。
140、
阅读下面的程序，分析代码是否能够编译通过，如果能编译通过，请列出运行的结果。否则请说明编译失败的原因。
public class Demo {
public static void main(String[] args) throws Exception {
System.out.println(showNum());
}
public static int showNum() throws Exception {
int i = 10;
try {
if (i++ == 10) {
throw new Exception();
}
i += 5;
System.out.println(i);
return i;
} catch (Exception e) {
i++;
return i;
} finally {
i++;
}
}
}
答案：
12
解析：if条件结果为true,跳转到catch,这时i的值为11,在catch中执行了
i++后结果为12,因为有finally，这时会将结果存储到内存中，当执行完
finally内容，这时的i的值为13,但是在catch中有return了，这时返
141、
class MyException extends (1) {
}
public class Demo {
public static void main(String[] args) {
try {
show();
} catch ( (2) e) {
e.printStackTrace();
}
}
public static void show() (3) MyException {
throw new MyException();
}
以上程序，创建了一个自定义异常(编译异常)，请补全空白处代码（ ）
A、 (1)Exception(2)MyException(3)throws
B、 (1)MyException(2)Exception(3)throws
C、 (1)Exception(2)Exception(3)throws
D、 (1)Exception(2)MyException(3)Exception
答案： A
解析：自定义的异常类继承自Exception或其子类。Throws用于抛出异常。
142、
阅读下面的程序，分析代码是否能够编译通过，如果能编译通过，请列出运行的结果并分析出现此结果的原因。否则请说明编译失败的原因。
class Cat{
void mi( ) throws NullPointerException{
System.out.println( "Cat mi mi .. " );
}
}
public class SmallCat extends Cat{
void mi( ) throws Exception{
System.out.println( "SmallCat mi mi .. " );
}
public static void main( String[] a ) throws Exception{
Cat cat = new SmallCat();
cat.mi();
}
}
答案：
程序编译失败。在子类中","如果要覆盖父类的一个方法","而父类中的方法声明了throws异常","则子类的方法也可以抛出异常","但切记子类方法抛出的异常只能是父类方法抛出的异常的同类或子类","而不能是父类。
143、
编写一段代码证明 java对try——catch——finally的执行机制是这样的：在虚拟机不退出，即程序不终止的情况下，finally方法总会得到执行，即便catch块里有return语句也会执行完finally再返回。并且返回的是catch快中return的值（finally中不存在return）。
答案：
public class TestFinally{
public static void main(String[] args) {
System.out.println("i的值为。。。"+new TestFinally().test());
}
private int test(){
int i = 1;
try {
return i;
}finally{
++i;
System.out.println("finally is Executed...");
}
}
}
输出结果为：finally is Executed...
i的值为。。。1
解析：在高级语言中，调用一个方法，若其有返回值，总是会返回return后面变量或语句的值，这时java机制会把return后面变量或语句的值存储在某一内存空间，只是由于还有finally还没执行，故暂不返回，等finally执行完毕，就返回刚才已经储存的i值。
144、
JDK中定义了大量的异常类，这些异常类足够我们使用了，所以，我们不需要自己定义异常类。
答案： 错误
解析：JDK中定义了大量的异常类，虽然这些异常类可以描述编程时出现的大部分异常情况，但是在程序开发中有时可能需要描述程序中特有的异常情况，所以，我们在开发中还是需要自己定义异常类。
145、
【】是指除了RuntimeException及其子类外的异常。
答案：
编译时异常
；
解析：编译时异常是指除了RuntimeException及其子类外的异常。
146、
在Java中允许用户自定义异常，但自定义的异常类必须继承自Exception或其子类。
答案： 正确
解析：在Java中允许用户自定义异常，但自定义的异常类必须继承自Exception或其子类，只有这样，你的类才能被认为是异常体系结构的一部分，是一个异常类。
147、
throws关键字用于对外声明方法可能发生的异常，这样调用者在调用方法时，可以明确知道该方法有异常，并进行相关处理。
答案： 正确
解析：throws主要是声明这个方法会抛出这种类型的异常，使它的调用者知道要捕获这个异常。
148、
下列选项中，不属于运行时异常类子类的是（ ）
A、 ArrayStoreException
B、 ClassCastException
C、 IllegalArgumentException
D、 ThreadDeath
答案： D
解析：ThreadDeath属于Error类的子类。
149、
下面关于throws作用的描述中，正确的是（ ）
A、 一个方法只能抛出一个异常信息
B、 一个方法上使用throws声明一个异常说明这个方法运行时一定会抛出这个异常
C、 throws可以声明在方法体中用来指定抛出的具体异常
D、 throws关键字需要写在方法声明的后面
答案： D
解析：throws关键字需要写在方法声明的后面，throws后面需要声明方法中发生异常的类型，通常将这种做法称为方法声明抛出一个异常。
150、
下列关于protected的说法中，正确的是（）
A、 protected修饰的方法，只能给子类使用
B、 protected修饰的类，类中的所有方法只能给子类使用
C、 如果一个类的成员被protected修饰，那么这个成员既能被同一包下的其它类访问，也能被不同包下该类的子类访问。
D、 以上都不对
答案： C
解析：如果一个类的成员被protected访问控制符修饰，那么这个成员既能被同一包下的其它类访问，也能被不同包下该类的子类访问。
151、
自定义运行时异常，必须继承自（ ）类。
A、 Error
B、 Exception
C、 RuntimeException
D、 Throwable
答案： C
解析：RuntimeException运行时异常的超类。
152、
请按照以下要求设计一个自定义异常，并进行测试。
要求如下：
1） 创建一个BlueException，要求继承自Exception.并提供可以自定义异常信息的构造方法
2） 创建一个BlueExceptionTest类，提供一个静态方法test。这个方法抛出BlueException
3） 在BlueExceptionTest创建一个main方法，并在mai方法中调用test方法使用try-catch处理这个方法产生的异常。将异常信息打印到控制台上
答案：
class BlueException extends Exception{
public BlueException(String message) {
super(message);
}
}
class BlueExceptionTest{
public static void test() throws BlueException{
}
public static void main(String[] args) {
try{
test();
}catch(BlueException e){
System.out.println(e.getMessage());
}
}
}
153、
运行时异常可以使用try…catch语句对异常进行捕获或者使用throws关键字声明抛出异常。
答案： 正确
解析：运行时异常的特点是Java编译器不会对其进行检查。但是，如果你使用try…catch语句对异常进行捕获或者使用throws关键字声明抛出异常也是没有问题的。
154、
自定义异常需要继承【】类。
答案：
Exception
；
解析：Exception，所有异常超类。
155、
如果一个方法要抛出多个异常，可以使用throws进行声明。
答案： 正确
解析：一个方法中可以抛出多个异常，可以使用throws关键字，并且每个异常之间用逗号隔开。
156、
在Java中，针对类、成员方法和属性提供了四种访问级别，分别是private、static、protected和public。
答案： 正确
解析：在Java中，针对类、成员方法和属性提供了四种访问级别，分别是private、default、protected和public。
157、
运行时异常的特点是Java编译器【】（会/不会？）对其进行检查。
答案：
不会
；
解析：运行时异常的特点是Java编译器不会对其进行检查，也就是说，当程序中出现这类异常时，即使没有使用try..catch语句捕获或使用throws关键字声明抛出，程序也能编译通过。
158、
下列异常声明中，正确的是（ ）
A、 publicvoidthrowsIOExceptionfun(){}
B、 publicvoidfunthrowsIOException(){}
C、 publicvoidfun()throwsIOException{}
D、 publicvoidfun()throwsIOException,throwsSQLException{}
答案： C
解析：throws关键字需要写在方法声明的后面，throws后面需要声明方法中发生异常的类型，通常将这种做法称为方法声明抛出一个异常。
159、
throws声明在一个方法上，说明这个方法一定会抛出异常。
答案： 错误
解析：throws声明在一个方法上，不能说明这个方法一定会抛出异常。
160、
自定义的异常类必须继承自Exception或其子类。
答案： 正确
161、
java中，方法上如果可能抛出多个异常，多个异常可以使用【】（中文填写）隔开。
答案：
逗号
；
解析：方法上如果可能抛出多个异常。多个异常可以使用逗号隔开。
162、
关键字【】通常被应用在声明方法时，用来指定可能抛出的异常。
答案：
throws
；
解析：throws通常被应用在声明方法时，用来指定可能抛出的异常。
163、
以下对于try…catch语句描述正确的是（ ）
A、 try…catch语句处理程序中的错误
B、 try...catch语句处理程序中的bug
C、 try...catch语句处理程序中的异常
D、 以上说法都不正确
答案： C
解析：try...catch语句处理程序中的异常。
164、
Object是所有类的父类。
答案： 正确
解析：Object是所有类的父类。
165、
Object类中的toString()方法用于返回对象的字符串表示形式。
答案： 正确
解析：toString()方法返回对象的字符串表示形式。
166、
下列关于匿名内部类的描述，错误的是（ ）
A、 匿名内部类是内部类的简化形式
B、 匿名内部类的前提是必须要继承父类或实现接口
C、 匿名内部类的格式是"new父类(参数列表)或父接口(){}"
D、 匿名内部类可以有构造方法
答案： D
解析：匿名内部类不能有构造方法，它连类名都没有。
167、
阅读下面的程序，分析代码是否能够编译通过，如果能编译通过，请列出运行的结果。否则请说明编译失败的原因。
public class Demo {
public static void main(String[] args) {
String name=new Father("tom"){
}.getName();
System.out.println(name);
}
}
class Father {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Father(String name) {
this.name = name;
}
}
答案：
tom
解析：匿名内部类继承了Father类，并自动继承了父类中的普通方法，其中包括setName()和getName()方法，匿名内部类并未对父类继承的方法进行重写，因此在调用getName()方法时打印输出了tom。
168、
Object类的构造方法第一行是super()语句。
答案： 错误
解析：Object没有父类，构造方法第一行不是super。
169、
任何类都可以写成匿名内部类的形式。
答案： 错误
解析：final类不可以被继承。
170、
下列程序运行结果是（ ）
public class Demo {
public static void main(String[] args) {
Object obj=new Father(){
public void show(){
System.out.println("helloworld");
}
};
obj.show();
}
}
class Father{
public void show(){
System.out.println("hello father");
}
}
A、 hellofather
B、 helloworld
C、 无结果
D、 程序编译报错
答案： D
解析：父类引用不能调用子类的特有的方法。
171、
Java中所有的类都是通过直接或间接地继承（ ）类得到的。
A、 java.lang.Object
B、 java.lang.Class
C、 任意类
D、 以上答案都不对
答案： A
解析：Object是所有类的父类。
172、
阅读下段代码，
class Dog
{
public String name;
Dog(String name){
this.name =name;
}
}
public class Demo1
{
public static void main(String[] args){
Dog dog1 = new Dog("xiaohuang");
Dog dog2 = new Dog("xiaohuang");
String s1 = dog1.toString();
String s2 = dog2.toString();
String s3 = "xiaohuang";
String s4 = "xiaohuang";
}
}
返回值为true的是（ ）
A、 dog1.equals(dog2)
B、 s1.equals(s2)
C、 s3.equals(s4)
D、 dog1==dog2
答案： C
解析：选项A比较的是两个对象的地址，结果为false，选项B比较的是dog1和dog2对象的to String()值，结果为false，选项C，比较的是内容，内容相同，所以为true，选项D比较的是dog1和dog2对象的地址，结果为false。
173、
阅读下列的程序
public class Example {
public static void main(String[] args) {
new Father () {
public void show() {
System.out.println("helloworld");
}
}.show();
}
}
class Father {
public void show() {
System.out.println("hellofather");
}
}
下列选项中，程序的运行结果是（ ）
A、 hellofather
B、 helloworld
C、 编译报错
D、 编译通过，运行报错
答案： B
解析：匿名内部类对Father类中的show()方法进行了重写，程序调用的是匿名内部类中的show()方法。
174、
try…catch语句，catch部分可以独立存在。
答案： 错误
解析：catch必须跟随try一起使用,不能独立存在。
175、
阅读下面的程序，分析代码是否能够编译通过，如果能编译通过，请列出运行的结果。否则请说明编译失败的原因。
public class Demo {
public static void main(String[] args) {
new Object(){
public void show(){
System.out.println("helloworld");
}
}.show();
}
}
答案：
helloworld
解析：匿名内部类继承了Object类，并自定义了一个show()方法，
* 使用匿名内部类调用show()方法，调用的是子类也就是匿名内部类自身的show()方法，
* 编译和运行均能正常进行，因此打印输出了helloworld。
176、
阅读下面的程序，分析代码是否能够编译通过，如果能编译通过，请列出运行的结果。否则请说明编译失败的原因。
public class Demo {
public static void main(String[] args) {
Base b1=Base.getBaseInstance1();
System.out.print(b1.getS());
Base b2=Base.getBaseInstance2();
System.out.print(b2.getS());
}
}
abstract class Base {
private static String s = "base";
public static Base getBaseInstance1() {
return new Base() {
public String getS() {
return s;
}
};
}
public static Base getBaseInstance2() {
return new Base("good") {
public String getS() {
return s;
}
};
}
public Base() {
}
public Base(String s) {
this.s = s;
}
public abstract String getS();
}
答案：
basegood
解析：当程序执行getBaseInstance1()方法时，调用Base的空构造函数，s值不变，然后调用b1的getS()方法时，输出默认值base；当程序执行getBaseInstance2()方法时，调用了Base的有参构造函数，s重新赋值为good，然后调用b2的getS()方法时，输出修改后的值good；因此输出结果为 base good。
177、
匿名内部类就是一个没有类名的内部类。
答案： 正确
解析：java的匿名内部类，当我们只需要创建一个类的对象而且用不上它的名字时，使用内部类可以使代码看上去简洁清楚。
178、
下列程序运行结果是（ ）
public class Demo {
public static void main(String[] args) {
Demo demo = new Demo();
demo.show(new Car() {
public void run() {
System.out.println("demo run");
}
});
}
public void show(Car c) {
c.run();
}
}
abstract class Car {
public void run() {
System.out.println("car run...");
}
}
- A、
A、 car run...
B、 demo run
C、 无结果
D、 程序编译报错
答案： B
解析：使用在show()方法中传入匿名内部类对象，匿名内部类中重写了父类Car中run()方法。
179、
下列关于对象的类型转换的描述，说法错误的是（ ）
A、 对象的类型转换可通过自动转换或强制转换进行
B、 无继承关系的两个类的对象之间试图转换会出现编译错误
C、 由new语句创建的父类对象可以强制转换为子类的对象
D、 子类的对象转换为父类类型后，父类对象不能调用子类的特有方法
答案： C
解析：由new语句创建的父类对象不能转换为子类的对象，否则会报编译出错。
180、
下列选项中，哪一个类是Object的子类（）
A、 public final class String{}
B、 public class Person{}
C、 public abstrac tAnimal{}
D、 以上三个类都是Object子类
答案： D
解析：所有类都是Object子类。
181、
以下关于抽象类的描述中，正确的是（）
A、 抽象类是对一系列看上去不同，但本质上相同的具体概念的抽象
B、 当一个类中包含了抽象方法，该类必须使用abstract关键字来修饰
C、 抽象类可以不定义抽象方法
D、 抽象类不能被实例化
答案： ABCD
解析：在定义抽象类时需要注意，包含抽象方法的类必须声明为抽象类，但抽象类可以不包含任何抽象方法，只需使用abstract关键字来修饰即可，另外，抽象类是不可以被实例化。
182、
接口中只能定义常量和抽象方法。
- 对
- 错
答案： 正确
解析：接口中只能定义常量和抽象方法。
183、
instanceof关键字可以用于判断一个对象是否为某个类(或接口)的实例或者子类实例。
答案： 正确
解析：instanceof关键字可以用于判断一个对象是否为某个类(或接口)的实例或者子类实例。
184、
下列选项中，关于final修饰成员变量的说法正确的是（ ）
A、 被final修饰的成员变量可以被多次赋值
B、 被final修饰的成员变量为常量
C、 final只能在接口中修饰成员变量
D、 以上都不对
答案： B
解析：被final修饰的变量为常量，不能被第二次赋值或改变引用。
185、
抽象方法必须定义在抽象类中，所以抽象类中的方法都是抽象方法。
答案： 错误
解析：抽象类中可以没有抽象方法。
186、
请阅读下面的程序，写出最终的结果：
interface Inter {
public void show();
}
abstract class AbstractInter implements Inter {
public void show() {
System.out.println("AbstractInter show()");
}
}
class InterImpl extends AbstractInter {
public void show() {
System.out.println("InterImpl show()");
}
}
public class InterImplTest {
public static void main(String[] args) {
InterImpl i = new InterImpl();
i. show();
}
}
答案：
InterImpl show()
解析：创建具体类的对象，最终调用的也是具体类中的方法。
187、
下面哪个修饰符不可以修饰接口中的成员变量（）
A、 public
B、 static
C、 final
D、 private
答案： D
解析：接口中的成员变量其实是一个常量，用public static final修饰，所以，用private修饰是错误的。
188、
定义一个抽象类的关键字是【】。
答案：
abstract
；
解析：Abstract是定义抽象类的固定修饰符。
189、
阅读下列的程序，并在程序空白处补充空缺的代码，以实现程序依次输出、执行B类的和c类的方法。
public class Demo{
public static void main(String[] args) {
A a1= ____;
a1.fun();
A a2= ____;
a2.fun();
}
}
abstract class A{
public abstract void fun();
}
class B extends A{
public void fun() {
System.out.println("执行B类的方法");
}
}
class C extends A{
public void fun() {
System.out.println("执行c类的方法");
}
}
答案：
new B() new C()
解析：多态中子类可以强制转换为父类，编译时看父类有没有对应的属性和方法，运行时调用子类的属性或方法（静态的方法子类不能复写）。
190、
当一个类实现接口时，必须实现接口中的所有方法。
答案： 正确
解析：当一个类实现接口时，如果这个类是抽象类，则实现接口中的部分方法即可，否则需要实现接口中的所有方法。
191、
接口可以实例化对象。
答案： 错误
解析：接口中的方法都是抽象的，不能实例化对象。
192、
Java提供了一个关键字【】，可以判断一个对象是否为某个类(或接口)的实例或者子类实例。
答案：
instanceof
；
解析：Java提供了一个关键字instanceof，它可以判断一个对象是否为某个类(或接口)的实例或者子类实例。
193、
在Java中一个接口可以继承多个接口，继承的接口之间使用【】隔开即可。
答案：
逗号
；
解析：在Java中，一个接口可以通过extends关键字继承多个接口，接口之间只需用逗号隔开即可。
194、
被final修饰的成员变量不能被继承。
答案： 错误
解析：被final修饰的变量可以被继承，被final修饰的类不能被继承。
195、
抽象类中不一定有抽象函数，但抽象函数一定在抽象类中。
答案： 正确
解析：在定义抽象类时需要注意，包含抽象方法的类必须声明为抽象类，但抽象类可以不包含任何抽象方法。
196、
下列关于对象间类型转换的描述中，正确的是（ ）
A、 类型转换的前提是存在继承关系
B、 强制类型转换可以实现对象间的类型转换。
C、 对象之间的类型转换是多态的一种体现
D、 对象之间的类型转换可以降低代码的耦合度
答案： ACD
解析：类型转换的定义和作用。
197、
子类和父类对象在进行类型转换时，子类对象可以被视为父类的一个对象，父类对象不能被当作是某一个子类的对象。
答案： 正确
解析：子父类的对象进行类型转换时，子类对象可以被视为是其父类的一个对象，父类对象不能被当作是某一个子类的对象。
198、
在定义方法时不写方法体，这种不包含方法体的方法为【】方法。
答案：
抽象
；
解析：Java允许在定义方法时不写方法体，不包含方法体的方法为抽象方法，抽象方法必须使用abstract关键字来修饰。
199、
一个具体类实现接口时，需要重写接口中的（）
A、 成员变量
B、 局部变量
C、 成员方法
D、 构造方法
答案： C
解析：接口中只有常量和抽象方法，所以类实现接口，要重写接口中的抽象方法也就是成员方法。
200、
如果一个类继承了一个抽象类，但是没有完全复写父类的所有的抽象方法那么这个类也必须是抽象类。
答案： 正确
解析：抽象方法是没有方法体的，不可以被调用，如果想调用抽象类中定义的方法，则需要创建一个子类，在子类中将抽象类中的抽象方法进行实现。
201、
一个类如果要实现一个接口，可以通过关键字【】来实现这个接口。
答案：
implements
；
解析：接口中的方法都是抽象方法，我们可以定义一个类，并使用implements关键字实现接口中所有的方法。
202、
有如下三个类
class A
{...}
class B extends A
{...}
class C extends A
{...}
因为 B类和C类不存在继承关系 ，因此他们之间不能进行类型转换。
答案： 正确
解析：不存在继承关系的对象之间不能进行类型转换。
203、
阅读下面的程序，分析代码是否能够编译通过，如果能编译通过，请列出运行的结果，否则请说明编译失败的原因。
public class Demo {
public static void main(String[] args) {
Father f=new Son();
f.show();
}
}
class Father{
public void show(){
System.out.print("father show");
}
}
class Son extends Father{
public void show(){
super.show();
System.out.print("son show");
}
}
答案：
father showson show
解析：在main()方法中，创建Son类的对象，并将其父类也就是Father类的引用指向了该对象，在调用show()方法时，其实调用的是子类的show()方法，子类的show()方法中又通过super关键字调用了父类的show()方法，因此程序先输出了"father show"，接着输出了"son show"。
204、
对于使用多态的应用程序，某个对象的确切类型何时能知道（ ）
A、 执行时才可以知道
B、 应用程序编译时能够判断
C、 程序员编写程序时就已知道
D、 永远不会知道
答案： B
解析：如果对象的类型转换错误，那么应用程序编译时能够判断，以此得出答案选B。
205、
抽象类实现接口时，可以不实现接口中的任何方法。
答案： 正确
解析：当一个类实现接口时，如果这个类是抽象类，则实现接口中的部分方法即可(其实也可以不实现)，否则需要实现接口中的所有方法。
206、
下列关于接口的说法中，错误的是（ ）
A、 接口中定义的方法默认使用“publicabstract”来修饰
B、 接口中的变量默认使用“publicstaticfinal”来修饰
C、 接口中的所有方法都是抽象方法
D、 接口中定义的变量可以被修改
答案： D
解析：接口中定义的变量是常量，不能被修改。
207、
抽象类中的方法只能定义成抽象的方法。
答案： 错误
解析：抽象类可以不包含任何抽象方法。
208、
下列选项中，不可以被final修饰的是（ ）
A、 接口
B、 类
C、 方法
D、 变量
答案： A
解析：final关键字可用于修饰类、变量和方法。
209、
阅读下面的程序，在不new Cat类的情况下,添加代码运行Demo的mian方法后执行Cat的eat()方法。
public class Demo {
public static void main(String[] args) {
Animal animal = new Cat();
________；
cat.eat();
}
}
class Animal{
public void eat(){
System.out.println("animal eat");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("cat eat");
}
}
答案：
Cat cat = (Cat)animal;
；
解析：由子类对象转化得到的父类对象可以强制转换为同类型的子类对象。
210、
父类的引用指向自己子类的对象是多态的一种体现形式。
答案： 正确
解析：在Java中为了实现多态，允许使用一个父类类型的变量来引用一个子类类型的对象，根据被引用子类对象特征的不同，得到不同的运行结果。
211、
下列关于对象间类型转换的说法中，正确的是（ ）
A、 与基本数据类型的相互转换一样，对象的类型转换可通过自动转换或强制转换进行
B、 无继承关系的两个类的对象之间试图转换时出现编译错误
C、 有继承关系的两个类的对象之间，子类的对象转换为父类的对象，可自动转换也可以强制转换
D、 由new语句创建的父类对象不能转换为子类的对象
答案： ABCD
212、
如果一个方法的形式参数定义的是父类对象,那么调用这个方法时,可以使用子类对象作为实际参数。
答案： 正确
解析：如果一个方法的形式参数定义的是父类对象,那么调用这个方法时,可以使用子类对象作为实际参数。
213、
我们可以使用final关键字修饰抽象方法。
答案： 错误
解析：final关键字和abstract关键字不能一起使用。
214、
final修饰符不可以修饰如下哪个内容（）
A、 类
B、 接口
C、 方法
D、 变量
答案： B
解析：final关键字可用于修饰类、变量和方法。
215、
final即可以修饰局部变量也可以修饰成员变量。
答案： 正确
解析：Final即可以修饰成员变量也可以修饰局部变量。
216、
下列选项中，可以被final修饰符修饰的是（）
A、 抽象方法
B、 局部变量
C、 接口
D、 抽象类
答案： B
解析：final关键字一般用于修饰类、变量和方法。还可以修饰局部变量。但不能与abstract修饰符一起使用，而且不能用于接口中。
217、
请阅读下面的程序，写出运行结果，如果编译失败，写明失败原因。
abstract class Animal{
public final abstract void eat();
}
class Cat extends Animal{
public void eat(){
System.out.println("cat...fish");
}
}
class CatDemo{
public static void main(String[] args){
Animal a = new Cat();
a.eat();
}
}
答案：
编译失败","非法修饰符组合。
解析：abstract和 final关键字不能共用。abstract方法需要子类重写，final修饰后不能重写，编译失败。
218、
final修饰的成员变量初始化赋值有两种方式,第一显示初始化赋值,第二【】初始化赋值。
答案：
构造函数
；
解析：final修饰的成员变量初始化赋值有两种方式,第一显示初始化赋值,第二构造函数初始化赋值。
219、
关于final修饰成员变量说法正确的是（）
A、 被final修饰的成员变量为常量
B、 被final修饰的成员变量不能被继承
C、 被final修饰的成员变量可以被多次赋值
D、 final只能在接口中修饰成员变量
答案： A
解析：被final修饰的变量可以被继承，被final修饰的类不能被继承，被final修饰的变量为常量不能被第二次赋值或改变引用。
220、
final修饰符修饰方法时，不能和以下哪个修饰符共用（）
A、 public
B、 static
C、 abstract
D、 synchronized
答案： C
解析：final修饰符不能和abstract修饰符一起使用。
221、
Java中的类被final关键字修饰后，该类将不可以被继承。
答案： 正确
解析：Java中的类被final关键字修饰后，该类将不可以被继承，也就是不能够派生子类。
222、
final修饰的方法，不能被子类【】。
答案：
重写
；
解析：final修饰的方法为最终方法，不能被重写。
223、
请阅读下面的程序，写出运行结果，若编译失败写出原因。
class SubString extends java.lang.String{
public boolean equals(Object obj){
return true;
}
}
class Demo{
public static void main(String[] args){
SubString s = new SubString();
System.out.println(s.equals("s"));
}
}
答案：
编译失败","String是final修饰类","不能继承。
解析：String类被final修饰，不能被继承。
224、
【】关键字可用于修饰类、变量和方法，它有“这是无法改变的”或者“最终”的含义。
答案：
final
；
解析：final关键字可用于修饰类、变量和方法，它有“这是无法改变的”或者“最终”的含义。
225、
分析下面的程序，输出的结果是？
public class Test {
public static void main(String[] args) {
final Person p = new Person("张三", 23);
p.setName("李四");
p.setAge(24);
System.out.println(p);
}
}
class Person {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = 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 ;
}
}
答案：
我的姓名是:李四","我的年龄是:24
解析：final修饰引用数据类型不能改变的是地址值,但是可以改变的是属性。
226、
final修饰的局部变量只能被赋值【】（大写）次。
答案：
一
；
解析：final最终变量，只能赋值一次。
227、
请定义一个由public修饰符修饰的int型成员变量MAX_LENGTH，并使该值保持为常数100，则定义这个变量的语句是（）
A、 public int MAX_LENGTH=100
B、 public const int MAX_LENGTH=100
C、 final int MAX_LENGTH=100
D、 public final int MAX_LENGTH=100
答案： D
解析：应题目的要求，需要将该值保持为常数，那么就需要使用关键字final，所以选择D，const是java的保留关键字,在java中使用final定义常量。
228、
以下代码的运行结果是
public class Temp {
public static final StringBuffer buffer = new StringBuffer("中国");
public static void main(String[] args) {
Temp.buffer.append("你好");
System.out.println(Temp.buffer);
}
}
答案：
中国你好
解析：final修饰的非基本类型的成员变量其引用不能改变，内容可以改变，所以当我们向buffer对象中增加内容后，内容被正常输出。
229、
final修饰的静态方法可以被类名直接调用。
答案： 正确
解析：final修饰静态方法，可以被类名调用。
230、
final修饰的成员变量可以在构造方法中对其重新赋值。
答案： 错误
解析：final修饰的成员变量不可以再被重新赋值。
231、
定义一个类Demo类， 使该类成为最终类，不能再被继承。
答案：
public final class Demo{
}
解析：使用final关键字定义的类为最终类，不能被继承。
232、
Java中任何类都直接或间接继承了Object类。
答案： 正确
解析：Java中任何类都直接或间接继承了Object类。
233、
Java中一个类最多可以继承【】（大写）个类。
答案：
一
；
解析：类的单继承
在Java中，类只支持单继承，不允许多重继承，也就是说一个类只能有一个直接父类，因此Java中一个类最多可以继承一个类。
234、
下列选项中，关于类的继承说法正确的是（ ）
A、 一个类只能有一个直接父类
B、 多个类可以继承一个父类
C、 一个类的父类可以再去继承另外的一个类
D、 一个类可以有多个直接父类
答案： ABC
解析：一个类只能有一个直接父类，多个类可以继承一个父类，一个类的父类可以再去继承另外的父类。
235、
以下关于super关键字的说法中，正确的是（ ）
A、 super()与this()可以同时存在于同一个构造方法中
B、 super()与this()不能同时存在于同一个构造方法中
C、 super关键字可以调用父类的成员方法
D、 super关键字可以调用父类的构造方法
答案： BCD
解析：super关键字用于访问父类的成员。例如访问父类的成员变量、成员方法和构造方法。super和this关键字都必须写在第一行的开头不能同时使用在同一个构造方法中。
236、
子类重写父类的方法时，重写的方法可以与父类被重写的方法名、参数列表以及返回值类型不相同。
答案： 错误
解析：在子类中重写的方法需要和父类被重写的方法具有相同的方法名、参数列表以及返回值类型。
237、
下列关于super关键字的说法中，正确的是（ ）
A、 super关键字是在子类对象内部指代其父类对象的引用
B、 super关键字不仅可以指代子类的直接父类，还可以指代父类的父类
C、 子类通过super关键字只能调用父类的方法，而不能调用父类的属性
D、 子类通过super关键字只能调用父类的属性，而不能调用父类的方法
答案： A
解析：super关键字是在子类对象内部指代其父类对象的引用，通过super关键字既能调用父类的属性，又能调用父类的方法。
238、
以下关于继承的描述，说法正确的是（ ）
A、 子类继承父类的所有属性和方法
B、 子类可以继承父类的私有的属性和方法
C、 子类可以继承父类的公有的属性和方法
D、 创建子类对象时，父类的所有构造方法都会被执行
答案： C
解析：子类可以继承父类的非私有成员，并且在创建子类时默认会调用父类的无参构造方法。
239、
final可以在方法中修饰基本数据类型变量,但是不可以修饰引用数据类型变量。
答案： 错误
解析：final即可以修饰引用数据类型变量,也可以修饰基本数据类型变量。
240、
在实例化子类对象时，会自动调用父类无参的构造方法。
答案： 正确
解析：在子类的构造方法中通过super指定调用父类的哪个构造方法，如果没有指定，在实例化子类对象时，会自动调用父类无参的构造方法。
241、
下列选项中，哪个是子类重写父类方法时，必须与父类方法一致的（）
A、 返回值类型
B、 修饰符
C、 函数名
D、 参数列表
答案： ACD
解析：子类在重写父类方法时，要求子类方法的返回值类型、函数名和参数列表必须与父类方法一致。
242、
下面选项中，哪个关键字可以修饰局部变量（）
A、 abstract
B、 final
C、 static
D、 private
答案： B
解析：final可以修饰局部变量。
243、
请阅读下面的程序，在空白处填写正确的代码，使Son类的eat方法重写Father的eat方法。
public class Father {
public void eat(String name){
System.out.println(name+"吃番薯");
}
}
class Son ______________{
@Override
public void eat(String name){
System.out.println(name+"吃米饭");
}
}
答案：
extends Father
；
解析：函数的重写前提是继承。
244、
在Java中，子类可以覆盖父类中的任意方法。
答案： 错误
解析：子类不能覆盖父类的私有方法和final方法。
245、
super调用父类构造方法的代码必须位于子类构造方法的第一行。
答案： 正确
解析：通过super调用父类构造方法的代码必须位于子类构造方法的第一行，并且只能出现一次。
246、
现有两个类A、B，以下描述中表示B继承自A的是（）
A、 class A extends B.class
B、 class B implements A
C、 class A implements B
D、 class B extends A
答案： D
解析：类的继承 关键字 extends
在Java中，类的继承是通过extends关键字表示的，要想描述B继承自A，则正确的写法是class B extends A。
247、
以下关于方法重写，说法错误的是（ ）
A、 方法重写时，子类的函数名与形参列表必须与父类的一致
B、 方法重写时，子类的返回值类型必须大于或者等于父类的返回值类型
C、 方法重写时，子类的权限修饰符必须大于或者等于父类的权限修饰符
D、 方法重写与返回值类型无关
答案： BD
解析：方法重写时，子类的返回值类型必须小于或者等于父类的返回值类型 。且在子类中重写的方法需要和父类被重写的方法具有相同的方法名、参数列表以及返回值类型。
248、
方法重写时，子类抛出的异常类型大于等于父类抛出的异常类型。
答案： 错误
解析：方法重写时，子类抛出的异常类型小于等于父类抛出的异常类型。
249、
方法重写的前提是必须存在着继承关系。
答案： 正确
解析：方法重写的前提是必须存在着继承关系。
250、
如果父类的方法是静态的，则子类的方法被（）修饰才能覆盖父类的静态方法 。
A、 protected
B、 static
C、 private
D、 final
答案： B
解析：只有子类的方法为静态时才能重写父类的静态方法。
251、
函数重写与函数重载的相同之处是（）
A、 权限修饰符
B、 函数名
C、 返回值类型
D、 形参列表
答案： B
解析：无论是函数重写还是函数重载都要求函数名要一致。
252、
class A{
String name;
A(){
System.out.println("父类默认隐式的构造方法！");
}
A(String name){
System.out.println("父类显式的构造方法！");
}
}
class B extends A{
B(){
super(null);
System.out.println("子类默认隐式的构造方法！");
}
}
public class Animal {
public static void main(String[] args) {
new B();
}
}
答案：
父类显式的构造方法！
子类默认隐式的构造方法！
解析：
表示父类对象的默认引用
如果子类要调用父类被覆盖的实例方法，可用super作为调用者调用父类被覆盖的实例方法。
使用super调用父类方法
使用super调用父类的构造方法
调用构造方法
本类中调用另一个重载构造方法用this(参数列表)
子类构造方法调用父类构造方法用super(参数列表)
253、
下列关于继承的描述中，错误的是（）
A、 在Java中，类只支持单继承，不允许多重继承，也就是说一个类只能有一个直接父类
B、 多个类可以继承一个父类
C、 在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类，例如C类继承自B类，而B类又可以去继承A类，这时，C类也可称作A类的子类
D、 Java是支持多继承的
答案： D
解析：Java不支持多继承。
6511
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
