1、关于类的叙述正确的是（）。
在类中定义的变量称为类的成员变量，在别的类中可以直接使用
局部变量的作用范围仅仅在定义它的方法内，或者是在定义它的控制流块中
使用别的类的方法仅仅需要引用方法的名字即可
只要没有定义不带参数的构造函数，JVM都会为类生成一个默认构造函数
A在类中定义的变量称为类的成员变量，在别的类中不可以直接使用局部变量的
C使用别的类的方法需要通过该类的对象引用方法的名字
D只要没有定义任何构造函数，JVM都会为类生成一个默认构造函数
B
2、以下类定义中的错误是什么？（）
abstract class xy
{
abstract sum (int x, int y) { }
}
没有错误
类标题未正确定义
方法没有正确定义
没有定义构造函数
1、抽象方法不能有方法体，这是规定
2、该方法缺少返回值，只有构造没有返回值
C
3、下列关于Java中类的构造方法的描述，正确的是（）
构造方法的返回类型为void
可以定义一个类而在代码中不写构造方法。
在同一个类中定义的重载构造方法不可以相互调用。
子类不允许调用父类的构造方法。
A、构造器没有返回值，这个没有返回值和返回值为void可部一样。
B、每个类在没有自己显式声明构造器的时候，都会有一个默认的无参构造。
C、构造器可以重载，而且可以使用super()、this()相互调用
D、每个构造器的默认第一行都是super()，但是一旦父类中没有无参构造，必须在子类的第一行显式的声明调用哪一个构造。
B
4、下列java程序的输出结果为____。
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';
}
}
B
5、try块后必须有catch块。（）
正确
错误
try-catch
try-finally
try-catch-finally
但catch和finally语句不能同时省略！
B
6、观察以下代码：
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");
}
}Car
Vehicle
Compiler error at line 3
Compiler error at line 5
首先final声明的方法是不能被覆盖的，但是这里并不错误，因为方法是private的，也就是子类没有继承父类的run方法，因此子类的run方法跟父类的run方法无关，并不是覆盖。new Car().run()也是调用子类的run方
A
7、对于Java中异常的描述正确的是（?）
用throws定义了方法可能抛出的异常，那么调用此方法时一定会抛出此异常。
如果try块中没有抛出异常，finally块中的语句将不会被执行。
抛出异常意味着程序发生运行时错误，需要调试修改
Java中的非检测（unchecked）异常可能来自RuntimeException类或其子类。
Exception（异常）
是程序本身可以处理的异常。主要包含RuntimeException等运行时异常和IOException，SQLException等非运行时异常。
运行时异常?包括：都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。
A错在 如果方法只在方法头 throws Exception{}，而方法里面没有实际的 异常对象 (引起异常的原因，或throw new Exception() ）,也就是没有异常，何来抛出(抛什么呢)。D
8、有如下一段程序：
public class Test{
private static int i=1;
public int getNext(){
return i++;
}
public static void main(String [] args){
Test test=new Test();
Test testObject=new Test();
test.getNext();
testObject.getNext();
System.out.println(testObject.getNext());
}
}2
3
4
5
用的次数和实例化的对象个数好像没啥关系，他如果高兴的可以调用100次， 调一次：i＋1 。
一次：test.getNext(); //返回的是1，但此时i=2；
二次：testObject.getNext();//返回的是2，但此时i=3 ；
三次：System.out.println(testObject.getNext());//返回的是3，但此时i=4C
9、关于Java语言中的final关键字的使用，下列说法正确的是（）
在使用final关键字定义的方法里面必须使用final关键字定义变量。
使用final关键字定义变量，必须在变量定义的同时给定变量的具体数值，完成变量初始化。
final关键字可以用来修饰方法，表明此方法不可以被子类重写。
使用final关键字定义变量，必须同时使用static关键字。
A 选项在 final 定义的方法里，不是必须要用 final 定义变量。
B final 定义的变量，可以在不是必须要在定义的同时完成初始化，也可以在构造方法中完成初始化。
C 正确，final修饰方法，不能被子类重写，但是可以被重载。
D final 定义变量，可以用 static 也可以不用。C
10、下列不属于Java语言性特点的是
Java致力于检查程序在编译和运行时的错误
Java能运行虚拟机实现跨平台
Java自己操纵内存减少了内存出错的可能性
Java还实现了真数组，避免了覆盖数据类型的可能
Java致力于检查程序在编译和运行时的错误。
Java虚拟机实现了跨平台接口
类型检查帮助检查出许多开发早期出现的错误。
Java自己操纵内存减少了内存出错的可能性。
Java还实现了真数组，避免了覆盖数据的可能。
注意，是避免数据覆盖的可能，而不是数据覆盖类型D
11、当编译并运行下面程序时会发生什么结果（）
public class Bground extends Thread{
public static void main(String argv[]){
Bground b = new Bground();
b.run();
}
public void start(){
for(int i=0;i<10;i++){
System.out.println("Value of i = "+i);
}
}
}编译错误，指明run方法没有定义
运行错误，只鞥呢run方法没有定义
编译通过并输出0到9
编译通过，但无输出
对于线程而言，start是让线程从new变成runnable。run方法才是执行体的入口。
但是在Thread中，run方法是个空方法，没有具体实现。
Bground继承了Thread，但是没有重写run方法，那么调用run方法肯定是无输出。
D
12、关于抽象类与接口，下列说法正确的有？
优先选用接口，尽量少用抽象类
抽象类可以被声明使用，接口不可以被声明使用
抽象类和接口都不能被实例化。
以上说法都不对
含有abstract修饰符的class即为抽象类，abstract类不能创建的实例对象。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。abstract class
类中定义抽象方法必须在具体
(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。
接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。
下面比较一下两者的语法区别：
1.抽象类可以有构造方法，接口中不能有构造方法。
2.抽象类中可以有普通成员变量，接口中没有普通成员变量
3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然
eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5. 抽象类中可以包含静态方法，接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
AC
13、jdk1.8中，下面有关java 抽象类和接口的区别，说法错误的是？
抽象类可以有构造方法，接口中不能有构造方法
抽象类中可以包含非抽象的普通方法，接口中的方法必须是抽象的，不能有非抽象的普通方法
一个类可以实现多个接口，但只能继承一个抽象类
接口中可以有普通成员变量，抽象类中没有普通成员变量
抽象类
特点:
1.抽象类中可以构造方法
2.抽象类中可以存在普通属性，方法，静态属性和方法。
3.抽象类中可以存在抽象方法。
4.如果一个类中有一个抽象方法，那么当前类一定是抽象类；抽象类中不一定有抽象方法。
5.抽象类中的抽象方法，需要有子类实现，如果子类不实现，则子类也需要定义为抽象的。
接口
1.在接口中只有方法的声明，没有方法体。
2.在接口中只有常量，因为定义的变量，在编译的时候都会默认加上
public static final?
3.在接口中的方法，永远都被public来修饰。
4.接口中没有构造方法，也不能实例化接口的对象。
5.接口可以实现多继承
6.接口中定义的方法都需要有实现类来实现，如果实现类不能实现接口中的所有方法
7.则实现类定义为抽象类。
BD
14、以下关于final关键字说法错误的是（）
final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性
final修饰的类不能被继承
final修饰的方法不能被重载
final修饰的变量不允许被再次赋值
1.final修饰变量，则等同于常量
2.final修饰方法中的参数，称为最终参数。
3.final修饰类，则类不能被继承
4.final修饰方法，则方法不能被重写。
final 不能修饰抽象类
final修饰的方法可以被重载 但不能被重写
AC
14、下列说法正确的是（）？
对于局部内部类，只有在方法的局部变量被标记为final或局部变量是effctively final的，内部类才能使用它们
成员内部类位于外部类内部，可以直接调用外部类的所有方法（静态方法和非静态方法）
由于匿名内部类只能用在方法内部，所以匿名内部类的用法与局部内部类是一致的
静态内部类可以直接访问外部类的非静态成员
AB
15、下面HttpServletResponse方法调用，那些给客户端回应了一个定制的HTTP回应头：(??????????)
response.setHeader("X-MyHeader",?"34");
response.addHeader("X-MyHeader",?"34");
response.setHeader(new?HttpHeader("X-MyHeader",?"34"));
response.addHeader(new?HttpHeader("X-MyHeader",?"34"));
1、同名Header可以有多个 ，Header[] getHeaders(String name)。
2、运行时使用的是第一个， Header getFirstHeader(String name)。
3、addHeader，如果同名header已存在，则追加至原同名header后面。
4、setHeader，如果同名header已存在，则覆盖一个同名header。AB
16、关于volatile关键字，下列描述不正确的是？
用volatile修饰的变量，每次更新对其他线程都是立即可见的。
对volatile变量的操作是原子性的。
对volatile变量的操作不会造成阻塞。
不依赖其他锁机制，多线程环境下的计数器可用volatile实现。
一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：
1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
2）禁止进行指令重排序。
volatile只提供了保证访问该变量时，每次都是从内存中读取最新值，并不会使用寄存器缓存该值——每次都会从内存中读取。
而对该变量的修改，volatile并不提供原子性的保证。
由于及时更新，很可能导致另一线程访问最新变量值，无法跳出循环的情况
多线程下计数器必须使用锁保护。
BD