考点1

ARP 的功能是将IP地址解析为MAC地址。

  • A 正确
  • B 错误

正确答案: A

解析

ARP 协议(Address Resolution Protocol),或称地址解析协议。在以太网链路上仅仅知道某台主机的IP address,并不能立即将封包传送过去,必须先查明该主机的实体地址(Physical address/MAC address)才能真正发送出去,而ARP协议的功用就是在于将IP address转换成实体地址,查询目标设备的MAC地址,以保证通信的顺利进行。

并且只能在区域网路内使用,解析网路装置的MAC位址,ARP是TCP/IP设计者利用乙太网的广播性质,设计出来的位址解释协定;它的主要特性和优点是它的位址对应关系是动态的,它以查询的方式来获得IP位址和实体位

考点2

OSI七层模型中,物理层,数据链路层,网络层,传输层的单位是什么()

  • A 帧frame,包packet,段segment,比特bit
  • B 比特bit,帧frame,包packet,段segment
  • C 帧frame,比特bit,段segment,包packet
  • D 比特bit,包packet,帧frame,段segment

正确答案: B

解析

比特成帧,帧成报文,报文成包,包成段

考点3

The lower layers of the OSI model are in correct order ( )

  • A physical,system,network,logical
  • B physical,logical,network,system
  • C physical,transport,network,datalink
  • D physical,datalink,network,transport

正确答案: D

解析

从下往上是:物理层,数据链路层,网络层,传输层

考点4

在 OSI 参考模型的物理层、数据链路层、网络层传送的数据单位分别为 ()。

  • A 比特、帧、分组
  • B 比特、分组、帧
  • C 帧、分组、比特
  • D 分组、比特、帧

正确答案: A

解析

考点5

承载信息量的基本信号单位是 () 。

  • A 码元
  • B 比特
  • C 数据传输速率
  • D 误码率

正确答案: A

解析

考点6

帧中继网是一种( )。

  • A 广域网
  • B 局域网
  • C ATM网
  • D 以太网

正确答案: A

解析

几种常用的广域网:
公用电话交换网( P S T N)、
分组交换网(X . 2 5)、
数字数据网( D D N)、
帧中继( F R)、
交换式多兆位数据服务( S M D S)和
异步传输模式(AT M)。

考点7

在TCP/IP模型中,数据从应用层到网际接口层所经历的传输格式分别是( )。

  • A 报文或字节流—>IP数据报—>网络帧—>传输协议分组
  • B 报文或字节流—>传输协议分组—>IP数据报—>网络帧
  • C 传输协议分组—>IP数据报—>网络帧—>报文或字节流
  • D IP数据报—>报文或字节流—>网络帧—>传输协议分组

正确答案: B

解析

OSI:
物理层——比特流
数据链路层——帧
网络层——包
传输层——段/消息
表示层——字符或字
应用层——程序
TCP/IP为四层模型
应用层:报文
运输层:传输层协议
网际层:数据报
网络接口层:网络帧

考点8

下列地址中哪些是私有地址

  • A 172.32.0.1
  • B 172.0.0.1
  • C 172.16.0.255
  • D 172.15.255.255

正确答案: C

解析

私有地址如下:
A类:10.0.0.0到10.255.255.255
B类:172.16.0.0到172.31.255.255
C类:192.168.0.0到192.168.255.255

考点9

在某办公室内铺设一个小型局域网,总共有4台PC机需要通过一台集线器连接起来。采用的线缆类型为5类双绞线。则理论上任意两台PC机的最大间隔距离是()

  • A 400米
  • B 100米
  • C 200米
  • D 500米

正确答案: B

解析

5类双绞线的最大传输距离为100,意思是两个节点之间的总距离应该在100以内,否则传输就会造成损耗。所以集线器节点-集线器-节点距离应为100米,集线器只是将线缆汇集的一个中心。

考点10

以下请求是一个订单提交的请求,请观察该请求包,说出你认为可能存在的安全风险点():
POST http://test.mi.cn/insert.html HTTP/1.1
Host: test.mi.com
Referer: http://test.mi.cn/index.php?data=58
Cookie: uid=1504174654;

addressid=1&productid=123&num=1&price=120

  • A CSRF
  • B 订单金额篡改
  • C 越权操作
  • D SQL 注入

正确答案: ABCD

解析

看不到这题什么意思

考点1

下面的方法,当输入为2的时候返回值是多少?

1
2
3
4
5
6
7
8
9
10
11
12
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;
}
  • A 0
  • B 2
  • C 4
  • D 10

正确答案: D

解析

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

考点2

下面那些情况可以终止当前线程的运行?

  • A 当一个优先级高的线程进入就绪状态时
  • B 抛出一个异常时
  • C 当该线程调用sleep()方法时
  • D 当创建一个新线程时

正确答案: B

解析

  • 当一个优先级高的线程进入就绪状态时,它只是有较高的概率能够抢到CPU的执行权,不是一定就能抢到执行权,所以A错
  • 抛出一个例外时,该线程就终止了,所以B正确
  • 当前线程调用sleep()方法或者wait()方法时,只是暂时停止了该线程的运行,不是终止线程,注意题目说的是“终止”,就是完全停止,所以C错误
  • 当创建一个新的线程时,该线程也加入到了抢占CPU执行权的队伍中,但是是否能抢到,并不清楚,和A的思想一样,所以D错误

线程结束的三个原因:

  • run方法执行完成,线程正常结束
  • 线程抛出一个未捕获的Exception或者Error
  • 直接调用该线程的Stop方法结束线程(不建议使用,容易导致死锁)

考点3

下列关于java 中的 wait()方法和 sleep()方法的区别描述错误的是?

  • A wait()方法属于Object类,sleep()属于Thread
  • B 调用wait()方法的时候,线程会放弃对象锁
  • C 调用sleep()方法的过程中,线程不会释放对象锁
  • D sleep()方法导致了程序暂停执行指定的时间,让出cpu给其他线程

正确答案: D

解析

sleep和wait的区别有:

  1. 这两个方法来自不同的类分别是ThreadObject
  2. 最主要是**sleep方法没有释放锁,而wait方法释放了锁**,使得敏感词线程可以使用同步控制块或者方法。
  3. waitnotifynotifyAll只能在同步控制方法或者同步控制块里面使用,而sleep可以在任何地方使用
    1
    2
    3
    4
    synchronized(x){
    x.notify()
    //或者wait()
    }
  4. sleep必须捕获异常,而waitnotifynotifyAll不需要捕获异常

D是线程暂停执行指定时间而不是程序暂停执行指定的时间。

考点4

执行以下程序后的输出结果是()

1
2
3
4
5
6
7
8
9
10
11
public class Test {
public static void main(String[] args) {
StringBuffer a = new StringBuffer("A");
StringBuffer b = new StringBuffer("B");
operator(a, b);
System.out.println(a + "," + b);
}
public static void operator(StringBuffer x, StringBuffer y) {
x.append(y); y = x;
}
}
  • A A,A
  • B A,B
  • C B,B
  • D AB,B

正确答案: D

解析

考点5

关于C++/JAVA类中static 成员和对象成员的说法正确的是?

  • A static 成员变量在对象构造时生成
  • B static 成员函数在对象成员函数中无法调用
  • C 虚成员函数不可能是static 成员函数
  • D static 成员函数不能访问static 成员变量

正确答案: C

解析

C++虚函数类似java语言中的抽象方法,抽象方法中不能用privatestaticsynchronizednative等修饰词修饰。

考点6

给出下面的代码段:

1
2
3
4
5
6
7
8
9
10
11
12
public class Base{
int w, x, y ,z;
public Base(int a,int b)
{
x=a; y=b;
}
public Base(int a, int b, int c, int d)
{
// assignment x=a, y=b
w=d;z=c;
}
}

在代码说明// assignment x=a, y=b处写入如下哪几个代码是正确的?()

  • A Base(a,b);
  • B x=a, y=b;
  • C x=a; y=b;
  • D this(a,b);

正确答案: CD

解析

考点7

下列哪些操作会使线程释放锁资源?

  • A sleep()
  • B wait()
  • C join()
  • D yield()

正确答案: BC

解析

考点8

往OuterClass类的代码段中插入内部类声明, 哪一个是错误的:

1
2
3
4
public class OuterClass{
private float f=1.0f;
//插入代码到这里
}
  • A class InnerClass{public static float func(){return f;} }
  • B abstract class InnerClass{ public abstract float func(){} }
  • C static class InnerClass{ protected static float func(){return f;} }
  • D public class InnerClass{ static float func(){return f;} }

正确答案: ABCD

解析

主要考核了这几个知识点:
1.静态内部类才可以声明静态方法,所以A错,D错
2.静态方法不可以使用非静态变量,所以C错误
3.抽象方法不可以有函数体,所以B错误

考点1

_______意味着一个操作在不同的类中可以有不同的实现方式。

  • A 多态性
  • B 多继承
  • C 类的组合
  • D 类的复用

正确答案: A

解析

类的复用有两种方式:组成(has-a)和继承(is-a)
1)组成就是在新的类中直接创建旧类的对象,这里我们复用的只是代码的功能而不是它的形式。
2)继承是在原有的类的基础上建立一个新类,新类具有旧类的形式,但也加入了一些新的特性。

继承

指一个新的类继承原有类的基本特性,并增加了新的特性。(Java不允许多继承,而C++可以)

多态性

指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。
1)多态存在的三个必要条件
①要有继承 ②要有重写 ③父类引用指向子类对象(向上转型)
2)实现多态性的三种形式

  • ①方法的重载
  • ②通过继承机制而产生方法覆盖
  • ③通过接口实现方法覆盖
    3)多态的分类
    多态分为编译时多态和运行时多态。其中
    编译
  • 时多态是静态的,主要是指方法的重载,它是根据参数列表的不同来区分不同的函数,通过编译之后会变成两个不同的函数,在运行时谈不上多态。
  • 而运行时多态是动态的,它是通过动态绑定来实现的,也就是我们平常所说的多态性。

多态的本质是:一个程序中同名的不同方法。在面向对象的程序设计中,多态主要有以下三种方式来实现。

  • 通过子类对父类方法的覆盖来实现多态。
  • 通过一个类中方法的重载来实现多态。
  • 通过将子类的对象作为父类的对象实现多态。

方法中的成员变量不具备多态性,因为变量不会被重写,在编译时有两块存储堆内存,并取决于编译时所声明变量类型。和运行时对象的变量不是一块内存区域。简洁得来说,不能重写就没法表现出多态。

考点2

以下关于java封装的描述中,正确的是:

  • A 封装的主要作用在于对外隐藏内部实现细节,增强程序的安全性
  • B 封装的意义不大,因此在编码中尽量不要使用
  • C 如果子类继承父类,对于父类中进行封装的方法,子类仍然可以直接调用
  • D 只能对一个类中的方法进行封装,不能对属性进行封装

正确答案: A

解析

什么是封装

封装就是将属性私有化,提供公有的方法访问私有属性。所以CD错误。

如何实现封装

做法就是:
修改属性的可见性来限制对属性的访问,
并为每个属性创建一对取值(getter)方法和赋值(setter)方法,用于对这些属性的访问。
如:

1
2
3
4
5
6
7
private String name;
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}

为什么需要封装

通过封装,可以实现对属性的数据访问限制,同时增加了程序的可维护性。
由于取值方法和赋值方法隐藏了实现的变更,因此并不会影响读取或修改该属性的类,避免了大规模的修改,程序的可维护性增强

考点3

java 语言使用的字符码集是

  • A ASCII
  • B BCD
  • C DCB
  • D Unicode

正确答案: D

解析

考点4

如果int x=20, y=5,则语句System.out.println(x+y +””+(x+y)+y); 的输出结果是()

  • A 2530
  • B 55
  • C 2052055
  • D 25255

正确答案: D

解析

1)不论有什么运算,小括号的优先级都是最高的,先计算小括号中的运算,得到x+y +””+25+y
2)任何字符与字符串相加都是字符串,但是是有顺序的,字符串前面的按原来的格式相加,字符串后面的都按字符串相加,得到25+””+25+5
3)上面的结果按字符串相加得到25255

考点5

以下哪一项正则能正确的匹配网址: http://www.bilibili.com/video/av21061574 ()

  • A /^(https?:\/\/)?([a-zA-Z\d]+).bilibili.com\/?video\/av(\D{1,8})\/?$/
  • B /^(http:\/\/)?(\w+)\.bilibili\.com\/?video\/av(\d{1,8})\/?$/
  • C /^(https?:\/\/)?(\w+)\.bilibili\.com\/?\w*$/
  • D /^(http:\/\/)?([a-zA-Z\d]+).bilibili.com\/?video\/av\w*\/+$/

正确答案: B

解析

考点6

下列代码执行结果为()
public static void main(String args[])throws InterruptedException{
Thread t=new Thread(new Runnable() {
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.print(“2”);
}
});
t.start();

        t.join();
        System.out.print("1");
    }
  • A 21
  • B 12
  • C 可能为12,也可能为21
  • D 以上答案都不对

正确答案: A

解析

thread.Join把指定的线程加入到当前线程,可以将两个交替执行的线程合并为顺序执行的线程。

join()可以理解为先执行t.join();可以理解为先执行t线程。则main线程等待

考点7

关于继承的说法正确的是()。

  • A 子类将继承父类所有的数据域和方法。
  • B 子类将继承父类的其可见的数据域和方法。
  • C 子类只继承父类public方法和数据域
  • D 子类只继承父类的方法,而不继承数据域

正确答案: A

解析

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

考点8

ArrayLists和LinkedList的区别,下述说法正确的有?

  • A ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。
  • B 对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要移动指针。
  • C 对于新增和删除操作add和remove,LinkedList比较占优势,因为ArrayList要移动数据。
  • D ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间,而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间。

正确答案: ABCD

解析

考点9

Servlet的生命周期可以分为初始化阶段,运行阶段和销毁阶段三个阶段,以下过程属于初始化阶段是()。

  • A 加载Servlet类及.class对应的数据
  • B 创建servletRequest和servletResponse对象
  • C 创建ServletConfig对象
  • D 创建Servlet对象

正确答案: ACD

解析

Servlet的生命周期一般可以用三个方法来表示:

  • init():仅执行一次,负责在装载Servlet时初始化Servlet对象
  • service() :核心方法,一般HttpServlet中会有get,post两种处理方式。在调用doGet和doPost方法时会构造servletRequest和servletResponse请求和响应对象作为参数。
  • destory():在停止并且卸载Servlet时执行,负责释放资源
  • 初始化阶段:Servlet启动,会读取配置文件中的信息,构造指定的Servlet对象,创建ServletConfig对象,将ServletConfig作为参数来调用init()方法。所以选ACD。B是在调用service方法时才构造的

考点1 序列化接口

要使对象具有序列化能力,则其类应该实现如下哪个接口( )。

  • A java.io.Serializable
  • B java.lang.Cloneable,
  • C java.lang.CharSequence
  • D java.lang.Comparable
展开/折叠 正确答案: A

解析

java.io.Serializable接口是一个标志性接口,在接口内部没有定义任何属性与方法。只是用于标志此接口的实现类可以被序列化与反序列化。
java.lang.Cloneable接口是一个标志性接口,在接口内部没有定义任何属性与方法。以指示Object.clone()方法可以合法地对该类实例进行按字段复制。
java.lang.CharSequence接口对许多不同种类的char序列提供统一的只读访问接口。CharSequence是char值的一个可读序列。
java.lang.Comparable接口,此接口强制对实现它的每个类的对象进行整体排序,此序列被称为该类的自然排序

考点2 子类调用父类方法的方式

子类要调用继承自父类的方法,必须使用super关键字。

  • A 正确
  • B 错误
展开/折叠 正确答案: B

解析

1、子类构造函数调用父类构造函数用super
2、子类重写父类方法后,若想调用父类中被重写的方法,用super
3、未被重写的方法可以直接调用。

考点3 泛型

以下说法错误的是()

  • A 虚拟机中没有泛型,只有普通类和普通方法
  • B 所有泛型类的类型参数在编译时都会被擦除
  • C 创建泛型对象时请指明类型,让编译器尽早的做参数检查
  • D 泛型的类型擦除机制意味着不能在运行时动态获取List中T的实际类型
展开/折叠 正确答案: D

解析

  • Java泛型是使用擦除来实现的,这意味着当你在使用泛型时,任何具体的类型信息都被擦除了,你唯一知道的就是你在使用一个对象。因此List<String>List<Integer>在运行时实际上是相同的类型。这两种类型都被擦除成它们的“原生”类型,即List。
  • 因此, 虚拟机中没有泛型,只有普通类和普通方法
  • 不过还是可以通过反射获得泛型类T的实际类型

考点4 实例化子类对象时 优先调用子类重写的方法

以下代码执行的结果显示是多少( )?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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);
}
}
  • 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
展开/折叠 正确答案: A

解析

在只想new Sub(5)的时候,父类先初始化了int flag = 1,然后执行父类的构造函数Super(),父类构造函数中执行的test()方法,因子类是重写了test()方法的,因此父类构造函数中的test()方法实际执行的是子类的test()方法,所以输出为Sub.test() flag=1,接着执行子类构造函数Sub(5) 将flag赋值为5,因此输出结果Sub.Sub() flag=5

重点在于要时刻记得子类重写父类方法,实例化子类对象,调用时会调用子类重写之后的方法

考点5 子类通过类名引用父类的静态成员,只会初始化父类,不会初始化子类

运行代码,输出的结果是()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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);
}
}
  • A
    P is init
    123
  • B
    S is init
    P is init
    123
  • C
    P is init
    S is init
    123
  • D
    S is init
    123
展开/折叠 正确答案: A

解析

静态代码块在 类初始化的时候 执行
S.abc属于 被动引用 不会出发子类初始化
1.子类引用父类的静态字段,只会触发子类的加载、父类的初始化,不会导致子类初始化
2.通过数组定义来引用类,不会触发子类的初始化
3.常量在编译阶段会进行常量优化,将常量存入调用类的常量池中, 本质上并没有直接引用到定义常量的类,因此不会触发定义常量的类的初始化
参考:《深入理解Java虚拟机》
这里有类主动引用和被动引用的demo:https://www.jianshu.com/p/3afa5d24bf71

考点6 String常量

关于下面的一段代码,以下哪些说法是正确的:

1
2
3
4
5
6
7
8
9
10
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);
}
  • A System.out.print(a == b)打印出来的是false
  • B System.out.print(a == c)打印出来的是true
  • C System.out.print(b == c)打印出来的是false
  • D System.out.print(b == d)打印出来的是true
展开/折叠 正确答案: AD

解析

a是运行时动态加载的,此时会在堆内存中生成一个myString字符串,指向堆内存字符串地址
b是编译时静态加载的,此时会在常量池中存放一个myString字符串,指向常量池字符串地址
A:a指向堆内存,b指向常量池,因此地址不相等,false
B:java有常量优化机制,c也指向常量池,且与b指向同一个,则a与c地址不相等,false;
C:b与c地址相等,true
D:d是c的副本,地址相同,所以b与d地址相等,true

考点7 系列化和反序列化

下列关于系列化和反序列化描述正确的是:

  • A 序列化是将数据转为n个 byte序列的过程
  • B 反序列化是将n个 byte转换为数据的过程
  • C 将类型int转换为4 byte是反序列化过程
  • D 将8个字节转换为long类型的数据为序列化过程
展开/折叠 正确答案: AB

解析

序列化:将数据结构转换称为二进制数据流或者文本流的过程。序列化后的数据方便在网络上传输和在硬盘上存储。
反序列化:与序列化相反,是将二进制数据流或者文本流转换称为易于处理和阅读的数据结构的过程。

考点8 使线程释放锁资源

下列哪些操作会使线程释放锁资源?

  • A sleep()
  • B wait()
  • C join()
  • D yield()
展开/折叠 正确答案: BC

解析

1.sleep会使当前线程睡眠指定时间,不释放锁
2.yield会使当前线程重回到可执行状态,等待cpu的调度,不释放锁
3.wait会使当前线程回到线程池中等待,释放锁,当被其他线程使用notify,notifyAll唤醒时进入可执行状态
4.当前线程调用 某线程.join()时会使当前线程等待某线程执行完毕再结束,底层调用了wait()方法的,wait()释放锁资源,故join也释放锁资源

考点9 类加载器

关于Java中的ClassLoader下面的哪些描述是错误的:( )

  • A 默认情况下,Java应用启动过程涉及三个ClassLoader: Boostrap, Extension, System
  • B 一般的情况不同ClassLoader装载的类是不相同的,但接口类例外,对于同一接口所有类装载器装载所获得的类是相同的
  • C 类装载器需要保证类装载过程的线程安全
  • D ClassLoader的loadClass在装载一个类时,如果该类不存在它将返回null
  • E ClassLoader的父子结构中,默认装载采用了父优先
  • F 所有ClassLoader装载的类都来自CLASSPATH环境指定的路径
展开/折叠 正确答案: BDF

解析

A、java中类的加载有5个过程,加载、验证、准备、解析、初始化;这便是类加载的5个过程,而类加载器的任务是根据一个类的全限定名来读取此类的二进制字节流到JVM中,然后转换为一个与目标类对应的java.lang.Class对象实例,在虚拟机提供了3种类加载器,引导(Bootstrap)类加载器、扩展(Extension)类加载器、系统(System)类加载器(也称应用类加载器)。A正确
B、一个类,由不同的类加载器实例加载的话,会在方法区产生两个不同的类,彼此不可见,并且在堆中生成不同Class实例。所以B前面部分是正确的,后面接口的部分真的没有尝试过,等一个大佬的讲解吧;
C、类加载器是肯定要保证线程安全的;C正确
D、装载一个不存在的类的时候,因为采用的双亲加载模式,所以强制加载会直接报错,D错误
java.lang.SecurityException: Prohibited package name: java.lang
E、双亲委派模式是在Java 1.2后引入的,其工作原理的是,如果一个类加载器收到了类加载请求,它并不会自己先去加载,而是把这个请求委托给父类的加载器去执行,如果父类加载器还存在其父类加载器,则进一步向上委托,依次递归,请求最终将到达顶层的启动类加载器,如果父类加载器可以完成类加载任务,就成功返回,倘若父类加载器无法完成此加载任务,子加载器才会尝试自己去加载,这就是双亲委派模式,即每个儿子都很懒,每次有活就丢给父亲去干,直到父亲说这件事我也干不了时,儿子自己想办法去完成,所以默认是父装载,E正确
F、自定义类加载器实现 继承ClassLoader后重写了findClass方法加载指定路径上的class,F错误

考点1 java main方法

在Java中,main()方法的返回值的类型是:

  • A public
  • B static
  • C void
  • D String
展开/折叠 正确答案: C

解析

main方法的格式讲解:

1
public static void main(String[] args) {...}
  • public:公共的,访问权限是最大的。由于main方法是被jvm调用,所以权限要够大。
  • static:静态的,不需要创建对象,通过类名就可以。方便jvm的调用。
  • void:方法的返回值是返回给调用者,而main方法是被jvm调用。你返回内容给jvm没有意义。
  • main:是一个常见的方法入口。我见过的语言都是以main作为入口。
  • String[] args:这是一个字符串数组。这个东西早期是为了接收键盘录入的数据的。

考点2 多线程 同一个对象作为锁的情况

执行如下程序,输出结果是( )

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
29
30
31
32
33
34
35
36
37
38
39
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();
}
}
  • A 0 22 44 6
  • B 2 42 42 4
  • C 2 24 46 6
  • D 4 44 46 6
展开/折叠 正确答案: C

解析

只要注意这里锁住的是对象就可以了
这里只创建了一个对象Test mv = new Test();
如果换成synchronized(Test.class)锁住的就是这个类,执行的结果就不一样了
这里是同一个对象锁 所以一个线程执行完另一个线程才能访问
三个线程传输的是同一个mv,而且加了同步锁synchronized(mv),所以执行的时候按照顺序执行即可

考点3 访问修饰符

下列哪个对访问修饰符作用范围由大到小排列是正确的?

  • A private>default>protected>public
  • B public>default>protected>private
  • C private>protected>default>public
  • D public>protected>default>private
展开/折叠 正确答案: D

解析

考点4 访问修饰符

下面哪个修饰符修饰的变量是所有同一个类生成的对象共享的( )

  • A public
  • B private
  • C static
  • D final
展开/折叠 正确答案: C

解析

考点5 包装类之间的比较

1
2
3
Integer i = 42; 
Long l = 42l;
Double d = 42.0;

下面为true的是

  • A (i == l)
  • B (i == d)
  • C (l == d)
  • D i.equals(d)
  • E d.equals(l)
  • F i.equals(l)
  • G l.equals(42L)
展开/折叠 正确答案: G

解析

考点6 for循环语句

设m和都是int类型,那么以下for循环语句的执行情况是( )

1
2
for (m = 0, n = -1; n = 0; m++, n++)
n++;
  • A 循环体一次也不执行 循环体执行一次 是无限循环 有限次循环 循环结束判断条件不合法 运行出错
  • B 循环体执行一次 是无限循环
  • C 有限次循环
  • D 循环结束判断条件不合法
展开/折叠 正确答案: D

解析

循环条件:n = 0是int类型,不是boolean型的。
所以语法错误

1
2
3
for(初始化语句;判断条件语句;控制条件语句){
循环体语句;
}

考点7 String 常量池

String s = new String("xyz");创建了几个StringObject?

  • A 两个或一个都有可能
  • B 两个
  • C 一个
  • D 三个
展开/折叠 正确答案: A

解析

  • 如果在常量池中已经存在“xyz”,那么只创建一个new String(“xyz”)的对象。
  • 如果常量池中没有“xyz”,则会创建两个对象,一个是常量池中的对象“xyz”,一个是new String(“xyz”)的对象。

考点8 Object类方法

java中下面哪些是Object类的方法()

  • A notify()
  • B notifyAll()
  • C sleep()
  • D wait()
展开/折叠 正确答案: ABD

解析

考点9 Java继承

java中关于继承的描述正确的是()

  • A 一个子类只能继承一个父类
  • B 子类可以继承父类的构造方法
  • C 继承具有传递性
  • D 父类一般具有通用性,子类更具体
展开/折叠 正确答案: ACD

解析

子类不可以继承父类的构造方法,只可以调用父类的构造方法。

考点1 boolean类型的正确赋值语句

现有一变量声明为 boolean aa; 下面赋值语句中正确的是 ( )

  • A aa=false;
  • B aa=False;
  • C aa=”true”;
  • D aa=0;

正确答案:

解析

考点2 重载函数

下面有关重载函数的说法中正确的是

  • A 重载函数必须具有不同的返回值类型
  • B 重载函数形参个数必须不同
  • C 重载函数必须有不同的形参列表
  • D 重载函数名可以不同
展开/折叠 正确答案: C

解析

两同一不同:同一个类中,方法名相同,形参列表不同。

考点3 String StringBuffer StringBuilder

关于String、StringBuffer、StringBuilder以下说法错误的是

  • A StringBuilder运行速度最快
  • B StringBuffer是线程安全的
  • C String的值是可变的
  • D StringBuffer运行速度比String快
展开/折叠 正确答案: C

解析

String的值一旦确认了就不可变,每次的变化实际上都创建了一个新的String,所以有多次变化时最好还是用StringBuffer更好
速度:String< Stringbuffer < Stringbuilder

考点4 网络编程

客户端要获取一个socket对象通过实例化,而服务器获得一个socket对象则通过什么方法的返回值?

  • A getRemoteSocketAddress()
  • B getInputStream()
  • C getOutputStream()
展开/折叠 正确答案: A

解析

考点5 垃圾收集

下面关于垃圾收集的说法正确的是

  • A 一旦一个对象成为垃圾,就立刻被收集掉。
  • B 对象空间被收集掉之后,会执行该对象的finalize方法
  • C finalize方法和C++的析构函数是完全一回事情
  • D 一个对象成为垃圾是因为不再有引用指着它,但是线程并非如此
展开/折叠 正确答案: D

解析

A,B其实是一个知识点,既一个对象到GC Roots没有任何引用链相连时就是一个可回收对象,可回收对象在被回收之前,JVM会判断是否有finalize方法,如果有则会调用finalize方法,在这个方法里面对象可以自救的。
C 肯定不对啦

  1. 与C++的析构函数不同,析构函数调用确定,而finalize()方法是不确定的,因为finalize()方法在对象被GC回收时调用。
  2. JVM将重写了finalize方法的对象放置于F-Queue队列,稍后会被一个优先级很低的Finalizer线程执行。Finalizer线程随时会终止,为了防止对象的finalize方法执行缓慢,或者发生死循环。
  3. finaliz的设计目的是保证对象在被垃圾收集前完成特定资源的回收或给予对象最后一次重生机会等
  4. finalize是个不太可控的方法因此并不常用,并且在JDK9+版本被标注为过时方法。

考点6 抽象类 抽象方法 重载的依据 赋值表达式可以出现的位置

选项中哪一行代码可以替换 //add code here 而不产生编译错误

1
2
3
4
5
6
public abstract class MyClass {
public int constInt = 5;
//add code here
public void method() {
}
}
  • A public abstract void method(int a);
  • B consInt=constInt+5;
  • C public int method();
  • D public abstract void anotherMethod(){}
展开/折叠 正确答案: A

解析

A 是抽象方法,抽象类可以包含抽象方法,也可以不包含,抽象方法可以重载。正确
B 在类中不能constInt = constInt +5这样的运算。错误
C 返回值不能作为重载的依据,错误
D 有方法体的不能作为抽象函数,错误

考点7 Java Web 容器的作用

在Web应用程序中,( )负责将HTTP请求转换为HttpServletRequest对象

  • A Servlet对象
  • B HTTP服务器
  • C Web容器
  • D JSP网页
展开/折叠 正确答案: C

解析

web容器是一种服务程序,在服务器一个端口就有一个提供相应服务的程序,而这个程序就是处理从客户端发出的请求,如JAVA中的Tomcat容器,ASP的IIS或PWS都是这样的容器。一个服务器可以多个容器。

考点8 垃圾回收器

如何放掉一个指定占据的内存空间?()

  • A 调用free()方法
  • B 代用system.gc()方法
  • C 赋值给该项对象的引用为null
  • D 程序员无法明确强制垃圾回收器运行
展开/折叠 正确答案: D

解析

考点9 网络编程 如何创建服务端socket

如果希望监听TCP端口9000,服务器端应该怎样创建socket?

  • A new Socket(“localhost”,9000);
  • B new ServerSocket(9000);
  • C new Socket(9000);
  • D new ServerSocket(“localhost”,9000);
展开/折叠 正确答案: B

解析

1
2
new Socket("localhost",9000); //客户端连接端口 
new ServerSocket(9000); //服务器端监听端口
  • 服务端:ServerSocket(port),因为服务器知道自己的IP所以不需要输入IP
  • 客户端:Socket(host,port),因为客户端不知道连接哪条IP所以需要输入IP

服务器端创建监听:

1
ServerSocket ss = new ServerSocket(int port)

客户端创建监听:

1
Socket s = new Socket(InetAddress address, int port)

考点1

java中,用( )关键字定义常量?

  • A final
  • B #define
  • C float
  • D const

正确答案: A

解析

final关键字可用于修饰类、变量和方法。final修饰变量时,表示该变量一旦获得了初始值就不可被改变,final既可以修饰成员变量也可以修饰局部变量、形参。

考点2

下面关于hibernate核心接口说明错误的是?

  • A Configuration 接口:配置Hibernate,根据其启动hibernate,创建SessionFactory 对象
  • B SessionFactory 接口:负责保存、更新、删除、加载和查询对象,是线程不安全的,避免多个线程共享同一个session,是轻量级、一级缓存
  • C Query 和Criteria 接口:执行数据库的查询
  • D Transaction 接口:管理事务

正确答案: B

解析

B选项中应该是Session接口而不是SessionFactory接口
1,Configuration接口:配置Hibernate,根据其启动Hibernate,创建SessionFactory对象;
2,SessionFactory接口:初始化Hibernate,充当数据存储源的代理,创建session对象,SessionFactory是
线程安全的,意味着它的同一个实例可以被应用的多个线程共享,是重量级二级缓存;
3,session接口:负责保存、更新、删除、加载和查询对象,是一个非线程安全的,避免多个线程共享一个session,是轻量级,一级缓存。
4,Transaction接口:管理事务。可以对事务进行提交和回滚;
5,Query和Criteria接口:执行数据库的查询。

考点3

执行如下代码段后,变量s1引用的字符串值是( )。
String s1 = “ABCD”;
String s2 = “1234”;
System.out.println(s1 + s2);

  • A ABCD
  • B 1234
  • C ABCD1234
  • D 1234ABCD

正确答案: A

解析

考点4

有以下类定义:
abstract class Animal{
abstract void say();
}
public class Cat extends Animal{
public Cat(){
System.out.printf(“I am a cat”);
}
public static void main(String[] args) {
Cat cat=new Cat();
}
}
运行后:

  • A I am a cat
  • B Animal能编译,Cat不能编译
  • C Animal不能编译,Cat能编译
  • D 编译能通过,但是没有输出结果

正确答案: B

解析

包含抽象方法的类称为抽象类,但并不意味着抽象类中只能有抽象方法,它和普通类一样,同样可以拥有成员变量和普通的成员方法。注意, 抽象类和普通类 的主要有三点区别:
1)抽象方法必须为public或者protected(因为如果为private,则不能被子类继承,子类便无法实现该方法),缺省情况下默认为public。
2)抽象类不能用来创建对象;
3) 如果一个类继承于一个抽象类,则子类必须实现父类的抽象方法 。如果子类没有实现父类的抽象方法,则必须将子类也定义为为abstract类。
在其他方面,抽象类和普通的类并没有区别。

考点5

以下代码执行的结果显示是多少()?
public class Demo{
public static void main(String[] args){
System.out.print(getNumber(0));
System.out.print(getNumber(1));
System.out.print(getNumber(2));
System.out.print(getNumber(4));
}

public static int getNumber(int num){
    try{
        int result = 2 / num;
        return result;
    }catch (Exception exception){
        return 0;
    }finally{
        if(num == 0){
            return -1;
        }
        if(num == 1){
            return 1;
        }
    }
}

}

  • A 0110
  • B -1110
  • C 0211
  • D -1211

正确答案: B

解析

finally中return语句会覆盖try-catch中的return语句

考点6

以下代码对其执行后,NumberList里的元素依次为:
List NumberList = new ArrayList();
NumberList.add(2);
NumberList.add(4);
NumberList.add(1);
NumberList.add(3);
NumberList.add(5);
for(int i =0;i<NumberList.size();++i){
int v = NumberList.get(i);
if(v%2==0){
NumberList.remove(v);
}
}
System.out.println(NumberList);

  • A 2,4,1,3,5
  • B 2,1,3,5
  • C 4,1,3,5
  • D 会出现越界情况

正确答案: D

解析

1.ArrayList删除元素后,剩余元素会依次向前移动,因此下标一直在变,size()也会减小;
2.这里的remove()方法调用的是remove(int index),而不是remove(Object o),因此删除的是index索引处的元素;
对于List而言,想要移除元素,要不然就用迭代器。要不然就从后往前删除。
万万不可从前往后删,会出现角标越界。

考点7

String str1 = “abc”,“abc”分配在内存哪个区域?

  • A 堆
  • B 栈
  • C 字符串常量区
  • D 寄存器

正确答案: C

解析

答案:C
用new创建的对象在堆区
函数中的临时变量在栈去
java中的字符串在字符串常量区

考点8

当编译并运行下面程序时会发生什么结果()
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);
}
}
}

  • A 编译错误,指明run方法没有定义
  • B 运行错误,只鞥呢run方法没有定义
  • C 编译通过并输出0到9
  • D 编译通过,但无输出

正确答案: D

解析

对于线程而言,start是让线程从new变成runnable。run方法才是执行体的入口。
但是在Thread中,run方法是个空方法,没有具体实现。
Bground继承了Thread,但是没有重写run方法,那么调用run方法肯定是无输出。
首先继承Thread,然后调用run方法,bgroud并没有重写run方法,那么就是调用父类Thread的run方法。

考点9

下面选项中,哪些是interface中合法方法定义?()

  • A public void main(String [] args);
  • B private int getSum();
  • C boolean setFlag(Boolean [] test);
  • D public float get(int x);

正确答案: ACD

解析

在jdk8之前,interface之中可以定义变量和方法,变量必须是public、static、final的,方法必须是public、abstract的。
JDK8及以后,允许我们在接口中定义static方法和default方法。
静态方法,只能通过接口名调用,不可以通过实现类的类名或者实现类的对象调用。default方法,只能通过接口实现类的对象来调用。
当然如果接口中的默认方法不能满足某个实现类需要,那么实现类可以覆盖默认方法。
JDK 1.9时,接口中的方法可以是private的

考点10

下面哪些属于JSP内置对象及方法?

  • A request
  • B out
  • C application
  • D config

正确答案: ABCD

解析

JSP内置对象有:
1.request对象
客户端的请求信息被封装在request对象中,通过它才能了解到客户的需求,然后做出响应。它是HttpServletRequest类的实例。
2.response对象
response对象包含了响应客户请求的有关信息,但在JSP中很少直接用到它。它是HttpServletResponse类的实例。
3.session对象
session对象指的是客户端与服务器的一次会话,从客户连到服务器的一个WebApplication开始,直到客户端与服务器断开连接为止。它是HttpSession类的实例.
4.out对象
out对象是JspWriter类的实例,是向客户端输出内容常用的对象
5.page对象
page对象就是指向当前JSP页面本身,有点象类中的this指针,它是java.lang.Object类的实例
6.application对象
application对象实现了用户间数据的共享,可存放全局变量。它开始于服务器的启动,直到服务器的关闭,在此期间,此对象将一直存在;这样在用户的前后连接或不同用户之间的连接中,可以对此对象的同一属性进行操作;在任何地方对此对象属性的操作,都将影响到其他用户对此的访问。服务器的启动和关闭决定了application对象的生命。它是ServletContext类的实例。
7.exception对象
exception对象是一个例外对象,当一个页面在运行过程中发生了例外,就产生这个对象。如果一个JSP页面要应用此对象,就必须把isErrorPage设为true,否则无法编译。他实际上是java.lang.Throwable的对象
8.pageContext对象
pageContext对象提供了对JSP页面内所有的对象及名字空间的访问,也就是说他可以访问到本页所在的SESSION,也可以取本页面所在的application的某一属性值,他相当于页面中所有功能的集大成者,它的本 类名也叫pageContext。
9.config对象
config对象是在一个Servlet初始化时,JSP引擎向它传递信息用的,此信息包括Servlet初始化时所要用到的参数(通过属性名和属性值构成)以及服务器的有关信息(通过传递一个ServletContext对象)

考点1

下列叙述错误的是( )

  • A java提供了丰富的类库
  • B java很好的利用了网络资源
  • C java支持多线程
  • D java不支持TCP/IP协议

正确答案: D

解析

考点2

对于java类型变量char c,short s,float f,double d,表达式c*s+f+d的结果类型为()

  • A float
  • B char
  • C short
  • D double

正确答案: D

解析

自动类型转换遵循下面的规则:
1.若参与运算的数据类型不同,则先转换成同一类型,然后进行运算。
2.转换按数据长度增加的方向进行,以保证精度不降低。例如int型和long型运算时,先把int量转成long型后再进行运算。
3.所有的浮点运算都是以双精度进行的,即使仅含float单精度量运算的表达式,也要先转换成double型,再作运算。
4.char型和short型参与运算时,必须先转换成int型。
5.在赋值运算中,赋值号两边的数据类型不同时,需要把右边表达式的类型将转换为左边变量的类型。如果右边表达式的数据类型长度比左边长时,将丢失一部分数据,这样会降低精度。
byte->short->int
char -> int -> long
float -> double
int -> float->double
long -> double

考点3

以下程序的运行结果是()
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);
}
}

  • A 666
  • B 667
  • C 677
  • D 676

正确答案: B

解析

a++表示先用后+,
而++a表示先+后用

考点4

BufferedReader的父类是以下哪个?

  • A FilterReader
  • B InputStreamReader
  • C PipedReader
  • D Reader

正确答案: D

解析

考点5

枚举(enum)属于原始数据类型(primitive type)。

  • A 正确
  • B 错误

正确答案: B

解析

这里的原始数据类型就是基本数据类型
byte,short,int,long,float,double,boolean,char.
枚举类是一种特殊对的类,既然是类。那他就不是原始数据类型了

考点6

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

  • A FALSE
  • B TRUE

正确答案: A

解析

1、java文件中类型为public的类有两种,一种是外部类,一种是内部类;
2、当外部类的类型为public时,文件名需要与其相同;
3、当内部类的类型为public时,而外部类不是public类型的,则文件名可随意,但需要满足命名规范(以字母或下划线开头)。

考点7

关于java编译和运行命令叙述不正确的是? ( )

  • A 运行“java Scut.class”
  • B 运行“java Scut”
  • C 运行“javac Scut.java”的输出文件是Scut.class
  • D java这个命令的运行对象是Scut.class

正确答案: A

解析

先编译:javac scut.java.产生字节码文件(scut.class).
再运行字节码文件:java scut.此时不需要加后缀

考点8

在java中重写方法应遵循规则的包括()

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

正确答案: BC

解析

两同两小一大原则:
两同:方法名和参数列表相同
两小:返回值或声明异常比父类小(或相同)
一大:访问修饰符比父类的大(或相同)
访问权限可以相同,所以A不对。
访问权限可以更大,则不同,所以B对

考点9

以下程序执行后,错误的结果是()
public class Test {
private String name = “abc”;
public static void main(String[] args) {
Test test = new Test();
Test testB = new Test();
String result = test.equals(testB) + “,”;
result += test.name.equals(testB.name) + “,”;
result += test.name == testB.name;
System.out.println(result);
}
}

  • A true,true,true
  • B true,false,false
  • C false,true,false
  • D false,true,true

正确答案: ABC

解析

Test重写equals方法。比较的是地址。所以test.equals(testB) 返回false。
String重写了equals方法,比较的是内容,所以,test.name.equals(testB.name)返回true。
String name = “abc”,name引用的是字符串直接量,字符串直接量放在常量区,只创建一次,所以是同一对象,所以test.name == testB.name返回true
也就是false,true,true

但是题目要你选错误的

考点10

下面有关java的引用类型,说法正确的有?

  • A 对于一个对象来说,只要有强引用的存在,它就会一直存在于内存中
  • B 如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收器回收。
  • C 如果一个对象只具有软引用,则内存空间足够,垃圾回收器就不会回收它;如果内存空间不足了,就会回收这些对象的内存
  • D 一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的空间

正确答案: ABCD

解析

1、强引用:一个对象赋给一个引用就是强引用,比如new一个对象,一个对象被赋值一个对象。
2、软引用:用SoftReference类实现,一般不会轻易回收,只有内存不够才会回收。
3、弱引用:用WeekReference类实现,一旦垃圾回收已启动,就会回收。
4、虚引用:不能单独存在,必须和引用队列联合使用。主要作用是跟踪对象被回收的状态。

考点1

以下代码执行后输出结果为( )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ClassTest{
String str = new String("hello");
char[] ch = {'a','b','c'};
public void fun(String str, char ch[]){
str="world";
ch[0]='d';
}
public static void main(String[] args) {
ClassTest test1 = new ClassTest();
test1.fun(test1.str,test1.ch);
System.out.print(test1.str + " and ");
System.out.print(test1.ch);
}
}
  • A hello and dbc
  • B world and abc
  • C hello and abc
  • D world and dbc

正确答案: A

解析

考点2

ArrayList list = new ArrayList(20);中的list扩充几次

  • A 0
  • B 1
  • C 2
  • D 3

正确答案: A

解析

ArrayList list=new ArrayList(); 这种是默认创建大小为10的数组,每次扩容大小为1.5倍
ArrayList list=new ArrayList(20); 这种是指定数组大小的创建,创建时直接分配其大小,没有扩充。 所以,扩充为0次

考点3

下面程序的输出结果是?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package algorithms.com.guan.javajicu;  
public class TestDemo {
public static String output ="";
public static void foo(int i){
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);
}
}
  • A 出错
  • B 342
  • C 34234
  • D 3423

正确答案: D

解析

考点4

下列哪个选项是合法的标识符?()

  • A 123
  • B _name
  • C class
  • D first

正确答案: BD

解析

Java标识符由数字、字母、下划线(_)、美元符号($)组成,首位不能是数字。并且Java关键字不能作为标识符

考点1 java程序命令文件名

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

  • A java.exe
  • B javac.exe
  • C applet.exe
展开/折叠 正确答案: B

解析

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

考点2 循环

以下代码的循环次数是

1
2
3
4
5
6
7
8
9
10
public class Test {
public static void main(String args[]) {
int i = 7;
do {
System.out.println(--i);
--i;
} while (i != 0);
System.out.println(i);
}
}
  • A 0
  • B 1
  • C 7
  • D 无限次
展开/折叠 正确答案: D

解析

每次循环都是减去2,7-2n恒不等于0,所以循环一直持续下去

考点3 C语言指针

int a[]= {1,2,3,4,5}, int *p = a, 下列表达式与 ++*p 相同的是()

  • A *++p
  • B a[0]
  • C ++a[0]
  • D *p++
展开/折叠 正确答案: C

解析

为什么java的题中老是出现C语言的题
*p指针指向第一位,也就是a[0]
++*p就是++a[0]

考点4 负数求余运算

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

1
2
3
4
5
6
7
public class Test {
public static void main(String args[]) {
int x = -5;
int y = -12;
System.out.println(y % x);
}
}
  • A -1
  • B 2
  • C 1
  • D -2
展开/折叠 正确答案: D

解析 求余运算本质上是减法

  • 求余(取模运算)结果与被除数符号相同
  • 取余模运算都属于除法,除法就可看作减法,-12-(-5)-(-5)

考点4 构造函数的正确格式

尝试编译以下程序会产生怎么样的结果?()

1
2
3
4
5
6
7
8
9
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)
}
}
  • A 编译错误将发生在(1),因为构造函数不能指定返回值
  • B 编译错误将发生在(2),因为该类没有默认构造函数
  • C 编译错误将在(3)处发生,因为该类没有构造函数,该构造函数接受一个int类型的参数
  • D 该程序将正确编译和执行
展开/折叠 正确答案: C

解析

(1)处代码,虽然方法名和类名相同,不过由于void的修饰,所以它并不是一个构造方法,只是一个普通方法。
因此这个类仍然只有默认的无参构造器,所以(2)处代码正确
(3)处代码,没有带参数构造器 所以错误。

考点5 静态成员和普通成员的执行顺序

以下代码执行后输出结果为( )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Test
{
public static Test t1 = new Test();
{
System.out.println("blockA");
}
static
{
System.out.println("blockB");
}
public static void main(String[] args)
{
Test t2 = new Test();
}
}
  • A blockAblockBblockA
  • B blockAblockAblockB
  • C blockBblockBblockA
  • D blockBblockAblockB
展开/折叠 正确答案: A

解析

  • 静态块:用static申明,JVM加载类时执行,仅执行一次
  • 构造块:类中直接用{}定义,每一次创建对象时执行
  • 执行顺序优先级:静态块>main()>构造块>构造方法
  • 静态块按照声明的顺序执行,先执行public static Test t1 = new Test();所以先输出blockA
  • 然后执行静态块,输出blockB
  • 最后执行main方法中的Test t2 = new Test();输出blockA

考点6 String类的split方法

1
2
String str = "";
System.out.print(str.split(",").length);

输出结果为:

  • A 0
  • B 1
  • C 出现异常
展开/折叠 正确答案: B

解析

就是单纯的分片成列表,因为不含有’,‘,所以就成为[""]这样的列表

考点7 集合Collection接口子接口

以下哪些继承自Collection接口()

  • A List
  • B Set
  • C Map
  • D Array
展开/折叠 正确答案: AB

解析

考点8 Java合法标识符

下列可作为java语言标识符的是()

  • A a1
  • B $1
  • C _1
  • D 11
展开/折叠 正确答案: ABC

解析

java中标识符由

  • 字母,数字,下划线, 美元符组成
  • 首位不能为数字
  • Java关键字不能当作Java标识符