Java专项练习二(选择题)

这里开始已经刷了200道题了!继续努力!

201、

int i, sum=0;
for(i=0;i<10;++i,sum+=i); i 的最终结果是?
A、10
B、9
C、11
D、以上答案都不正确

202、下列不属于算法结构的是()

A、输入数据
B、处理数据
C、存储数据
D、输出结果

解析:算法包括0个或多个输入,1个或多个输出,中间有穷个处理过程。
存储结构不属于算法结构

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

A、BB
B、CBB
C、BAB
D、None of the above

解析: 初始化过程是这样的:
1.首先,初始化父类中的静态成员变量和静态代码块,按照在程序中出现的顺序初始化;
2.然后,初始化子类中的静态成员变量和静态代码块,按照在程序中出现的顺序初始化;
3.其次,初始化父类的普通成员变量和代码块,在执行父类的构造方法;
4.最后,初始化子类的普通成员变量和代码块,在执行子类的构造方法;

(1)初始化父类的普通成员变量和代码块,执行 C c = new C(); 输出C
(2)super(“B”); 表示调用父类的构造方法,不调用父类的无参构造函数,输出B
(3) System.out.print(“B”);
所以输出CBB

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

《Java专项练习二(选择题)》
A、num * count = 505000
B、num * count = 0
C、运行时错误
D、num * count = 5050

解析:
count = count++ 原理是 temp = count; count = count+1 ; count = temp; 因此count始终是0 这仅限于java 与c是不一样的

205、 jre 判断程序是否执行结束的标准是()

A、所有的前台线程执行完毕
B、所有的后台线程执行完毕
C、所有的线程执行完毕
D、和以上都无关

解析:后台线程:指为其他线程提供服务的线程,也称为守护线程。JVM的垃圾回收线程就是一个后台线程。 前台线程:是指接受后台线程服务的线程,其实前台后台线程是联系在一起,就像傀儡和幕后操纵者一样的关系。傀儡是前台线程、幕后操纵者是后台线程。由前台线程创建的线程默认也是前台线程。可以通过isDaemon()和setDaemon()方法来判断和设置一个线程是否为后台线程。

206、以下代码执行的结果是多少()?

		public class Demo { 
	public static void main(String[] args) { 
		Collection<?>[] collections = 
{ new HashSet<String>(), new ArrayList<String>(), new HashMap<String, String>().values()};
				Super subToSuper = new Sub();
				for(Collection<?> collection: collections) { 
	System.out.println(subToSuper.getType(collection));
}
}
abstract static class Super { 
	public static String getType(Collection<?> collection) { 
		return “Super:collection”;
}
public static String getType(List<?> list) { 
		return “Super:list”;
}
public String getType(ArrayList<?> list) { 
		return “Super:arrayList”;
}
public static String getType(Set<?> set) { 
		return “Super:set”;
}
public String getType(HashSet<?> set) { 
		return “Super:hashSet”;
}
}
static class Sub extends Super { 
	public static String getType(Collection<?> collection) { 
            return "Sub"; }
}
}

A、
Sub:collection
Sub:collection
Sub:collection
B、
Sub:hashSet
Sub:arrayList
Sub:collection
C、
Super:collection
Super:collection
Super:collection
D、
Super:hashSet
Super:arrayList
Super:collection

解析:这是静态分派的过程,在编译时已经决定了使用super的方法,因为subToSuper 是指super对象,可是为什么会选择collection呢,for循环出来他们实际上指的是collection对象表示的,即类似于Collection col = new HashSet<>();这样传入方法getType()中的参数就是col,左边是静态类型,右边是实际类型。由于重载实际上是使用静态分派的,重载时是通过参数的静态类型而不是实际类型作为判定依据的。详细参考深入理解java虚拟机248页解释。

207、Java网络程序设计中,下列正确的描述是()

A、Java网络编程API建立在Socket基础之上
B、Java网络接口只支持tcP以及其上层协议
C、Java网络接口只支持UDP以及其上层协议
D、Java网络接口支持IP以上的所有高层协议

208、下面哪个语句是创建数组的正确语句?( )

A、float f[][] = new float[6][6];
B、float []f[] = new float[6][6];
C、float f[][] = new float[][6];
D、float [][]f = new float[6][6];
E、float [][]f = new float[6][];

解析:数组命名时名称与[]可以随意排列,但声明的二维数组中第一个中括号中必须要有值,它代表的是在该二维数组中有多少个一维数组。 即数组声明,必须要明确行数,列数随意

209、下面有关java threadlocal说法正确的有?

A、ThreadLocal存放的值是线程封闭,线程间互斥的,主要用于线程内共享一些数据,避免通过参数来传递
B、从线程的角度看,每个线程都保持一个对其线程局部变量副本的隐式引用,只要线程是活动的并且 ThreadLocal 实例是可访问的;在线程消失之后,其线程局部实例的所有副本都会被垃圾回收
C、在Thread类中有一个Map,用于存储每一个线程的变量的副本
D、对于多线程资源共享的问题,同步机制采用了“以时间换空间”的方式,而ThreadLocal采用了“以空间换时间”的方式

210、下面的switch语句中,x可以是哪些类型的数据:()

switch(x)
{ 
default:
System.out.println("Hello");
}

A、long
B、char
C、float
D、byte
E、double
F、Object

解析:以java8为准,switch支持10种类型 基本类型:byte char short int 对于包装类 :Byte,Short,Character,Integer String enum 2、实际只支持int类型 Java实际只能支持int类型的switch语句,那其他的类型时如何支持的 a、基本类型byte char short 原因:这些基本数字类型可自动向上转为int, 实际还是用的int。 b、基本类型包装类Byte,Short,Character,Integer 原因:java的自动拆箱机制 可看这些对象自动转为基本类型 c、String 类型 原因:实际switch比较的string.hashCode值,它是一个int类型 如何实现的,网上例子很多。此处不表。 d、enum类型 原因 :实际比较的是enum的ordinal值(表示枚举值的顺序),它也是一个int类型 所以也可以说 switch语句只支持int类型

211、只有实现了()接口的类,其对象才能序列化。

A、Serializable
B、Cloneable
C、Comparable
D、Writeable

解析:Serializable接口是专门提供给类实现序列化用的。要实现序列化对象必须要实现 Serializable 接口

212、下列程序段的输出结果是:( )

public void complicatedexpression_r(){ 
    int x=20, y=30;
    boolean b;
    b = x > 50 && y > 60 || x > 50 && y < -60 || x < -50 && y > 60 || x < -50 && y < -60;
    System.out.println(b);
}

A、true
B、false
C、1
D、0

解析:
x>50为false,由于&&与操作,||或操作都是短路操作符,即与操作时一旦遇到false就停止执行后当前关系式中的后续代码,同理或操作时一旦遇到true也停止执行。
x>50&&y>60中x>50结果为false,所以就不需要判断y>60。继续判断第一个||或操作符后面的代码,结果为false || false || false || false。因此最终答案选择false。

213、请问所有的异常类皆直接继承于哪一个类?()

A、java.applet.Applet
B、java.lang.Throwable
C、java.lang.Exception
D、java.lang.Error

解析:
《Java专项练习二(选择题)》

214、以下代码在编译和运行过程中会出现什么情况

public class TestDemo{ 
	private int count;
	public static void main(String[] args) { 
		TestDemo test=new TestDemo(88);
		System.out.println(test.count);
	}
	 TestDemo(int a) { 
		 count=a;
	}
}

A、编译运行通过,输出结果是88
B、编译时错误,count变量定义的是私有变量
C、编译时错误,System.out.println方法被调用时test没有被初始化
D、编译和执行时没有输出结果

解析:private是私有变量,只能用于当前类中,题目中的main方法也位于当前类,所以可以正确输出

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

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

解析: B选项中应该是Session接口而不是SessionFactory接口\

1,Configuration接口:配置Hibernate,根据其启动Hibernate,创建SessionFactory对象;

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

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

4,Transaction接口:管理事务。可以对事务进行提交和回滚;

5,Query和Criteria接口:执行数据库的查询。

216、JDK中提供的java、javac、jar等开发工具也是用Java编写的。对

217、下面哪个不属于HttpServletResponse接口完成的功能?

A、设置HTTP头标
B、设置cookie
C、读取路径信息
D、输出返回数据

解析:《Java专项练习二(选择题)》

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

A、new Socket(“localhost”,9000);
B、new ServerSocket(9000);
C、new Socket(9000
D、new ServerSocket(“localhost”,9000);

解析:
《Java专项练习二(选择题)》

219、 下面哪个行为被打断不会导致InterruptedException:( )?

A、Thread.join
B、Thread.sleep
C、Object.wait
D、CyclicBarrier.await
E、Thread.suspend

解析:

抛InterruptedException的代表方法有:
java.lang.Object 类的 wait 方法
java.lang.Thread 类的 sleep 方法
java.lang.Thread 类的 join 方法

220、下面代码的运行结果为:()

import java.io.*;
import java.util.*;
public class foo{ 
public static void main (String[] args){ 
String s;
System.out.println("s=" + s);
}
}

A、代码得到编译,并输出“s=”
B、代码得到编译,并输出“s=null”
C、由于String s没有初始化,代码不能编译通过
D、代码得到编译,但捕获到 NullPointException异常

解析:局部变量可以先申明不用必须初始化,但使用到了一定要先初始化

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

A、java.exe
B、javac.exe
C、applet.exe

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

222、下列选项中属于面向对象设计方法主要特征的是( )。

A、继承
B、自顶向下
C、模块化
D、逐步求精

解析:
A,面向对象设计方法主要特征有继承封装多态。

223、在异常处理中,如释放资源,关闭数据库、关闭文件应由( )语句来完成。

A、try子句
B、catch子句
C、finally子句
D、throw子句

解析:

    try:可能发生异常的语句
    catch:捕获,并处理异常(printStackTrace()用来跟踪异常事件发生时执行堆栈的内容)
    throw: 在程序中引发异常
    throws:把方法中异常抛出该方法
    finally:代码中无论是否有异常都会执行,清除资源 

224、以下代码的循环次数是无限次

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

解析:
执行1次,输出是6,然后再减1为5进行while判定不为o再进入do
执行2次,输出是4,然后再减1为3进行while判定不为o再进入do
执行3次,输出是2,然后再减1为1进行while判定不为o再进入do
执行4次,输出是0,然后再减1为-1进行while判定不为o再进入do
永远执行不到0

225、在异常处理中,以下描述不正确的有

A、try块不可以省略
B、可以使用多重catch块
C、finally块可以省略
D、catch块和finally块可以同时省略

解析:
用try-catch 捕获异常;
用try-finally 清除异常;
用try-catch-finally 处理所有的异常. 三者选一种即可

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

解析:this()和super()都是构造器,this()调用本类构造器,super()调用父类构造器

227、运行结果为:

public static void main(String[] args) { 
Thread t = new Thread() { 

public void run() { 
my360DW();
}
};

t.run();
System.out.print("DW");

}

static void my360DW() { 

System.out.print("360");

}

A、DW
B、360
C、360DW
D、都不输出

解析:本题意在考察开启线程的方法t.start()和直接调用t.run()的区别。但在题目中没有提现 注:直接调用线程的run()方法不是开启线程,就是普通调用,会直接执行run()方法中的内容

228、有如下代码:请写出程序的输出结果。

public class Test
{ 
    public static void main(String[] args)
    { 
        int x = 0;
        int y = 0;
        int k = 0;
        for (int z = 0; z < 5; z++) {  
            if ((++x > 2) && (++y > 2) && (k++ > 2))
            { 
                x++;
                ++y;
                k++;
            }
        }
        System.out.println(x + ”” +y + ”” +k);
    }
}

531
解析:
z=0时候,执行++x > 2,不成立,&&后面就不执行了,此时 x=1,y=0,k=0;
z=1时候,执行++x > 2,还不成立 ,&&后面就不执行了,此时 x=2,y=0,k=0;
z=2时候, 执行++x > 2,成立,继续执行 ++y > 2, 不成立 , &&后面就不执行了, 此时 x=3,y=1,k=0;
z=3时候,执行++x > 2,成立,继续执行++y > 2,不成立 , &&后面就不执行了, 此时 x=4,y=2,k=0;
z=4 时候,执行++x > 2,成立,继续执行 ++y > 2, 成立 , 继续执行k++>2 ,不成立,此时仍没有进入for循环的语句中, 但此时 x=5,y=3,k=1;
z=5时候,不满足条件了,整个循环结束,所以最好打印时候: x=5,y=3,k=1;

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

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

AB,B
解析:《Java专项练习二(选择题)》

230、设三个整型变量 x = 1 , y = 2 , z = 3,则表达式 y+=z--/++x 的值是( )。

3
解析:《Java专项练习二(选择题)》y是2,返回的结果是2+(z–/++x),再来看z–/++x,结果应该是3/2,但是因为x,y,z都是int型的,所以最后的返回值只能是int,这时候z–/++x的值就是1,那么最终的结果就是2+1=3

231、下列程序的运行结果

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

232、关于protected 修饰的成员变量,以下说法正确的是

A、可以被该类自身、与它在同一个包中的其它类、在其它包中的该类的子类所访问
B、只能被该类本身和该类的所有的子类访问
C、只能被该类自身所访问
D、只能被同一个包中的类访问

233、默认RMI采用的是什么通信协议?

A、HTTP
B、UDP/IP
C、TCP/IP
D、Multicast

234、下列说法正确的是( )

A、volatile,synchronized 都可以修改变量,方法以及代码块
B、volatile,synchronized 在多线程中都会存在阻塞问题
C、volatile能保证数据的可见性,但不能完全保证数据的原子性,synchronized即保证了数据的可见性也保证了原子性
D、volatile解决的是变量在多个线程之间的可见性、原子性,而sychroized解决的是多个线程之间访问资源的同步性

解析:
synchronized关键字和volatile关键字比较:

volatile关键字是线程同步的轻量级实现,所以volatile性能肯定比synchronized关键字要好。但是volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块。synchronized关键字在JavaSE1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升,实际开发中使用 synchronized 关键字的场景还是更多一些。
多线程访问volatile关键字不会发生阻塞,而synchronized关键字可能会发生阻塞
volatile关键字能保证数据的可见性,但不能保证数据的原子性。synchronized关键字两者都能保证。
volatile关键字主要用于解决变量在多个线程之间的可见性,而 synchronized关键字解决的是多个线程之间访问资源的同步性。

235、我们在程序中经常使用“System.out.println()”来输出信息,语句中的System是包名,out是类名,println是方法名。


解析:System是java.lang中的一个类,out是System内的一个成员变量,这个变量是一个java.io.PrintStream类的对象,println呢就是一个方法了

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

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

解析:
Test mv =newTest()声明并初始化对data赋默认值
使用synchronized关键字加同步锁线程依次操作m()
t1.start();使得result=2,data=2,输出即为2 2
t2.start();使得result=4,data=4,输出即为4 4
t3.start();使得result=6,data=6,输出即为6 6
System.out.print(result +” “+ data);是print()方法不会换行,输出结果为2 24 46 6

237、 关于 Socket 通信编程,以下描述错误的是:( )

A、服务器端通过new ServerSocket()创建TCP连接对象
B、服务器端通过TCP连接对象调用accept()方法创建通信的Socket对象
C、客户端通过new Socket()方法创建通信的Socket对象
D、客户端通过new ServerSocket()创建TCP连接对象

解析: Socket套接字
就是源Ip地址,目标IP地址,源端口号和目标端口号的组合
服务器端:ServerSocket提供的实例
ServerSocket server= new ServerSocket(端口号)
客户端:Socket提供的实例
Socket soc=new Socket(ip地址,端口号)

238、java中下面哪个能创建并启动线程()

public class MyRunnable implements Runnable          {  
     public void run()             {  
         //some code here 
     } 
 }

A、new Runnable(MyRunnable).start()
B、new Thread(MyRunnable).run()
C、new Thread(new MyRunnable()).start()
D、new MyRunnable().start()

解析: C正确
首先:创建并启动线程的过程为:定义线程—》实例化线程—》启动线程。
一 、定义线程: 1、扩展java.lang.Thread类。 2、实现java.lang.Runnable接口。
二、实例化线程: 1、如果是扩展java.lang.Thread类的线程,则直接new即可。
2、如果是实现了java.lang.Runnable接口的类,则用Thread的构造方法:
Thread(Runnable target)
Thread(Runnable target, String name)
Thread(ThreadGroup group, Runnable target)
Thread(ThreadGroup group, Runnable target, String name)
Thread(ThreadGroup group, Runnable target, String name, long stackSize)
所以A、D的实例化线程错误。
三、启动线程: 在线程的Thread对象上调用start()方法,而不是run()或者别的方法。
所以B的启动线程方法错误。

239、Which statement is true for the class java.util.ArrayList?

A、The elements in the collection are ordered.
B、The collection is guaranteed to be immutable.
C、The elements in the collection are guaranteed to be unique.
D、The elements in the collection are accessed using a unique key.
E、The elements in the collections are guaranteed to be synchronized.

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

240、下列关于Java并发的说法中正确的是()

A、CopyOnWriteArrayList适用于写多读少的并发场景
B、ReadWriteLock适用于读多写少的并发场景
C、ConcurrentHashMap的写操作不需要加锁,读操作需要加锁
D、只要在定义int类型的成员变量i的时候加上volatile关键字,那么多线程并发执行i++这样的操作的时候就是线程安全的了

解析: A,CopyOnWriteArrayList适用于写少读多的并发场景
B,ReadWriteLock即为读写锁,他要求写与写之间互斥,读与写之间互斥,
读与读之间可以并发执行。在读多写少的情况下可以提高效率
C,ConcurrentHashMap是同步的HashMap,读写都加锁
D,volatile只保证多线程操作的可见性,不保证原子性

241、结构型模式中最体现扩展性的模式是()

A、装饰模式
B、合成模式
C、桥接模式
D、适配器

解析: A
结构型模式是描述如何将类对象结合在一起,形成一个更大的结构,结构模式描述两种不同的东西:类与类的实例。故可以分为类结构模式和对象结构模式。

在GoF设计模式中,结构型模式有:
1.适配器模式 Adapter
适配器模式是将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
两个成熟的类需要通信,但是接口不同,由于开闭原则,我们不能去修改这两个类的接口,所以就需要一个适配器来完成衔接过程。
2.桥接模式 Bridge
桥接模式将抽象部分与它的实现部分分离,是它们都可以独立地变化。它很好的支持了开闭原则和组合锯和复用原则。实现系统可能有多角度分类,每一种分类都有可能变化,那么就把这些多角度分离出来让他们独立变化,减少他们之间的耦合。
3.组合模式 Composite
组合模式将对象组合成树形结构以表示部分-整体的层次结构,组合模式使得用户对单个对象和组合对象的使用具有一致性。
4.装饰模式 Decorator
装饰模式动态地给一个对象添加一些额外的职责,就增加功能来说,它比生成子类更灵活。也可以这样说,装饰模式把复杂类中的核心职责和装饰功能区分开了,这样既简化了复杂类,有去除了相关类中重复的装饰逻辑。 装饰模式没有通过继承原有类来扩展功能,但却达到了一样的目的,而且比继承更加灵活,所以可以说装饰模式是继承关系的一种替代方案。
5.外观模式 Facade

外观模式为子系统中的一组接口提供了同意的界面,外观模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。

外观模式中,客户对各个具体的子系统是不了解的,所以对这些子系统进行了封装,对外只提供了用户所明白的单一而简单的接口,用户直接使用这个接口就可以完成操作,而不用去理睬具体的过程,而且子系统的变化不会影响到用户,这样就做到了信息隐蔽。
6.享元模式 Flyweight

享元模式为运用共享技术有效的支持大量细粒度的对象。因为它可以通过共享大幅度地减少单个实例的数目,避免了大量非常相似类的开销。.

  享元模式是一个类别的多个对象共享这个类别的一个对象,而不是各自再实例化各自的对象。这样就达到了节省内存的目的。

7.代理模式 Proxy
为其他对象提供一种代理,并由代理对象控制对原对象的引用,以间接控制对原对象的访问。
《大话设计模式》

242、关于数据库连接的程序,以下哪个语句的注释是错误的( )

A、Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”); //指定MySQL JDBC驱动程序
B、String url=”jdbc:odbc:student_access”; //指定数据源为student_access
C、Connection con=DriverManager.getConnection(url); //创建连接指定数据库的对象
D、Statement stmt=con.creatStatement();//创建执行SQL语句的Statement对象

解析:
《Java专项练习二(选择题)》

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

A、compiletime error
B、prints:1
C、prints:2
D、prints:3
E、prints:7
F、prints:8

解析: D
1.静态语句块中x为局部变量,不影响静态变量x的值
2.x和y为静态变量,默认初始值为0,属于当前类,其值得改变会影响整个类运行。
3.java中自增操作非原子性的
main方法中:

执行x--后 x=-1
调用myMethod方法,x执行x++结果为-1(后++),但x=0,++x结果1,x=1 ,则y=0
x+y+ ++x,先执行x+y,结果为1,执行++x结果为2,得到最终结果为3 

244、下列Java代码中的变量a、b、c分别在内存的____存储区存放。

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

堆区、栈区、栈区
解析:
答案是C
a是类中的成员变量,存放在堆区
b、c都是方法中的局部变量,存放在栈区

245、存根(Stub)与以下哪种技术有关

动态链接
解析:存根类是一个类,它实现了一个接口,它的作用是:如果一个接口有很多方法,如果要实现这个接口,就要实现所有的方法。但是一个类从业务来说,可能只需要其中一两个方法。如果直接去实现这个接口,除了实现所需的方法,还要实现其他所有的无关方法。而如果通过继承存根类就实现接口,就免去了这种麻烦。
RMI 采用stubs 和 skeletons 来进行远程对象(remote object)的通讯。stub 充当远程对象的客户端,有着和远程对象相同的远程接口,远程对象的调用实际是通过调用该对象的客户端对象stub来完成的。
每个远程对象都包含一个对象stub,当运行在本地Java虚拟机上的程序调用运行在远程Java虚拟机上的对象方法时,它首先在本地创建该对象的对象stub, 然后调用对象上匹配的方法。每一个远程对象同时也包含一个skeleton对象,skeleton运行在远程对象所在的虚拟机上,接受来自stub对象的调用。这种方式符合等到程序要运行时将目标文件动态进行链接的思想

246、如果Child extends Parent,那么正确的有()?

A、如果Child是class,且只有一个有参数的构造函数,那么必然会调用Parent中相同参数的构造函数
B、如果Child是interface,那么Parent必然是interface
C、如果Child是interface,那么Child可以同时extends Parent1,Parent2等多个interface
D、如果Child是class,并且没有显示声明任何构造函数,那么此时仍然会调用Parent的构造函数

解析: A、子类的构造器第一行默认都是super(),默认调用直接父类的无参构造,一旦直接父类没有无参构造,那么子类必须显式的声明要调用父类或者自己的哪一个构造器。
BC、接口只能继承接口,但是可以多继承。类都是单继承,但是继承有传递性。
D、一个类一旦没有显式的定义任何构造,那么JVM会默认给你一个无参构造。无参构造的第一行依然默认是super()。

247、面向对象程序设计方法的优点包含:

A、可重用性
B、可扩展性
C、易于管理和维护
D、简单易懂

248、关于下列代码的执行顺序,下面描述正确的有哪些选项()

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的构造函数
B、打印顺序A的静态代码块> A的构造代码块
C、打印顺序A的构造代码块> A的构造函数
D、打印顺序A的构造函数> A的构造代码块

解析:
打印顺序为A的静态代码块,A的构造代码块,A的构造函数

249、常用的servlet包的名称是?

A、java.servlet
B、javax.servlet
C、servlet.http
D、javax.servlet.http

解析:
JEE5.0中的Servlet相关的就下面这几个包:
javax.servlet
javax.servlet.jsp
java.servlet.jsp.el
java.servlet.jsp.tagext
而最用得多的就是
javax.servlet
javax.servlet.http
这两个包了.

250、局部内部类可以用哪些修饰符修饰?

A、public
B、private
C、abstract
D、final

解析:《Java专项练习二(选择题)》

251、在程序代码中写的注释太多,会使编译后的程序尺寸变大。

错误
解析:javadoc 用来识别注释,javac 用来识别代码,二者互不影响,注释不会被编译 ,注释是给程序员看的 。

252、关于异常处理机制的叙述正确的是()

A、catch部分捕捉到异常情况时,才会执行finally部分
B、当try区段的程序发生异常时,才会执行finally部分
C、当try区段不论程序是否发生错误及捕捉到异常情况,都会执行finally部分
D、以上都是

解析:
在Java语言的异常处理中,finally块的作用就是为了保证无论出现什么情况,finally块里的代码一定会执行。
由于程序执行return就意味着结束了对当前函数的调用并跳出这个函数体,因此任何语句执行都要放在return前执行(除非碰到exit函数),因此finally块里面的函数也是在return前执行的。
如果try-finally或者catch-finally中都有return语句,那么finally中的return语句会覆盖别处的,最终返回到调用者那里的是finally中的return值。

253、 下列选项中,用于在定义子类时声明父类名的关键字是:( )

A、interface
B、package
C、extends
D、class

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

final

255、 执行以下程序,最终输出可能是:

《Java专项练习二(选择题)》
A、010 2123012 3434
B、01201 340124 2334
==C、0012314 01223344
==
D、12345 12345 12345

解析:每个线程输出0,1,2,3,4,’空格, 输出空格前必有线程输出了0-4,所以选C、

256、下面程序的输出是什么?

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

A、342
B、3423
C、34234
D、323

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

257、判断对错。在java的多态调用中,new的是哪一个类就是调用的哪个类的方法。


解析: java多态有两种情况:重载和覆写
在覆写中,运用的是动态单分配,是根据new的类型确定对象,从而确定调用的方法;
在重载中,运用的是静态多分派,即根据静态类型确定对象,因此不是根据new的类型确定调用的方法

258、ResultSet中记录行的第一列索引为?

1
解析:ResultSet跟普通的数组不同,索引从1开始而不是从0开始

259、下面哪个描述正确? ()

**==A、echo KaTeX parse error: Can’t use function ‘$’ in math mode at position 20: …shell的PID和echo $̲? 返回上一个命令的状态== …返回上一个命令和echo $的状态? 返回登录shell的PID
C、echo KaTeX parse error: Can’t use function ‘$’ in math mode at position 7: 和echo $̲? 返回一些无意义的整数值 D…
代表所在命令的PID
$!
代表最后执行的后台命令的PID
$?
代表上一个命令执行后的退出状态 echo $? 如果返回值是0,就是执行成功;如果是返回值是0以外的值,就是失败。

260、下列哪些情况下会导致线程中断或停止运行( )

A、InterruptedException异常被捕获
B、线程调用了wait方法
C、当前线程创建了一个新的线程
D、高优先级线程进入就绪状态

解析:
A选项正确,Java中一般通过interrupt方法中断线程
B选项正确,线程使用了wait方法,会强行打断当前操作,进入阻塞(暂停)状态,然后需要notify方法或notifyAll方法才能进入就绪状态
C选项错误,新创建的线程不会抢占时间片,只有等当前线程把时间片用完,其他线程才有资格拿到时间片去执行。
D选项错误,调度算法未必是剥夺式的,而准备就绪但是还没有获得CPU,它的权限更高只能说明它获得CPU被执行的几率更大而已

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

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

解析: 关于封装:
封住、继承、多态是面向对象的三大特征,其重要性与使用频率不言而喻。——所以B错误。
1 、什么是封装?

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

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

 private String name;

public String getName(){ 

                    return;

           }

        public void setName(String name){ 

                    this.name=name;

           }

2、为什么需要封装?

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

262、已知int a[]=new int[10],则下列对数组元素的访问不正确的是()

A、a[0]
B、a[1]
C、a[9]
D、a[10]

解析:ArrayIndexOutOfBoundsException

263、 在 java 中 , 一个类()

A、可以继承多个类
B、可以实现多个接口
C、在一个程序中只能有一个子类
D、只能实现一个接口

解析:一个类可以有多个子类,但是只能有一个直接父类,但是类对于接口可以多实现(接口本身可以多继承)

264、下面有关java classloader说法错误的是?

A、Java默认提供的三个ClassLoader是BootStrap ClassLoader,Extension ClassLoader,App ClassLoader
B、ClassLoader使用的是双亲委托模型来搜索类的
C、JVM在判定两个class是否相同时,只用判断类名相同即可,和类加载器无关
D、ClassLoader就是用来动态加载class文件到内存当中用的

解析:JVM在判定两个class是否相同时,不仅要判断两个类名是否相同,而且要判断是否由同一个类加载器实例加载的。

265、为AB类的一个无形式参数无返回值的方法method书写方法头,可以用AB.method()方式调用,该方法头的形式为( )。

A、static void method( )
B、public void method( )
C、final void method( )
D、abstract void method( )

解析:
首先声明什么是静态方法:

用static修饰的方法
静态方法是使用公共内存空间的,就是说所有对象都可以直接引用,不需要创建对象再使用该方法。  

其次说明静态方法的使用:

在外部调用静态方法时,可以使用"类名.方法名"的方式,也可以使用"对象名.方法名"的方式。
而实例方法只有后面这种方式。 

也就是说,只有调用静态方法时可以无需创建对象。

根据题目. 

1:AB为一个类,可以不创建对象,直接使用AB.method (“类名.方法名”的方式)
—————所以method是static修饰的静态方法
2:其次method无返回值
—————-所以method是void类型的方法.
所以选B static void method();

266、哪个关键字可以对对象加互斥锁?()

A、synchronized
B、volatile
C、serialize
D、static

解析:synchronized关键字是同步代码块关键字,对对象加互斥锁

267、下列程序执行后输出结果为( )

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

A、
static BaseClass
I’m BaseClass class
static Base
I’m Base class
B、
I’m BaseClass class
I’m Base class
static BaseClass
static Base
C、
I’m BaseClass class
static BaseClass
I’m Base class
static Base
D、
static BaseClass
static Base
I’m BaseClass class
I’m Base class

解析:
父类静态代码块 ->子类静态代码块 ->父类非静态代码块 -> 父类构造函数 -> 子类非静态代码块 -> 子类构造函数。

268、根据下面的程序代码,哪些选项的值返回true?

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、a = = b
B、s = = a
C、b = = c
D、a.equals(s)

解析:a = new Square(42L); b = new Square(42L);
这里new了两个对象,所以a,b不是同一个引用a!=b
s的类型跟a,b不同类型,所以s!=a,s!=b
c = b;
这里b,c是同一个对象的引用,所以b==c是true

269、java接口的方法修饰符可以为?(忽略内部接口)

A、private
B、protected
C、final
D、abstract

解析:《Java专项练习二(选择题)》

270、下面这段java代码,当 T 分别是引用类型和值类型的时候,分别产生了多少个 T对象和T类型的值()

T t = new T();(值类型时:T t;)
Func(t);
Func 定义如下:
public void Func(T t) { }
1 2
解析:引用类型作为函数的参数时,复制的是引用的地址,不会产生一个新的T;而如果T是值类型,其作为函数实参时会复制其值,也就是产生了一个新的T。

271、看以下代码:

文件名称:forward.jsp

<html>  
     <head><title> 跳转  </title> </head> 
     <body>  
         <jsp:forward page="index.htm"/>     
     </body>
 </html> 

如果运行以上jsp文件,地址栏的内容为
A、http://127.0.0.1:8080/myjsp/forward.jsp
B、http://127.0.0.1:8080/myjsp/index.jsp
C、http://127.0.0.1:8080/myjsp/index.htm
D、http://127.0.0.1:8080/myjsp/forward.htm

解析: forward和redirect是最常问的两个问题
forward,服务器获取跳转页面内容传给用户,用户地址栏不变
redirect,是服务器向用户发送转向的地址,redirect后地址栏变成新的地址
因此这个题是A

272、在jdk1.5之后,下列 java 程序输出结果为______。

int i=0;
Integer j = new Integer(0);
System.out.println(i==j);
System.out.println(j.equals(i));

true,true
解析:
《Java专项练习二(选择题)》

273、下列哪个选项是Java调试器?如果编译器返回程序代码的错误,可以用它对程序进行调试。

A、java.exe
B、javadoc.exe
C、jdb.exe
D、javaprof.exe

解析:
java,exe是java虚拟机
javadoc.exe用来制作java文档
jdb.exe是java的调试器
javaprof,exe是剖析工具

274、以下哪一个不是赋值符号?

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

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

275、java8中,下面哪个类用到了解决哈希冲突的开放定址法

A、LinkedHashSet
B、HashMap
C、ThreadLocal
D、TreeMap

解析:ThreadLocalMap中使用开放地址法来处理散列冲突,而HashMap中使用的是分离链表法。之所以采用不同的方式主要是因为:在ThreadLocalMap中的散列值分散得十分均匀,很少会出现冲突。并且ThreadLocalMap经常需要清除无用的对象,使用纯数组更加方便。

276、 下列不是 Java 关键字的是 ( )

A、abstract
B、false
C、native
D、sizeof

解析:
Java中的关键字有哪些?
答:1)48个关键字:abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while。
2)2个保留字(现在没用以后可能用到作为关键字):goto、const。
3)3个特殊直接量:true、false、null。

277、Java是一门支持反射的语言,基于反射为Java提供了丰富的动态性支持,下面关于Java反射的描述,哪些是错误的:( )

A、Java反射主要涉及的类如Class, Method, Filed,等,他们都在java.lang.reflet包下
B、通过反射可以动态的实现一个接口,形成一个新的类,并可以用这个类创建对象,调用对象方法
C、通过反射,可以突破Java语言提供的对象成员、类成员的保护机制,访问一般方式不能访问的成员
D、Java反射机制提供了字节码修改的技术,可以动态的修剪一个类
E、Java的反射机制会给内存带来额外的开销。例如对永生堆的要求比不通过反射要求的更多
F、Java反射机制一般会带来效率问题,效率问题主要发生在查找类的方法和字段对象,因此通过缓存需要反射类的字段和方法就能达到与之间调用类的方法和访问类的字段一样的效率

解析:
A:Class类在java.lang包下,错;
B:动态代理可以通过接口与类实现,通过反射形成新的代理类,这个代理类增强了原来类的方法。对;
C:反射可以强制访问private类型的成员,对;
D:反射并不能对类进行修改,只能对类进行访问,错;
E:反射机制对永生堆要求较多,对;
F:即使使用换成,反射的效率也比调用类的方法低,错;

278、以下哪些方法可以取到http请求中的cookie值()?

A、request.getAttribute
B、request.getHeader
C、request.getParameter
D、request.getCookies

解析: 下面的方法可用在 Servlet 程序中读取 HTTP 头。这些方法通过 HttpServletRequest 对象可用:

1)Cookie[] getCookies()
返回一个数组,包含客户端发送该请求的所有的 Cookie 对象。

2)Object getAttribute(String name)
以对象形式返回已命名属性的值,如果没有给定名称的属性存在,则返回 null。

3)String getHeader(String name)
以字符串形式返回指定的请求头的值。Cookie也是头的一种;

4)String getParameter(String name)
以字符串形式返回请求参数的值,或者如果参数不存在则返回 null。

279、Java语言中,下面哪个语句是创建数组的正确语句?( )

A、float f[][] = new float[6][6];
B、float []f[] = new float[6][6];
C、float f[][] = new float[][6];
D、float [][]f = new float[6][6];
E、float [][]f = new float[6][];

解析:二维数组定义,一维长度必须定义,二维可以后续定义

280、关于Java中的数组,下面的一些描述,哪些描述是准确的:( )

A、数组是一个对象,不同类型的数组具有不同的类
B、数组长度是可以动态调整的
C、数组是一个连续的存储结构
D、一个固定长度的数组可类似这样定义: int array[100]
E、两个数组用equals方法比较时,会逐个便利其中的元素,对每个元素进行比较
F、可以二维数组,且可以有多维数组,都是在Java中合法的

解析:数组是一种引用数据类型 那么他肯定是继承Object类的 所以里面有equals() 方法 但是肯定没有重写过 因为他并不是比较数组内的内容
使用Arrays.equals() 是比较两个数组中的内容。

281、 下列描述中,错误的是( )

A、java要求编程者管理内存
B、java的安全性体现在多个层次上
C、java中没有指针机制
D、java有多线程机制

解析:Java与C++的区别在于:Java去除了指针的概念,使用引用,并且Java的内存管理不需要程序员来管理,由Java虚拟机来完成对内存的管理

282、java语言中的数组元素下标总是从0开始,下标可以是整数或整型表达式。()

正确
解析:《Java专项练习二(选择题)》

283、一个以”.java”为后缀的源文件

A、只能包含一个类,类名必须与文件名相同
B、只能包含与文件名相同的类以及其中的内部类
C、只能有一个与文件名相同的类,可以包含其他类
D、可以包含任意类

284、针对下面的代码块,哪个equal为true:()

String s1 = "xiaopeng" ;
String s2 = "xiaopeng" ;
String s3 =new String (s1);

A、s1 == s2
B、s1 = s2
C、s2 = = s3
D、都不正确

解析:String s 1 = “xiaopeng”,这种定义字符串的方式,首先看看字符串常量池中是否有“xiaopeng”如果有就就直接从常量池中取,没有则将“xiaopeng”放到常量池中。String s2 = ‘xiaopeng”,常量池中有”xiaopeng”,直接取值。string s3 = new String(“xiaopeng”);直接在堆中产生一个字符串“xiaopeng”.所以s1和s2地址一样,和s3地址不一样

285、下列关于异常处理的描述中,错误的是()。

A、程序运行时异常由Java虚拟机自动进行处理
B、使用try-catch-finally语句捕获异常
C、可使用throw语句抛出异常
D、捕获到的异常只能在当前方法中处理,不能在其他方法中处理

解析:
编译时异常必须显示处理,运行时异常交给虚拟机。
运行时异常可以不处理。当出现这样的异常时,总是由虚拟机接管。比如我们从来没有人去处理过Null Pointer Exception异常,它就是运行时异常,并且这种异常还是最常见的异常之一。出现运行时异常后,系统会把异常一直往上层抛,一直遇到处理代码。如果没有处理块,到最上层,如果是多线程就由Thread.run()抛出,如果是单线程就被main()抛出。抛出之后,如果是线程,这个线程也就退出了。如果是主程序抛出的异常,整个程序也就退出了。运行时异常是Exception的子类,也有一般异常的特点,是可以被Catch块处理的。只不过往往不对它处理罢了。也就是说,如果不对运行时异常进行处理,那么出现运行时异常之后,要么是线程中止,要么是主程序终止。

286、语句:char foo=‘中’,是否正确?(假设源文件以GB2312编码存储,并且以javac – encoding GB2312命令编译)

正确
解析:《Java专项练习二(选择题)》

287、已知如下类说明:

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

A、t.f = 1.0
B、this.n
C、Test.m
D、Test.n

解析:A:编译不成功,因为float浮点类型默认是double类型 所以float f=1.0f;(必须加上f 强调定义的是float)此处是精度由高(double)向低(float)转型所以会报错 但是若是float f=1;这里是默认类型是Int 类型 精度由低(int)向高转型(float)不丢失精度不会报错。
B:this的使用时针对在方法内部使局部变量等值于实例变量而使用的一个关键字,此处的n是静态变量而非实例变量 所以this的调用会出错(试想一下,static本来是全类中可以使用的,是全局的,你非得this去调用,这不是区分局部变量和实例变量的分水线吗?但是此处是全局的,不需要区分)
C:m是实例变量,什么是实例变量:就是需要new 一个对象出来才能使用的,这里直接用类名就调用了,jvm怎么知道m是谁?
D:类变量可以通过类直接调用

288、要求匹配以下16进制颜色值,正则表达式可以为: #ffbbad #Fc01DF #FFF #ffE

A、/#([0-9a-f]{6}|[0-9a-fA-F]{3})/g
B、/#([0-9a-fA-F]{6}|[0-9a-fA-F]{3})/g
C、/#([0-9a-fA-F]{3}|[0-9a-f]{6})/g
D、/#([0-9A-F]{3}|[0-9a-fA-F]{6})/g

解析:
以#开头,后面是数字和a-f的字符(大写或小写),这个值是6位或3位。要匹配一个3位是为了符合16进制颜色的简写规则

289、有以下类定义:

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 当一个实体类集成一个抽象类,必须实现抽象类中的抽象方法,抽象类本身没有错误,但是cat类编译通不过

290、下面哪种流可以用于字符输入:

A、java.io.inputStream
B、java.io.outputStream
C、java.io.inputStreamReader
D、java.io.outputStreamReader

291、下列说法正确的是

A、java中包的主要作用是实现跨平台功能
B、package语句只能放在import语句后面
C、包(package)由一组类(class)和接口(interface)组成
D、可以用#include关键词来标明来自其它包中的类

292、以下哪一个正则表达式不能与字符串“https://www.tensorflow.org/”(不含引号)匹配?()

A、[a-z]+://[a-z.]+/
B、https[/]www[.]tensorflow[.]org[/]
C、[htps]+://www.tensorflow.org/
D、[a-zA-Z.]+

解析:《Java专项练习二(选择题)》

293、面向对象的基本特征是()

封装、继承、多态

294、Java中的集合类包括ArrayList、LinkedList、HashMap等类,下列关于集合类描述正确的是()

A、ArrayList和LinkedList均实现了List接口
B、ArrayList的访问速度比LinkedList快
C、添加和删除元素时,ArrayList的表现更佳
D、HashMap实现Map接口,它允许任何类型的键和值对象,并允许将null用作键或值

解析:
ArrayList插入和现有项的删除开销很大,除非在末端
LinkedList插入和删除开销很小
ArrayList和LinkedList都是实现了List接口
HashMap可以用null值和空字符串作为K,不过只能有一个

295、关于equals和hashCode描述正确的是 ()

A、两个obj,如果equals()相等,hashCode()一定相等(符合代码规范的情况下)
B、两个obj,如果hashCode()相等,equals()不一定相等
C、两个不同的obj, hashCode()可能相等
D、其他都不对

解析:
“= =”:作用是判断两个对象的地址是否相等,即,判断两个对象是不是同一个对象,如果是基本数据类型,则比较的是值是否相等。
“equal”:作用是判断两个对象是否相等,但一般有两种使用情况
1.类没有覆盖equals()方法,则相当于通过“==”比较
2.类覆盖equals()方法,一般,我们都通过equals()方法来比较两个对象的内容是否相等,相等则返回true,如String

地址比较是通过计算对象的哈希值来比较的,hashcode属于Object的本地方法,对象相等(地址相等),hashcode相等,对象不相等,hashcode()可能相等,哈希冲突

296、Choose the correct ones from the following statements:

A、A class can implement more than one interfaces
B、A class can extend more than one class
C、An interface has at least one method declared.
D、An abstract class which has no abstract methods declared is legal

解析:《Java专项练习二(选择题)》

297、下面哪些情况可以引发异常:

A、数组越界
B、指定URL不存在
C、使用throw语句抛出
D、使用throws语句

解析:1、throws出现在方法头,throw出现在方法体 2、throws表示出现异常的一种可能性,并不一定会发生异常;throw则是抛出了异常,执行throw则一定抛出了某种异常。 3、两者都是消极的异常处理方式,只是抛出或者可能抛出异常,是不会由函数处理,真正的处理异常由它的上层调用处理。

298、以下关于final关键字说法错误的是()

A、final是java中的修饰符,可以修饰类、接口、抽象类、方法和属性
B、final修饰的类肯定不能被继承
C、final修饰的方法不能被重载
D、final修饰的变量不允许被再次赋值

解析:
1.final修饰变量,则等同于常量
2.final修饰方法中的参数,称为最终参数。
3.final修饰类,则类不能被继承
4.final修饰方法,则方法不能被重写。
5.final 不能修饰抽象类
6.final修饰的方法可以被重载 但不能被重写

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

A、初始标记
B、并发标记
C、重新标记
D、并发清理

解析:《Java专项练习二(选择题)》

300、在Java语言中,下列关于字符集编码(Character set encoding)和国际化(i18n)的问题,哪些是正确的?

A、每个中文字符占用2个字节,每个英文字符占用1个字节
B、假设数据库中的字符是以GBK编码的,那么显示数据库数据的网页也必须是GBK编码的。
C、Java的char类型,通常以UTF-16 Big Endian的方式保存一个字符。
D、实现国际化应用常用的手段是利用ResourceBundle类

解析:

301、 下列程序段执行后t3的结果是()。

int t1=2, t2=3, t3;

t3=t1<t2?t1:(t2+t1); 

2
解析:三目运算符的使用

302、 Java 源程序文件的扩展名为()

A、.java
B、.class
C、.exe
D、.jar

解析:
.class 编译后的Java文件
.java是未编译的程序
.jsp是页面程序
.xml配置程序
.jar是.calss的集合

303、 如果一个接口Cow有个方法drink(),有个类Calf实现接口Cow,则在类Calf中正确的是? ( )

A、void drink() { …}
B、protected void drink() { …}
C、public void drink() { …}
D、以上语句都可以用在类Calf中

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

304、运行代码,结果正确的是:

Boolean flag = false;
if(flag = true){ 
System.out.println("true");
}else{ 

System.out.println("false");
}

A、编译错误
B、TRUE
C、FALSE
D、什么也没有输出

解析:if(flag = true)的时候flag已经是true了,所以输出true;
要是为if(flag == true)输出才为false

305、以下声明合法的是

A、default String s
B、public final static native int w( )
C、abstract double d
D、abstract final double hyperbolicCosine( )

解析: A:java的访问权限有public、protected、private和default的,default不能修饰变量
C:普通变量不能用abstract修饰,abstract一般修饰方法和类
D:被定义为abstract的类需要被子类继承,但是被修饰为final的类是不能被继承和改写的

306、下面程序段的时间复杂度是()

i = k = 0;
while( k < n ){ 
   i ++ ;
k += i ;
}

A、O(n)
B、O(n^1/2)
C、O(n*i)
D、O(n+i)

解析:《Java专项练习二(选择题)》

307、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?
A、The program prints”0”
B、The program prints”4”
C、The program prints”8”
D、The program prints”12”
E、The code does not complete.

解析:《Java专项练习二(选择题)》

308、下面哪一项不是加载驱动程序的方法?

A、通过DriverManager.getConnection方法加载
B、调用方法 Class.forName
C、通过添加系统的jdbc.drivers属性
D、通过registerDriver方法注册

解析:DriverManager.getConnection方法返回一个Connection对象,这是加载驱动之后才能进行的

309、单例模式中,两个基本要点是

A、构造函数私有
B、静态工厂方法
C、以上都不对
D、唯一实例

解析:

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

A、一个子类只能继承一个父类
B、子类可以继承父类的构造方法
C、继承具有传递性
D、父类一般具有通用性,子类更具体

    原文作者:玉米迪迪
    原文地址: https://blog.csdn.net/weixin_46041230/article/details/113871006
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞