Java选择题练习 ---（NKW）

最新推荐文章于 2021-08-23 20:42:21 发布

~JORDAN~

最新推荐文章于 2021-08-23 20:42:21 发布

阅读量1.9k

点赞数 6

文章标签： java

原文链接：https://www.nowcoder.com/

版权

Java选择题

第一周期：

注：题目均来自于牛客网

1、Java 语言中，负责并发管理的机制是（多线程）。

解析：多线程是Java程序的并发机制，它能同步共享数、处理不同的事件。

2、区分类中重载方法的依据是( 不同的形参列表 )。

解析：两个重载函数必须在下列一个或两个方面有所区别： 1、函数的参数个数不同。 2、函数的参数类型不同或者参数类型顺序不同。

3、定义类中成员变量时不可能用到的修饰是（void）。

解析：void修饰的是成员方法

4、以下程序

main()
{ 
int m=12,n=34;
printf("%d%d",m++,++n);
printf("%d%d\n",n++,++m);
}

程序运行后的输出结果是（ 12353514 ）。

解析：熟练计算++ – 的关系

5、try块后必须有catch块。（错误）

解析： try块后面不一定需要跟着catch块。

6、BufferedReader的父类是以下哪个？（Reader）。

解析：在这里插入图片描述

7、执行如下程序，输出结果是 ( 2 24 46 6 )

class Test
{
     private int data;
     int result = 0;
     public void m()
     {
         result += 2;
         data += 2;
         System.out.print(result + "  " + data);
     }
 }
 class ThreadExample extends Thread
 {
     private Test mv;
     public ThreadExample(Test mv)
     {
         this.mv = mv;
     }
     public void run()
     {
         synchronized(mv)
         {
             mv.m();
         }
     }
 }
 class ThreadTest
 {
     public static void main(String args[])
     {
         Test mv = new Test();
         Thread t1 = new ThreadExample(mv);
         Thread t2 = new ThreadExample(mv);
         Thread t3 = new ThreadExample(mv);
         t1.start();
         t2.start();
         t3.start();
     }
 }

解析：暂无

8、计算机所能处理的最小的数据项称为（位）

解析：位、字节、字是计算机数据存储的单位。位是最小的存储单位，每一个位存储一个1位的二进制码，一个字节由8位组成。而字通常为16、32或64个位组成。

9、客户端要获取一个socket对象通过实例化，而服务器获得一个socket对象则通过什么方法的返回值？
答：getRemoteSocketAddress()

解析：暂无

10、如果一个接口Glass有个方法setColor()，有个类BlueGlass实现接口Glass，则在类BlueGlass中正确的是？ ( public void setColor() { …} )

解析：JAVA 子类重写继承的方法时,不可以降低方法的访问权限，子类继承父类的访问修饰符要比父类的更大，也就是更加开放，假如我父类是protected修饰的，其子类只能是protected或者public，绝对不能是friendly(默认的访问范围)或者private，当然使用private就不是继承了。还要注意的是，继承当中子类抛出的异常必须是父类抛出的异常的子异常，或者子类抛出的异常要比父类抛出的异常要少。

11、Java 的屏幕坐标是以像素为单位，容器的左下角被确定为坐标的起点。（错误）

解析：容器的左上角被确定为坐标的起点。

12、关键字super的作用是？
用来访问父类被隐藏的非私有成员变量
用来调用父类中被重写的方法
用来调用父类的构造函数

解析：super代表父类对应的对象，所以用super访问在子类中无法直接使用的父类成员和方法。

13、子类A继承父类B, A a = new A(); 则父类B构造函数、父类B静态代码块、父类B非静态代码块、子类A构造函数、子类A静态代码块、子类A非静态代码块执行的先后顺序是？
父类Ｂ静态代码块->子类Ａ静态代码块->父类Ｂ非静态代码块->父类Ｂ构造函数->子类Ａ非静态代码块->子类Ａ构造函数

解析：暂无

14、要使某个类能被同一个包中的其他类访问，但不能被这个包以外的类访问，可以( 让该类不使用任何关键字 )

解析：暂无

15、已知如下类说明

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();
    }
}

如下哪些使用是正确的（ Test.n ）

解析：类变量可以通过类直接调用

16、下面赋值语句中正确的是（double d=5.3e12;）

解析：5.3e12表示5.3乘以10的12次方，正确

17、off-heap是指那种内存（JVM进程管理的内存
）

解析：off-heap叫做堆外内存，将你的对象从堆中脱离出来序列化，然后存储在一大块内存中，这就像它存储到磁盘上一样，但它仍然在RAM中。对象在这种状态下不能直接使用，它们必须首先反序列化，也不受垃圾收集。序列化和反序列化将会影响部分性能（所以可以考虑使用FST-serialization）使用堆外内存能够降低GC导致的暂停。堆外内存不受垃圾收集器管理，也不属于老年代，新生代。

18、在一个基于分布式的游戏服务器系统中，不同的服务器之间，哪种通信方式是不可行的？（管道）

解析：暂无

19、以下哪个类包含方法flush()？（OutputStream）

解析：暂无

20、what is the result of the following code?

enum AccountType
{
    SAVING, FIXED, CURRENT;
    private AccountType()
    {
        System.out.println(“It is a account type”);
    }
}
class EnumOne
{
    public static void main(String[]args)
    {
        System.out.println(AccountType.FIXED);
    }
}

Compiles fine and output is prints”It is a account type”thrice followed by”FIXED”

解析：暂无

21、

void waitForSignal()
{
    Object obj = new Object();
    synchronized(Thread.currentThread())
    {
        obj.wait();
        obj.notify();
    }
}

Which statement is true?
This code may throw an InterruptedException

解析：暂无

22、（<<）运算符和（>>）运算符分别把一个值的位向左和向右移动

解析：位运算符

23、下列关于if-else if选择结构的说法正确的是：

多个else if块之间的顺序可以改变，改变之后可能对程序的执行结果有影响
多个else if块之间的顺序可以改变，改变后程序编译可以通过

解析：多分支语句的用法

24、关于equals和hashCode描述正确的是 ()
两个obj，如果equals()相等，hashCode()一定相等（符合代码规范的情况下）
两个obj，如果hashCode()相等，equals()不一定相等
两个不同的obj， hashCode()可能相等

解析：暂无

25、以下哪些方法是Object类中的方法（全是）
clone()
toString()
wait()
finalize()

解析：暂无

26、线程安全的map在JDK 1.5及其更高版本环境有哪几种方法可以实现?
Map map = new ConcurrentHashMap();
Map map = Collections.synchronizedMap(new HashMap());

解析：暂无

27、以下哪种JAVA的变量表达式使得变量a和变量b具有相同的内存引用地址( )
String a = “hello”; String b = “hello”;
Integer a; Integer b = a;

解析：暂无

28、有关静态初始化块说法正确的是？
无法直接调用静态初始化块
在创建第一个实例前或引用任何静态成员之前，将自动调用静态初始化块来初始化
静态初始化块既没有访问修饰符，也没有参数

解析：暂无

29、What might cause the current thread to stop or pause executing？
An InterruptedException is thrown.
The thread executes a wait() call.
The thread executes a waitforID()call on a MediaTracker.

解析：暂无

30、

public class NameList
{
    private List names = new ArrayList();
    public synchronized void add(String name)
    {
        names.add(name);
    }
    public synchronized void printAll()     {
        for (int i = 0; i < names.size(); i++)
        {
            System.out.print(names.get(i) + ””);
        }
    }
 
    public static void main(String[]args)
    {
        final NameList sl = new NameList();
        for (int i = 0; i < 2; i++)
        {
            new Thread()
            {
                public void run()
                {
                    sl.add(“A”);
                    sl.add(“B”);
                    sl.add(“C”);
                    sl.printAll();
                }
            } .start();
        }
    }
}

Which two statements are true if this class is compiled and run?
The code may rum with output “A B C A B C A B C “, then exit.
The code may ruin with output “A B C A A B C A B C “, then exit.

解析：暂无

第二周期

1、下列对接口的说法，正确的是( B)

接口与抽象类是相同的概念

若要实现一个接口为普通类则必须实现接口的所有抽象方法

接口之间不能有继承关系

一个类只能实现一个接口

解析：
A 接口与抽象类是不同的概念。抽象类是用于捕捉子类的通用特性，接口是抽象方法的集合；
B 实现接口必须实现接口的所有方法；
C 接口可以继承一个或多个接口，抽象类只能继承一个类或者实现多个接口；
D 一个类只能继承一个类，但是可以实现多个接口。

2、定义一个接口必须使用的关键字是？（interface ）

public
class
interface
static

解析：
public 公用的共有的
class 类
interface 接口
static 静态
故选C.Interface 接口

3、判断对错。List，Set，Map都继承自继承Collection接口。（错）

解析：
在这里插入图片描述

4、在try的括号里面有return一个值，那在哪里执行finally里的代码？
答：return前执行

解析：假设利用 return 语句从 try 语句块中退出。在方法返回前，finally子句的内容将被执行。如果 finally 子句中也有一个 return 语句，这个返回值将会覆盖原始的返回值。

5、下列说法错误的有（ ABCD）
Java面向对象语言容许单独的过程与函数存在

Java面向对象语言容许单独的方法存在

Java语言中的非静态方法属于类中的成员（member）

Java语言中的方法必定隶属于某一类（对象），调用方法与C语言的过程或C++语言的函数相同

解析：暂无

6、关于AOP错误的是？（C）

AOP将散落在系统中的“方面”代码集中实现
AOP有助于提高系统可维护性
AOP已经表现出将要替代面向对象的趋势
AOP是一种设计模式，Spring提供了一种实现

解析：AOP不能替代OOP，OOP是obejct abstraction，而AOP是concern abstraction，前者主要是对对象的抽象，诸如抽象出某类业务对象的公用接口、报表业务对象的逻辑封装，更注重于某些共同对象共有行为的抽象，如报表模块中专门需要报表业务逻辑的封装，其他模块中需要其他的逻辑抽象，而AOP则是对分散在各个模块中的共同行为的抽象，即关注点抽象。一些系统级的问题或者思考起来总与业务无关又多处存在的功能，可使用AOP，如异常信息处理机制统一将自定义的异常信息写入响应流进而到前台展示、行为日志记录用户操作过的方法等，这些东西用OOP来做，就是一个良好的接口、各处调用，但有时候会发现太多模块调用的逻辑大都一致、并且与核心业务无大关系，可以独立开来，让处理核心业务的人专注于核心业务的处理，关注分离了，自然代码更独立、更易调试分析、更具好维护。核心业务还是要OOP来发挥作用，与AOP的侧重点不一样，前者有种纵向抽象的感觉，后者则是横向抽象的感觉， AOP只是OOP的补充，无替代关系。

7、执行下列程序的输出结果为（）

public class Test {
 public static void main(String[] args) {
 String s1 = "HelloWorld";
 String s2 = new String("HelloWorld");
 if (s1 == s2) {
 System.out.println("s1 == s2");
 } else {
 System.out.println("s1 != s2");
 }
 if (s1.equals(s2)) {
 System.out.println("s1 equals s2");
 } else {
 System.out.println("s1 not equals s2");
 }
 }
 }

结果：
s1 != s2
s1 equals s2

解析：“ == ”用于比较基本数据类型时比较的是值，用于比较引用类型时比较的是引用指向的地址。String类中，equals（）方法，比较的是对象中的内容。

8、如果一个接口Cow有个方法drink()，有个类Calf实现接口Cow，则在类Calf中正确的是？ ( C )

void drink() { …}

protected void drink() { …}

public void drink() { …}

以上语句都可以用在类Calf中

解析：子类重写父类方法时，方法的访问权限不能小于原访问权限，在接口中，方法的默认权限就是public，所以子类重写后只能是public

9、下列程序的运行结果：

public static void main(String args[]) {
    Thread t = new Thread() {
        public void run() {
            pong();
        }
    };
    t.run();
    System.out.print("ping");
}
static void pong() {
    System.out.print("pong");

结果：
pongping

解析：暂无

10、当你编译和运行下面的代码时，会出现下面选项中的哪种情况？

public class Pvf{
    static boolean Paddy;
    public static void main(String args[]){
        System.out.println(Paddy);
    }
}

答：编译通过并输出结果false

解析：类中声明的变量有默认初始值；方法中声明的变量没有默认初始值，必须在定义时初始化，否则在访问该变量时会出错。boolean类型默认值是false

11、如果要建立一个java.scut.computer的包，叙述正确的是？ ( A )

只需在代码中加入“package java.scut.computer;”一个语句，并且必须放在代码的第一行

只需在代码中加入“package java.scut;”一个语句

必须在代码中加入“package java.scut;”和“package java.scut.computer;”两个语句

在代码中，不一定是第一句，只要是类定义前，加入package语句即可

解析：暂无

12、下面程序的输出是什么？

package algorithms.com.guan.javajicu;
public class TestDemo
{
    public static String output = ””;
    public static void foo(inti)
    {
        try
        {
            if (i == 1)
            {
                throw new Exception();
            }
        }
        catch (Exception e)
        {
            output += “2”;
            return ;
        } finally
        {
            output += “3”;
        }
        output += “4”;
    }
    public static void main(String[] args)
    {
        foo(0);
        foo(1);
        System.out.println(output);
    }
}

结果：3423

解析：首先是foo(0),在try代码块中未抛出异常，finally是无论是否抛出异常必定执行的语句，所以 output += “3”;然后是 output += “4”;执行foo(1)的时候，try代码块抛出异常，进入catch代码块，output += “2”;前面说过finally是必执行的，即使return也会执行output += “3”由于catch代码块中有return语句，最后一个output += “4”不会执行。所以结果是3423

13、检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。

package algorithms.com.guan.javajicu; 
public class Inc { 
    public static void main(String[] args) { 
       Inc inc = new Inc(); 
       int i = 0; 
       inc.fermin(i); 
       i= i ++; 
       System.out.println(i);
    
    } 
    void fermin(int i){ 
       i++; 
    } 
}

结果： 0

解析：从执行顺序可以看到，这里第1和第6执行了2次将0赋值给变量i的操作（=号赋值），i++操作是在这两次操作之间执行的，自增操作是对局部变量表中的值进行自增，而栈顶的值没有发生变化，这里需要注意的是保存这个初始值的地方是操作数栈而不是局部变量表，最后再将栈顶的值覆盖到局部变量表i所在的索引位置中去。

14、关于以下代码的说明，正确的是（）

 class StaticStuff
 {
 static int x=10；
 static { x+=5；}
 public static void main（String args[ ]）
 {
 System.out.println(“x=” + x);
 }
 static { x/=3;}
 }

结果：编译通过，执行结果为：x=5

解析：父类静态成员变量父类静态代码块子类静态成员变量子类静态代码块父类非静态成员变量，父类非静态代码块，父类构造函数，子类非静态成员变量，子类非静态代码块，子类构造函数

15、程序中常采用变量表示数据，变量具有名、地址、值、作用域、生存期等属性。关于变量的叙述，（ A C D ）是正确的。

根据作用域规则，在函数中定义的变量只能在函数中引用

在函数中定义的变量，其生存期为整个程序执行期间

在函数中定义的变量不能与其所在函数的形参同名

在函数中定义的变量，其存储单元在内存的栈区

解析：
可参考：https://blog.csdn.net/wangbo1998/article/details/80379016

16、以下说法错误的是（ C ）

数组是一个对象

数组不是一种原生类

数组的大小可以任意改变

在Java中，数组存储在堆中连续内存空间里

解析：在java中,数组是一个对象, 不是一种原生类,对象所以存放在堆中,又因为数组特性,是连续的,只有C不对

17、给定以下方法声明，调用执行mystery（1234）的输出结果？

//precondition:  x >=0
public void mystery (int x)
{
System.out.print(x % 10);
 
if ((x / 10) != 0)
{
mystery(x / 10);
}
System.out.print(x % 10);
}

结果： 43211234

解析：这个题目是考递归，总共调用了4次mystery方法，注意：程序是从上往下执行的，所以当一个方法，调用另一个或本方法时，程序会等调用完毕以后在接着执行

第一次调用mystery方法，此时参数（x）为1234,进入第四行，x不变为x=1234，1234%10=4,输出 4

接着进入if语句，1234/10=123 !=0,进入if语句，此时x还是1234,接着第二次调用mystery方法（此时第一次调用的方法不会继续执行，会等第二次（本次）调用的方法执行完毕后继续执行），mystery(x/10),传入的参数(x)为123,然后第四行123%10=3,参数还是不变为123，输出 3

接着进入if语句，第三次调用mystery()方法（此时第二次调用的方法不会继续执行，会等第三次（本次）调用的方法执行完毕后继续执行），传入参数为123/10=12, x=12,接着第四行12%10=2，传入的参数值不会变，输出 2

然后进入if语句12/10!=0,第四次调用mystery()方法（此时第三次调用的方法不会继续执行，会等第四次调用的方法（本次）执行完毕后继续执行），传入的参数（x=1）为1，进入第四行1%10，输出 1

然后进入if语句1/10=0不满足if语句x/10 != 0,所以本次不会继续调用mystery方法，然后程序继续执行调用下面的输出参数为1，1%10，输出 1

然后第四次调用的方法执行结束然后返回第三次调用的方法继续执行，调用下面的输出，参数为12,x%10=2，输出 2

然后第三次调用的方法执行结束然后返回第二次调用的方法继续执行，此时调用下面的输出，参数为123,x%10=3,输出 3

最后第二次调用的方法执行结束然后回第一次调用的方法继续执行，此时调用下面的输出，参数为1234,x%10=4,输出 4

第一次调用方法结束

18、在运行时，由java解释器自动引入，而不用import语句引入的包是( java.lang )。

解析：java.lang包是java语言的核心包，lang是language的缩写，java.lang包定义了一些基本的类型，包括Integer,String之类的，是java程序必备的包，有解释器自动引入，无需手动导入

19、关于protected 修饰的成员变量，以下说法正确的是（ A ）

可以被该类自身、与它在同一个包中的其它类、在其它包中的该类的子类所访问

只能被该类本身和该类的所有的子类访问

只能被该类自身所访问

只能被同一个包中的类访问

解析：protected访问控制符能被用于方法和成员变量。

声明为protected的方法和成员变量能被同一个包里的所有类所访问，就像默认修饰符package一样。

能被该类的子类所访问，子类可以和父类不在一个包中。

20、以下代码的输出的正确结果是（ 8 ）

public class Test {
public static void main(String args[]) {
String s = "祝你考出好成绩！";
System.out.println(s.length());
}
}

解析：java的String底层是char数组，它的length()返回数组大小，而unicode中一个汉字是可以用一个char表示的

21、下面代码的输出结果是什么？

public class ZeroTest {
    public static void main(String[] args) {
     try{
       int i = 100 / 0;
       System.out.print(i);
  }catch(Exception e){
       System.out.print(1);
       throw new RuntimeException();
  }finally{
       System.out.print(2);
  }
      System.out.print(3);
 }
 }

结果：12

解析：inti = 100/ 0; 会出现异常，会抛出异常，System.out.print(i)不会执行，catch捕捉异常，继续执行System.out.print(1);当执行 thrownewRuntimeException(); 又会抛出异常，这时，除了会执行finally中的代码，其他地方的代码都不会执行

22、What will be printed when you execute the following code?

class C {
    C() {
        System.out.print("C");
    }
}
 
class A {
    C c = new C();
 
    A() {
        this("A");
        System.out.print("A");
    }
 
    A(String s) {
        System.out.print(s);
    }
}
 
class Test extends A {
    Test() {
        super("B");
        System.out.print("B");
    }
 
    public static void main(String[] args) {
        new Test();
    }
}

结果：CBB

解析：首先，初始化父类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；

然后，初始化子类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；

其次，初始化父类的普通成员变量和代码块，在执行父类的构造方法；

最后，初始化子类的普通成员变量和代码块，在执行子类的构造方法；

初始化父类的普通成员变量和代码块，执行 C c = new C(); 输出C

super(“B”); 表示调用父类的构造方法，不调用父类的无参构造函数，输出B

System.out.print(“B”);

23、在创建派生类对象，构造函数的执行顺序（A）

基类构造函数，派生类对象成员构造函数，派生类本身的构造函数

派生类本身的构造函数，基类构造函数，对象成员构造函数

基类构造函数，派生类本身的构造函数，派生类对象成员构造函数

对象成员构造函数，基类构造函数，派生类本身的构造函数

解析：
父类的静态域-子类的静态域父类的非静态域-父类的构造函数子类的非静态域-子类的构造函数规律就是父类先于子类静态的先于非静态的。
其中静态域包含静态代码块与静态方法，这个谁在前面，则先执行谁。
非静态域同理

24、What will happen when you attempt to compile and run the following code?

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;
 }
}

结果： prints:3

解析：静态语句块中x为局部变量，不影响静态变量x的值

x和y为静态变量，默认初始值为0，属于当前类，其值得改变会影响整个类运行。

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

25、以下代码段执行后的输出结果为

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,3,2

解析：finally代码块在return中间执行。return的值会被放入临时空间，然后执行finally代码块，如果finally中有return，会刷新临时空间的值，方法结束返回临时空间值。
执行顺序为：
输出try里面的初始temp：1；
temp=2；
保存return里面temp的值：2；
执行finally的语句temp：3，输出temp：3；
返回try中的return语句，返回存在里面的temp的值：2；
输出temp：2。

26、关于final说法正确的是？ ( B )

final类的方法肯定不能被同一个包的类访问
final类的方法能否被同一个包的类访问不是由final决定
final方法等同于private方法
final对象本身的引用和值都不能改变

解析：final变量，如果是基本数据类型，则其数值一旦初始化后就不能被改变。如果是引用类型的变量，则对其初始化后，便不能再指向另一个对象，但是其里面的值是可以改变的。引用变量所指向的对象中的内容是可以改变的。

27、字符界面下接受用户从键盘输入，需要import的包是：（ java.io包）

解析：字符界面下前端用户输入、后台程序获取，都是字符流的传输，因此需要导入java.io包。
而java.util中的Scanner则是获取控制台的输入。

28、下面代码的输出是什么？

public class Base
{
    private String baseName = "base";
    public Base()
    {
        callName();
    }
 
    public void callName()
    {
        System. out. println(baseName);
    }
 
    static class Sub extends Base
    {
        private String baseName = "sub";
        public void callName()
        {
            System. out. println (baseName) ;
        }
    }
    public static void main(String[] args)
    {
        Base b = new Sub();
    }
}

结果：null

解析： new Sub();在创造派生类的过程中首先创建基类对象，然后才能创建派生类。创建基类即默认调用Base()方法，在方法中调用callName()方法，由于派生类中存在此方法，则被调用的callName（）方法是派生类中的方法，此时派生类还未构造，所以变量baseName的值为null。

29、关于下面的一段代码，以下哪些说法是正确的：（ AD ）

public static void main(String[] args) {
    String a = new String("myString");
    String b = "myString";
    String c = "my" + "String";
    String d = c;
    System.out.print(a == b);
    System.out.print(a == c);
    System.out.print(b == c);
    System.out.print(b == d);
}

System.out.print(a == b)打印出来的是false

System.out.print(a == c)打印出来的是true

System.out.print(b == c)打印出来的是false

System.out.print(b == d)打印出来的是true

解析：
A：a指向堆内存，b指向常量池，因此地址不相等，false
B：java有常量优化机制，c也指向常量池，且与b指向同一个，则a与c地址不相等,false；
C：b与c地址相等，true
D：d是c的副本，地址相同，所以b与d地址相等，true

30、已知String a=“a”,String b=“b”,String c=a+b,String d=new String(“ab”) 以下操作结果为true的是（AD）

(a+b).equals©
a+b== c
c==d
c.equals(d)

解析：A的值都不一样；B中左方和右方实质上都是new出来的新String，“==”比较地址，故B不对；C同理，而D中equals在String中被重载，相当于只比较值。

第三周期

1、类Person里面有个方法sleep()，如果直接用Person.sleep()，则方法sleep前面必须用的关键词是？ ( static )

class
static
public
final

解析：能被类直接调用，说明是静态的，随着类的加载而加载

2、下面关于构造方法的说法不正确的是 ( B )

构造方法也属于类的方法，可以创建对象的时候给成员变量赋值
构造方法不可以重载
构造方法没有返回值
构造方法一定要和类名相同

解析：
构造方法也是类的方法，可以在创建对象时为成员变量赋值
构造方法可以进行重载，但是参数列表必须不相同，不以返回值和访问级别进行区分
构造方法没有返回值
构造方法一定要与定义为public的类同名

3、导出类调用基类的构造器必须用到的关键字： (super)

解析：其实觉得这道题难的，基本上都是不了解什么是基类和导出类。基类就是父类，也叫超类。导出类就是子类，也叫派生类。

4、给出以下代码，请给出结果（ true ）

public class TestObj{
    public static void main(String[] args){
        Object o=new Object(){
            public boolean equals(Object obj){
                return true;
            }
        };
        System.out.println(o.equals(“Fred”));
    }
}

解析：创建了一个匿名内部类，并将所创建的匿名对象赋给 Object (多态：子类对象赋给超类引用)。同时，该匿名内部类重写了 Object 类的 equals 方法。在执行语句时，根据多态及覆盖原则，会调用匿名内部类重写后的 equals 方法。

5、java中将ISO8859-1字符串转成GB2312编码，语句为？
答：new String(“ISO8859-1”.getBytes(“ISO8859-1”),“GB2312”)

解析：注意这里"ISO8859-1"是一个普通字符串，不要被迷惑了，String.getBytes(“ISO8859-1”）表示获取这个字符串的byte数组，然后new String(String.getBytes(“ISO8859-1”），GB2312)是上面的字符数组按照GB2312编码成新的字符串。

6、java程序内存泄露的最直接表现是（ C ）

频繁FullGc
jvm崩溃
程序抛内存控制的Exception
java进程异常消失

解析：java是自动管理内存的，通常情况下程序运行到稳定状态，内存大小也达到一个基本稳定的值，但是内存泄露导致Gc不能回收泄露的垃圾，内存不断变大，最终超出内存界限，抛出OutOfMemoryExpection

7、如下代码，执行test()函数后，屏幕打印结果为（以上都不对）

public class Test2
{
    public void add(Byte b)
    {
        b = b++;
    }
    public void test()
    {
        Byte a = 127;
        Byte b = 127;
        add(++a);
        System.out.print(a + " ");
        add(b);
        System.out.print(b + "");
    }
}

解析：public void add(Byte b){ b=b++; } 这里涉及java的自动装包/自动拆包(AutoBoxing/UnBoxing) Byte的首字母为大写，是类，看似是引用传递，但是在add函数内实现++操作，会自动拆包成byte值传递类型，所以add函数还是不能实现自增功能。也就是说add函数只是个摆设，没有任何作用。 Byte类型值大小为-128~127之间。 add(++a);这里++a会越界，a的值变为-128 add(b); 前面说了，add不起任何作用，b还是127

8、说明输出结果。( test.SuperTest )

package test;
import java.util.Date; 
public class SuperTest extends Date{ 
    private static final long serialVersionUID = 1L; 
    private void test(){ 
       System.out.println(super.getClass().getName()); 
    } 
      
    public static void main(String[]args){ 
       new SuperTest().test(); 
    } 
}

解析：TestSuper和Date的getClass都没有重写，他们都是调用Object的getClass，而Object的getClass作用是返回的是运行时的类的名字。这个运行时的类就是当前类，所以
super.getClass().getName()
返回的是test.SuperTest，与Date类无关
要返回Date类的名字需要写super.getClass().getSuperclass()

9、关于下列代码的执行顺序，下面描述正确的有哪些选项（ ABC ）

public class HelloA {
    public HelloA() { 
        System.out.println("A的构造函数");
    }
{ 
    System.out.println("A的构造代码块");
}
static { 
    System.out.println("A的静态代码块");
}
public static void main(String[] args) {
    HelloA a = new HelloA();
}
}

打印顺序A的静态代码块> A的构造函数
打印顺序A的静态代码块> A的构造代码块
打印顺序A的构造代码块> A的构造函数
打印顺序A的构造函数> A的构造代码块

解析：Java类的初始化顺序：1. 静态代码块；2. 普通代码块；3. 构造函数。

10、有关线程的叙述正确的是( CD )

可以获得对任何对象的互斥锁定
通过继承Thread类或实现Runnable接口，可以获得对类中方法的互斥锁定
线程通过使用synchronized关键字可获得对象的互斥锁定
线程调度算法是平台独立的

解析：“任何对象”锁定，太绝对了
前半句话讲的是创建线程的方式，后半句讲的是锁定
线程调度分为协同式调度和抢占式调度，Java使用的是抢占式调度，也就是每个线程将由操作系统来分配执行时间，线程的切换不由线程本身来决定（协同式调度）。

11、Java 语言中，负责并发管理的机制是（ D ）

垃圾回收
虚拟机
代码安全
多线程

解析：
选项A，Java语言中，垃圾回收机制对系统中不使用的内存进行回收，从而使程序员从繁忙的内存管理中解放出来。
选项B，Java编写好的程序首先由编译器转换为标准字节代码，然后由虚拟机执行。虚拟机把字节代码程序与各操作系统和硬件分开，使Java程序独立于平台。
选项C，Java的代码安全检测体现在多个层次上，在编译层、解释层、平台层分别作不同的安全检查。
选项D，多线程是Java程序的并发机制，它能同步共享数、处理不同的事件。

12、与InputStream流相对应的Java系统的“标准输入对象”是（ A ）

System.in
System.out
System.err
System.exit()

解析：A.标准输入 B.标准输出 C.错误输出 D.结束程序

13、检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。

public class HelloB extends HelloA 
{
 public HelloB()
 {
 }
 {
     System.out.println("I’m B class");
 }
 static
 {
     System.out.println("static B");
 }
 public static void main(String[] args)
 {
     new HelloB();
 }
}
class HelloA
{
 public HelloA()
 {
 }
 {
     System.out.println("I’m A class");
 }
 static
 {
     System.out.println("static A");
 }
}

答：
static A
static B
I’m A class
I’m B class

解析：

/*其中涉及：静态初始化代码块、构造代码块、构造方法
当涉及到继承时，按照如下顺序执行：*/
1、执行父类的静态代码块
static {
        System.out.println("static A");
    }
输出:static A
2、执行子类的静态代码块
static {
        System.out.println("static B");
    }
输出:static B
3、执行父类的构造代码块
{
        System.out.println("I’m A class");
    }
输出:I'm A class
4、执行父类的构造函数
public HelloA() {
    }
输出：无
5、执行子类的构造代码块
{
        System.out.println("I’m B class");
    }
输出:I'm B class
6、执行子类的构造函数
public HelloB() {
    }
输出：无

/*那么，最后的输出为：
static A
static B
I'm A class
I'm B class*/

14、下列描述中，错误的是（ C ）

SQL语言又称为结构化查询语言

java中”static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问

面向对象开发中，引用传递意味着传递的并不是实际的对象，而是对象的引用，因此，外部对引用对象所做的改变不会反映到所引用的对象上

java是强类型语言，javascript是弱类型语言

面向对象的三大特性包括：封装，继承，多态

解析：因为引用代表引用的是实际的对象，对引用的修改就是对对象的修改，可以理解为两把钥匙可以打开同一扇门，所以C错。

15、如下的Java程序，若采用命令行“java Test one two three”调用，则程序输出的结果为：

public class Test { 
     public static void main(String[] args) { 
     System.out.println(args[0]); 
     } 
}

结果：one

解析：采用命令行“ java Test one two three ”调用
其中Test为调用的方法，而one two three则为Test方法里面main函数的参数；
System.out.println(args[0]);表示输出第一个元素，故为one

16、在一个基于分布式的游戏服务器系统中，不同的服务器之间，哪种通信方式是不可行的？（ A ）

管道
消息队列
高速缓存数据库
套接字

解析：
在这里插入图片描述
17、

 public void test() {
        int a = 10;
        System.out.println(a++ + a--);
    }

最后输出什么？
结果：21

解析：a++ 先把10赋值给a 再+1 所以左边是10 但此时a=11。右边a-- 也是先赋值 a=11，再-1。10+11=21 此时a=10。

18、对于子类的构造函数说明，下列叙述中错误的是（ D ）。

子类不能继承父类的无参构造函数。

子类可以在自己的构造函数中使用super关键字来调用父类的含参数构造函数，但这个调用语句必须是子类构造函数的第一个可执行语句。

在创建子类的对象时，若不含带参构造函数，将先执行父类的无参构造函数，然后再执行自己的无参构造函数。

子类不但可以继承父类的无参构造函数，也可以继承父类的有参构造函数。

解析：构造函数不能被继承，构造方法只能被显式或隐式的调用。

19、Which statement is true for the class java.util.ArrayList? （ A ）

The elements in the collection are ordered.
集合中的元素是并序的

The collection is guaranteed to be immutable.
集合不可改变

The elements in the collection are guaranteed to be unique.
集合中的元素必须唯一

The elements in the collection are accessed using a unique key.
集合中的元素的键是唯一的

The elements in the collections are guaranteed to be synchronized.
集合中的元素是线程同步的

解析：Serializable, Cloneable , Iterable < E >, Collection < E >, List < E >, RandomAccess List接口是有序的，通常允许重复，因此可以确定A对，C错；ArrayList是实现List 接口的大小可变数组，所以B错；D是Map的特性，所以D错；查看手册： Note that this implementation is not synchronized. ArrayList的实现是不是线程同步的，所以E错。

20、以下哪种JAVA的变量表达式使得变量a和变量b具有相同的内存引用地址 ( AB )

String a = “hello”; String b = “hello”;
Integer a; Integer b = a;
int a = 1; Integer b = new Integer(1);
int a = 1; Integer b = 1;

解析：
int与Integer、new Integer() 进行 = = 比较时，结果永远为true
Integer与new Integer() 进行= =比较时，结果永远为false
Integer与Integer进行= =比较时，看范围；在大于等于-128小于等于127的范围内为true，在此范围外为false。

Integer与int比较时，Integer会有拆箱的过程直接返回的就是value，因此int与Integer以及new Integer()进行 = =比较时结果都是true。

Integer a=n时，如果n大于等于-128小于等于127时，会直接从IntegerCache中取，不在这个范围内，会new一个对象，所以Integer与new Integer进行 ==比较时，结果都是false。

Integer与Integer比较，需要看范围，如果在-128~127(包含-128，不包含127)范围内，因为都是从IntegerCache中取值，所以相等；若不在这个范围内，则都要去new一个对象，所以结果为false。

21、下面不是类及类成员的访问控制符的是( C )。（不考虑内部类的情况）

public
private
static
protected

解析：类访问控制符只有三种：public ，private， protected；static和访问控制无关

22、下面的代码运行的结果是：

class B extends Object
{
    static
    {
        System.out.println("Load B");
    }
    public B()
    {
        System.out.println("Create B");
    }
}
class A extends B
{
    static
    {
        System.out.println("Load A");
    }
    public A()
    {
        System.out.println("Create A");
    }
}
 
public class Testclass
{
    public static void main(String[] args)
    {
        new A();
    }
}

结果：Load B -> Load A ->Create B ->Create A

解析：初始化块在构造器执行之前执行，类初始化阶段先执行最顶层父类的静态初始化块，依次向下执行，最后执行当前类的静态初始化块；创建对象时，先调用顶层父类的构造方法，依次向下执行，最后调用本类的构造方法。

23、关于String、StringBuffer、StringBuilder以下说法错误的是（ C ）

StringBuilder运行速度最快
StringBuffer是线程安全的
String的值是可变的
StringBuffer运行速度比String快

解析：String是final修饰的，不可变；运行速度StringBuilder>StringBuffer>String；StringBuffer是线程安全的

24、下面代码的运行结果是（ C ）

public static void main(String[] args){
    String s;
    System.out.println("s="+s);
}

代码编程成功，并输出”s=”
代码编译成功，并输出”s=null”
由于String s没有初始化，代码不能编译通过。
代码编译成功，但捕获到NullPointException异常

解析：局部变量没有默认值

25、instanceof运算符能够用来判断一个对象是否为: （ C ）

一个类的实例
一个实现指定接口的类的实例
全部正确
一个子类的实例

解析：instance是java的二元运算符，用来判断他左边的对象是否为右面类（接口，抽象类，父类）的实例

26、要使某个类能被同一个包中的其他类访问，但不能被这个包以外的类访问，可以( A )

让该类不使用任何关键字
使用private关键字
使用protected关键字
使用void关键字

解析：
包以外的类包括子类
外部包 > 子类 > 本包 > 该类内部
publi c> protected > default > private

27、对于子类的构造函数说明，下列叙述中错误的是（ D ）。

子类不能继承父类的无参构造函数。

子类可以在自己的构造函数中使用super关键字来调用父类的含参数构造函数，但这个调用语句必须是子类构造函数的第一个可执行语句。

在创建子类的对象时，若不含带参构造函数，将先执行父类的无参构造函数，然后再执行自己的无参构造函数。

子类不但可以继承父类的无参构造函数，也可以继承父类的有参构造函数。

解析：构造函数不能被继承，构造方法只能被显式或隐式的调用。

28、以下声明合法的是（ B ）

default String s
public final static native int w( )
abstract double d
abstract final double hyperbolicCosine( )

解析：java的访问权限有public、protected、private和default的，default不能修饰变量

普通变量不能用abstract修饰，abstract一般修饰方法和类

被定义为abstract的类需要被子类继承，但是被修饰为final的类是不能被继承和改写的

29、下面哪个不属于HttpServletResponse接口完成的功能？（ C ）

设置HTTP头标
设置cookie
读取路径信息
输出返回数据

解析：
A：设置HTTP头标

response.setHeader("Refresh","3"); //三秒刷新页面一次

B：设置cookie

Cookie c1 = new Cookie("username","only");
response.addCookie(c1);

C（错误）：读取路径信息,request读取路径信息
复制代码

从request获取各种路径总结
request.getRealPath("url"); // 虚拟目录映射为实际目录
request.getRealPath("./");    // 网页所在的目录
request.getRealPath("../"); // 网页所在目录的上一层目录
request.getContextPath();    // 应用的web目录的名称

D：输出返回数据

HttpServleteResponse.getOutputStream().write();

30、下面哪些赋值语句是正确的（ ABD ）

long test=012
float f=-412
int other =(int)true
double d=0x12345678
byte b=128

解析：
A和B中long和float，正常定义需要加l和f，但是long和float属于基本类型，会进行转化，所以不会报出异常。AB正确

boolean类型不能和任何类型进行转换，会报出类型异常错误。所以C错。

D选项可以这样定义，D正确。

E选项中，byte的取值范围是-128—127。报出异常： cannot convert from int to byte.所以E选项错误。

在这里插入图片描述

第四周期

1、接口不能扩展（继承）多个接口。（错误）

解析:Java中类是单继承，但接口可以多继承，Interfere1 extends Interface2,Interface3…

2、要使某个类能被同一个包中的其他类访问，但不能被这个包以外的类访问，可以( 让该类不使用任何关键字 )

解析：default和protected的区别是：前者只要是外部包，就不允许访问。后者只要是子类就允许访问，即使子类位于外部包。总结：default拒绝一切包外访问；protected接受包外的子类访问。

3、以下程序会输出什么：

       int a =100,b=50,c=a---b,d=a---b;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);

答： 98 50 50 49

解析：自增自减运算符优先级大于加减运算符的优先级，所以：
int a = 100 , b = 50,c = a - - - b , d = a - - - b;
先考虑a–，a执行后自减操作，即先用a后再自减1，与–a先反
（1）c=a—b，先执行a-b操作，得到c=50，再执行a减1操作，得到a=99
（2）d=a—b，先执行a-b操作，得到d=49，再执行a减1操作，得到a=98
在这里插入图片描述
4、下列说法正确的是( C )

volatile,synchronized 都可以修改变量，方法以及代码块

volatile，synchronized 在多线程中都会存在阻塞问题

volatile能保证数据的可见性，但不能完全保证数据的原子性，synchronized即保证了数据的可见性也保证了原子性

volatile解决的是变量在多个线程之间的可见性、原子性，而sychroized解决的是多个线程之间访问资源的同步性

解析：synchronized关键字和volatile关键字比较：
· volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比synchronized关键字要好。但是volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块。synchronized关键字在JavaSE1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升，实际开发中使用 synchronized 关键字的场景还是更多一些。

· 多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞

· volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。

· volatile关键字主要用于解决变量在多个线程之间的可见性，而 synchronized关键字解决的是多个线程之间访问资源的同步性。

5、以下是java concurrent包下的4个类，选出差别最大的一个（ C ）

Semaphore
ReentrantLock
Future
CountDownLatch

解析：
Semaphore：类，控制某个资源可被同时访问的个数;

ReentrantLock：类，具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大；

Future：接口，表示异步计算的结果；

CountDownLatch：类，可以用来在一个线程中等待多个线程完成任务的类。

6、以下 b 的值是： byte b = (byte)129;

答：- 127

解析：
知识点：一、强制转换（主要涉及各个类型占几个字节，这里我只简单说一下byte型占一个字节，也就是8位，int型4个字节，32位）；二、在计算机系统中，数值一律用补码来表示（存储）。

正数：补码=反码=原码（以二进制形式表达）
129 int类型（4个字节）二进制： 00000000 00000000 00000000 10000001
强制转换byte型后，只有一个字节即 10000001（注意这里从二进制角度看，第一位是符号位，即求负数的补码接下来）
只要求出上面原码对应的补码就行了，然后再转换对应的int型数值（因为题干所给的答案都是比较int型）
10000001（原码）对应的反码为1111 1110，又因为补码等于反码+1
即1111 1111 该二进制转换int型刚好是-127（1+2+4+8+16+32+64）

注意：正数原码，反码，补码相同
负数反码除了符号位不变，其他位取反，补码=反码+1。

7、下列哪个选项是Java调试器？如果编译器返回程序代码的错误，可以用它对程序进行调试。（ C ）

java.exe
javadoc.exe
jdb.exe
javaprof.exe

解析：
javac.exe 是编译.java文件
java.exe 是java虚拟机，执行编译好的.class文件
javadoc.exe 用来制作java文档
jdb.exe 是java的调试器
javaprof.exe 是剖析工具

8、下列Java代码中的变量a、b、c分别在内存的( 堆区、栈区、栈区 )存储区存放。

class A {
    private String a = “aa”;
    public boolean methodB() {
        String b = “bb”;
        final String c = “cc”;
    }
}

解析：a是类中的成员变量，存放在堆区；b、c都是方法中的局部变量，存放在栈区
堆区：只存放类对象，线程共享；
方法区：又叫静态存储区，存放class文件和静态数据，线程共享;
栈区：存放方法局部变量，基本类型变量区、执行环境上下文、操作指令区，线程不共享;

9、CMS垃圾回收器在那些阶段是没用用户线程参与的（ AC ）

初始标记
并发标记
重新标记
并发清理

解析：（注：牛客大佬所写！！！）
CMS全称 Concurrent Mark Sweep，是一款并发的、使用标记-清除算法的垃圾回收器，以牺牲吞吐量为代价来获得最短回收停顿时间的垃圾回收器，对于要求服务器响应速度的应用上，这种垃圾回收器非常适合。
CMS的基础算法是：标记—清除。
它的过程可以分为以下6个步骤：
在这里插入图片描述
①初始标记：在这个阶段，需要虚拟机停顿正在执行的任务，官方的叫法STW(Stop The Word)。这个过程从垃圾回收的"根对象"开始，只扫描到能够和"根对象"直接关联的对象，并作标记。所以这个过程虽然暂停了整个JVM，但是很快就完成了。

②并发标记：这个阶段紧随初始标记阶段，在初始标记的基础上继续向下追溯标记。并发标记阶段，应用程序的线程和并发标记的线程并发执行，所以用户不会感受到停顿。

③并发预清理：并发预清理阶段仍然是并发的。在这个阶段，虚拟机查找在执行并发标记阶段新进入老年代的对象(可能会有一些对象从新生代晋升到老年代，或者有一些对象被分配到老年代)。通过重新扫描，减少下一个阶段"重新标记"的工作，因为下一个阶段会Stop The World。

④重新标记：这个阶段会暂停虚拟机，收集器线程扫描在CMS堆中剩余的对象。扫描从"根对象"开始向下追溯，并处理对象关联。

⑤并发清理：清理垃圾对象，这个阶段收集器线程和应用程序线程并发执行。

⑥并发重置：这个阶段，重置CMS收集器的数据结构，等待下一次垃圾回收。

CMS不会整理、压缩堆空间，这样就带来一个问题：经过CMS收集的堆会产生空间碎片，CMS不对堆空间整理压缩节约了垃圾回收的停顿时间，但也带来的堆空间的浪费。

为了解决堆空间浪费问题，CMS回收器不再采用简单的指针指向一块可用堆空间来为下次对象分配使用。而是把一些未分配的空间汇总成一个列表，当JVM分配对象空间的时候，会搜索这个列表找到足够大的空间来hold住这个对象。

从上面的图可以看到，为了让应用程序不停顿，CMS线程和应用程序线程并发执行，这样就需要有更多的CPU，单纯靠线程切换是不靠谱的。并且，重新标记阶段，为空保证STW快速完成，也要用到更多的甚至所有的CPU资源。

B.并发标记和 D.并发清理这两个阶段是有用户线程参与的，所以答案选A和C。

10、下面的Java赋值语句哪些是有错误的（ BF ）

int i =1000;
float f = 45.0;
char s = ‘\u0639’
Object o = ‘f’;
String s = “hello,world\0”;
Double d = 100;

解析：选项F是自动装箱，装箱过程中调用的是Double类的valueOf( double d )方法，而这里是100为int型，所以编译会“cannot convert from int to Double”。

11、以下叙述正确的是（ D ）

实例方法可直接调用超类的实例方法
实例方法可直接调用超类的类方法
实例方法可直接调用子类的实例方法
实例方法可直接调用本类的实例方法

解析：
类的实例方法是与该类的实例对象相关联的，不能直接调用，只能通过创建超类的一个实例对象，再进行调用

当父类的类方法定义为private时，对子类是不可见的，所以子类无法调用

子类具体的实例方法对父类是不可见的，所以无法直接调用，只能通过创建子类的一个实例对象，再进行调用

实例方法可以调用自己类中的实例方法

12、下面哪种流可以用于字符输入：（ C ）

java.io.inputStream
java.io.outputStream
java.io.inputStreamReader
java.io.outputStreamReader

解析：A和C之间，inputStream是字节流输入流；而inputStreamReader是对字符流的处理，inputStreamReader将字符流处理成字节流，题目要求是用于处理字符输入，所以选C。

13、以下描述正确的是（ B ）

CallableStatement是PreparedStatement的父接口
PreparedStatement是CallableStatement的父接口
CallableStatement是Statement的父接口
PreparedStatement是Statement的父接口

解析：
在这里插入图片描述
14、

public void test() {
        int a = 10;
        System.out.println(a++ + a--);
    }

最后输出什么？
答： 21

解析：a++ 先把10赋值给a 再+1 所以左边是10 但此时a=11。右边a-- 也是先赋值 a=11，再-1。10+11=21 此时a=10。

15、下面不是面向对象的基本原则的是？（ C ）

单一职责原则（Single-Resposibility Principle）
开放封闭原则（Open-Closed principle）
抽象类原则（Abstract-Class principle）
依赖倒置原则（Dependecy-Inversion Principle）
接口隔离原则（Interface-Segregation Principle）

解析：面向对象的五大基本原则：单一职责原则（SRP）、开放封闭原则（OCP）、里氏替换原则（LSP）、依赖倒置原则（DIP）、接口隔离原则（ISP）。

16、What will happen when you attempt to compile and run the following code?

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;
 }
}

答：prints:3

解析：静态语句块中x为局部变量，不影响静态变量x的值

x和y为静态变量，默认初始值为0，属于当前类，其值得改变会影响整个类运行。

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

17、已知String a=“a”,String b=“b”,String c=a+b,String d=new String(“ab”) 以下操作结果为true的是（ AD ）

(a+b).equals( c )
a+b= =c
c= =d
c.equals(d)

解析：
= = 和 equals():
(1)“= =” 用于比较基本数据类型时比较的是值，用于比较引用类型时比较的是引用指向的地址。
(2)Object 中的equals() 与 “==” 的作用相同，但String类重写了equals()方法，比较的是对象中的内容。

18、以下说法错误的是（ BCD ）

其他选项均不正确
java线程类优先级相同
Thread和Runnable接口没有区别
如果一个类继承了某个类，只能使用Runnable实现线程

解析：
B选项，在java中线程是有分优先等级的所以优先级不能相同，错误

C选项，Thread实现了Runnable接口是一个类不是接口，错误

D选项，实现多线程的三种方式，一种是继承Thread类使用此方式就不能继承其他的类了。还有两种是实现Runnable接口或者实现Callable接口
，所以D错误。

19、下列容器中，哪些容器按 key 查找的复杂度为 O(log(n)) （ BC ）

std::unordered_set
std::multimap
std::map
std::deque

解析：
在这里插入图片描述
20、以下可以正确获取结果集的有（ AD ）

Statement sta=con.createStatement();
ResultSet rst=sta.executeQuery(“select * from book”);

Statement sta=con.createStatement(“select * from book”); ResultSet rst=sta.executeQuery();

PreparedStatement pst=con.prepareStatement();
ResultSet rst=pst.executeQuery(“select * from book”);

PreparedStatement pst=con.prepareStatement(“select * from book”);
ResultSet rst=pst.executeQuery();

解析：preparedStatement和statement的区别与联系：在JDBC应用中,如果你已经是稍有水平开发者,你就应该始终以PreparedStatement代替Statement.也就是说,在任何时候都不要使用Statement。 PreparedStatement 接口继承 Statement ， PreparedStatement 实例包含已编译的 SQL 语句，所以其执行速度要快于 Statement 对象。 Statement为一条Sql语句生成执行计划，如果要执行两条sql语句
select colume from table where colume=1;select colume from table where colume=2; 会生成两个执行计划一千个查询就生成一千个执行计划！ PreparedStatement用于使用绑定变量重用执行计划 select colume from table where colume=:x; 通过set不同数据只需要生成一次执行计划，可以重用。

21、如果类的方法没有返回值，该方法的返回值类型应当是abstract。（错误）

解析：如果类的方法没有返回值，该方法的返回值类型应当是void。
被abstract修饰的类是抽象类，抽象类不能被实例化，但是可以被继承，也可以继承。

22、

int  i, sum=0;
for(i=0;i<10;++i,sum+=i);

i 的最终结果是？
答： 10

解析：i = 10; sum = 55;

23、指出下列程序运行的结果（）

public class Example{
    String str = new String("good");
    char[ ] ch = { 'a' , 'b' , 'c' };
    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] = 'g';
    }
}

结果： good and gbc

解析：直接赋值而不是使用new关键字给字符串初始化，在编译时就将String对象放进字符串常量池中；使用new关键字初始化字符串时，是在堆栈区存放变量名和内容；字符串的拼接操作在程序运行时，才在堆中创建对象。一般，可以认为用"=="比较的是引用，equals比较的是内容。

24、下面的方法，当输入为2的时候返回值是多少？

public static int getValue(int i) {
	int result = 0;
	switch (i) {
		case 1:
		result = result + i;
		case 2:
		result = result + i * 2;
		case 3:
		result = result + i * 3;
	}
	return result;
}

答：10

解析：没有break，发生case穿透现象，程序会继续向下执行，直到遇到break或者结束switch语句的大括号为止。

25、给定以下JAVA代码，这段代码运行后输出的结果是（）

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");
    }
}

答：finally finished

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

26、某程序要求每次输入只能是正整数，并且每次输入的数值要求必须是100的倍数且小于等于500，则下列哪个是正确的无效等价类( D )

（0，100）、（100，200）、（200，300）、（300，400）、（400，500）、（500，+∞）;

（500，+∞）

（500，+∞）、任意大于0小于500的非100倍数的整数；

（-∞，100）、（100，200）、（200，300）、（300，400）、（400，500）、（500，+∞）;

解析：无效等价类和有效等价类相反，即不满足程序输入要求或者无效的输入数据构成的集合。

27、对于如下代码段

class A{
    public A foo(){return this;}
}
class B extends A{
    public A foo(){
        return this;
    }
}
class C extends B{
    _______
}

可以放入到横线位置，使程序正确编译运行，而且不产生错误的选项是（ C ）

public void foo(){}
public int foo(){return 1;}
public A foo(B b){return b;}
public A foo(){return A;}

解析：重写要求两同两小一大原则，方法名相同，参数类型相同，子类返回类型小于等于父类方法返回类型，子类抛出异常小于等于父类方法抛出异常，子类访问权限大于等于父类方法访问权限。［注意：这里的返回类型必须要在有继承关系的前提下比较］

重载方法名必须相同，参数类型必须不同，包括但不限于一项，参数数目，参数类型，参数顺序

这道题 A B 都是方法名和参数相同，是重写，但是返回类型没与父类返回类型有继承关系，错误 D 返回一个类错误 c的参数类型与父类不同，所以不是重写，可以理解为广义上的重载访问权限小于父类，都会显示错误；虽然题目没点明一定要重载或者重写，但是当你的方法名与参数类型与父类相同时，已经是重写了，这时候如果返回类型或者异常类型比父类大，或者访问权限比父类小都会编译错误

28、下列哪一项不属于Swing的顶层容器？（ B ）

JApplet
JTree
JDialog
JFrame

解析：顶层容器是指可以不能被其他容器包含是容纳其他容器的容器组件，顶层容器包含JApplet、JDialog、JFrame和JWindow及其子类. JFrame中就可以放Jtree（树形组件）所以B不是

29、以下代码将打印出？

public static void main (String[] args) { 
    String classFile = "com.jd.". replaceAll(".", "/") + "MyClass.class";
    System.out.println(classFile);
}

答：///MyClass.class

解析：由于replaceAll方法的第一个参数是一个正则表达式，而".“在正则表达式中表示任何字符，所以会把前面字符串的所有字符都替换成”/"。如果想替换的只是"."，那么就要写成"\."

30、以下JSP代码定义了一个变量，如何输出这个变量的值？（ BCD ）
< bean:define id=“stringBean” value=“helloWorld”/ >

选项：
< bean:write name=“helloWorld”/ >

<%=stringBean%>

< bean:write name=“stringBean”/ >

< %String myBean = (String) pageContext.getAttribute (“stringBean”,PageContext.PAGE_SCOPE) ;% >< %=myBean% >

解析：bean:define：定义新字符串常量。
< bean:define id=“stringBean” value=“helloWorld”/>定义了一个id为stringBean的字符串

C选项：< bean:write name=“stringBean”/>：该标签将指定的bean的属性值写到当前的JspWriter中，并且可以对输出进行格式化。可在jsp页面中通过bean:write将name属性输出。

D选项：<%String myBean=(String)pageContext.getAttribute(“stringBean”,PageContext.PAGE_SCOPE);%>：pageContext是PageContext类的实例，使用pageContext可以访问page、request、session、application范围的变量。

第五周期

1、下面有关List接口、Set接口和Map接口的描述，错误的是？（ A ）

他们都继承自Collection接口

List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置

Set是一种不包含重复的元素的Collection

Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value

解析：
在这里插入图片描述
2、如下代码的结果是什么 ?

class Base {
    Base() {
    System.out.print("Base");
    }
}
public class Alpha extends Base {
    public static void main( String[] args ) {
        new Alpha();
        //调用父类无参的构造方法
        new Base();
    }
}

结果： BaseBase

解析：在执行new Alpha()时，会先执行父类的构造方法，在执行相应的子类的构造方法，所以此处会打印Base，在执行new Base()时，会直接执行Base中无参构造器的代码，再输出Base，所以选B

3、在面向对象编程里，经常使用is-a来说明对象之间的继承关系，下列对象中不具备继承关系的是？（ D ）

手机与小米手机
企业家与雷军
编程语言与Java
中国与北京

解析：小米手机是一个手机；雷军是一个企业家；Java是一门编程语言；中国与北京不具备继承关系。

4、下面关于JAVA的垃圾回收机制，正确的是（ B ）

当调用“System.gc()”来强制回收时，系统会立即回收垃圾
垃圾回收不能确定具体的回收时间
程序可明确地标识某个局部变量的引用不再被使用
程序可以显式地立即释放对象占有的内存

解析：java提供了一个系统级的线程，即垃圾回收器线程。用来对每一个分配出去的内存空间进行跟踪。当JVM空闲时，自动回收每块可能被回收的内存，GC是完全自动的，不能被强制执行。程序员最多只能用System.gc()来建议执行垃圾回收器回收内存，但是具体的回收时间，是不可知的。当对象的引用变量被赋值为null，可能被当成垃圾。

5、下面这三条语句，的输出结果分别是？ ( D )

System.out.println("is"+ 100 + 5);
System.out.println(100 + 5 +"is");
System.out.println("is"+ (100 + 5));

is 1005, 1005 is, is 1005
is 105, 105 is, is 105
is 1005, 1005 is, is 105
is 1005, 105 is, is 105

解析："is"说明后面的内容都会被强制转换string，所以是最后结果是拼接起来的

100+5先得到105，然后与is拼接

先算括号内的

6、下列说法正确的是 ( C )

WebLogic中开发消息Bean的non－persistent 方式可以保证消息的可靠

EJB容器发生错误，non－persistent方式下JMS容器仍然会将消息发送

EJB容器发生错误，persistent方式下JMS容器仍然会将消息发送

EJB容器发生错误，两种方式下JMS容器仍会在MDB可用的时候将消息发送

解析：weblogic中开发消息Bean时的persistent与non-persisten的差别：
· persistent方式的MDB可以保证消息传递的可靠性,也就是如果EJB容器出现问题而JMS服务器依然会将消息在此MDB可用的时候发送过来。

· non－persistent方式的消息将被丢弃。

7、有以下一个对象：

public class DataObject implements Serializable{
    private static int i=0;
    private String word=" ";
    public void setWord(String word){
        this.word=word;
    }
    public void setI(int i){
        Data0bject. i=I;
     }
}

创建一个如下方式的DataObject：

DataObject object=new Data0bject ( );
object. setWord("123");
object. setI(2);

将此对象序列化为文件，并在另外一个JVM中读取文件，进行反序列化，请问此时读出的Data0bject对象中的word和i的值分别为：( “123” , 0 )

解析：这道题的答案应该是: D,序列化保存的是对象的状态，静态变量属于类的状态，因此，序列化并不保存静态变量。所以i是没有改变的

8、在各自最优条件下,对N个数进行排序,哪个算法复杂度最低的是? （ A ）

在各自最优条件下,对N个数进行排序,哪个算法复杂度最低的是? （）

插入排序
快速排序
堆排序
归并排序

解析：
在这里插入图片描述
9、若需要定义一个类，下列哪些修饰符是允许被使用的？（ ACD ）

static
package
private
public

解析：这题只说定义一个类，但是没有说这个类是普通外部类或者内部类。

因为普通类也就是外部类，通过 eclipse 的警告“Illegal modifier for the class Test; only public, abstract & final are permitted” 可知只能用 public, abstract 和 final 修饰。

内部类则可以用修饰成员变量的修饰符修饰内部类，比如 private, static, protected 修饰。

10、Which are keywords in Java? （ DE ）

null
true
sizeof
implements
instanceof

解析： java中true ,false , null在java中不是关键字，也不是保留字，它们只是显式常量值，但是你在程序中不能使用它们作为标识符。
其中const和goto是java的保留字。java中所有的关键字都是小写的，还有要注意true,false,null,　friendly，sizeof不是java的关键字,但是你不能把它们作为java标识符用。

可参考：http://download.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html

11、编译java程序的命令文件是( B )

java.exe
javac.exe
applet.exe

解析：
javac.exe是编译功能javaCompiler
java.exe是执行程序，用于执行编译好的.class文件
javadoc.exe用来制作java文档
jdb.exe是java的调试器
javaprof.exe是剖析工具

12、以下程序输出（ 5 ）

public static void main(String[] args) {
   int num = 2;
   switch (num) {
   case 1:
        ++num;
   case 2:
        ++num;
   case 3:
        ++num;
   default:
        ++num;
   break;
   }
   System.out.println(num);
 }
}

解析：遇到break才跳出，default : 表示“默认”，即其他情况都不满足。default 后要紧跟冒号，default 块和 case 块的先后顺序可以变动，不会影响程序执行结果。通常，default 块放在末尾，也可以省略不写。break : 表示“停止”，即跳出当前结构。如果在 case 分支语句的末尾没有 break 语句，有可能触发多个 case 分支。那么就会接着执行下一个 case 分支语句。这种情况相当危险，常常会引发错误。为此，我们在程序中从不使用 switch 语句。

13、下列程序的运行结果 ( pongping )

public static void main(String args[]) {
    Thread t = new Thread() {
        public void run() {
            pong();
        }
    };
    t.run();
    System.out.print("ping");
}
static void pong() {
    System.out.print("pong");
}

解析：这里需要注意Thread的start和run方法
用start方法才能真正启动线程，此时线程会处于就绪状态，一旦得到时间片，则会调用线程的run方法进入运行状态。
而run方法只是普通方法，如果直接调用run方法，程序只会按照顺序执行主线程这一个线程。

14、关于下面程序，哪些描述是正确的: ( B )

 public class While {
	public void loop() {
		int x= 10;
		while ( x )  {
			System.out.print("x minus one is " + (x - 1));
			x -= 1;
		}
	}
}

行1有语法错误
行4有语法错误
行5有语法错误
行6有语法错误
行2有语法错误,loop是关键字
程序能够正常编译和运行

解析：这个题主要考while（）中表达式的判断，在C语言中大于0的int值都会被认为是true，而java中没有这个机制，必须是boolean类型的。

15、在 main() 方法中给出的整型数组，如果将其写到一个文件中，需要（ B ）。

System.out.print (buffer[i]);
DataOutputStream dout = new DataOutputStream(new FileOutputStream(this.filename));
DataInputStream din = new DataInputStream(new FileInputStream(this.filename));。
System.in.read(buffer)。

解析：input和output指的是对于程序而言。input是从文件读取进来，output是输出到文件。

16、如果一个list初始化为{5，3，1}，执行以下代码后，其结果为（ B ）？

nums.add(6);
nums.add(0,4);
nums.remove(1);

解析：
nums.add(6); //把6添加到list中，变为｛5,3,1,6｝
nums.add(0,4); //在list的第0个位置添加4，list变为｛4,5,3,1,6｝
nums.remove(1); //移除list的第一个元素，list变为｛4,3,1,6｝

17、关于以下代码的说明，正确的是（ C ）

class StaticStuff{
	static int x=10；
	static { x+=5；}
	public static void main（String args[ ]）
	{
	System.out.println(“x=” + x);
	}
	static { x/=3;}
	}

结果：编译通过，执行结果为：x=5

解析：java初始化的加载顺序为：父类静态成员变量父类静态代码块子类静态成员变量子类静态代码块父类非静态成员变量，父类非静态代码块，父类构造函数，子类非静态成员变量，子类非静态代码块，子类构造函数

18、判断一块内存空间是否符合垃圾收集器收集的标准有哪些？（ ABD ）

给对象赋予了空值null,以下再没有调用过
对象重新分配了内存空间
给对象赋予了空值null
给对象赋予了新值

解析：在java语言中，判断一块内存空间是否符合垃圾收集器收集标准的标准只有两个：
· 给对象赋值为null，以下没有调用过。
· 给对象赋了新的值，重新分配了内存空间。

19、关于struts项目中的类与MVC模式的对应关系，说法错误的是（ CD ）

Jsp文件实现视图View的功能
ActionServlet这一个类是整个struts项目的控制器
ActionForm、Action都属于Model部分
一个struts项目只能有一个Servlet

解析：
在这里插入图片描述
20、关于Java内存区域下列说法不正确的有哪些（ BC ）

程序计数器是一块较小的内存空间，它的作用可以看做是当前线程所执行的字节码的信号指示器，每个线程都需要一个独立的程序计数器.

Java虚拟机栈描述的是java方法执行的内存模型，每个方法被执行的时候都会创建一个栈帧，用于存储局部变量表、类信息、动态链接等信息

Java堆是java虚拟机所管理的内存中最大的一块，每个线程都拥有一块内存区域，所有的对象实例以及数组都在这里分配内存。

方法区是各个线程共享的内存区域，它用于存储已经被虚拟机加载的常量、即时编译器编译后的代码、静态变量等数据。

解析：
A.程序计数器是一块较小的内存空间，它的作用可以看做是当前线程所执行的字节码的信号指示器（偏移地址），Java编译过程中产生的字节码有点类似编译原理的指令，程序计数器的内存空间存储的是当前执行的字节码的偏移地址，每一个线程都有一个独立的程序计数器（程序计数器的内存空间是线程私有的），因为当执行语句时，改变的是程序计数器的内存空间，因此它不会发生内存溢出，并且程序计数器是jvm虚拟机规范中唯一一个没有规定 OutOfMemoryError 异常的区域；

B.java虚拟机栈：线程私有，生命周期和线程一致。描述的是 Java 方法执行的内存模型：每个方法在执行时都会床创建一个栈帧(Stack Frame)用于存储局部变量表、操作数栈、动态链接、方法出口等信息。每一个方法从调用直至执行结束，就对应着一个栈帧从虚拟机栈中入栈到出栈的过程。没有类信息，类信息是在方法区中

C.java堆：对于绝大多数应用来说，这块区域是 JVM 所管理的内存中最大的一块。线程共享，主要是存放对象实例和数组

D.方法区：属于共享内存区域，存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

可参考：https://blog.csdn.net/qq_41701956/article/details/81664921

21、已知int a[]=new int[10]，则下列对数组元素的访问不正确的是（ D ）

a[0]
a[1]
a[9]
a[10]

解析：对应角标0-9

22、下列代码的执行结果是（ B ）

public class Test {

    public static int a = 1;

    public static void main(String[] args) {

        int a = 10;

        a++; Test.a++;

        Test t=new Test();

        System.out.println("a=" + a + " t.a=" + t.a);

    }

}

a=10 t.a=3
a=11 t.a=2
a=12 t.a=1
a=11 t.a=1

解析：值为1的a属于类变量也叫作成员变量，值为10的a是局部变量首先a＋＋时就近原则，用局部变量10来加，Text.a直接用类名调用成员变量的情况，只能是static 修饰的成员变量1来加，然后又实例化了对象，在输出中第一个a＝用就近原则输出11，第二个t.a 对象只能调用类变量输出2

23、下列说法正确的是( C )

volatile,synchronized ，都可以修改变量，方法以及代码块

volatile，synchronized 在多线程中都会存在阻塞问题

volatile能保证数据的可见性，但不能完全保证数据的原子性，synchronized即保证了数据的可见性也保证了原子性

volatile解决的是变量在多个线程之间的可见性、原子性，而sychroized解决的是多个线程之间访问资源的同步性

解析：关键字volatile是线程同步的轻量级实现，所以volatile性能肯定比synchronized要好，并且只能修改变量，而synchronized可以修饰方法，以及代码块。多线程访问volatile不会发生阻塞，而synchronized会出现阻塞，volatile能保证数据的可见性，但不能保证原子性；而synchronized可以保证原子性，也可以间接保证可见性，因为它会将私有内存和公共内存中的数据做同步，关键字volatile解决的下变量在多线程之间的可见性；而synchronized解决的是多线程之间资源同步问题

24、下面关于hibernate核心接口说明错误的是？（ B ）

Configuration 接口：配置Hibernate，根据其启动hibernate，创建SessionFactory 对象

SessionFactory 接口：负责保存、更新、删除、加载和查询对象，是线程不安全的，避免多个线程共享同一个session，是轻量级、一级缓存

Query 和Criteria 接口：执行数据库的查询

Transaction 接口：管理事务

解析：
Configuration接口：配置Hibernate，根据其启动Hibernate，创建SessionFactory对象；

SessionFactory接口：初始化Hibernate，充当数据存储源的***，创建session对象，SessionFactory是
线程安全的，意味着它的同一个实例可以被应用的多个线程共享，是重量级二级缓存；

session接口：负责保存、更新、删除、加载和查询对象，是一个非线程安全的，避免多个线程共享一个session，是轻量级，一级缓存。

Transaction接口：管理事务。可以对事务进行提交和回滚；

Query和Criteria接口：执行数据库的查询。

25、下列哪项不属于jdk1.6垃圾收集器？（ D ）

Serial收集器
parNew收集器
CMS收集器
G1收集器

解析：
① Serial收集器
单线程收集器，收集时会暂停所有工作线程（我们将这件事情称之为Stop The World，下称STW），使用复制收集算法，虚拟机运行在Client模式时的默认新生代收集器。

② ParNew收集器
ParNew 收集器就是Serial的多线程版本，除了使用多条收集线程外，其余行为包括算法、STW、对象分配规则、回收策略等都与Serial收集器一摸一样。对应的这种收集器是虚拟机运行在Server模式的默认新生代收集器，在单CPU的环境中，ParNew收集器并不会比Serial收集器有更好的效果。

③ Parallel Scavenge收集器
Parallel Scavenge收集器（下称PS收集器）也是一个多线程收集器，也是使用复制算法，但它的对象分配规则与回收策略都与ParNew收集器有所不同，它是以吞吐量最大化（即GC时间占总运行时间最小）为目标的收集器实现，它允许较长时间的STW换取总吞吐量最大化。

④ Serial Old收集器
Serial Old是单线程收集器，使用标记－整理算法，是老年代的收集器，上面三种都是使用在新生代收集器。

⑤ Parallel Old收集器
老年代版本吞吐量优先收集器，使用多线程和标记－整理算法，JVM 1.6提供，在此之前，新生代使用了PS收集器的话，老年代除Serial Old外别无选择，因为PS无法与CMS收集器配合工作。

⑥ CMS（Concurrent Mark Sweep）收集器
CMS 是一种以最短停顿时间为目标的收集器，使用CMS并不能达到GC效率最高（总体GC时间最小），但它能尽可能降低GC时服务的停顿时间，这一点对于实时或者高交互性应用（譬如证券交易）来说至关重要，这类应用对于长时间STW一般是不可容忍的。CMS收集器使用的是标记－清除算法，也就是说它在运行期间会产生空间碎片，所以虚拟机提供了参数开启CMS收集结束后再进行一次内存压缩。

26、在java中，下列对继承的说法，正确的是（ A ）

子类能继承父类的所有成员
子类继承父类的非私有方法和状态
子类只能继承父类的public方法和状态
子类只能继承父类的方法

解析：在一个子类被创建的时候，首先会在内存中创建一个父类对象，然后在父类对象外部放上子类独有的属性，两者合起来形成一个子类的对象。所以所谓的继承使子类拥有父类所有的属性和方法其实可以这样理解，子类对象确实拥有父类对象中所有的属性和方法，但是父类对象中的私有属性和方法，子类是无法访问到的，只是拥有，但不能使用。就像有些东西你可能拥有，但是你并不能使用。所以子类对象是绝对大于父类对象的，所谓的子类对象只能继承父类非私有的属性及方法的说法是错误的。可以继承，只是无法访问到而已。

27、下面哪些标识符是正确的？（ AB ）

MyWorld
parseXML
–value
&maybe

解析：Java中标识符有字母、数字、美元符号$、下划线4种，不能以数字开头，不能用保留字和关键字

28、下面关于volatile的功能说法正确的是哪个（ BC ）

原子性
有序性
可见性
持久性

解析：synchronized保证三大性，原子性，有序性，可见性，volatile保证有序性，可见性，不能保证原子性

29、下面有关servlet的层级结构和常用的类，说法正确的有? （ABCD）

GenericServlet类：抽象类，定义一个通用的、独立于底层协议的Servlet。

大多数Servlet通过从GenericServlet或HttpServlet类进行扩展来实现

ServletConfig接口定义了在Servlet初始化的过程中由Servlet容器传递给Servlet得配置信息对象

HttpServletRequest接口扩展ServletRequest接口，为HTTP Servlet提供HTTP请求信息

解析：
在这里插入图片描述
30、下面哪项技术可以用在WEB开发中实现会话跟踪实现？（ABCD）

session
Cookie
地址重写
隐藏域

解析：会话跟踪是一种灵活、轻便的机制，它使Web上的状态编程变为可能。
HTTP是一种无状态协议，每当用户发出请求时，服务器就会做出响应，客户端与服务器之间的联系是离散的、非连续的。当用户在同一网站的多个页面之间转换时，根本无法确定是否是同一个客户，会话跟踪技术就可以解决这个问题。当一个客户在多个页面间切换时，服务器会保存该用户的信息。
有四种方法可以实现会话跟踪技术：URL重写、隐藏表单域、Cookie、Session。
① 隐藏表单域：，非常适合步需要大量数据存储的会话应用。
② URL 重写:URL 可以在后面附加参数，和服务器的请求一起发送，这些参数为名字/值对。
③ Cookie:一个 Cookie 是一个小的，已命名数据元素。服务器使用 SET-Cookie 头标将它作为 HTTP
响应的一部分传送到客户端，客户端被请求保存 Cookie 值，在对同一服务器的后续请求使用一个
Cookie 头标将之返回到服务器。与其它技术比较，Cookie 的一个优点是在浏览器会话结束后，甚至
在客户端计算机重启后它仍可以保留其值
④ Session：使用 setAttribute(String str,Object obj)方法将对象捆绑到一个会话

第六周期

1、定义一个接口必须使用的关键字是？（ interface ）

2、在程序代码中写的注释太多，会使编译后的程序尺寸变大。（错误）

解析：注释不参与编译

3、

public boolean returnTest()
{
    try
    {
        return true;
    }
    catch (Exception e)
    {
 
    }
    finally
    {
        return false;
    }
}

以上代码返回值是什么？

答：false

解析：一旦在finally块中使用了return或throw语句，将会导致try块，catch块中的return，throw语句失效

4、Given the following code:

public class Test {
    private static int j = 0;
 
    private static Boolean methodB(int k) {
        j += k;
        return true;
    }
 
    public static void methodA(int i) {
        boolean b;
        b = i < 10 | methodB(4);
        b = i < 10 || methodB(8);
 
    }
 
    public static void main(String args[]) {
        methodA(0);
        System.out.println(j);
    }
}

What is the result ? ( B )

The program prints”0”
The program prints”4”
The program prints”8”
The program prints”12”
The code does not complete.

解析：
在main函数中先调用methodA（0）
在methodA中，第二行

b = i < 10 | methodB(4); //中间为与计算符，执行完methodB(4)后，j = 4
methodA中，第三行

b = i < 10 || methodB(8);//中间为或计算符，因为i < 10 已成立，不需要后续计算
所以最后结果输出为4

5、下面程序的输出是什么？

package algorithms.com.guan.javajicu;
public class TestDemo
{
    public static String output = ””;
    public static void foo(inti)
    {
        try
        {
            if (i == 1)
            {
                throw new Exception();
            }
        }
        catch (Exception e)
        {
            output += “2”;
            return ;
        } finally
        {
            output += “3”;
        }
        output += “4”;
    }
    public static void main(String[] args)
    {
        foo(0);
        foo(1);
        System.out.println(output);
    }
}

答：3423

解析：首先是foo(0),在try代码块中未抛出异常，finally是无论是否抛出异常必定执行的语句，所以 output += “3”;然后是 output += “4”; 执行foo(1)的时候，try代码块抛出异常，进入catch代码块，output += “2”; 前面说过finally是必执行的，即使return也会执行output += “3”
由于catch代码块中有return语句，最后一个output += “4”不会执行。
所以结果是3423

6、public class contained in a Java program file must have the same name as the file, except for the extension “.java”.

答：FALSE

解析：除去扩展名.java的部分，包含在java文件里的Java里的公共类必须与文件的名字相同。但是公共的内部类是不需要和文件的名字相同的。

7、下面有关java object默认的基本方法，说法错误的是？（ B ）

equals(Object obj) 指示某个其他对象是否与此对象“相等”
copy() 创建并返回此对象的一个副本
wait() 导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法
toString() 返回该对象的字符串表示

解析：Object中没有copy方法

8、以下哪一个不是赋值符号？（ C ）

A +=
B <<=
C <<<=
D >>>=

解析：
A 很明显是赋值符号
B <<=左移赋值
C 不是
D >>>= 右移赋值，左边空出的位以0填充

9、java中Hashtable, Vector, TreeSet, LinkedList哪些线程是安全的？（ AB ）

Hashtable
Vector
TreeSet
LinkedList

解析：HashMap是线程安全的HashMap
Vector是线程安全的ArrayList
TreeSet和LinkedList都不是线程安全的

10、在java中重写方法应遵循规则的包括（ BC ）

访问修饰符的限制一定要大于被重写方法的访问修饰符
可以有不同的访问修饰符
参数列表必须完全与被重写的方法相同
必须具有不同的参数列表

解析：

方法重写

· 参数列表必须完全与被重写方法的相同；
· 返回类型必须完全与被重写方法的返回类型相同；
· 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
· 父类的成员方法只能被它的子类重写。
· 声明为final的方法不能被重写。
· 声明为static的方法不能被重写，但是能够被再次声明。
· 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
· 子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
· 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
· 构造方法不能被重写。
· 如果不能继承一个方法，则不能重写这个方法。

方法重载

· 被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；
· 被重载的方法可以改变返回类型；
· 被重载的方法可以改变访问修饰符；
· 被重载的方法可以声明新的或更广的检查异常；
· 方法能够在同一个类中或者在一个子类中被重载。
· 无法以返回值类型作为重载函数的区分标准。

11、若有定义：byte[]x={11,22,33,﹣66}；其中0≤k≤3，则对x数组元素错误的引用是（ C ）

x[5-3]
x[k]
x[k+5]
x[0]

解析：下标越界问题，数组中有4个元素，下标对应为0~3，C选项中下标越界了。

12、Java Application 源程序的主类是指包含有（ A ）方法的类。

public static void main方法
toString方法
init方法
actionPerfromed方法

解析：main方法是Java程序的入口

13、以下哪个方法用于定义线程的执行体？（ C ）

start()
join()
run()
synchronized()

解析：start（）方法是执行线程
join（）方法是停止当前正在运行的线程，运行该线程，直到结束。
run（）方法是线程所执行的方法体
synchronized是同步代码块加锁解锁用的

14、执行下列程序的输出结果为（）

public class Test {
 public static void main(String[] args) {
 String s1 = "HelloWorld";
 String s2 = new String("HelloWorld");
 if (s1 == s2) {
 System.out.println("s1 == s2");
 } else {
 System.out.println("s1 != s2");
 }
 if (s1.equals(s2)) {
 System.out.println("s1 equals s2");
 } else {
 System.out.println("s1 not equals s2");
 }
 }
 }

结果：s1 != s2
s1 equals s2

解析：= = 和 equals():
(1)“ = = ” 用于比较基本数据类型时比较的是值，用于比较引用类型时比较的是引用指向的地址。
(2)Object 中的equals() 与 “==” 的作用相同，但String类重写了equals()方法，比较的是对象中的内容。

15、以下关于 abstract 关键字的说法，正确的是（ D ）

abstract 可以与final 并列修饰同一个类。
abstract 类中不可以有private的成员。
abstract 类中必须全部是abstract方法。
abstract 方法必须在abstract类或接口中。

解析：abstract类不能与final,static使用。final修饰方法，子类可以调用，但不能覆盖。

最好不要有private因为私有和抽象放在一起，子类如果想重写父类的私有方法根本继承不过来，也就无法重写

抽象类中可以有非抽象方法

抽象类中可以都是非抽象的，但是抽象方法一定要在类和接口中

16、根据下面的程序代码，哪些选项的值返回true？ ( C )

public class Square {  
    long width;  
    public Square(long l) {   
        width = l;  
    }  
    public static void main(String arg[]) {   
        Square a, b, c;  
        a = new Square(42L);   
        b = new Square(42L);   
        c = b;   
        long s = 42L;  
    } 
}

a = = b
s = = a
b = = c
a.equals(s)

解析：

这题考的是引用和内存。
//声明了3个Square类型的变量a, b, c
//在stack中分配3个内存，名字为a, b, c
Square a, b, c; 
//在heap中分配了一块新内存，里边包含自己的成员变量width值为48L，然后stack中的a指向这块内存
a = new Square(42L);
//在heap中分配了一块新内存，其中包含自己的成员变量width值为48L，然后stack中的b指向这块内存
b = new Square(42L);   
//stack中的c也指向b所指向的内存
c = b;
//在stack中分配了一块内存，值为42
long s = 42L;

在这里插入图片描述
A: a = = b
由图可以看出a和b指向的不是同一个引用，故A错
B：s = = a
一个Square类型不能与一个long型比较，编译就错误，故B错
C：b = = c
由图可以看出b和c指向的是同一个引用，故C正确
D：a equal s
程序会把s封装成一个Long类型，由于Square没有重写Object的equals方法，所以调用的是Object类的equals方法，源码如下

 public boolean equals(Object obj) {
     return (this == obj);
 }

其实就是判断两个引用是否相等，故D也错误。

17、下面的程序输出的结果是( B )

public class A implements B{
public static void main(String args[]){
    int i;
    A a1=new  A();
    i =a1.k;
    System.out.println("i="+i);
    }
}
interface B{
    int k=10；
}

i=0
i=10
程序有编译错误
i=true

解析：在接口里面的变量默认都是public static final 的，它们是公共的,静态的,最终的常量.相当于全局常量，可以直接省略修饰符。实现类可以直接访问接口中的变量

18、下面这段java代码，当 T 分别是引用类型和值类型的时候，分别产生了多少个 T对象和T类型的值（ D ）

T t = new T();(值类型时:T t;)
Func(t);
Func 定义如下：
public void Func(T t) {  }

1 1
2 1
2 2
1 2

解析：引用类型作为函数的参数时，复制的是引用的地址，不会产生一个新的T；而如果T是值类型，其作为函数实参时会复制其值，也就是产生了一个新的T。所以D选项正确

19、关于ASCII码和ANSI码，以下说法不正确的是（ D ）？

标准ASCII只使用7个bit
在简体中文的Windows系统中，ANSI就是GB2312
ASCII码是ANSI码的子集
ASCII码都是可打印字符

解析：标准ASCII只使用7个bit，扩展的ASCII使用8个bit。

ANSI通常使用 0x00 ~ 0x7f 范围的1 个字节来表示 1 个英文字符。超出此范围的使用0x80 ~ 0xFFFF来编码，即扩展的ASCII编码。不同 ANSI 编码之间互不兼容。在简体中文Windows操作系统中，ANSI 编码代表 GBK 编码；在繁体中文Windows操作系统中，ANSI编码代表Big5；在日文Windows操作系统中，ANSI 编码代表 Shift_JIS 编码。

ANSI通常使用 0x00~0x7f 范围的1 个字节来表示 1 个英文字符，即ASCII码

ASCII码包含一些特殊空字符

20、DBMS 中实现事务持久性的子系统是( D )

安全性管理子系统
完整性管理子系统
并发控制子系统
恢复管理子系统

解析：原子性：事务是一组不可分割的操作单元，这组单元要么同时成功要么同时失败（由DBMS的事务管理子系统来实现）；

一致性：事务前后的数据完整性要保持一致（由DBMS的完整性子系统执行测试任务）；

隔离性:多个用户的事务之间不要相互影响，要相互隔离（由DBMS的并发控制子系统实现）；

持久性:一个事务一旦提交，那么它对数据库产生的影响就是永久的不可逆的，如果后面再回滚或者出异常，都不会影响已提交的事务（由DBMS的恢复管理子系统实现的）

21、下列关于容器集合类的说法正确的是？（ C ）

LinkedList继承自List
AbstractSet继承自Set
HashSet继承自AbstractSet
WeakMap继承自HashMap

解析：linkedlist类是实现了List接口，而不是继承
AbstractSet类实现Set接口
HashSet继承 AbstractSet类，同时也实现set
WeakMap是js里面的吧
在这里插入图片描述
22、

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

关于上面代码片段叙述正确的是（ C ）

输出结果：13
语句：b6=b4+b5编译出错
语句：b3=b1+b2编译出错
运行期抛出异常

解析：被final修饰的变量是常量，这里的b6=b4+b5可以看成是b6=10；在编译时就已经变为b6=10了，而b1和b2是byte类型，java中进行计算时候将他们提升为int类型，再进行计算，b1+b2计算后已经是int类型，赋值给b3，b3是byte类型，类型不匹配，编译不会通过，需要进行强制转换。Java中的byte，short，char进行计算时都会提升为int类型。

23、关于AWT和Swing说法正确的是？（ D ）

Swing是AWT的子类
AWT在不同操作系统中显示相同的风格
AWT不支持事件类型，Swing支持事件模型
Swing在不同的操作系统中显示相同的风格

解析：AWT，抽象窗口工具包，是Java提供的建立图形用户界面的工具集，可用于生成现代的、鼠标控制的图形应用接口，且无需修改，就可以在各种软硬件平台上运行。

而swing是Java语言在编写图形用户界面方面的新技术，Swing采用模型-视图-控制设计范式，Swing可以使Java程序在同一个平台上运行时能够有不同外观以供用户选择。

两者不同在于一个是初代工具集，一个是进化版的工具集，用户不会再满足于初始的功能，而是更加注重于附加价值，明显从这点上，Swing是比AWT要好很多。

写法上，Swing的头文件引用包需要用到Javax，组件调用时也需要在AWT的基础上加上“J”。

24、运行代码，输出的结果是（ A ）

public class P {
public static int abc = 123;
static{
System.out.println("P is init");
}
}
public class S extends P {
static{
System.out.println("S is init");
}
}
public class Test {
public static void main(String[] args) {
System.out.println(S.abc);
}
}

P is init < br />123
S is init < br />P is init
123
P is init < br />S is init
123
S is init < br />123

解析：属于被动引用不会出发子类初始化
子类引用父类的静态字段，只会触发子类的加载、父类的初始化，不会导致子类初始化

通过数组定义来引用类，不会触发此类的初始化常量在编译阶段会进行常量优化，将常量存入调用类的常量池中，本质上并没有直接引用到定义

常量的类，因此不会触发定义常量的类的初始化。

25、根据下面这个程序的内容，判断哪些描述是正确的：（ CD ）

public class Test {
public static void main(String args[]) {
String s = "tommy";
Object o = s;
sayHello(o); //语句1
sayHello(s); //语句2
}
public static void sayHello(String to) {
System.out.println(String.format("Hello, %s", to));
}
public static void sayHello(Object to) {
System.out.println(String.format("Welcome, %s", to));
}
}

这段程序有编译错误
语句1输出为:Hello, tommy
语句2输出为:Hello, tommy
语句1输出为:Welcome, tommy
语句2输出为:Welcome, tommy
根据选用的Java编译器不同，这段程序的输出可能不同

解析：上边是s o顺序调用方法就变成o s了

26、常用的servlet包的名称是？（ BD ）

java.servlet
javax.servlet
servlet.http
javax.servlet.http

解析：最用得多的就是
javax.servlet
javax.servlet.http
这两个包了.

27、在java中重写方法应遵循规则的包括（ BC ）

访问修饰符的限制一定要大于被重写方法的访问修饰符
可以有不同的访问修饰符
参数列表必须完全与被重写的方法相同
必须具有不同的参数列表

解析：方法的重写（override）两同两小一大原则：
方法名相同，参数类型相同
子类返回类型小于等于父类方法返回类型，
子类抛出异常小于等于父类方法抛出异常，
子类访问权限大于等于父类方法访问权限。

28、关于JSP生命周期的叙述，下列哪些为真?（ AC ）

JSP会先解释成Servlet源文件，然后编译成Servlet类文件
每当用户端运行JSP时，jsp init()方法都会运行一次
每当用户端运行JSP时，jsp service()方法都会运行一次
每当用户端运行JSP时，jsp destroy()方法都会运行一次

解析：init方法：负责初始化Servlet对象。在Servlet的整个生命周期类，init（）方法只被调用一次。

destroy方法：销毁Servlet对象，释放占用的资源，Servlet要被卸载时调用

29、下面哪些类可以被继承？ Java.lang.Thread、java.lang.Number、java.lang.Double、java.lang.Math、 java.lang.ClassLoader （ ABE ）

Thread
Number
Double
Math
ClassLoader

解析：Thread可以被继承，用于创建新的线程

Number类可以被继承，Integer，Float，Double等都继承自Number类

Double类的声明为

public final class Doubleextends Numberimplements Comparable<Double>

final生明的类不能被继承

Math类的声明为

public final class Mathextends Object

不能被继承

ClassLoader可以被继承，用户可以自定义类加载器

30、下面有关java threadlocal说法正确的有？( ABCD )

ThreadLocal存放的值是线程封闭，线程间互斥的，主要用于线程内共享一些数据，避免通过参数来传递

从线程的角度看，每个线程都保持一个对其线程局部变量副本的隐式引用，只要线程是活动的并且 ThreadLocal 实例是可访问的；在线程消失之后，其线程局部实例的所有副本都会被垃圾回收

在Thread类中有一个Map，用于存储每一个线程的变量的副本

对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式

解析：暂无

第七周期

1、关键字（ B ）表明一个对象或变量的引用在初始化后不能被修改。

private
final
static
没有这种关键字

解析：final修饰的变量内容是不能修改的，如果final修饰一个对象的引用，那么指的是这个对象的地址值是无法改变的，对象的内容还是可以修改的。如果final修饰一个普通变量的话，就是变量的值无法修改。综上，final修饰变量的本质就是：修饰的变量值(地址或内容)无法改变。

2、类声明中，声明抽象类的关键字是（ B ）

public
abstract
final
class

解析：public 共有类，可以在包外使用，此时，源文件必须和类名相同。
abstract 抽象类，抽象类位于继承树的抽象层，抽象类不能被实例化。
final 不能被继承，没有子类，final 类中的方法默认是final的。
class 只能在包内使用的类

3、一个类的构造器不能调用这个类中的其他构造器。（错误）

解析：this() 就可以

4、在 main() 方法中给出的整型数组，如果将其写到一个文件中，需要（ B

解析：input和output指的是对于程序而言。input是从文件读取进来，output是输出到文件。

5、以下代码将打印出：（ 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);
}

编译错误
true true
true false
false false

解析：collection类型的集合（ArrayList,LinkedList）只能装入对象类型的数据，该题中装入了0，是一个基本类型，但是JDK5以后提供了自动装箱与自动拆箱，所以int类型自动装箱变为了Integer类型。编译能够正常通过。
将list1的引用赋值给了list2，那么list1和list2都将指向同一个堆内存空间。instanceof是Java中关键字，用于判断一个对象是否属于某个特定类的实例，并且返回boolean类型的返回值。显然，list1.get(0)和list2.get(0)都属于Integer的实例

6、Panel 和 Applet 的默认布局管理器是（ B ）

CardLayout
FlowLayout
BorderLayout
GridLayout

解析：BorderLayout布局管理器，是Frame默认布局管理器，它是一个布置容器的边框布局，它可以对容器组件进行安排，并调整其大小，使其符合下列五个区域：北、南、东、西、中。每个区域最多只能包含一个组件，并通过相应的常量进行标识：NORTH、SOUTH、EAST、WEST、CENTER。
FlowLayout流式布局管理器,是Panel和Applet默认布局管理器，它具有指定的对齐方式以及指定的水平和垂直间隙。
GridLayout布局管理器,GridLayout(int rows,int cols,int hgap,int vgap);建立一个表格的版面对象。rows代表有几行，cols代表有几列；hgap是组件之间的水平距离，vgap是组件之间的竖直距离。

7、在java7中，下列不能做switch()的参数类型是？（ D ）

int型
枚举类型
字符串
浮点型

解析：switch语句后的控制表达式只能是short、char、int、long整数类型和枚举类型，不能是float，double和boolean类型。

8、假设 a 是一个由线程 1 和线程 2 共享的初始值为 0 的全局变量，则线程 1 和线程 2 同时执行下面的代码，最终 a 的结果不可能是（ D ）

boolean isOdd = false;

for(int i=1;i<=2;++i)
{
if（i%2==1）isOdd = true；
else isOdd = false；
a+=i*(isOdd?1:-1)；
}

-1
-2
0
1

解析：假设两线程为A、B，设有3种情况：
AB不并发：此时相当于两个方法顺序执行。A执行完后a=-1，B使用-1作为a的初值，B执行完后a=-2

AB完全并发：此时读写冲突，相当于只有一个线程对a的读写最终生效。相同于方法只执行了一次。此时a=-1

AB部分并发：假设A先进行第一次读写，得到a=1;之后A的读写被B覆盖了。B使用用1作为a的初值，B执行完后a=0

9、下面有关 java 类加载器,说法正确的是?( ABCD )

引导类加载器(bootstrap class loader):它用来加载 Java 的核心库,是用原生代码来实现的
扩展类加载器(extensions class loader):它用来加载 Java 的扩展库。
系统类加载器(system class loader):它根据 Java 应用的类路径(CLASSPATH)来加载 Java 类
tomcat 为每个 App 创建一个 Loader,里面保存着此 WebApp 的 ClassLoader。需要加载 WebApp 下的类时,就取出 ClassLoader 来使用

解析：Bootstrap ClassLoader

负责加载$JAVA_HOME中jre/lib/rt.jar里所有的class，由C++实现，不是ClassLoader子类

Extension ClassLoader

负责加载java平台中扩展功能的一些jar包，包括$JAVA_HOME中jre/lib/*.jar或-Djava.ext.dirs指定目录下的jar包

App ClassLoader

负责记载classpath中指定的jar包及目录中class

Custom ClassLoader

属于应用程序根据自身需要自定义的ClassLoader，如tomcat、jboss都会根据j2ee规范自行实现ClassLoader

加载过程中会先检查类是否被已加载，检查顺序是自底向上，从Custom ClassLoader到BootStrap ClassLoader逐层检查，只要某个classloader已加载就视为已加载此类，保证此类只所有ClassLoader加载一次。而加载的顺序是自顶向下，也就是由上层来逐层尝试加载此类。

10、下面有关 JAVA 异常类的描述,说法正确的有( ABC )

异常的继承结构:基类为 Throwable,Error 和 Exception 。实现 Throwable, RuntimeException 和 IOException 等继承 Exception
非 RuntimeException 一般是外部错误(不考虑Error的情况下),其可以在当前类被 try{}catch 语句块所捕获
Error 类体系描述了 Java 运行系统中的内部错误以及资源耗尽的情形,Error 不需要捕捉
RuntimeException 体系包括错误的类型转换、数组越界访问和试图访问空指针等等,必须被 try{}catch 语句块所捕获

解析：
在这里插入图片描述
都是Throwable的子类：
Exception（异常） :是程序本身可以处理的异常。

Error（错误）: 是程序无法处理的错误。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，一般不需要程序处理。

检查异常（编译器要求必须处置的异常）：除了Error，RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。

非检查异常(编译器不要求处置的异常): 包括运行时异常（RuntimeException与其子类）和错误（Error）。

11、以下二维数组声明合法的是（ C ）

char [ 2 ] [ 3 ] ch = new char [ ] [ ]
char[ 2 ] [ ] ch = new char[ ] [ 3 ]
char[ ] [ ] ch = new char[ 2 ] [ 3 ]
char[ ][ ] ch = new [ 2 ]char[ 3 ]

解析：定义数组，等号左边不能出现数字。

12、关于依赖注入，下列选项中说法错误的是（ B ）

依赖注入能够独立开发各组件，然后根据组件间关系进行组装
依赖注入使组件之间相互依赖，相互制约
依赖注入提供使用接口编程
依赖注入指对象在使用时动态注入

解析：依赖注入的动机就是减少组件之间的耦合度，使开发更为简洁

13、

public class SwitchTest{//1
    public static void main(String[] args) {//2
        System.out.println("value="+switchit(4));//3
    }//4
    public static int switchit(int x) {
        int j=1;
        switch (x) {
        case 1:j++;
        case 2:j++;
        case 3:j++;
        case 4:j++;
        case 5:j++;
        default:j++;
        }
        return j+x;
    }
}

第三行将输出什么？
答：value = 8

解析：没有break，从case 4开始一直执行到最后，j自加3次变成了4,结果返回8

14、以下叙述正确的是（ D ）

实例方法可直接调用超类的实例方法
实例方法可直接调用超类的类方法
实例方法可直接调用子类的实例方法
实例方法可直接调用本类的实例方法

解析：类的实例方法是与该类的实例对象相关联的，不能直接调用，只能通过创建超类的一个实例对象，再进行调用

当父类的类方法定义为private时，对子类是不可见的，所以子类无法调用

子类具体的实例方法对父类是不可见的，所以无法直接调用，只能通过创建子类的一个实例对象，再进行调用

实例方法可以调用自己类中的实例方法

15、transient 变量和下面哪一项有关？（ B ）

Cloneable
Serializable
Runnable
Comparable

解析：和序列化有关，这是一个空接口，起标记作用，具体的序列化由ObjectOutputStream和ObjectInputStream完成。transient修饰的变量不能被序列化，static变量不管加没加transient都不可以被序列化

16、如果一个list初始化为{5，3，1}，执行以下代码后，其结果为（ B ）？

nums.add(6);
nums.add(0,4);
nums.remove(1);

[5, 3, 1, 6]
[4, 3, 1, 6]
[4, 3, 6]
[5, 3, 6]

解析：初始化为{5,3,1}
nums.add(6)后list为{5,3,1,6}
nums.add(0,4)是在0号索引上添加数字4得到list为{4,5,3,1,6}
nums.remove(1)是将1号索引上的5进行remove得到list为{4,3,1,6}

17、尝试编译以下程序会产生怎么样的结果？（ C ）

public class MyClass {
    long var;
    public void MyClass(long param) { var = param; }//(1)
    public static void main(String[] args) {
        MyClass a, b;
        a =new MyClass();//(2)
        b =new MyClass(5);//(3)
    }
}

编译错误将发生在（1），因为构造函数不能指定返回值
编译错误将发生在（2），因为该类没有默认构造函数
编译错误将在（3）处发生，因为该类没有构造函数，该构造函数接受一个int类型的参数
该程序将正确编译和执行

解析：这道题一定要看仔细了，MyClass方法并不是构造参数，而是返回类型为void的普通方法，普通方法自然需要实例化对象然后去调用它，所以124不对，第三个是正确的，因为没有带参数的构造器，所以自然不能传一个int进去。

18、在一个基于分布式的游戏服务器系统中，不同的服务器之间，哪种通信方式是不可行的（ A ）？

管道
消息队列
高速缓存数据库
套接字

解析：对于管道，有下面这几种类型：
①普通管道（PIPE）：通常有两种限制，一是单工，即只能单向传输；二是血缘，即常用于父子进程间（或有血缘关系的进程间）。

②流管道（s_pipe）：去除了上述的第一种限制，实现了双向传输。

③命名管道（name_pipe）：去除了上述的第二种限制，实现了无血缘关系的不同进程间通信。
显然，要求是对于不同的服务器之间的通信，是要要求全双工形式的，而管道只能是半双工，虽然可以双向，但是同一时间只能有一个方向传输，全双工和半双工的区别可以如下图示理解：
在这里插入图片描述
19、java中提供了哪两种用于多态的机制（ AB ）

通过子类对父类方法的覆盖实现多态
利用重载来实现多态.即在同一个类中定义多个同名的不同方法来实现多态。
利用覆盖来实现多态.即在同一个类中定义多个同名的不同方法来实现多态。
通过子类对父类方法的重载实现多态

解析：Java通过方法重写和方法重载实现多态
方法重写是指子类重写了父类的同名方法
方法重载是指在同一个类中，方法的名字相同，但是参数列表不同

20、下面哪些写法能在 java8 中编译执行（ AD ）

dir.listFiles((File f)->f.getName().endsWith(“.Java”));
dir.listFiles((File f)=>f.getName().endsWith(“.Java”));
dir.listFiles((_.getName().endsWith(“.Java”)));
dir.listFiles( f->f.getName().endsWith(“.Java”));

解析：Lanbda表达式的主要作用就是代替匿名内部类的繁琐语法，它由三部分组成：
（1）形参列表。形参列表允许省略形参类型。如果形参列表中只有一个参数，甚至连形参列表的圆括号也可以省略。
（2）箭头（→）。必须通过英文中画线和大于符号组成。
（3）代码块。如果代码块只包含一条语句，Lambda表达式允许省略代码块的花括号，那么那条语句就不要用花括号表示语句结束。Lambda代码块只有一条return语句，甚至可以省略return关键字。Lambda表达式需要返回值，而它的代码块中仅有一套省略了return的语句。Lambda表达式会自动返回这条语句的值。
由此可见，应该是A和D正确。

~JORDAN~

关注

6
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
Java选择题练习 ---（NKW）

Java选择题第一周期：1、Java 语言中，负责并发管理的机制是（多线程）。解析：多线程是Java程序的并发机制，它能同步共享数、处理不同的事件。2、区分类中重载方法的依据是( 不同的形参列表 )。解析：两个重载函数必须在下列一个或两个方面有所区别： 1、函数的参数个数不同。 2、函数的参数类型不同或者参数类型顺序不同。3、定义类中成员变量时不可能用到的修饰是（void）。解析：void修饰的是成员方法4、以下程序main(){ int m=12,n=34;printf("%d%
复制链接

扫一扫