java测试复盘3（2019.8.25）_public static void main(string args) 下一定要用try

复盘3

1.问题：
以下程序的运行结果是（） B*

public class Increment
{
    public static void main(String args[])
    {
        int a;
        a = 6;
        System.out.print(a);
        System.out.print(a++);
        System.out.print(a);
    }
}
1
2
3
4
5
6
7
8
9
10
11

A.666
B.667
C.677
D.676
解析:第一个a没有进行操作直接输出，为6；第二个a是输出后再进行自增操作；第三个是将已经进行自增的a输出

2.问题：
计算机所能处理的最小的数据项称为（） A*
A.位
B.字节
C.字
D.双字
解析数据项的大小为位<字节<字<双字

3.问题：
以下代码执行的结果显示是多少（ ）？ A*

public class Demo { class Super{  int flag=1;
         Super(){
             test();
         }  void test(){
            System.out.println("Super.test() flag="+flag);
         }
    } class Sub extends Super{
        Sub(int i){  flag=i;
            System.out.println("Sub.Sub()flag="+flag);
        }  void test(){
            System.out.println("Sub.test()flag="+flag);
        }
    }  public static void main(String[] args) {  new Demo().new Sub(5);
     }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

A.Sub.test() flag=1
Sub.Sub() flag=5
B.Sub.Sub() flag=5
Sub.test() flag=5
C.Sub.test() flag=0
Sub.Sub() flag=5
D.Super.test() flag=1
Sub.Sub() flag=5
解析：
首先调用父类构造方法，即super（）
2.调用test（）方法。
3.由于在子类sub（）中重写了test（）方法，所以调用子类test（）
4.输出Sub.test() flag=1
5.调用sub的有参构造方法
6.输出Sub.Sub() flag=5
重点在于要时刻记得子类重写父类方法，调用时会调用子类重写之后的方法
当然，这一切的前提都是 实例化子类对象

4.问题：
java用（）机制实现了进程之间的同步执行 A*
A.监视器
B.虚拟机
C.多个CPU
异步调用
解析：监视器用来监视线程进入这个特别房间，他确保同一时间只能有一个线程可以访问特殊房间中的数据和代码。

5.问题：
下列程序的运行结果 A*

public void getCustomerInfo() {
   try {
      // do something that may cause an Exception
    } catch (java.io.FileNotFoundException ex) {
      System.out.print("FileNotFoundException!");
      } catch (java.io.IOException ex) {
      System.out.print("IOException!");
          } catch (java.lang.Exception ex) {
               System.out.print("Exception!");
          }
}
1
2
3
4
5
6
7
8
9
10
11

A.IOException!
B.IOException!Exception!
C.FileNotFoundException!IOException!
D.FileNotFoundException!IOException!Exception!

解析：考察多个catch语句块的执行顺序。当用多个catch语句时，catch语句块在次序上有先后之分。从最前面的catch语句块依次先后进行异常类型匹配，这样如果父异常在子异常类之前，那么首先匹配的将是父异常类，子异常类将不会获得匹配的机会，也即子异常类型所在的catch语句块将是不可到达的语句。所以，一般将父类异常类即Exception老大放在catch语句块的最后一个。

6.问题：
假定x和y为double型，则表达式x=2，y=x+3/2的值是（） D*
A.3.500000
B.3
C.2.00000
D.3.00000
解析：3/2这个是取整运算，3/2的整数部分是1，则2+1得3。又因为是double型变量，所以结果就是D

7.问题：
设三个整型变量 x = 1 , y = 2 , z = 3，则表达式 y＋＝z－－/＋＋x 的值是( )。 A*
A.3
B.3.5
C.4
D.5
解析：由于z–是后缀，所以在除的时候还是Z等于3,而x为前缀自加，此时x等于2；3/2=1;y+=1;所以y=2+1;

8.问题：
关于static说法不正确的是（ ） D*
A.可以直接用类名来访问类中静态方法(public权限)
B.静态块仅在类加载时执行一次
C.static方法中不能有用this调用的方法
D.不可以用对象名来访问类中的静态方法(public权限)
解析:A、静态方法属于类本身，可以使用类名调用。B、静态块只执行一次。C、static块和方法不能出现this和super.D、可以的，实例对象也可以调用静态方法。

9.问题：
JAVA语言的下面几种数组复制方法中，哪个效率最高？ B*
A.for循环逐一复制
B.System.arraycopy
C.Arrays.copyOf
使用clone方法
解析:数组复制方法的效率由高到低应该是System.arraycopy 、 clone 、 (Arrays.copyOf、Arrays.copyOfRange） 、 for循环

10.问题：
以下关于 abstract 关键字的说法，正确的是（） D*
A.abstract 可以与final 并列修饰同一个类。
B.abstract 类中不可以有private的成员。
C.abstract 类中必须全部是abstract方法。
D.abstract 方法必须在abstract类或接口中。
解析：1abstract类不能与final,static使用。final修饰方法，子类可以调用，但不能覆盖。 2最好不要有private因为私有和抽象放在一起，子类如果想重写父类的私有方法根本继承不过来，也就无法重写 3抽象类中可以有非抽象方法 4抽象类中可以都是非抽象的，但是抽象方法一定要在类和接口中

11.问题：
在 main() 方法中给出的字节数组，如果将其显示到控制台上，需要（ ）。 A*
A.标准输出流System.out.println()。
B.建立字节输出流。
C.建立字节输入流。
标准输入流System.in.read()。
解析： 标准输出流System.out.println()。out是java.io.PrintStream类的对象，而println()是java.io.PrintStream类里的一个方法，它的作用就是用来在控制台输出信息的。标准输入流System.in.read()，一次只能读取一个字符，返回输入字符的ASCII码

12.问题：
以下代码段执行后的输出结果为 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);
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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

13.问题：
关于Java语言描述正确的是？ ( ) B*

A.java和C++都保留了指针
B.java和C++都有三个特征：封装、继承和多态
C.java的垃圾回收机制是指程序结束时系统自动回收内存
D.以上说法都不正确
解析：c是面向过程，java和c++都是面向对象，面向对象的三大特征是：封装、继承、多态。Java没有指针，只有引用。

14.问题：
覆盖（重写）与重载的关系是（）。 A*
A.覆盖（重写）只有出现在父类与子类之间，而重载可以出现在同一个类中
B.覆盖（重写）方法可以有不同的方法名，而重载方法必须是相同的方法名
C.final修饰的方法可以被覆盖（重写），但不能被重载
覆盖（重写）与重载是同一回事
解析：首先，重载和重写都是多态的一种体现方式。重载是编译期间的活动，重写是运行期间的活动。
其次，重载是在一个类中定义相同的名字的方法，方法的参数列表或者类型要互相不同，但是返回值类型不作为是否重载的标准，可以修改可见性；
重写是不同的，要求子类重写基类的方法时要与父类方法具有相同的参数类型和返回值，可见性需要大于等于基类的方法

15.问题：
下面所示的java代码，运行时，会产生（）类型的异常 D*

	int Arry_a[] = new int[10];
System.out.println(Arry_a[10]);
1
2

A.ArithmeticException
B.NullPointException
C.IOException
D.ArrayIndexOutOfBoundsException
解析：定义的数组长度为10，角标即为0-9 访问数组角标10会出现数组角标越界异常 ArithmeticException 算术异常 NullPointException 空指针异常 IOException IO异常 ArrayIndexOutOfBoundsException 数组下标越界异常

16.问题：
给定以下JAVA代码，这段代码运行后输出的结果是（） B*

	public class Test
{
    public static int aMethod(int i)throws Exception
    {
        try{
            return i / 10;
        }
        catch (Exception ex)
        {
            throw new Exception("exception in a Method");
        } finally{
            System.out.printf("finally");
        }
    }
 
    public static void main(String [] args)
    {
        try
        {
            aMethod(0);
        }
        catch (Exception ex)
        {
            System.out.printf("exception in main");
        }
        System.out.printf("finished");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

A.exception in main finished
B.finally finished
C.exception in main finally
D.finally exception in main finished
解析：
无论i是多少，永远不会抛出异常，所以catch语句不会执行。
而finally语句是必定执行的语句。
所以先指向aMathod()的finally代码块，输出finally
然后执行main()方法的最后一条输出语句，输出finished

17.问题：
以下多线程对int型变量x的操作,哪个不需要进行同步() D*
A.++x
B.x=y
C.x++
D.x=1
解析：同步是害怕在操作过程的时候被其他线程也进行读取操作，一旦是原子性的操作就不会发生这种情况。
因为一步到位的操作，其他线程不可能在中间干涉。另外三项都有读取、操作两个步骤，而X=1则是原子性操作。

18.问题：
代码String str=”123456a”；int i=Integer.parseInt(str);会报异常的是（） B*
A.java.lang.NullPoninterException
B.java.lang.NumberFormatException
C.java.lang.RuntimeException
D.java.lang.ArrayindexOutOfBoundsException
解析：java.lang.NullPoninterException：变量未被初始化、对象未赋值、对象为空（俗称的空指针异常）
java.lang.NumberFormatException：数据格式转换失败（integer的取值范围为：-127-128，超过范围都会访问false）
java.lang.RuntimeException：运行时异常
java.lang.ArrayindexOutOfBoundsException：数组下标越界

19.问题：
以下方法，哪个不是对add方法的重载? B*

		public class Test
{
    public void add( int x,int y,int z){}
}
1
2
3
4

A.public int add(int x,int y,float z){return 0;}
B.public int add(int x,int y,int z){return 0;}
C.public void add(int x,int y){}
D.以上都不是
解析：方法重载是指方法名相同，但参数不同
B和第2行完全一样，如果调用这个方法，程序不清楚要调用第2的还是第3行

20.问题：
在J2EE中，使用Servlet过滤器，需要在web.xml中配置（）元素 AB*
A.
B.
C.
D.
解析：Servlet过滤器的配置包括两部分： 第一部分是过滤器在Web应用中的定义，由元素表示，包括和两个必需的子元素 第二部分是过滤器映射的定义，由元素表示,可以将一个过滤器映射到一个或者多个Servlet或JSP文件，也可以采用url-pattern将过滤器映射到任意特征的URL

21.问题：
如果一个方法或变量是"private"访问级别，那么它的访问范围是: D*
A.在当前类，或者子类中
B.在当前类或者它的父类中
C.在当前类，或者它所有的父类中
D.在当前类中
解析：private 修饰的方法和变量只能在当前类中访问，不带任何修饰符，只能在同一包内的类中，被访问，protected 只能在子类或者当前类中被访问，public 所有类中可以访问

22.问题：
A派生出子类B，B派生出子类C，并且在java源代码中有如下声明： A*

		A a0=new A();
A a1=new B();
A a2=new C();
1
2
3

以下哪个说法是正确的？
A.第1行，第2行和第3行的声明都是正确的
B.第1,2,3行都能通过编译，但第2,3行运行时出错
C.第1,2行能通过编译，但第3行编译出错
D.只有第1行能通过编译
解析：多态的三种表现形式:继承重写，重载，向上转型。A a=new B()属于向上转型，该语句创建了一个B的对象，并将A的对象变量(引用)指向B的对象，即父类引用指向子类对象，是可以的

23.问题：
若有下列定义，下列哪个表达式返回false？ B*
String s = “hello”;
String t = “hello”;
char c[] = {‘h’,‘e’,‘l’,‘l’,‘o’} ;
A.s.equals(t);
B.t.equals©;
C.s==t;
D.t.equals(new String(“hello”));
解析：A、D选项是对字符串内容的比较。JVM为了减少字符串对象的重复创建，其维护了一个特殊的内存，这段内存被成为字符串常量池。代码中出现字面量形式创建字符串对象时，JVM首先会对这个字面量进行检查，如果字符串常量池中存在相同内容的字符串对象的引用，则将这个引用返回，否则新的字符串对象被创建，然后将这个引用放入字符串常量池，并返回该引用。所以返回true。C选项是引用地址的比较，同上也属于常量池的同一个字符串地址，所以相等返回true。

24.问题：
从以下哪一个选项中可以获得Servlet的初始化参数? C*
A.Servlet
B.ServletContext
C.ServletConfig
D.GenericServlet
解析：servlet的生命周期的方法中有一个init方法，其中一个重载的init方法的参数为ServletConfig可以获取初始化参数。

25.问题：

对于下面这段代码，以下说法正确的是： C*

	
public class Test
{
    public int x;
    public static void main(String []args)
    {
        System. out. println("Value is" + x);
    }
}
1
2
3
4
5
6
7
8
9

A.程序会打出 “Value is 0”
B.程序会抛出 NullPointerException
C.非静态变量不能够被静态方法引用
D.编译器会抛出 "possible reference before assignment"的错误
解析：非静态成员只能被类的实例化对象引用，因此这里在静态方法中访问x会造成编译出错

26.问题：
下列有关Servlet的生命周期，说法不正确的是？ A*
A.在创建自己的Servlet时候，应该在初始化方法init()方法中创建Servlet实例
B.在Servlet生命周期的服务阶段，执行service()方法，根据用户请求的方法，执行相应的doGet()或是doPost()方法
C.在销毁阶段，执行destroy()方法后会释放Servlet 占用的资源
D.destroy()方法仅执行一次，即在服务器停止且卸载Servlet时执行该方法
解析:Servlet的生命周期分为5个阶段：加载、创建、初始化、处理客户请求、卸载。
(1)加载：容器通过类加载器使用servlet类对应的文件加载servlet
(2)创建：通过调用servlet构造函数创建一个servlet对象
(3)初始化：调用init方法初始化
(4)处理客户请求：每当有一个客户请求，容器会创建一个线程来处理客户请求
(5)卸载：调用destroy方法让servlet自己释放其占用的资源
servlet是由Servlet容器负责加载Servlet类，创建Servlet对象并实例化，然后调用Servlet的init方法，进行初始化，之后调用Service方法。实例化和初始化不同

27.问题：
java8中，下面哪个类用到了解决哈希冲突的开放定址法 C*
A.LinkedHashSet
B.HashMap
C.ThreadLocal
D.TreeMap
解析:ThreadLocalMap中使用开放地址法来处理散列冲突，而HashMap中使用的是分离链表法。之所以采用不同的方式主要是因为：在ThreadLocalMap中的散列值分散得十分均匀，很少会出现冲突。并且ThreadLocalMap经常需要清除无用的对象，使用纯数组更加方便。

28.问题：
下列关于java抽象类的说法哪个正确? D*
A.某个抽象类的父类是抽象类，则这个子类必须重载父类的所有抽象方法
B.接口和抽象类是同一回事
C.可以用抽象类直接去实例化创建对象
D.一个类只能继承一个抽象类
解析:A不正确，如果子类是非抽象的，它就必须实现父类的所有抽象方法。但是如果子类是抽象的，就没有必要再重新实现了。
B显然是不正确的。
D中抽象类中可以有非抽象方法，反过来，抽象方法只能在抽象类中。
C是正确的。因为抽象类不允许被实例化

29.问题：
通过HttpServletRequest. getParameter获取的参数. C*
A.总是采用UTF-8编码
B.总是采用lS08859-1编码
C.由客户端浏览器和Web容器配置共同决定编码
D.由服务器所在的操作系统决定编码
解析:浏览器根据jsp页面开头声明的编码方式对request中参数编码； 2、tomcat默认解码是ISO-8859-1， 但是我们可以显示指定解码格式通过调用 request.setCharacterEncoding(“UTF-8”)，或者修改tomcat的配置文件server.xml中的编码，添加uriEncoding属性。

30.问题：
下列程序test 类中的变量c 的最后结果为 D*

	
public class Test {  
public static void main(String args[]) {  
int a = 10;  
int b;  
int c;  
if (a > 50) {  
b = 9;  
}  
c = b + a;  
}  
}  
1
2
3
4
5
6
7
8
9
10
11
12

A.10
B.0
C.19
D.编译出错
解析:if (a > 50)初始化b 但是a=10 所以b永远无法被初始化,故编译出错

31.问题：
关于protected 修饰的成员变量，以下说法正确的是 A*
A.可以被该类自身、与它在同一个包中的其它类、在其它包中的该类的子类所访问
B.只能被该类本身和该类的所有的子类访问
C.只能被该类自身所访问
D.只能被同一个包中的类访问
解析:public：可以被所有其他类所访问。 (2）private：只能被自己访问和修改。 （3）protected：自身，子类及同一个包中类可以访问。 （4）default（默认）：同一包中的类可以访问，声明时没有加修饰符，认为是friendly。

32.问题：
在类设计中，类的成员变量要求仅仅能够被同一package下的类访问，请问应该使用下列哪个修饰词 D*
A.protected
B.public
C.private
D.不需要任何修饰词
解析:private使用范围仅限本类中
protected使用范围为含继承关系的类中（子类可以使用父类）
什么都不写叫友好类，默认是本包中
public特别随意，包内包外，类内类外都可访问

33.问题：
下列哪种异常是检查型异常，需要在编写程序时声明？ C*
A.NullPointerException
B.ClassCastException
C.FileNotFoundException
D.IndexOutOfBoundsException
解析:2、撇去错误，JAVA中的异常分为编译异常和运行异常，前者需要在编码时显性用try catch捕捉，后者不强制要求。 3、A、B、D都是运行时异常，C是在用流对象（如file）读取文件时要求显性捕捉的。

34.问题：
关于Java中参数传递的说法，哪个是错误的？ D*
A.在方法中，修改一个基础类型的参数不会影响原始参数值
B.在方法中，改变一个对象参数的引用不会影响到原始引用
C.在方法中，修改一个对象的属性会影响原始对象参数
D.在方法中，修改集合和Maps的元素不会影响原始集合参数
解析:在Java里，只有值传递，因为引用本身就是一个地址值，我们说的”传递引用“本质上也是“值传递”，只不过传递的是地址值。 在方法中，改变一个对象参数的引用不会影响到原始引用。这是很自然的。 举个例子，假设在函数外有 A a = new A();那么引用a指向堆中的一个对象A()。

35.问题：
What will happen when you attempt to compile and run the following code? D*

	public class Test{  
static{  
  int x=5;  
  }  
static int x,y;  
public static void main(String args[]){  
 x--;  
   myMethod( );  
   System.out.println(x+y+ ++x);  
}  
public static void myMethod( ){  
 y=x++ + ++x;  
 }  
}  
1
2
3
4
5
6
7
8
9
10
11
12
13
14

A.compiletime error
B.prints:1
C.prints:2
D.prints:3
E.prints:7
F.prints:8
解析:1.静态语句块中x为局部变量，不影响静态变量x的值 2.x和y为静态变量，默认初始值为0，属于当前类，其值得改变会影响整个类运行。 3.java中自增操作非原子性的main方法中：
执行x–后 x=-1
调用myMethod方法，x执行x++结果为-1(后++)，但x=0，++x结果1，x=1 ，则y=0
x+y+ ++x,先执行x+y，结果为1，执行++x结果为2，得到最终结果为3

36.问题：
Hashtable 和 HashMap 的区别是： BCDE*
A.Hashtable 是一个哈希表，该类继承了 AbstractMap，实现了 Map 接口
B.HashMap 是内部基于哈希表实现，该类继承AbstractMap，实现Map接口
C.Hashtable 线程安全的，而 HashMap 是线程不安全的
D.Properties 类 继承了 Hashtable 类，而 Hashtable 类则继承Dictionary 类
E.HashMap允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许。
解析：A、×，Hashtable 是一个哈希表，该类继承自Dictionary类，实现了 Map 接口B、×，HashMap是基于哈希表实现的，每一个元素是一个key-value对，其内部通过单链表解决冲突问题，容量不足（超过了阀值）时，同样会自动增长。该类继承AbstractMap，实现Map接口 C、 √，Hashtable 线程安全的，而 HashMap 是线程不安全的。Hashtable 中的方法是Synchronize的，而HashMap中的方法在缺省情况下是非Synchronize的。 D、讲的没错，但是不符合题意 E、语句挑不出毛病。 哈希值的使用不同，HashTable直接使用对象的hashCode。而HashMap重新计算hash值。 hashCode是jdk根据对象的地址或者字符串或者数字算出来的int类型的数值。 Hashtable计算hash值，直接用key的hashCode()，而HashMap重新计算了key的hash值，Hashtable在求hash值对应的位置索引时，用取模运算，而HashMap在求位置索引时，则用与运算，且这里一般先用hash&0x7FFFFFFF后，再对length取模，&0x7FFFFFFF的目的是为了将负的hash值转化为正值，因为hash值有可能为负数，而&0x7FFFFFFF后，只有符号外改变，而后面的位都不变。

37.问题：
下列哪个类的声明是正确的？ B*
A.protected private number;
B.public abstract class Car{}
C.abstract private move(){}
D.abstract final class HI{}
解析：抽象类的目的就是为了让子类实现他本身的方法
final修饰的东西不能被更改或继承
abstract存在的意义是为了让子类实现方法而存在，final的意义是不让子类进行修改。两者存在互斥关系

38.问题：
在 main() 方法中给出的整型数组，如果将其写到一个文件中，需要 B*
A.标准输出流System.out.println()。
B.建立数据字节输出流。
C.建立数据字节输入流。
D.标准输入流System.in.read()。
解析：input和output指的是对于程序而言。input是从文件读取进来，output是输出到文件

39.问题：
关于抽象类的叙述正确的是？ A*
A.抽象类不可以实例化
B.抽象类就是一种特殊的接口
C.抽象类的方法都是抽象方法
D.抽象类的导出类一定不是抽象类
解析：抽象类和接口都不能实例化；抽象类可以不包含抽象方法，但是包含了抽象方法一定要声明为抽象类；抽象类可以继承抽象类

40.问题：
以下运行结果: B*

	for(var i = 0; i < 10; i++) {  
  setTimeout(function() {  
       console.log(i);  
   }, 1000);  
}  
1
2
3
4
5

A.0–9
B.10个10
C.10个9
D.无限循环
解析：setTimeout中的闭包函数是每1s执行一次，由于for循环的执行速度远小于1s，所以当开始执行闭包函数的时候for循环已经结束了（i=10），之后闭包函数执行十次（因为循环了10次），所以打印了10个10。

41.问题：
下列关于Java中类的构造方法的描述，正确的是 B*
A.构造方法的返回类型为void
B.可以定义一个类而在代码中不写构造方法。
C.在同一个类中定义的重载构造方法不可以相互调用。
D.子类不允许调用父类的构造方法。
解析：A、构造器没有返回值 B、可以有一个默认的无参构造。 C、构造器可以重载，而且可以使用super()、this()相互调用 D、每个构造器的默认第一行都是super()，但是一旦父类中没有无参构造，必须在子类的第一行显式的声明调用哪一个构造。

42.问题：
有这么一段程序： C*

	public class Test{   
    public String name="abc";   
   public static void main(String[] args){   
        Test test=new Test();   
        Test testB=new Test();   
        System.out.println(test.equals(testB)+","+test.name.equals(testB.name));   
    }   
}
1
2
3
4
5
6
7
8

请问以上程序执行的结果是
A.true,true
B.true,false
C.false,true
D.false,false
解析：equals没重写时候和==一样，比较的是对象的地址，题中new 了两个对象，所以各自地址不一样，使用equals比较为false，但是string类型中的equals方法Java默认重写了，可以比较对象里的值；两个对象指向的同一个string成员变量里的值相同，所以eqauals比较也相同

43.问题：
关于以下程序代码的说明正确的是? D*

	 public class HasStatic{  
   private static int x=100;  
   public static void main(String args[]){  
         HasStatic hs1=new HasStatic();  
        hs1.x++;  
         HasStatic  hs2=new HasStatic();  
        hs2.x++;  
        hs1=new HasStatic();  
       hs1.x++;  
       HasStatic.x--;  
       System.out.println("x="+x);  
   }  
   }   
1
2
3
4
5
6
7
8
9
10
11
12
13

A.程序通过编译，输出结果为：x=103
B.10行不能通过编译，因为x是私有静态变量
C.5行不能通过编译，因为引用了私有静态变量
D.程序通过编译，输出结果为：x=102
解析：main是HasStatic的静态方法，在其内部可直接访问静态变量，不存在因为私有变量不能通过编译的问题；如果在其他类中，包括HasStatic的派生类中，均不能访问其私有静态变量

44.问题：
以下代码将打印出 B*

	public static void main(String args[]) {  
    List  Listlist1 = new ArrayList();  
     Listlist1.add(0);  
      List Listlist2 = Listlist1;  
        System.out.println(Listlist1.get(0) instanceof Integer);  
       System.out.println(Listlist2.get(0) instanceof Integer);  
       }  
1
2
3
4
5
6
7

A.编译错误
B.true true
C.true false
D.false false
解析：1.collection类型集合（ArrayList,LinkedList只能装入对象类型的数据），题目中装入0，基于对象的自动封装与拆箱 0–>Interger对象 2.instanceof是java关键字 用于测试一个对象是否是某个类的实例，并且返回Boolean类型数据， 3.基于自动封装和自动拆箱以及instanceof 可以知道返回值为true

45.问题：
下列描述中，错误的是 C*
A.SQL语言又称为结构化查询语言
B.java中”static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问
C.面向对象开发中，引用传递意味着传递的并不是实际的对象，而是对象的引用，因此，外部对引用对象所做的改变不会反映到所引用的对象上
D.java是强类型语言，javascript是弱类型语言
E.面向对象的三大特性包括：封装，继承，多态
解析：

46.问题：
如果一个接口Cup有个方法use()，有个类SmallCup实现接口Cup，则在类SmallCup中正确的是？ C*
A.void use() { …}
B.protected void use() { …}
C.public void use() { …}
D.以上语句都可以用在类SmallCup中
解析：既然是实现接口，就要实现接口的所以方法，相当于重写方法，方法的重写需要满足：三同一大一小（方法名、返回值类型、形参相同；访问权限>=重写前；抛出异常<=重写前）

47.问题：
选项中哪一行代码可以添加 到题目中而不产生编译错误？ A*

	public abstract class MyClass {  
    public int constInt = 5;  
    //add code here  
     public void method() {  
    }  
}  
1
2
3
4
5
6

A.public abstract void method(int a);
B.constInt = constInt + 5;
C.public int method();
D.public abstract void anotherMethod() {}
解析：A.方法的重载，编译不会出错 B.加进去会编译不过去，报错（错误为 Syntax error on token “;”, , expected） C.两处错误 第一 普通方法没有方法体， 第二 即使有方法体，并没有与public void method(){ }构成重载，所以不能共存 D.抽象方法没有方法体

48.问题：
抽象类和接口的区别，一下说法错误的是 D*
A.接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的。
B.abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface，实现多重继承。接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面的变量全是常量）的作用。
C.在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是 static final的，不过在 interface中一般不定义数据成员），所有的成员方法默认都是 public abstract 类型的。
D.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"has-a"关系，interface表示的是"is-a"关系。
解析：D项： abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。

49.问题：
以下代码运行输出的是 C*

	public class Person{  
    private String name = "Person";  
    int age=0;  
}  
public class Child extends Person{  
  public String grade;  
    public static void main(String[] args){  
        Person p = new Child();  
       System.out.println(p.name);  
   }  
}  
1
2
3
4
5
6
7
8
9
10
11

A.输出：Person
B.没有输出
C.编译出错
D.运行出错
解析：Java中对字段属性是静态绑定，方法成员是动态绑定，这里错在：在子类中试图访问父类的private字段，所以编译不通过，将private去掉就可访问，不是动态绑定的问题，它本来就属于静态绑定

50.问题：
下面赋值语句中正确的是 A*
A.double d=5.3e12;
B.float f=11.1;
C.int i=0.0;
D.Double oD=3;
解析：A 科学计数法，double类型赋值给double，正确。 B 浮点数默认类型为double，大范围不能赋值给小范围（除非强转），错误。 C double不能赋值给int（理由同b），错误。 D int虽可以转换成double，但在类型转换时无法进行自动装箱，故错误。

51.问题：
下列关于构造函数说法正确的是 C*
A.构造函数的返回值为void
B.构造函数不可以被重载
C.构造函数可以是内联函数
D.构造函数可以没有参数
解析

52.问题：
已知如下类说明：

	public class Test{  
    private float f=1.0f;  
    int m=12;  
    static int n=1;  
   public static void main(String args[]){  
       Test t=new Test();  
    }  
}  
1
2
3
4
5
6
7
8

如下哪些使用是正确的 D*
A.t.f = 1.0
B.this.n
C.Test.m
D.Test.n
解析：A.1.0默认为double类型，float f = 1.0编译出错，如果是float f= 1就可以通过B.static中没有对象的说法，this不存在C.m不是static的，需要依附于对象存在

53.问题：
对于Java中异常的描述正确的是 D*
A.用throws定义了方法可能抛出的异常，那么调用此方法时一定会抛出此异常。
B.如果try块中没有抛出异常，finally块中的语句将不会被执行。
C.抛出异常意味着程序发生运行时错误，需要调试修改
D.Java中的可不检测（unchecked）异常可能来自RuntimeException类或其子类
解析：A错 在调用此方法的时候 也可以再次申明以将异常交由更高一级处理。
B错 finally块中的语句一定会被执行。除非catch块中有System.exit(0)。
C错 抛出异常不一定是运行时异常，也有可能是编译时异常。
D对 运行时异常的特点是Java编译器不会检查它。

54.问题：
Which of the following can be applied to constructors: E*
A.final
B.static
C.synchronized
D.Native
E.None of these.
解析：构造方法不能被子类继承，所以用final修饰没有意义。构造方法用于创建一个新的对象，不能作为类的静态方法，所以用static修饰没有意义。此外，Java语言不支持native或synchronized的构造方法

55.问题：
有如下代码：请写出程序的输出结果。?B*

public class Test  
{  
    public static void main(String[] args)  
   {  
        int x = 0;  
       int y = 0;  
        int k = 0;  
       for (int z = 0; z < 5; z++) {  
            if ((++x > 2) && (++y > 2) && (k++ > 2))  
           {  
                x++;  
                ++y;  
               k++;  
           }  
       }  
       System.out.println(x + ”” +y + ”” +k);  
    }  
}  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

A.432
B.531
C.421
D.523
解析：&&和||都是短路运算符，只要满足前面就不用看后面

56.问题：
关于sleep()和wait()，以下描述错误的一项是 D*
A.sleep是线程类（Thread）的方法，wait是Object类的方法；
B.sleep不释放对象锁，wait放弃对象锁
C.sleep暂停线程、但监控状态仍然保持，结束后会自动恢复
D.wait后进入等待锁定池，只有针对此对象发出notify方法后获得对象锁进入运行状态
解析：D选项，notity()和notifyAll()两个方法均可，应该进入就绪状态而不是运行状态。

57.问题：
关于访问权限说法正确的是 ？ B*
A.外部类前面可以修饰public,protected和private
B.成员内部类前面可以修饰public,protected和private
C.局部内部类前面可以修饰public,protected和private
D.以上说法都不正确
解析：类一般只能被public以及默认修饰符修饰，而内部类可以看做是类的成员，则可以被四种权限修饰符修饰；局部内部类类似于局部变量，没有权限修饰符

58.问题：
定义：String s1 = “uml”; String s2 = “uml”; String s3= new String(“uml”); String s4= new String(“uml”);那么，s1==s2；s3 == s4；s1.equals(s3); 判断正确与否 A
A.T，F，T
B.F，T，F
解析：

59.问题：
下列选项中关于Java中super关键字的说法正确的是 A
A.super关键字是在子类对象内部指代其父类对象的引用
B.super关键字不仅可以指代子类的直接父类，还可以直接指代父类的父类
C.子类通过super关键字只能调用父类的方法，而不能调用父类的属性
D.子类通过super关键字只能调用父类的属性，而不能调用父类的方法
解析：A.super是父类标识符，是子类对象内部指代父类对象的引用 super只可以指代子类的父类，不能指代父类的父类 可以通过super.xx来获取父类的变量(属性) 可以通过super.xx()来访问父类的方法