java 错题集
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了java 错题集，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含76403字，纯文字阅读大概需要110分钟。
内容图文
2019.7.21
1.下列哪个类的声明是正确的？
abstract final class HI{}
abstract private move(){}
protected private number;
public abstract class Car{}
对于A选项，使用final修饰的类表示的是最终类，不能被继承；
而abstrct类是抽象类，需要被继承，两者冲突，所以abstract和final不能同时修饰一个类。
对于B选项，由于private修饰的方法不能被子类实现，而抽象类的子类必须实现所有的抽象方法。
所以private不能修饰抽象方法，抽象方法只能使用protected和public关键字修饰。
对于C选项，修饰符public、protected、private只需要使用其中一个修饰变量，
也可以不适用修饰符，例如int age;所以C选项的修饰符重复，而且没有定义数据类型。
D选项，正确，这是抽象类的通常写法 正确答案: D
2.以下代码执行后输出结果为（ ）
public class ExceptionTest
{
public void method()
{
try
{
System.out.println("进入到try块");
}
catch (Exception e)
{
System.out.println("异常发生了！");
}
finally
{
System.out.println("进入到finally块");
}
System.out.println("后续代码");
}
public static void main(String[] args)
{
ExceptionTest test = new ExceptionTest();
test.method();
}
}
进入到try块 异常发生了！ 进入到finally块 后续代码
进入到try块 进入到finally块 后续代码
进入到try块 后续代码
异常发生了！ 后续代码
try { //执行的代码，其中可能有异常。一旦发现异常，则立即跳到catch执行。
否则不会执行catch里面的内容 }catch { //除非try里面执行代码发生了异常，
否则这里的代码不会执行 }finally { //不管什么情况都会执行，包括try catch 里面用了return
,可以理解为只要执行了try或者catch，就一定会执行 finally }
总结一下，不管你try中有没有return，finally中的代码一定会执行。
当try中有return，但是finally中没有，则finally中的代码在try中return执行前执行；
当两者中均有return，那么先执行finally中return之前的代码，
然后执行try中return，最后执行finally中的return!!!
3.A 派生出子类 B ， B 派生出子类 C ，并且在 Java 源代码中有如下声明：
- A a0=new A();
- A a1 =new B();
- A a2=new C();
问以下哪个说法是正确的？ （ ）
正确答案: D 你的答案: B (错误)
只有第1行能通过编译
第1、2行能通过编译，但第3行编译出错
第1、2、3行能通过编译，但第2、3行运行时出错
第1行、第2行和第3行的声明都是正确的
继承具有传递性，子类可以无条件向上转型！
4.不考虑反射，String类型变量所指向内存空间中的内容是不能被改变的 。 （ ）
正确答案: A 你的答案: B (错误)
正确
错误
指向的内容在常量池中不可以变，但是可以改变string的指向
5.以下哪个接口的定义是正确的？（ ）
正确答案: D 你的答案: D (正确)
interface B
{ public abstract void print() { } ;}
interface B
{ static void print() ;}
abstract interface B extends A1, A2 //A1、A2为已定义的接口
{private abstract void print();}
interface B
{ void print();}
A 抽象方法不能有方法体，仔细点可以看到有大括号。
B 接口里的方法只能用 public 和 abstract 修饰，如果你不写也没关系，默认的也是 public abstract 修饰.
C 同上
D 正确
6.在Java中，关于HashMap类的描述，以下错误的是
正确答案: B 你的答案: C (错误)
HashMap使用键/值得形式保存数据
HashMap 能够保证其中元素的顺序
HashMap允许将null用作键
HashMap允许将null用作值
HashMap不能保证元素的顺序,
HashMap能够将键设为null，也可以将值设为null，
与之对应的是Hashtable,(注意大小写：不是HashTable)，
Hashtable不能将键和值设为null，否则运行时会报空指针异常错误；
HashMap线程不安全，Hashtable线程安全
7.下面有关JVM内存，说法错误的是？
正确答案: C 你的答案: C (正确)
程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行到了第几行，是线程隔离的
虚拟机栈描述的是Java方法执行的内存模型，用于存储局部变量，操作数栈，动态链接，方法出口等信息，是线程隔离的
方法区用于存储JVM加载的类信息、常量、静态变量、以及编译器编译后的代码等数据，是线程隔离的
原则上讲，所有的对象都在堆区上分配内存，是线程之间共享的
方法区在JVM中也是一个非常重要的区域，它与堆一样，是被 线程共享 的区域。
在方法区中，存储了每个类的信息（包括类的名称、方法信息、字段信息）、
静态变量、常量以及编译器编译后的代码等。
8.下面有关JAVA swing的描述，说法错误的是？
正确答案: C 你的答案: D (错误)
Swing是一个基于Java的跨平台MVC框架。使用单线程模式。
Swing 是为了解决 AWT 存在的问题而新开发的包，它以 AWT 为基础的
Swing优化了AWT，运行速度比AWT快
Swing是一个基于组件的框架，所有的组件都是从javax.swing.JComponent类继承来的
Swing 是在AWT的基础上构建的一套新的图形界面系统，它提供了AWT 所能够提供的所有功能，
并且用纯粹的Java代码对AWT 的功能进行了大幅度的扩充。AWT 是基于本地方法的C/C++程序，
其运行速度比较快；Swing是基于AWT 的Java程序，其运行速度比较慢。
9.下面说法正确的是？（）
正确答案: B C 你的答案: C (错误)
调用Thread的sleep()方法会释放锁，调用wait()方法不释放锁
一个线程调用yield方法，可以使具有相同优先级线程获得处理器
在Java中，高优先级的可运行的线程会抢占低优先级线程的资源
java中，线程可以调用yield方法使比自己低优先级的线程运行
还记得马老师说过，yiled方法属于高风亮节的行为，
这个坑位我不上了，后面跟我同级别的先上厕所。这样比较好记！
高优先级的就是你们的县长，县长要上厕所，对不起，你得出来，县长先上，
县长上完了，CPU分配到你了，你才能继续拉X。
yield()让当前正在运行的线程回到可运行状态，以允许具有相同优先级的其他线程获得运行的机会。
因此，使用yield()的目的是让具有相同优先级的线程之间能够适当的轮换执行。
但是，实际中无法保证yield()达到让步的目的，因为，让步的线程可能被线程调度程序再次选中。
10.往OuterClass类的代码段中插入内部类声明, 哪一个是错误的:
public class OuterClass{
private float f=1.0f;
//插入代码到这里
}
正确答案: A B C D 你的答案: B C (错误)
class InnerClass{
public static float func(){return f;}
}
abstract class InnerClass{
public abstract float func(){}
}
static class InnerClass{
protected static float func(){return f;}
}
public class InnerClass{
static float func(){return f;}
}
静态方法不能访问非静态变量，A和C错；
抽象类中的抽象方法不能有方法体，B错；
一个类中有多个类声明时，只能有一个public类，D错
选ABCD。
A选项，InnerClass非静态内部类中出现了static修饰的func()方法，静态内部类才可以声明静态方法。
B选项，abstract修饰的抽象类中抽象方法func(){}包含了方法体。
C选项，static的内部类不能引用外部类的非static的私有成员变量 f 。
D选项，静态内部类才可以声明静态方法， 静态方法不能使用非静态变量。
2019.07.22
11.下面属于java合法变量定义的是？
final
1var1
_var2
var3&
A.final 是关键字
B.不能以数字做首写
C.首写字母可以为下划线
D.不能与&相组合来命名
标识符可以包括这4种字符：字母、下划线、$、数字；开头不能是数字；不能是关键字
12.以下哪个区域不属于新生代？
正确答案: C 你的答案: B (错误)
eden区
from区
元数据区
to区
java 中的堆是 JVM 所管理的最大的一块内存空间，主要用于存放各种类的实例对象。
在 Java 中，堆被划分成两个不同的区域：新生代 ( Young )、老年代 ( Old )。
新生代 ( Young ) 又被划分为三个区域：Eden、From Survivor、To Survivor。
这样划分的目的是为了使 JVM 能够更好的管理堆内存中的对象，包括内存的分配以及回收。
堆大小 = 新生代 + 老年代。其中，堆的大小可以通过参数 –Xms、-Xmx 来指定。
13.java 接口的修饰符可以为（）
正确答案: D 你的答案: D (正确)
private
protected
final
abstract
接口是通用的，用来描述方法是干什么用的，方法的默认修饰符为public abstract.
不可以为final 是因为方法要被重写， 描述符如果为private或者protected，
那么子类重写的方法的描述符也可以为private或者protected
这样就是有了访问显示，不符合接口所要达到的的任何人都可以使用了
14.下面的程序段创建了BufferedReader类的对象in，以便读取本机c盘my文件夹下的文件1.txt。
File构造函数中正确的路径和文件名的表示是( )。
File f = new File( 填代码处);
file =new FileReader(f);
in=new BufferedReader(file);
正确答案: C 你的答案: C (正确)
"./1.txt"
"../my/1.txt"
"c:\\my\\1.txt"
"c:\\ my\1.txt"
./表示当前项目的路径
…/表示当前目录的父目录路径
盘符：\name\file 或者 盘符：/name/file
表示物理路径
可以这么记:"“这个符号在中英文环境下是不一样的显示；
而”/"在中英文环境下是相同的显示。所以前者需要转义。
15.执行完以下代码 int [ ] x = new int[10] ；后，以下哪项说明是正确的（ ）
正确答案: A 你的答案: D (错误)
x[9]为0
x[9]未定义
x[10]为0
x[0]为空
数组引用类型的变量的默认值为 null。当数组变量的实例后，
如果没有没有显示的为每个元素赋值，Java 就会把该数组的所有元素初始化为其相应类型的默认值。
int型的默认值为0
当编译并运行下面程序时会发生什么结果（）
public class Bground extends Thread{
public static void main(String argv[]){
Bground b = new Bground();
b.run();
}
public void start(){
for(int i=0;i<10;i++){
System.out.println("Value of i = "+i);
}
}
}
编译错误，指明run方法没有定义
运行错误，只鞥呢run方法没有定义
编译通过并输出0到9
编译通过，但无输出
查看正确选项
对于线程而言，start是让线程从new变成runnable。run方法才是执行体的入口。
但是在Thread中，run方法是个空方法，没有具体实现。
Bground继承了Thread，但是没有重写run方法，那么调用run方法肯定是无输出
最后说一说，Thread 的执行过程，Theard的启动方法是start().线程类调用start();
然后执行start0()本地方法，然后就没办法再追溯下去了。
start我听过别人说，是一个准备工作（比如你要吃苹果，不得先洗一下，真正吃时间是洗完后），
并没有获得cpu，调用run()才是获得了cpu。
17.下面有关webservice的描述，错误的是？
正确答案: B 你的答案: C (错误)
Webservice是跨平台，跨语言的远程调用技术
Webservice通信机制实质就是json数据交换
Webservice采用了soap协议（简单对象协议）进行通信
WSDL是用于描述 Web Services 以及如何对它们进行访问
解析:Webservice是跨平台，跨语言的远程调用技术;
它的通信机制实质就是xml数据交换;
它采用了soap协议（简单对象协议）进行通信
Web service顾名思义是基于web的服务，它是一种跨平台，跨语言的服务。
我们可以这样理解它，比如说我们可以调用互联网上查询天气信息的web服务，
把它嵌入到我们的B/S程序中，当用户从我们的网点看到天气信息时，
会认为我们为他提供很多的服务，但其实我们什么也没做，
只是简单的调用了一下服务器上的一端代码而已。
Web service 可以将你的服务发布到互联网上让别人去调用，
也可以调用别人发布的web service，和使用自己的代码一样。
它是采用XML传输格式化的数据，它的通信协议是SOAP(简单对象访问协议).
18.下面有关java的引用类型，说法正确的有？
正确答案: A B C D 你的答案: A C (错误)
对于一个对象来说，只要有强引用的存在，它就会一直存在于内存中
如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存
一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的空间
1、强引用：一个对象赋给一个引用就是强引用，比如new一个对象，一个对象被赋值一个对象。
2、软引用：用SoftReference类实现，一般不会轻易回收，只有内存不够才会回收。
3、弱引用：用WeekReference类实现，一旦垃圾回收已启动，就会回收。
4、虚引用：不能单独存在，必须和引用队列联合使用。主要作用是跟踪对象被回收的状态。
19.下列说法错误的有（ ）
正确答案: A C D 你的答案: A D (错误)
在类方法中可用this来调用本类的类方法
在类方法中调用本类的类方法时可直接调用
在类方法中只能调用本类中的类方法
在类方法中绝对不能调用实例方法
A:类方法是指类中被static修饰的方法，无this指针。
C：类方法是可以调用其他类的static方法的。
D:可以在类方法中生成实例对象再调用实例方法。
2019.07.23
20.
代码 的运行结果是（）
package com.sunline.java;
public class A implements B extends C{
public static void main(String args[]){
System.out.println(“hello sunline!”);
}
}
在控制台打印hello sunline！
报异常java.lang.NullPoninterException
编译报错
报异常java.lang.RuntimeExcception
正确答案：c
1、Java 中单实现通过 implements 关键字，多实现通过 extends 关键字
2、Java 中单继承通过 extends 关键字，没有多继承
3、如果同时出现继承和实现，则必须先继承（extends）再实现（implements）
21.JVM内存不包含如下哪个部分( )
正确答案: D 你的答案: B (错误)
Stacks
PC寄存器
Heap
Heap Frame
JVM内存五大区域：虚拟机栈（VM Stacks(栈帧Frame）），
本地方法栈（Native Method Stack），
pc寄存器（Program Counter Register），
方法区（Method Area），堆（Heap）
22.下面叙述那个是正确的？（）
正确答案: B 你的答案: B (正确)
java中的集合类（如Vector）可以用来存储任何类型的对象，且大小可以自动调整。但需要事先知道所存储对象的类型，才能正常使用。
在java中，我们可以用违例（Exception）来抛出一些并非错误的消息，但这样比直接从函数返回一个结果要更大的系统开销。
java接口包含函数声明和变量声明。
java中，子类不可以访问父类的私有成员和受保护的成员。
A.vector是线程安全的ArrayList，在内存中占用连续的空间。初始时有一个初始大小
当数据条数大于这个初始大小后会重写分配一个更大的连续空间。
如果Vector定义为保存Object则可以存放任意类型。
B.try{}catch{}会增加额外的开销
C.接口中声明的’变量’必须为public final static,所以为常量
D.子类可以访问父类受保护的成员
23.下面哪一项不属于优化Hibernate所鼓励的？
正确答案: A 你的答案: B (错误)
使用单向一对多关联，不使用双向一对多
不用一对一，用多对一取代
配置对象缓存，不使用集合缓存
继承类使用显式多态
优化Hibernate所鼓励的7大措施：
1.尽量使用many-to-one，避免使用单项one-to-many
2.灵活使用单向one-to-many
3.不用一对一，使用多对一代替一对一
4.配置对象缓存，不使用集合缓存
5.一对多使用Bag 多对一使用Set
6.继承使用显示多态 HQL:from object polymorphism=“exlicit” 避免查处所有对象
7.消除大表，使用二级缓存
24.下面哪些情况可以引发异常：
正确答案: A B C 你的答案: A B (错误)
数组越界
指定URL不存在
使用throw语句抛出
使用throws语句
throw出现在方法体中 throw是抛出了异常，所以执行 的时候则一定抛出了某种异常
throws出现在方法头，表示出现异常的可能性，并不一定会发生某种异常
25.A,B,C,D 中哪些是 setvar的重载？
public class methodover
{
public void setVar(int a, int b, float c) {}
}
正确答案: A C D 你的答案: C D (错误)
private void setVar(int a， float c， int b){}
protected void setVar(int a， int b， float c){}
public int setVar(int a， float c， int b){return a;}
public int setVar(int a， float c){return a;}
方法的重载是指：
1、在同一个类中
2、方法名相同
3、方法的形参列表不同
具体的不同表现为：
类型、个数、顺序的不同才可以构成重载
4、#比较容易忽略的一点#
与方法的返回值类型与访问权限无关
26.不考虑反射，关于私有访问控制符 private 修饰的成员变量，以下说法正确的是（）
正确答案: C 你的答案: B (错误)
可以三种类所引用：该类自身、与它在同一包中的其他类，在其他包中的该类的子类
可以被两种类访问和引用：该类本身、该类的所有子类
只能被该类自身所访问和修改
只能被同一个包中的类访问
private 修饰的变量 是私有变量
私有变量只能被本类自己所使用,
一个经典的例子是 刘备死了之后，阿斗继承刘备的所有东西，但是刘备的媳妇还是刘备的媳妇。
比喻私有变量被子类继承后 不能使用，不可修改
访问修饰符\作用范围 所在类 同一包内其他类 其他包内子类 其他包内非子类
private 可以访问 不可以 不可以 不可以
default 可以 可以 不可以 不可以
protected 可以 可以 可以 不可以
public 可以 可以 可以 可以
27.下列关于修饰符混用的说法，错误的是( )
正确答案: D 你的答案: C (错误)
abstract不能与final并列修饰同一个类
abstract 类中不建议有private的成员
abstract 方法必须在abstract类或接口中
static方法中能直接处理非static的属性
A、被abstract 修饰的类表示必须被其他类继承使用，而被final修饰的类，
表示不能作为其他类的父类，两者矛盾。故不能同时使用
B、abstract 类里可以有private成员，但是 abstract 类是要被继承使用，
也就是说该类的属性方法是要被其他类所访问使用的，如果有属性或者方法被private修饰，
表示只能内部使用，两者似乎又矛盾了。故不建议有private成员
C、抽象方法只能声明在抽象类或者接口中，这个是母庸质疑的
D、类方法不能直接使用实例方法，必须实例化后，利用对象调用方法，才能处理。故D错误
28.假设 A 类有如下定义，设 a 是 A 类同一个包下的一个实例，下列语句调用哪个是错误的？（）
class A{
int i;
static String s;
void method1() { }
static void method2() { }
}
正确答案: C 你的答案: A (错误)
System.out.println(a.i)；
a.method1();
A.method1();
A.method2()
非静态方法只能通过实例对象来调用，不能直接通过类名调用。
静态方法（static）才能通过类名直接调用
类中变量：除了private权限外，其他权限的变量（没有表示默认default），
均可以用“对象.变量名”来调用。对于private变量，即使使用static，
也不能用“类.变量名”来调用私有变量。只能通过类中的public get()方法来调用。
类中方法：除了private权限外，其他权限的方法（没有表示默认default），
均可以用“对象.方法名”来调用。private方法可以用java反射机制调用。
当然如果用 private修饰方法，该方法只在类的内部调用。
其中比较著名的就是单例模式中的私有构造方法。
static属性：static方法在编译期就已经生成了，其他方法在运行期生成。
非私有的static方法可以用“类.方法名”调用。
但是私有的static变量和方法都是不可能被调用的，虽然private static这种写法很少见，
但仍然存在，且编译器不会报错。题中static void method2() { }的权限是默认权限，
所以可以用“类.方法名”来调用。如果题目中写成private static void method2(){ } ,
那么D选项也是错误的。
29.
Web程序中，当前用户上下文信息应该保存在下面哪个对象中（）
正确答案: C 你的答案: C (正确)
page
request
session
Application
当前用户上下文信息：session
appication:当前应用
pageContext：当前页面
request:当前请求
30.指出下列程序运行的结果：
public class Example{
String str=new String(“tarena”);
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’;
}
}
正确答案: B 你的答案: D (错误)
tarena and abc
tarena and gbc
test ok and abc
test ok and gbc
string和char数组都是引用类型，引用类型是传地址的，会影响原变量的值，
但是string是特殊引用类型，为什么呢？因为string类型的值是不可变的，
为了考虑一些内存，安全等综合原因，把它设置成不可变的; 不可变是怎么实现的？
Java在内存中专门为string开辟了一个字符串常量池，用来锁定数据不被篡改，
所以题目中函数中的str变量和原来的str已经不是一个东西了，它是一个局部引用，
指向一个testok的字符串，随着函数结束，它也就什么都没了，但是char数组是会改变原值的
31.在Java中，以下关于方法重载和方法重写描述正确的是？
正确答案: D 你的答案: B (错误)
方法重载和方法的重写实现的功能相同
方法重载出现在父子关系中，方法重写是在同一类中
方法重载的返回值类型必须一致，参数项必须不同
方法重写的返回值类型必须相同或相容。
目前的问题：父类的功能无法满足子类的需求。
方法重写的前提： 必须要存在继承的关系。
方法的重写: 子父类出了同名的函数，这个我们就称作为方法的重写。
什么是时候要使用方法的重写：父类的功能无法满足子类的需求时。
方法的重写Override要遵循“两同两小一大”规则：
①“两同”即方法名相同，形参列表相同；
②“两小”指的是子类方法返回值类型应比父类方法返回值类型更小或相等，
子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等；
③“一大”指的是子类方法的访问权限应比父类方法的访问权限更大或相等。
注：构造方法不受以上规则约束
方法的重载：在一个类中 存在两个或者两个 以上的同名函数,称作为方法重载。
方法重载的要求
1. 函数名要一致。
2. 形参列表不一致（形参的个数或形参 的类型不一致）
3. 与返回值类型无关。
32.下面程序的运行结果：()
public static void main(String args[]) {
Thread t=new Thread(){
public void run(){
dianping();
}
};
t.run();
System.out.print(“dazhong”);
}
static void dianping(){
System.out.print(“dianping”);
}
A dazhongdianping
B dianpingdazhong
C a和b都有可能
D dianping循环输出，dazhong夹杂在中间
在上面main()方法中，并没有创建一个新的线程，只是简单地方法调用而已，
如果想要创建线程，需要t.start();创建线程，等待cpu时间片，
而run()方法只是简单地方法调用，所以先执行run()，在输出dazhong
33.如果int x=20, y=5，则语句System.out.println(x+y +""+(x+y)+y); 的输出结果是（）
2530
55
2052055
25255
x,y都是整型数，然后输出两个相加之和，但是中间出现了“”，
代码默认将“”后面的变成了字符串相加，也就出现了25 25 5
-
一个完整的URL地址由(),(),端口和文件四部分组成。
正确答案: B 你的答案: C (错误)协议 用户名
协议 主机名
主机名 ip
以上都不正确
URL(Uniform Resource Locator) ，统一资源定位符，能够对因特网的资源进行定位。
URL一般有四部分组成： <协议>://<主机>:<端口>/<路径>
现在最常用的<协议>为http协议。
<主机>是指主机在因特网上的域名。
http协议的默认<端口>为80（可以省略）。
<路径>是指要活的的文件的路径。
35.对于如下代码段
class A{
public A foo(){return this;}
}
class B extends A{
public A foo(){
return this;
}
}
class C extends B
{
_______
}
可以放入到横线位置，使程序正确编译运行，而且不产生错误的选项是（ ）
正确答案: C 你的答案: A (错误)
public void foo(){}
public int foo(){return 1;}
public A foo(B b){return b;}
public A foo(){return A;}
C 选项 重载了父类集成的foo方法。C 正确
A 选项 若是重写，返回值类型不可小于父类返回值类型；若是重载需参数列表不同。A 错误。
B 选项 同上。
D 选项 返回值中A未定义，编译错误。D错误
在Java中，对于不再使用的内存资源，如调用完成的方法，“垃圾回收器”会自动将其释放。（ ）
正确答案: B 你的答案: A (错误)
正确
错误
JVM 内存可简单分为三个区：
1、堆区（heap）：用于存放所有对象，是线程共享的（注：数组也属于对象）
2、栈区（stack）：用于存放基本数据类型的数据和对象的引用，是线程私有的
（分为：虚拟机栈和本地方法栈）
3、方法区（method）：用于存放类信息、常量、静态变量、编译后的字节码等，
是线程共享的（也被称为非堆，即 None-Heap）
Java 的垃圾回收器（GC）主要针对堆区
37.下列描述正确的是（ ）？
类不可以多继承而接口可以多实现
抽象类自身可以定义成员而接口不可以
抽象类和接口都不能被实例化
一个类可以有多个基类和多个基接口
选ac
这个题的答案有问题，不知道后面会不会改。
A、类是单继承，就是说只能有一个直接父类，但是继承有传递性的，所以一个类可以有多个间接父类。接口可以多继承，接口不能实现接口。
B、抽象类中可以有成员变量，但是接口中只能有静态常量。
C、抽象类和接口都不能实例化。
D、参考A的解释
38.以下各类中哪几个是线程安全的？( )
正确答案: B C D 你的答案: A B C (错误)
ArrayList
Vector
Hashtable
Stack
线程安全：喂，SHE
喂（Vector）
S（Stack）
H（hashtable）
E（enumeration）
2019.7.24
39.对于文件的描述正确的是（ ）
文本文件是以“.txt”为后缀名的文件，其他后缀名的文件是二进制文件。
File类是Java中对文件进行读写操作的基本类。
无论文本文件还是二进制文件，读到文件末尾都会抛出EOFException异常。
Java中对于文本文件和二进制文件，都可以当作二进制文件进行操作。
正确答案: D 你的答案: B (错误)
D:正确
B:File类是java中文件和目录路径名的抽象表示形式。Java中对文件进行读写操作的基本类是IO类。
C:读到文件末尾不会抛出异常。EOFException：当输入过程中意外到达文件或流的末尾时，抛出此异常。
40.查看解析
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;
}
}
compiletime error
prints:1
prints:2
prints:3
prints:7
prints:8
JVM加载class文件时，就会执行静态代码块，静态代码块中初始化了一个变量x并初始化为5，
由于该变量是个局部变量，静态代码快执行完后变被释放。
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
正确答案: D 你的答案: A (错误)
41。
定义有StringBuffer s1=new StringBuffer(10);s1.append(“1234”)则s1.length()和s1.capacity()分别是多少?
4 10
4 4
10 10
10 4
length 返回当前长度
如果字符串长度没有初始化长度大，capacity返回初始化的长度
如果append后的字符串长度超过初始化长度，capacity返回增长后的长度
正确答案: A 你的答案: D (错误)
42.查看解析
下面代码的输出是什么？
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();
}
}
正确答案: A 你的答案: B (错误)
null
sub
base
1.首先，需要明白类的加载顺序。
(1) 父类静态代码块(包括静态初始化块，静态属性，但不包括静态方法)
(2) 子类静态代码块(包括静态初始化块，静态属性，但不包括静态方法 )
(3) 父类非静态代码块( 包括非静态初始化块，非静态属性 )
(4) 父类构造函数
(5) 子类非静态代码块 ( 包括非静态初始化块，非静态属性 )
(6) 子类构造函数
其中：类中静态块按照声明顺序执行，并且(1)和(2)不需要调用new类实例的时候就执行了(意思就是在类加载到方法区的时候执行的)
2.其次，需要理解子类覆盖父类方法的问题，也就是方法重写实现多态问题。
Base b = new Sub();它为多态的一种表现形式，声明是Base,实现是Sub类， 理解为 b 编译时表现为Base类特性，运行时表现为Sub类特性。
当子类覆盖了父类的方法后，意思是父类的方法已经被重写，题中 父类初始化调用的方法为子类实现的方法，子类实现的方法中调用的baseName为子类中的私有属性。
由1.可知，此时只执行到步骤4.,子类非静态代码块和初始化步骤还没有到，子类中的baseName还没有被初始化。所以此时 baseName为空。 所以为null。
下面哪些标识符是正确的？
正确答案: A B 你的答案: A B C D (错误)
MyWorld
parseXML
–value
&maybe
我做了一个类似的题 之后评论很有意思
字下美人数意思就是字母 下划线 美元 人民币 数字 感觉这样更好记一些
以下说法错误的是（）
正确答案: C 你的答案: D (错误)
数组是一个对象
数组不是一种原生类
数组的大小可以任意改变
在Java中，数组存储在堆中连续内存空间里
在java中,数组是一个对象, 不是一种原生类,对象所以存放在堆中,又因为数组特性,是连续的,只有C不对
2019.07.29
45.对抽象类的描述正确的是()
抽象类的方法都是抽象方法
一个类可以继承多个抽象类
抽象类不能有构造方法
抽象类不能被实例化
A.抽象类可以有非抽象的方法，而接口中的方法都是抽象方法
B.java中类只能单继承，接口可以‘继承’多个接口
C.抽象类必须有构造方法，接口一定没有构造方法
D.实例化一般指new一个对象，所以抽象类不能实例化
正确答案: D 你的答案: D (正确)
46.静态变量static在不同的实例中地址是否一样？他们储存在什么区域？（）
正确答案: C 你的答案: A (错误)
地址一样，在堆栈区。
地址不一样，在堆栈区。
地址一样，在全局区。
地址不一样，在全局区。
个人观点，见者可以进行纠正，大家互相学习，欢迎来评论： static表示的是静态的意思，
所以它修饰的变量或方法都是共享的。而且静态变量或方法是在类被创建的时候加载，
并且只会加载一次，所以不管整个过程如何运行，static的地址是不会变的，
而且是储存在全局区的，毕竟这样才可以共享嘛
47.以下哪项不属于java类加载过程？
正确答案: B 你的答案: A (错误)
生成java.lang.Class对象
int类型对象成员变量赋予默认值
执行static块代码
类方法解析
推荐
StrongYoung头像StrongYoung
不应该选D，而应该选B
类的加载包括：加载，验证，准备，解析，初始化。
选项A：生成java.lang.Class对象是在加载时进行的。生成Class对象作为方法区这个类的各种数据的访问入口。
选项B：既然是对象成员，那么肯定在实例化对象后才有。在类加载的时候会赋予初值的是类变量，而非对象成员。
选项C：这个会调用。可以用反射试验。
选项D：类方法解析发生在解析过程。
48.JDK提供的用于并发编程的同步器有哪些？
Semaphore
CyclicBarrier
CountDownLatch
Counter
答案：ABC
A，Java 并发库 的Semaphore 可以很轻松完成信号量控制，Semaphore可以控制某个资源可被同时访问的个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。
B，CyclicBarrier 主要的方法就是一个：await()。await() 方法没被调用一次，计数便会减少1，并阻塞住当前线程。当计数减至0时，阻塞解除，所有在此 CyclicBarrier 上面阻塞的线程开始运行。
C，直译过来就是倒计数(CountDown)门闩(Latch)。倒计数不用说，门闩的意思顾名思义就是阻止前进。在这里就是指 CountDownLatch.await() 方法在倒计数为0之前会阻塞当前线程。
D，Counter不是并发编程的同步器
2019.7.30
在JAVA中，下面关于String类和StringBuffer类的描述正确的是那一个？
正确答案: A 你的答案: D (错误)
StringBuffer类的对象调用toString（）方法将返回String类型的结果
两个类都有append（）方法
可以直接将字符串“test”赋值给声明的String类和StringBuffer类的变量
两个类的实例的值都能够被改变
StringBuffer类的对象调用toString（）方法将转换为String类型 这个正确
两个类都有append（）方法 String类没有append方法
可以直接将字符串“test”复制给声明的Stirng类和StringBuffer类的变量
引用类型只有String可以直接复制，其他的都要new出来
两个类的实例的值都能够被改变 StringBuffer类可以直接改变它的内容，
不用重新分配地址； String 对象/ 实例 是不可以被改变的。
当new一个String对象时，JVM会在内存中创建一个String对象，
当另外一个String对象值与它一样时，会将该对象直接指向对应的地址。
String a = “abc”;
String b = “abc”;
System.out.println(a == b);//true
50.要使对象具有序列化能力，则其类应该实现如下哪个接口()。
正确答案: A 你的答案: A (正确)
java.io.Serializable
java.lang.Cloneable,
java.lang.CharSequence
java.lang.Comparable
Serializable接口是专门提供给类实现序列化用的；
Cloneable 接口是用来实现克隆方法的。
Object.clone() 方法可以合法地对该类实例进行按字段复制；
实现CharSequence接口的类有：CharBuffer、String、StringBuffer、StringBuilder四个类，
这样当处理String或者StringBuffer的类就不用重载了；
Comparable接口用于对实现它的每个类的对象进行整体排序。
51.下列关于Java中类的构造方法的描述，正确的是（）
构造方法的返回类型为void
可以定义一个类而在代码中不写构造方法。
在同一个类中定义的重载构造方法不可以相互调用。
子类不允许调用父类的构造方法。
A、构造器没有返回值，这个没有返回值和返回值为void可部一样。
B、每个类在没有自己显式声明构造器的时候，都会有一个默认的无参构造。
C、构造器可以重载，而且可以使用super()、this()相互调用
D、每个构造器的默认第一行都是super()，但是一旦父类中没有无参构造，必须在子类的第一行显式的声明调用哪一个构造。
正确答案: B 你的答案: B (正确)
52.下面有关 java 实例变量 , 局部变量 , 类变量和 final 变量的说法，错误的是？ ( )
正确答案: B 你的答案: B (正确)
实例变量指的是类中定义的变量，即类成员变量，如果没有初始化，会有默认值
局部变量指的是在方法中定义的变量，如果没有初始化，会有默认值
类变量指的是用static修饰的属性
final变量指的是用final 修饰的变量
选B。考察的是类所包含的类型变量。
实例变量：是定义在是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。
成员变量可以被类中方法、构造方法和特定类的语句块访问。
分配了内存空间后会给所有的成员变量一次初始化，没有赋值的会给成员变量对应类型的值，
数据类型不同则默认值不同。所以A正确。
局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。
变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
用的时候是直接入栈的，如果没有赋值，这个变量就没有初始值，也就无法操作，
所以局部变量要初始化。所以B错误。
类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。所以C正确。
final变量，final 修饰的变量。如果是基本数据类型的变量，
则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，
则在对其初始化之后便不能再让其指向另一个对象。所以D正确。
53.下面的程序输出的结果是( )
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；
}
正确答案: B 你的答案: C (错误)
i=0
i=10
程序有编译错误
i=true
在接口里面的变量默认都是public static final 的，它们是公共的,静态的,最终的常量.
相当于全局常量，可以直接省略修饰符。实现类可以直接访问接口中的变量
54.下列哪个修饰符可以使在一个类中定义的成员变量只能被同一包中的类访问？
正确答案: B 你的答案: A (错误)
private
无修饰符
public
protected
名称 说明 备注
public 可以被任何类访问
protected 可以被同一包中的所有类访问 子类没有在同一包中也可以访问
可以被所有子类访问
private 只能够被 当前类的方法访问
缺省
无访问修饰符 可以被同一包中的所有类访问 如果子类没有在同一个包中，也不能访问
55.检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。
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++;
}
}
正确答案: A 你的答案: C (错误)
0
1
2
3
56.以下哪一个不是赋值符号？
正确答案: C 你的答案: B (错误)
+=
<<=
<<<=
>>>=
C.混合赋值运算符的使用
<<表示左移位
表示带符号右移位
表示无符号右移
但是没有<<<运算符
57.如下哪些是 java 中有效的关键字（）
正确答案: A D 你的答案: C D (错误)
native
NULL
false
this
这个关键字常见的坑：
true、false、null都不是关键字
goto、const、是保留的关键字
abstract continue for new
switch default if package
synchronized do goto private
this break double implements
protected throw byte else
import public throws case
enum instanceof return transient
catch extends int short
try char final interface
static void class finally
long strictfp volatile const
float native super while
boolean assert
58.对于线程局部存储TLS(thread local storage)，以下表述正确的是
正确答案: A B D 你的答案: A B D (正确)
解决多线程中的对同一变量的访问冲突的一种技术
TLS会为每一个线程维护一个和该线程绑定的变量的副本
每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了
Java平台的java.lang.ThreadLocal是TLS技术的一种实现
ThreadLocal可以给一个初始值，而每个线程都会获得这个初始化值的一个副本，
这样才能保证不同的线程都有一份拷贝。ThreadLocal 不是用于解决共享变量的问题的，
不是为了协调线程同步而存在，而是为了方便每个线程处理自己的状态而引入的一个机制.
2019.7.31
59.下列对接口的说法，正确的是( )
接口与抽象类是相同的概念
若要实现一个接口为普通类则必须实现接口的所有抽象方法
接口之间不能有继承关系
一个类只能实现一个接口
A 接口与抽象类是不同的概念。抽象类是用于捕捉子类的通用特性，接口是抽象方法的集合；
B 实现接口必须实现接口的所有方法；
C 接口可以继承一个或多个接口，抽象类只能继承一个类或者实现多个接口；
D 一个类只能继承一个类，但是可以实现多个接口。
正确答案: B 你的答案: B (正确)
60.以下哪个不是Collection的子接口？
正确答案: D 你的答案: C (错误)
List
Set
SortedSet
Map
Collection主要的子接口:
List:可以存放重复内容
Set:不能存放重复内容,所有重复的内容靠hashCode()和equals()两个方法区分
Queue:队列接口
SortedSet:可以对集合中的数据进行排序
Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，
每个key只能映射一个value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合
，一组value集合，或者一组key-value映射。
61.下列说法正确的有（ ）
class中的constructor不可省略
constructor必须与class同名，但方法不能与class同名
constructor可在一个对象被new时执行
一个class只能定义一个constructor
a. 类中的构造方法可以省略不写的
b. 构造方法必须跟类名相同，普通的类方法能与类同名的，但是要返回一个值。
c. 构造方法都在new 对象的时候调用的
d. 一个类可以定义多个构造方法的
正确答案: C 你的答案: D (错误)
javac的作用是（ ）。
正确答案: A 你的答案: A (正确)
将源程序编译成字节码
将字节码编译成源程序
解释执行Java字节码
调试Java代码
javac是将源程序.java编译成.class文件
java是将字节码转换为机器码文件执行
63.10
下列说法正确的是
正确答案: C 你的答案: C (正确)
java中包的主要作用是实现跨平台功能
package语句只能放在import语句后面
包（package）由一组类（class）和接口（interface）组成
可以用#include关键词来标明来自其它包中的类
A： java中"包"的引入的主要原因是java本身跨平台特性的需求。实现跨平台的是JVM。
B： package语句是Java源文件的第一条语句。（若缺省该语句，则指定为无名包。），
如果想在另一个类里面引用包里面的类，要把名字写全。
（相当用文件的绝对路径访问）或者用import导入。
D：java中并无#include关键字， 如果想在另一个类里面引用包里面的类，要把名字写全。（相当用文件的绝对路径访问）或者用import导入。
包的作用
1 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
2 如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
3 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
package必须放在import的前面
64.以下程序的输出结果是
public class Print{
static boolean out(char c){
System.out.println©;
return true;
}
public static void main(String[] argv){
int i = 0;
for(out(‘A’);out(‘B’) && (i<2);out(‘C’)){
i++;
out(‘D’);
}
}
}
正确答案: A 你的答案: C (错误)
ABDCBDCB
BCDABCD
编译错误
运行错误
其实这题考察的是for(int i=0;i<10;i++){}循环的执行顺序：
1.int i=0;初始化这一步只执行一次；
2.i<10；进行条件判断；条件达成返回true 否则false不往下执行，跳出for循环圈
3.i++ ； 是最后执行的，当循环体内的代码执行完它才进行赋值。
for循环执行开始
首先执行out(‘A’) 输出A；
然后执行out(‘B’)&&(i<2)此时输出B，i=0，判断条件为真，执行for循环的循环体；
执行i++，out(‘D’)，输出D i=1；
执行out(‘C’),输出C
然后执行out(‘B’)&&(i<2) 此时输出B，i=1 判断条件为真 ，执行for循环的循环体；
执行i++，out(‘D’)，输出D i=2；
执行out(‘C’),输出C
然后执行out(‘B’)&&(i<2) 此时输出B，i=2，不满足i<2 判断条件为假 ，跳出循环；
所以结果为ABDCBDCB
65.我们在程序中经常使用“System.out.println()”来输出信息，语句中的System是包名，
out是类名，println是方法名。
正确答案: B 你的答案: A (错误)
对
错
System是类，out是成员变量，println是方法
System是java.lang中的一个类，out是System内的一个成员变量，
这个变量是一个java.io.PrintStream类的对象，println呢就是一个方法了。
66.下面有关java的一些细节问题，描述错误的是？
构造方法不需要同步化
一个子类不可以覆盖掉父类的同步方法
定义在接口中的方法默认是public的
容器保存的是对象的引用
关于java中覆盖的问题
（1）子类不能覆盖父类中声明为final或者static的方法。
（2）子类必须覆盖父类中声明为abstract的方法，或者子类也必须声明为abstract。
（3）子类覆盖父类中的同名方法时，子类的方法声明也必须和父类中被覆盖的方法的声明相同。
下列关于包（package）的描述，正确的是（）
包（package）是Java中描述操作系统对多个源代码文件组织的一种方式。
import语句将所对应的Java源文件拷贝到此处执行。
包（package）是Eclipse组织Java项目特有的一种方式。
定义在同一个包（package）内的类可以不经过import而直接相互使用
1、为了更好地组织类，Java提供了包机制。包是类的容器，用于分隔类名空间。如果没有指定包名，所有的示例都属于一个默认的无名包。Java中的包一般均包含相关的类，java是跨平台的，所以java中的包和操作系统没有任何关系，java的包是用来组织文件的一种虚拟文件系统。A错
2、import语句并没有将对应的java源文件拷贝到此处仅仅是引入，告诉编译器有使用外部文件，编译的时候要去读取这个外部文件。B错
3、Java提供的包机制与IDE没有关系。C错
4、定义在同一个包（package）内的类可以不经过import而直接相互使用。
下列关于管道（Pipe）通信的叙述中，正确的是（）？
正确答案: A 你的答案: B (错误)
进程对管道进行读操作和写操作都可能被阻塞
一个管道只能有一个进程或一个写进程对其操作
一个管道可实现双向数据传输
管道的容量仅受磁盘容量大小限制
A.正确，因为管道为空，读操作会被阻塞；管道满了，写操作会被阻塞
B.可以有多个进程对其读；也可以有多个进程写，只不过不能同时写。
并且题目没有说“同时”，B不对
C.匿名管道只能单向；命名管道可以双向；所以C过于绝对
D.管道是内存中的，所以D不对
下面程序的运行结果（）
Object obj=new Object();
List aList=new ArrayList();
List bList=new LinkedList();
long t1=System.currentTimeMillis();
for(int i=0;i<50000;i++){
aList.add(0,obj);
}
long t2=System.currentTimeMillis()-t1;
t1=System.currentTimeMillis();
for(int i=0;i<50000;i++){
bList.add(0,obj);
}
long t3=System.currentTimeMillis()-t1;
正确答案: D 你的答案: D (正确)
t2
t2=t3
不确定
t2>t3
ArrayList内部是动态数组实现，在增加空间时会复制全部数据到新的容量大一些的数组中。
而LinkedList内部为双向链表，可以按需分配空间，扩展容量简单，因此LinkedList用时少。
70.以下代码的输出结果是？
public class B
{
public static B t1 = new B();
public static B t2 = new B();
{
System.out.println(“构造块”);
}
static
{
System.out.println(“静态块”);
}
public static void main(String[] args)
{
B t = new B();
}
}
正确答案: C 你的答案: A (错误)
静态块 构造块 构造块 构造块
构造块 静态块 构造块 构造块
构造块 构造块 静态块 构造块
构造块 构造块 构造块 静态块
静态块：用static申明，JVM加载类时执行，仅执行一次
构造块：类中直接用{}定义，每一次创建对象时执行
执行顺序优先级：静态块>main()>构造块>构造方法
静态块按照申明顺序执行，所以先执行publicstaticB t1 = newB();该语句创建对象，
则又会调用构造块，输出构造块
接着执行public static B t1 = new B();输出构造块
再执行
static
{
System.out.println(“静态块”);
}输出静态块
最后main方法执行，创建对象，输出构造块。
之前我一直有一个误区!就是认为静态块一定是最先初始化的!但是,阿里爸爸今天又用一记重拳猛击我的脸,额,好疼…当时的情况是这样的:
我在牛客网找虐中,碰到了这样的一道题,心中充满了鄙夷,心想"这tm还用看吗,肯定先是静态块,再接着三个构造块,弱鸡题",但是 = = ,答案却是"构造块 构造块 静态块 构造块".
…[黑线|||||||||]
于是总结了一下,以警后世 - -
正确的理解是这样的:
并不是静态块最先初始化,而是静态域.(BM：啊!多么痛的领悟!)
而静态域中包含静态变量、静态块和静态方法,其中需要初始化的是静态变量和静态块.而他们两个的初始化顺序是靠他们俩的位置决定的!
So！
初始化顺序是 t1 t2 静态块
71.以下java程序代码，执行后的结果是（）
java.util.HashMap map=new java.util.HashMap();
map.put(“name”,null);
map.put(“name”,“Jack”);
System.out.println(map.size());
正确答案: C 你的答案: D (错误)
0
null
1
2
HashMap可以插入null的key或value，插入的时候，检查是否已经存在相同的key，
如果不存在，则直接插入，如果存在，则用新的value替换旧的value，
在本题中，第一条put语句，会将key/value对插入HashMap，而第二条put，
因为已经存在一个key为name的项，所以会用新的value替换旧的vaue，因此，
两条put之后，HashMap中只有一个key/value键值对。那就是（name，jack）。
所以，size为1.
2019.08.01
72.在 main() 方法中给出的整型数组，如果将其写到一个文件中，需要（ ）。
正确答案: B 你的答案: C (错误)
标准输出流System.out.println()。
建立数据字节输出流。
建立数据字节输入流。
标准输入流System.in.read()。
Java中的io都是以程序（内存）为参照物的，写入文件相比程序是向外写，
程序是主动方，即从程序向文件输出，且传输字符数组，故选择建立数据字节输出流。
读进去 写出来 六字真言
73.在try的括号里面有return一个值，那在哪里执行finally里的代码？
正确答案: B 你的答案: B (正确)
不执行finally代码
return前执行
return后执行
“假设利用 return 语句从 try 语句块中退出。在方法返回前，
finally子句的内容将被执行。如果 finally 子句中也有一个 return 语句，
这个返回值将会覆盖原始的返回值。”
public static void main(String[] args) {
int k = f_test();
System.out.println(k);
}
public static int f_test(){
int a = 0;
try{
a = 1;
return a;
}
finally{
System.out.println("It is in final chunk.");
a = 2;
return a;
}
}
输出：
It is in final chunk.
2
如果将 return a; 注释掉，将输出
It is in final chunk.
1
74.下列说法正确的是（）
在类方法中可用this来调用本类的类方法
在类方法中调用本类的类方法时可直接调用
在类方法中只能调用本类中的类方法
在类方法中绝对不能调用实例方法
B 类方法是指用static修饰的方法，普通方法叫对象方法。
A.this指的是当前对象，类方法依附于类而不是对象this会编译出错
C.类方法中也可以调用其他类的类方法。同时可以通过创建对象来调用普通方法
D.类方法中可以创建对象，所以可以调用实例方法
-
对于abstract声明的类，下面说法正确的是
正确答案: E 你的答案: D (错误)可以实例化
不可以被继承
子类为abstract
只能被继承
可以被抽象类继承
抽象类也可以调用静态方法直接使用
A.可以实例化 //错误，抽象类中有抽象方法，需要被实现，不能实例化。
B.不可以被继承 //错误，可以被继承，如果不继承，里面的抽象方法就没意思了。
C.子类为abstract //错误，子类不一定为抽象类，可以是，也可以不是。
D.只能被继承 //错误，我觉得，抽象类不仅可以被继承，还可以直接拿来使用的，
当然，这个使用是拿来声明，而不是实例化，因为抽象类不能实例化，
但可以声明使用。就像接口一样。可以动态绑定，地实现多态
76.JSP 表达式的写法：
正确答案: C 你的答案: C (正确)
<% expression %>
<=% expression %>
<%= expression %>
<expression/>
(1)<%…%>：可以插入一些语句。
(2)<%! … %>：只能放置全局变量、全局常量、类、函数。
(3)<%= … %>：只能放置一个变量、常量。
程序读入用户输入的一个值，要求创建一个自定义的异常，如果输入值大于 10 ，使用 throw 语句显式地引发异常，异常输出信息为 ”something’swrong!” ，语句为（）
正确答案: A 你的答案: C (错误)
if(i>10)throw new Exception("something’swrong!");
if(i>10)throw Exception e("something’swrong!");
if(i>10) throw new Exception e("something’swrong!");
if(i>10)throw Exception( "something’swrong!");
这题目C选项其实是if(i>10) throw new Exception e(“something’swrong!”);
考察的点是是否需要给Exception起名字 而不是楼上那些说题目故意加个e的
77.关于匿名内部类叙述正确的是？ ( )
正确答案: B 你的答案: C (错误)
匿名内部类可以继承一个基类，不可以实现一个接口
匿名内部类不可以定义构造器
匿名内部类不能用于形参
以上说法都不正确
由于构造器的名字必须与类名相同，而匿名类没有类名，所以匿名类不能有构造器。
78.在Java中,下列说法错误的有（ ）
正确答案: B C D 你的答案: C D (错误)
数组是一种对象
数组属于一种原生类
int number = []{31,23,33,43,35,63};
数组的大小可以任意改变
java中的数据类型分类：
基本数据类型（或叫做原生类、内置类型）8种：
整数：byte，short，int，long（默认是int类型）
浮点类型： float，double（默认是double类型）
字符类型：char
布尔类型：boolean
引用数据类型3种：数组，类，接口
其中，基本数据类型之间除了boolean，其他数据类型之间可以任意的相互转换（强制转化或默认转换），这个与c++中有点区别。
个人认为c定义数组的方式是正确的，只不过少了一个分号。java中定义数组有两种方式，一种是int[ ] number，一种是int number[ ]，推荐第一种，可读性更高。
以下哪些内存区域属于JVM规范？（ ）
正确答案: A D E 你的答案: A B C E (错误)
方法区
实例变量
静态变量
程序计数器
虚拟机栈
JVM内存区：程序计数器、虚拟机栈、本地方法栈、堆、方法区（包括常量池）。
不属于JVM内存区：直接内存（Direct Memory），用户I/O操作
java中 String str = "hello world"下列语句错误的是？
正确答案: A B C 你的答案: A B C (正确)
str+=’ a’
int strlen = str.length
str=100
str=str+100
A a前面有空格就是字符串，需要用双引号，
B，数组有length属性，字符串只有length（）方法
81.下列哪些操作会使线程释放锁资源？
正确答案: B C 你的答案: A C D (错误)
sleep()
wait()
join()
yield()
1.sleep()方法
在指定时间内让当前正在执行的线程暂停执行，但不会释放“锁标志”。不推荐使用。
sleep()使当前线程进入阻塞状态，在指定时间内不会执行。
2.wait()方法
在其他线程调用对象的notify或notifyAll方法前，导致当前线程等待。
线程会释放掉它所占有的“锁标志”，从而使别的线程有机会抢占该锁。
当前线程必须拥有当前对象锁。如果当前线程不是此锁的拥有者，
会抛出IllegalMonitorStateException异常。唤醒当前对象锁的等待线程使用notify或notifyAll方法，
也必须拥有相同的对象锁，否则也会抛出IllegalMonitorStateException异常。
waite()和notify()必须在synchronized函数或synchronized block中进行调用。
如果在non-synchronized函数或non-synchronized block中进行调用，
虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。
3.yield方法
暂停当前正在执行的线程对象。
yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
yield()只能使同优先级或更高优先级的线程有执行的机会。
4.join方法
join()等待该线程终止。
等待调用join方法的线程结束，再继续执行。如：t.join();//主要用于等待t线程运行结束，若无此句，main则会执行完毕，导致结果不可预测
2019.8.2
82.以下关于Object类的说法正确的是（）
正确答案: A 你的答案: A (正确)
Java中所有的类都直接或间接继承自Object，无论是否明确的指明，无论其是否是抽象类。
Java中的接口(interface)也继承了Object类
利用“==”比较两个对象时，Java调用继承自Object的equals方法，判断是否相等。
如果类的定义中没有重新定义toString()方法，则该类创建的对象无法使用toStrig()方法。
A，Object是所有类的直接或者间接父类。
B，接口没有继承Object类。（一旦继承，Object中可以有实例方法的）
C，Object的equals方法，只有一句话，return this==object。这句话说反了。
D，和A一样，都是Object的子类了，肯定有Object的方法：
hashCode、equals、toString、clone、notify、notifyall、
wait、finalize、getClass
83.在java中，无论在何处调用，使用静态属性必须以类名做前缀。
正确答案: B 你的答案: B (正确)
正确
错误
1如果是本类使用，可以直接就用静态变量名。
2如果是其他类使用，可以使用类名来调用，也可以创建一个实例对象来调用。
3如果静态变量所在的类是静态类，那么不管在本类里或者在其他外部类，
都可以直接使用静态变量名。
84.下列关于java 中的 wait()方法和 sleep()方法的区别描述错误的是？
正确答案: D 你的答案: D (正确)
wait()方法属于Object类，sleep()属于Thread类
调用wait()方法的时候，线程会放弃对象锁
调用sleep()方法的过程中，线程不会释放对象锁
sleep()方法导致了程序暂停执行指定的时间，让出cpu给其他线程
sleep和wait的区别有：
1，这两个方法来自不同的类分别是Thread和Object
2，最主要是sleep方法没有释放锁，而wait方法释放了锁，使得敏感词线程可以使用同步控制块或者方法。
3，wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在
任何地方使用
synchronized(x){
x.notify()
//或者wait()
}
4,sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常
如下语句通过算术运算和逻辑运算之后i和 j的结果是（ ）
int i=0;
int j=0;
if((++i>0)||(++j>0))
{
//打印出i和j的值。
}
正确答案: D 你的答案: B (错误)
i=0;j=0
i=1;j=1
i=0;j=1
i=1;j=0
||前面正确，后面内容就不会执行
86.观察以下代码：
class Car extends Vehicle
{
public static void main (String[] args)
{
new Car(). run();
}
private final void run()
{
System. out. println (“Car”);
}
}
class Vehicle
{
private final void run()
{
System. out. println(“Vehicle”);
}
}
下列哪些针对代码运行结果的描述是正确的？
正确答案: A 你的答案: E (错误)
Car
Vehicle
Compiler error at line 3
Compiler error at line 5
Exception thrown at runtime
答案：A
首先final声明的方法是不能被覆盖的，但是这里并不错误，因为方法是private的，
也就是子类没有继承父类的run方法，因此子类的run方法跟父类的run方法无关，
并不是覆盖。new Car().run()也是调用子类的run方法。
此题的父类方法有private修饰，所以对子类不可见，子类不能覆盖。所以子类方法和父类是两个方法。
扩展：如果父类方法将private改为public 会怎样？
会报错，因为父类方法有final修饰，不能被覆盖。
关于 JAVA 堆,下面说法错误的是()
正确答案: D 你的答案: B (错误)
所有类的实例和数组都是在堆上分配内存的
对象所占的堆内存是由自动内存管理系统回收
堆内存由存活和死亡的对象,空闲碎片区组成
数组是分配在栈中的
Java把内存分成两种，一种叫做栈内存，一种叫做堆内存。
在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。
当在一段代码块中定义一个变量时，java就在栈中为这个变量分配内存空间，
当超过变量的作用域后，java会自动释放掉为该变量分配的内存空间，
该内存空间可以立刻被另作他用。堆内存用于存放由new创建的对象和数组。
在堆中分配的内存，由java虚拟机自动垃圾回收器来管理。
在堆中产生了一个数组或者对象后，还可以在栈中定义一个特殊的变量，
这个变量的取值等于数组或者对象在堆内存中的首地址，
在栈中的这个特殊的变量就变成了数组或者对象的引用变量，
以后就可以在程序中使用栈内存中的引用变量来访问堆中的数组或者对象，
引用变量相当于为数组或者对象起的一个别名，或者代号。
引用变量是普通变量，定义时在栈中分配内存，引用变量在程序运行到作用域外释放。
而数组＆对象本身在堆中分配，
即使程序运行到使用new产生数组和对象的语句所在地代码块之外，
数组和对象本身占用的堆内存也不会被释放，
数组和对象在没有引用变量指向它的时候（比如先前的引用变量x=null时），
才变成垃圾，不能再被使用，但是仍然占着内存，
在随后的一个不确定的时间被垃圾回收器释放掉。
这个也是java比较占内存的主要原因。
以上段落来自于某一本Java程序设计的书中，实际上，
栈中的变量指向堆内存中的变量，这就是Java中的指针。
总结起来就是对象存储在堆内存，引用变量存储在栈内存。栈内存指向堆内存。
88.列表(List)和集合(Set)下面说法正确的是？ ( )
正确答案: A 你的答案: A (正确)
Set中至多只能有一个空元素
List中至多只能有一个空元素
List和Set都可以包含重复元素的有序集合
List和Set都是有序集合
Set 不能有重复的元素，且是无序的，要有空值也就只能有一个。
因为它不允许重复。 L ist 可以有重复元素，且是有序的，
要有空值也可以有多个，因为它可重复
89.transient变量和下面哪一项有关（）？
正确答案: A 你的答案: B (错误)
Serializable
Cloneable
Runnable
Throwable
Comparable
我们都知道一个对象只要实现了Serilizable接口，这个对象就可以被序列化，
java的这种序列化模式为开发者提供了很多便利，
我们可以不必关系具体序列化的过程，只要这个类实现了Serilizable接口，
这个类的所有属性和方法都会自动序列化。
这个类的有些属性需要序列化，而其他属性不需要被序列化；
java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，
将不需要序列化的属性前添加关键字transient，序列化对象的时候，
这个属性就不会序列化到指定的目的地中。
90.以下程序的输出结果是？
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 static void change(String str, char ch[])
{
str = “test ok”;
ch[0] = ‘g’;
}
}
正确答案: B 你的答案: B (正确)
good and abc
good and gbc
test ok and abc
test ok and gbc
其实都是引用传递，只是因为String是个特殊的final类，
所以每次对String的更改都会重新创建内存地址并存储
（也可能是在字符串常量池中创建内存地址并存入对应的字符串内容），
但是因为这里String是作为参数传递的，
在方法体内会产生新的字符串而不会对方法体外的字符串产生影响。
下面程序的输出是什么？
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);
}
}
正确答案: B 你的答案: C (错误)
342
3423
34234
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
以下 b 的值是： byte b = (byte)129;
正确答案: B 你的答案: B (正确)
-126
-127
-128
-129
都写的啥几把玩意，我来正解，上面没看到完全正确的，所以实在忍不了写出正确的解答
这题考察的就两个知识点：一、强制转换（主要涉及各个类型占几个字节，这里我只简单说一下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；
之前那些解答都啥玩意，不会别误导大家，我的是正解，嘻嘻
下列代码输出什么（）
char *a[] = {“BEIJING”, “SHENZHEN”, “SHANGHAI”, “GUANGZHOU”};
char **pa[] = {a+3, a+2, a+1, a};
char ***ppa = pa;
int main(void) {
printf("%s, “, **++ppa);
printf(”%s, “, –++ppa+3);
printf(”%s, “, *ppa[-2]+3);
printf(”%s", ppa[-1][-1]+1);
}
正确答案: B 你的答案: C (错误)
BEIJING, SHENZHEN, SHANGHAI,GUANGZHOU
SHANGHAI, JING, NGZHOU, HENZHEN
SHANGHAI,BEIJING, GUANGZHOU, SHENZHEN
SHANGHAI,EIJING,ZHOU,ZHEN
94.假设 a 是一个由线程 1 和线程 2 共享的初始值为 0 的全局变量，则线程 1 和线程 2 同时执行下面的代码，最终 a 的结果不可能是（）
boolean isOdd = false;
for(int i=1;i<=2;++i)
{
if（i%2==1）isOdd = true；
else isOdd = false；
a+=i*(isOdd?1:-1)；
}
正确答案: D 你的答案: C (错误)
-1
-2
0
1
首先,每个线程对a做的操作都是+1或者-2
其次,线程对a做的操作有可见不可见的问题.
- 如果线程A 做了+1,-2,结果是-1,此时如果该结果对于线程B 可见,
那么再执行+1,-2,结果是-2; - 如果线程A做了+1,-2,结果是-1,但是该结果对线程B并没有见到,
那么线程B 最后依然以a==0开始计算,结果是0+1-2=-1,之前线程A 的结果也是-1,
此时无论A和B谁的计算结果被最后刷新到公共内存,最后a的值都是-1; - 如果线程A做了+1,该结果立即被B看到,B开始进行+1,-2,结果是0,
如果该结果被刷新到内存的时机晚于线程A的计算结果,那么结果就是0.
========
对于结果为1的情况,找不到一种执行顺序.
每个线程都有自己的内存区域,线程计算结果刷新到主存的时机也是要考虑的,
具体可以了解volatile关键字.
95.如果希望监听TCP端口9000，服务器端应该怎样创建socket?
正确答案: B 你的答案: D (错误)
new Socket("localhost",9000);
new ServerSocket(9000);
new Socket(9000);
new ServerSocket("localhost",9000);
ServerSocket (int port)
创建一个serversocket 绑定在特定的端口
Socket(InetAddress address, int port)
创建一个socket流，连接到特定的端口和ip地址
96.下面哪几个函数 public void example(){…} 的重载函数？（）
正确答案: A D 你的答案: A B D (错误)
public void example(int m){...}
public int example(){..}
public void example2(){..}
public int example(int m,float f){...}
函数方法名必须相同，看参数列表即可，无关返回值。
java重载的时候以参数个数和类型作为区分，方法名相同，
返回类型可以相同也可以不同，但不以返回类型作为区分，
所以b也是错的，因为b的参数列表和原来的一样
下列描述错误的是?
正确答案: B D 你的答案: B D (正确)
类只能继承一个父类，但是可以实现多个接口
抽象类自身可以定义成员而接口不可以
抽象类和接口都不能被实例化(忽略匿名内部类)
一个类可以有多个父类和多个基接口
A、java为单继承，多实现。可以实现多个接口。
B、接口允许定义成员，但必须是常量。
C、抽象类和接口类的无法实例化，任何编译器中直接使用new会报错。
D、同A，单继承，多实现。
Which are keywords in Java?
正确答案: D E 你的答案: A C D E (错误)
null
true
sizeof
implements
instanceof
java中true ,false , null在java中不是关键字，也不是保留字，
它们只是显式常量值，但是你在程序中不能使用它们作为标识符。
其中const和goto是java的保留字。
java中所有的关键字都是小写的，
还有要注意true,false,null, friendly，sizeof不是java的关键字,
但是你不能把它们作为java标识符用。
2019.8.3
99.在开发中使用泛型取代非泛型的数据类型（比如用ArrayList取代ArrayList），程序的运行时性能会变得更好。（）
正确答案: B 你的答案: A (错误)
正确
错误
使用泛型的好处
1，类型安全。 泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。没有泛型，这些假设就只存在于程序员的头脑中（或者如果幸运的话，还存在于代码注释中）。
2，消除强制类型转换。 泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。
3，潜在的性能收益。 泛型为较大的优化带来可能。在泛型的初始实现中，编译器将强制类型转换（没有泛型的话，程序员会指定这些强制类型转换）插入生成的字节码中。但是更多类型信息可用于编译器这一事实，为未来版本的 JVM 的优化带来可能。由于泛型的实现方式，支持泛型（几乎）不需要 JVM 或类文件更改。所有工作都在编译器中完成，编译器生成类似于没有泛型（和强制类型转换）时所写的代码，只是更能确保类型安全而已。
所以泛型只是提高了数据传输安全性，并没有改变程序运行的性能
100.关于Java的抽象类、接口，以下描述错误的是？
正确答案: C 你的答案: B (错误)
抽象类不一定含有抽象方法，接口中的方法都是抽象方法
一个类只能继承一个抽象类，但可以实现多个接口；一个接口可以继承多个接口
抽象类和接口中的方法都没有方法体
抽象类可以含有私有成员变量，接口不含有私有成员变量
A----------抽象类不一定含有抽象方法，接口中的方法都是抽象方法。
接口中的方法默认修饰符有public abstract。
B----------一个类只能继承一个一个抽象类，但可以实现多个接口；一个接口可以继承多个接口。
Java里类是单继承的，接口是可以多继承的，用关键字extends。
C----------抽象类和接口中的方法都没有方法体。
抽象类中的方法是可以有方法体的。JDK1.8之后，接口中的方法也可以有方法体，用default关键字修饰方法。
D----------抽象类可以含有私有成员变量，接口不含有私有成员变量。
接口中的成员变量都是public static final的，一般用作常量。
101.void foo(void){
unsigned int a = 10;
int b = -20;
((a+b) > 10 )? printf(">10"):printf("<=10");
}
正确答案: A 你的答案: B (错误)
>10
<=10
不应该出现在java里面呀 跟java分类没关系
但是还是说一下
unsigned 是无符号数，2个操作数中有unsigned类型的默认将两个数都当做
unsigned进行处理，然后看你的结果类型了~
如果你的结果是有符号的结果值将被隐式转换为有符号的，
结果为无符号的就是无符号的。
所以，10+20=30>10 --> true ? printf(">10"):printf("<=10");
三元运算符，执行前面的 执行 输出">10"
102.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();
}
}
正确答案: B 你的答案: B (正确)
BB
CBB
BAB
None of the above
初始化过程是这样的：
1.首先，初始化父类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；
2.然后，初始化子类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；
3.其次，初始化父类的普通成员变量和代码块，在执行父类的构造方法；
4.最后，初始化子类的普通成员变量和代码块，在执行子类的构造方法；
（1）初始化父类的普通成员变量和代码块，执行 C c = new C(); 输出C
（2）super(“B”); 表示调用父类的构造方法，不调用父类的无参构造函数，输出B
（3） System.out.print(“B”);
所以输出CBB
以下程序的输出结果为
class Base{
public Base(String s){
System.out.print(“B”);
}
}
public class Derived extends Base{
public Derived (String s) {
System.out.print(“D”);
}
public static void main(String[] args){
new Derived(“C”);
}
}
正确答案: D 你的答案: A (错误)
BD
DB
C
编译错误
在调用子类构造器之前，会先调用父类构造器，
当子类构造器中没有使用"super(参数或无参数)"指定调用父类构造器时，
是默认调用父类的无参构造器，如果父类中包含有参构造器，却没有无参构造器，
则在子类构造器中一定要使用“super(参数)”指定调用父类的有参构造器，不然就会报错。
关于volatile关键字，下列描述不正确的是？
正确答案: B D 你的答案: A C (错误)
用volatile修饰的变量，每次更新对其他线程都是立即可见的。
对volatile变量的操作是原子性的。
对volatile变量的操作不会造成阻塞。
不依赖其他锁机制，多线程环境下的计数器可用volatile实现。
所谓 volatile的措施，就是
- 每次从内存中取值，不从缓存中什么的拿值。这就保证了用 volatile修饰的共享变量，
每次的更新对于其他线程都是可见的。 - volatile保证了其他线程的立即可见性，就没有保证原子性。
3.由于有些时候对 volatile的操作，不会被保存，说明不会造成阻塞。
不可用与多线程环境下的计数器。
105.关于抽象类和接口叙述正确的是？ ( )
正确答案: D 你的答案: D (正确)
抽象类和接口都能实例化的
抽象类不能实现接口
抽象类方法的访问权限默认都是public
接口方法的访问权限默认都是public
抽象类
特点:
1.抽象类中可以构造方法
2.抽象类中可以存在普通属性，方法，静态属性和方法。
3.抽象类中可以存在抽象方法。
4.如果一个类中有一个抽象方法，那么当前类一定是抽象类；抽象类中不一定有抽象方法。
5.抽象类中的抽象方法，需要有子类实现，如果子类不实现，则子类也需要定义为抽象的。
6,抽象类不能被实例化，抽象类和抽象方法必须被abstract修饰
关键字使用注意：
抽象类中的抽象方法（其前有abstract修饰）不能用private、static、synchronized、native访问修饰符修饰。
接口
1.在接口中只有方法的声明，没有方法体。
2.在接口中只有常量，因为定义的变量，在编译的时候都会默认加上public static final
3.在接口中的方法，永远都被public来修饰。
4.接口中没有构造方法，也不能实例化接口的对象。（所以接口不能继承类）
5.接口可以实现多继承
6.接口中定义的方法都需要有实现类来实现，如果实现类不能实现接口中的所有方法则实现类定义为抽象类。
7，接口可以继承接口，用extends
106.下列关于一个类的静态成员的描述中，不正确的是
正确答案: D 你的答案: B (错误)
该类的对象共享其静态成员变量的值
静态成员变量可被该类的所有方法访问
该类的静态方法能访问该类的静态成员变量
该类的静态数据成员变量的值不可修改
关于static定义的变量只能初始化一次是指在开始定义static变量的时候，如下列代码：
public class sb{
static int a=1;//说明一下如果不给a赋值，a默认等于0，
因为static定义的变量只能初始化一次，
即在此处就算初始化了，即使没定义具体的值，
默认的0也算初始化了
int b=2;//这里指第一行代码
a=b;//对于只能初始化一次是指在此处，即函数体外，
而不是指在函数体内或者在方法体内，
所以如果这里多了第一行代码和此行代码的话就会出错。
public static void main(Stirng[] args){
int a=2;//而在函数体内或者在方法体内定义的话则可以修改变量的值
System.out.println(a);//输出结果为2，同理在方法体内的情况也是一样，
那种情况留给读者自己证明一下吧。
}
}
107.Which lines of the following will produce an error?
-
byte a1 = 2, a2 = 4, a3;
-
short s = 16;
-
a2 = s;
-
a3 = a1 * a2;
正确答案: A 你的答案: C (错误)
Line 3 and Line 4
Line 1 only
Line 3 only
Line 4 only
数值型变量在默认情况下为Int型，byte和short型在计算时会自动转换为int型计算，
结果也是int 型。所以a1*a2的结果是int 型的。
108.下列说法正确的是( )
正确答案: C 你的答案: D (错误)
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关键字解决的是多个线程之间访问资源的同步性。
synchronized: 具有原子性，有序性和可见性；
volatile：具有有序性和可见性
原子性是指一个操作是不可中断的，要么全部执行成功要么全部执行失败，
有着“同生共死”的感觉
109.经过强制类型转换以后，变量a，b的值分别为多少？
short a =128；
byte b =(byte) a；
正确答案: B 你的答案: A (错误)
128 127
128 - 128
128 128
编译错误
1.short类型，a的二进制是：0000 0000 1000 0000；
2.强制转换的截后8位，正数用源码表示，负数用补码表示，第一位是符号。
3.因此，a截取后8位的二进制是：1000 0000，第一位是1，表示是一个负数，
二进制的值是128，所以结果是 -128。
不知道是否说清楚了，
110.given the following code,what will be the output?
class Value{
public int i=15;
}
public class Test{
public static void main(String argv[]){
Test t=new Test( );
t.first( );
}
public void first( ){
int i=5;
Value v=new Value( );
v.i=25;
second(v,i);
System.out.println(v.i);
}
- public void second(Value v,int i){
i = 0;
v.i = 20;
Value val = new Value( );
v = val;
System.out.println(v.i+" "+i);
}
}
正确答案: A 你的答案: B (错误)
15 0 20
15 0 15
20 0 20
0 15 20
可能有人会选择B，包括我刚开始也是。总以为v不是已经指向了val了吗？？为什么还是20呢？不应该是15吗？
其实，原因很简单。现在我们把second（）换一下
publicvoidsecond(Value tmp,inti){
i = 0;
tmp.i = 20;
Value val = newValue( );
tmp = val;
System.out.println(tmp.i+" "+i);
}
这个tmp其实相当于是一个指向原来first中的V这个对象的指针，
也就是对v对象的引用而已。但是引用是会改变所指的地址的值的。
所以在second中当tmp.i= 20的时候，就把原来first中的v的i值改为20了。
接下来，又把tmp指向了新建的一个对象，所以在second中的tmp
现在指的是新的对象val，i值为15.
当执行完毕second后，在first中在此输出v.i的时候，
应为前面second中已经把该位置的i的值改为了20，所以输出的是20.
至于疑惑v指向了val，其实只是名字的问题，在second中的v实践也是另外的一个变量，
名字相同了而已，这个估计也是纠结的重点。
112.下列说法正确的是（）？
正确答案: A B 你的答案: B D (错误)
对于局部内部类，只有在方法的局部变量被标记为final或局部变量是effctively final的，内部类才能使用它们
成员内部类位于外部类内部，可以直接调用外部类的所有方法（静态方法和非静态方法）
由于匿名内部类只能用在方法内部，所以匿名内部类的用法与局部内部类是一致的
静态内部类可以访问外部类的成员变量
A、对。
B、对。
C、错。匿名内部类用法与局部内部类不一致，首先从定义上就不一样，
匿名类用在任何允许存在表达式的地方，
而局部内部类用于在任何允许出现局部变量的地方出现。
还有更重要的是匿名类只能使用一次，而局部类则可以在自己的定义域内多次使用。
D、错。静态内部类不能直接访问外部类的非静态成员，
但可以通过new外部类（）.成员的方式访问。
2019.08.08
113.以下叙述正确的是
正确答案: D 你的答案: D (正确)
实例方法可直接调用超类的实例方法
实例方法可直接调用超类的类方法、
实例方法可直接调用子类的实例方法
实例方法可直接调用本类的实例方法
A错误，类的实例方法是与该类的实例对象相关联的，不能直接调用，只能通过创建超类的一个实例对象，再进行调用
B错误，当父类的类方法定义为private时，对子类是不可见的，所以子类无法调用
C错误，子类具体的实例方法对父类是不可见的，所以无法直接调用， 只能通过创建子类的一个实例对象，再进行调用
D正确，实例方法可以调用自己类中的实例方法
114.运行下面代码，输出的结果是（）
class A {
public A() {
System.out.println(“class A”);
}
{ System.out.println(“I’m A class”); }
static { System.out.println(“class A static”); }
}
public class B extends A {
public B() {
System.out.println(“class B”);
}
{ System.out.println(“I’m B class”); }
static { System.out.println(“class B static”); }
public static void main(String[] args) {
new B();
}
}
正确答案: A 你的答案: C (错误)
class A static
class B static
I'm A class
class A
I'm B class
class B
class A static
I'm A class
class A
class B static
I'm B class
class B
class A static
class B static
class A
I'm A class
class B
I'm B class
class A static
class A
I'm A class
class B static
class B
I'm B class
此题考虑 Java 中构造器、初始化块、静态初始化块的执行顺序。
静态初始化块 > 初始化块 > 构造器
父类 > 子类
综合下来顺序就是：
父类静态初始化块
子类静态初始化块
父类初始化块
父类构造器
子类初始化块
子类构造器
需要注意静态初始化块是在类第一次加载的时候就会进行初始化。
115.以下Java程序运行的结果是:
public class Tester{
public static void main(String[] args){
Integer var1=new Integer(1);
Integer var2=var1;
doSomething(var2);
System.out.print(var1.intValue());
System.out.print(var1==var2);
}
public static void doSomething(Integer integer){
integer=new Integer(2);
}
}
正确答案: A 你的答案: C (错误)
1true
2true
1false
2false
主要分析下doSomething（），因为这里传递的是引用，而不是地址值，即新建了一个Integer integer，其指向var2所指向的那个栈中的1.至此，integer和var毫无关系，除了同时指向同一个栈中的值。然后integer = new Integer（2）；便是在栈中新建了一个为2的值，然后integer重新指向了这个栈中的值。所以var1和var2都没有改变，都是指向栈中为1的那个值。
同时说明下： == 与equal
equal是值的比较
==是引用的比较
现在很明显了吧。
关于异常的编程，以下描述错误的是：（ ）
正确答案: A 你的答案: C (错误)
在有除法存在的代码处，为了防止分母为零，必须抛出并捕获异常
int i=Integer.parseInt(”123a”);将产生NumberFormatException
int a[]=null; a[0]=1; 将产生NullPointerException
输入输出流编程中，读和写时都要抛出IOException
异常分为运行时异常，非运行时异常和error，其中error是系统异常，
只能重启系统解决。非运行时异常需要我们自己补获，
而运行异常是程序运行时由虚拟机帮助我们补获，运行时异常包括数组的溢出，
内存的溢出空指针，分母为0等！
117.关于类的叙述正确的是（）。
正确答案: B 你的答案: D (错误)
在类中定义的变量称为类的成员变量，在别的类中可以直接使用
局部变量的作用范围仅仅在定义它的方法内，或者是在定义它的控制流块中
使用别的类的方法仅仅需要引用方法的名字即可
只要没有定义不带参数的构造函数，JVM都会为类生成一个默认构造函数
【解析】
A在类中定义的变量称为类的成员变量，在别的类中不可以直接使用局部变量的
C使用别的类的方法需要通过该类的对象引用方法的名字
D只要没有定义任何构造函数，JVM都会为类生成一个默认构造函数
118.对 Map 的用法，正确的有：
正确答案: C D 你的答案: A B C (错误)
new java.util.Map().put("key" , "value") ;
new java.util.SortedMap().put("key" , "value") ;
new java.util.HashMap().put( null , null ) ;
new java.util.TreeMap().put( 0 , null ) ;
选C、D。考察的是Map接口实现类的创建对象以及对象类型包含的方法。
A选项Map属于接口类型，不可以new的方式创建对象。所以A错误。
B选项SortedMap属于接口类型，不可以new的方式创建对象。所以B错误。
C选项HashMap基于哈希表实现Map接口的类，并允许null的值和null键。
D选项TreeMap通过红黑树实现Map接口的类，key不可以为null，
会报NullPointerException异常,value可以为null。
2019.8.13
119.在java7中，下列不能做switch()的参数类型是？
正确答案: D 你的答案: B (错误)
int型
枚举类型
字符串
浮点型
switch语句后的控制表达式只能是short、char、int、long整数类型和枚举类型，
不能是float，double和boolean类型。String类型是java7开始支持。
120.有一个源代码，只包含import java.util.* ; 这一个import语句，
下面叙述正确的是？ ( )
正确答案: C 你的答案: B (错误)
只能写在源代码的第一句
可以访问java/util目录下及其子目录下的所有类
能访问java/util目录下的所有类，不能访问java/util子目录下的所有类
编译错误
导入java.util.*不能读取其子目录的类，因为如果java.util里面有个a类，
java.util.regex里面也有个a类，我们若是要调用a类的方法或属性时，
应该使用哪个a类呢。所以也应该选C
以下代码可以使用的修饰符是：（）
public interface Status {
/INSERT CODE HERE/ int MY_VALUE=10;
}
正确答案: A B D 你的答案: B C D (错误)
final
static
abstract
public
接口中字段的修饰符：public static final（默认不写）
接口中方法的修饰符：public abstract（默认不写）
122.下列程序执行后结果为( )
class A {
public int func1(int a, int b) {
return a - b;
}
}
class B extends A {
public int func1(int a, int b) {
return a + b;
}
}
public class ChildClass {
public static void main(String[] args) {
A a = new B();
B b = new B();
System.out.println(“Result=” + a.func1(100, 50));
System.out.println(“Result=” + b.func1(100, 50));
}
}
正确答案: A 你的答案: A (正确)
Result=150Result=150
Result=100Result=100
Result=100Result=150
Result=150Result=100
其实很简单，涉及转型的题目，分为向上或者向下转型。
关键的来了，不论向上或者向下转型，都是一句话，“编译看左边，运行看右边”。
也就是编译时候，会看左边引用类型是否能正确编译通过，
运行的时候是调用右边的对象的方法。
就本题来说，编译时候会发现左边满足条件所以编译通过，
运行时候又会调用右边也就是 class B 的方法，所以答案都是150。
123.下列关于构造方法不正确的是：（ ）
正确答案: D 你的答案: C (错误)
类的构造方法和类同名
一个类可以有多个构造方法
在实例化对象时必须调用类的构造方法
构造方法可以和该类其他方法一样被该类对象调用
A、构造方法的名称和 类名称必须相同
B、一个类是可以有多个构造方法，利用重载实现
C、这个选项不严谨，因为用普通的创建方法（new）是要调用构造方法，
如果使用反射 或者 克隆 这些就可以绕过构造函数直接创建对象
D、构造方法不属于类方法（没有用static修饰）
也不属于实例方法（普通方法不能调用），构造方法只能由构造方法本身去调用，
而且必须是第一行（构造方法是普通方法的一种特例是不成立的，方法的调用，
一般都是通过方法名直接使用，普通方法真的要调用构造方法的话，
可以使用反射技术，但是没有任何意义）由于D选项是绝对错误
C选项属于一半对一半错吧（因为没有说明使用什么方式去实例化对象）
故答案是 D
124.以下代码将打印出
1
2
3
4
public static void main (String[] args) {
String classFile = “com.jd.”. replaceAll(".", “/”) + “MyClass.class”;
System.out.println(classFile);
}
正确答案: C 你的答案: B (错误)
com. jd
com/jd/MyClass.class
///////MyClass.class
com.jd.MyClass
C。由于replaceAll方法的第一个参数是一个正则表达式，
而".“在正则表达式中表示任何字符，所以会把前面字符串的所有字符都替换成”/"。
如果想替换的只是"."，那么久要写成"\.".
2018.8.15
类中的数据域使用private修饰为私有变量，所以任何方法均不能访问它。
正确答案: B 你的答案: A (错误)
正确
错误
1、本类的方法可以访问
2、反射也可以访问
126.编译java程序的命令文件是( )
正确答案: B 你的答案: B (正确)
java.exe
javac.exe
applet.exe
javac.exe是编译功能javaCompiler
java.exe是执行程序，用于执行编译好的.class文件
javadoc.exe用来制作java文档
jdb.exe是java的调试器
javaprof.exe是剖析工具
127.Java7特性中,abstract class和interface有什么区别。
正确答案: A B D 你的答案: A D (错误)
抽象类可以有构造方法，接口中不能有构造方法
抽象类中可以有普通成员变量，接口中没有普通成员变量
抽象类中不可以包含静态方法，接口中可以包含静态方法
一个类可以实现多个接口，但只能继承一个抽象类。
针对本题：
1、抽象类可以有构造，只不过不能new。
2、接口中可以有变量，但是无论你怎么写，最后都是public static final的。
3、抽象类中可以有静态方法，接口中也可以有。
扩展：
1、接口中可以有非抽象的方法，比如default方法（Java 1.8）。
2、接口中可以有带方法体的方法。（Java 1.8）
3、接口中的方法默认是public的。
2018.8.17
128.欲构造ArrayList类的一个实例，此类实现了List接口，
下列哪个方法是正确的？
正确答案: B 你的答案: A (错误)
ArrayList myList=new Object（）
List myList=new ArrayList()
ArrayList myList=new List()
List myList=new List()
本题考查在Java中如何实现接口。选项A错误，
只是实例化了一个ArrayList类的对象myList，而没有实现接口；
选项B正确，用List来声明MyList实现接口，并用ArrayList构造出一个实例；
选项C错误，List并不是一个类，不能用new关键字；
选项D错误，接口不能实例化—个接口。故本题的答案是B。
129.下面不是类及类成员的访问控制符的是( )。（不考虑内部类的情况）
正确答案: C 你的答案: B (错误)
public
private
static
protected
类访问控制符只有三种：
public 公有private私有 protected受保护
static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，
也可以形成静态static代码块,不可以用来控制类成员！
130.关于构造 器 的说法哪个正确？（ ）
正确答案: C 你的答案: C (正确)
一个类只能有一个构造器
一个类可以有多个不同名的构造器
构造器与类同名
构造器必须自己定义，不能使用父类的构造器
一个类可以有多个构造器，多个构造器用的是方法重载，所以方法名要相同，
不同的是参数列表（参数个数、参数类型和参数的顺序），当自己没有定义构造器时，
系统会自动地添加一个默认构造器，子类可以调用父类的构造器。
在使用super和this关键字时，以下描述正确的是（）
正确答案: A 你的答案: C (错误)
在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过
super（）和this（）不一定要放在构造方法内第一行
this（）和super（）可以同时出现在一个构造函数中
this（）和super（）可以在static环境中使用，包括static方法和static语句块
使用super()或者this()方法是必须放在构造函数的第一行
由于this函数指向的构造函数默认有super()方法，
所以规定this()和super()不能同时出现在一个构造函数中。
因为staic方法或者语句块没有实例时可以使用，而此时不需要构造实例，
所以不能用this()和super()
下列关于继承的描述正确的是（）
正确答案: C 你的答案: A (错误)
在Java中允许定义一个子类的引用，指向父类的对象。
在Java中一个子类可以继承多个抽象类，在extends关键字后依次列出，用逗号隔开。
在Java中继承是通过extends关键字来描述的，而且只允许继承自一个直接父类。
在Java中抽象类之间不允许出现继承关系，所有的抽象类都相互独立。
A、说反了。父类引用指向子类对象
B、类都是单继承。
D、抽象类也可以继承。
133.表达式(short)10/10.2*2运算后结果是什么类型？
正确答案: C 你的答案: A (错误)
short
int
double
float
强制类型转换的优先级高于+ - * /
134.以下代码段执行后的输出结果为
public class Test {
public static void main(String args[]) {
int x = -5;
int y = -12;
System.out.println(y % x);
}
}
正确答案: D 你的答案: B (错误)
-1
2
1
-2
System.out.println((-3)%2);
System.out.println(4%3);
System.out.println((-3)%(-2));
System.out.println(4%(-3));
-1
1
-1
1
取模运算，余数的符号跟被除数符号相同
关于Java以下描述正确的有( )
正确答案: C D 你的答案: A D (错误)
Class类是Object类的超类
Object类是一个final类
String类是一个final类
Class类可以装载其它类
Object类是所有类的父类，所以Object类不能用final修饰
（因为被final修饰的类不能被继承）
String类是一个不变类，只有String是不可变的，
才实现字符串常量池，节省空间，提高效率，同一个字符串常量被多个线程共享，
实现线程安全
1
在Jdk1.7中，下述说法中抽象类与接口的区别与联系正确的有哪些？
正确答案: A B C D 你的答案: A C D (错误)
抽象类中可以有普通成员变量，接口中没有普通成员变量。
抽象类和接口中都可以包含静态成员常量。
一个类可以实现多个接口，但只能继承一个抽象类
抽象类中可以包含非抽象的普通方法，接口中的方法必须是抽象的，不能有非抽象的普通方法。
- 一个子类只能继承一个抽象类,但能实现多个接口
- 抽象类可以有构造方法,接口没有构造方法
- 抽象类可以有普通成员变量,接口没有普通成员变量
- 抽象类和接口都可有静态成员变量,抽象类中静态成员变量访问类型任意,
接口只能public static final(默认) - 抽象类可以没有抽象方法,抽象类可以有普通方法,接口中都是抽象方法
- 抽象类可以有静态方法,接口不能有静态方法
- 抽象类中的方法可以是public、protected;接口方法只有public
内容总结
以上是互联网集市为您收集整理的java 错题集全部内容，希望文章能够帮你解决java 错题集所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。