java基础

3.5 本章小结

----2020/4/3

正确答案: B
432
531
421
523
解析：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;

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

正确答案: D
子类不能继承父类的无参构造函数。
子类可以在自己的构造函数中使用super关键字来调用父类的含参数构造函数，但这个调用语句必须是子类构造函数的第一个可执行语句。
在创建子类的对象时，若不含带参构造函数，将先执行父类的无参构造函数，然后再执行自己的无参构造函数。
子类不但可以继承父类的无参构造函数，也可以继承父类的有参构造函数。
解析：构造函数不能被继承，构造方法只能被显式或隐式的调用。

----以下 json 格式数据，错误的是

正确答案: A C
{company：4399}
{“company”:{“name”:[4399,4399,4399]}}
{[4399,4399,4399]}
{“company”:[4399,4399,4399]}
{“company”:{“name”:4399}}
解析：JSON语法可以表示以下三种类型的值:
1.简单值：使用与JavaScript 相同的语法，可以在JSON中表示字符串，数值，布尔值和null。
2.对象：对象作为一种复杂数据类型，表示的是一组有序的键值对。而每组键值对中的值可以是简单值，也可以是复杂数据类型的值。
3.数组：数组也是一种复杂数据类型，表示一组有序的值的列表，可以通过数值索引来访问其中的值。数组的值也可以是任意类型–简单值，对象或数组。

----关于java集合下列说法不正确的有哪些（）
正确答案: A B D
HashSet 它是线程安全的，不允许存储相同的对象
ConcurrentHashMap 它是线程安全的，其中存储的键对象可以重复，值对象不能重复
Collection接口是List接口和Set接口的父接口，通常情况下不被直接使用
ArrayList线程安全的，允许存放重复对象
解析：线程安全(Thread-safe)的集合对象：

Vector 线程安全：
HashTable 线程安全：
StringBuffer 线程安全：
非线程安全的集合对象：

ArrayList ：
LinkedList：
HashMap：
HashSet：
TreeMap：
TreeSet：
StringBulider：

----2020/4/8

----进行Java基本的GUI设计需要用到的包是（）
正确答案: C
java.io
java.sql
java.awt
java.rmi

解析：图形用户界面（Graphical User Interface，简称 GUI）是指采用图形方式显示的计算机操作用户界面。
java.io提供了全面的IO接口。包括：文件读写、标准设备输出等。
java.sql 提供使用 Java 编程语言访问并处理存储在数据源中的数据的 API。此 API 包括一个框架，凭借此框架可以动态地安装不同驱动程序来访问不同数据源。
java.awt是一个软件包，包含用于创建用户界面和绘制图形图像的所有分类。功能：包含用于创建用户界面和绘制图形图像的所有类。
java.rmi 提供 RMI 包。RMI 指的是远程方法调用 (Remote Method Invocation)。它是一种机制，能够让在某个 Java虚拟机上的对象调用另一个 Java 虚拟机中的对象上的方法。

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

----2020/4/11

正确答案: B
666
667
677
676
解析：a++可以理解为当访问a之后再对a进行加一操作。

----一个Java源程序文件中定义几个类和接口，则编译该文件后生成几个以.class为后缀的字节码文件。
正确答案: A
正确
错误
解析：一个.java文件中定义多个类：
注意一下几点：
(1) public权限类只能有一个（也可以一个都没有，但最多只有一个）；
(2)这个.java文件名只能是public 权限的类的类名；
(3)倘若这个文件中没有public 类，则它的.java文件的名字是随便的一个类名；
(4)当用javac命令生成编译这个.java 文件的时候，则会针对每一个类生成一个.class文件；

----java语言的下面几种数组复制方法中，哪个效率最高？
正确答案: B
for 循环逐一复制
System.arraycopy
Array.copyOf
使用clone方法
解析：效率：System.arraycopy > clone > Arrays.copyOf > for循环。
https://blog.csdn.net/tingzhiyi/article/details/52344845

----下列语句正确的是：
正确答案: D
形式参数可被字段修饰符修饰
形式参数不可以是对象
形式参数为方法被调用时真正被传递的参数
形式参数可被视为local variable
解析：
A：形式参数只能被final修饰
B：形式参数可以是对象
C：形式参数被调用时被传递的是实际参数的拷贝
D：local variable：局部变量
分类
Java语言提供了很多修饰符，大概分为两类：

1. 访问权限修饰符
2. 非访问权限修饰符

访问权限修饰符
public：共有访问。对所有的类都可见。
protected：保护型访问。对同一个包可见，对不同的包的子类可见。
default：默认访问权限。只对同一个包可见，注意对不同的包的子类不可见。
private：私有访问。只对同一个类可见，其余都不见。

非访问权限修饰符

static 修饰符，用来创建类方法和类变量。
final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
abstract 修饰符，用来创建抽象类和抽象方法。
synchronized 用于多线程的同步。
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
transient：序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。

类

外部类修饰符
public（访问控制符），将一个类声明为公共类，它可以被任何对象访问，一个程序的主类必须是公共类。
default（访问控制符），类只对包内可见，包外不可见。
abstract（非访问控制符），将一个类声明为抽象类，抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充，抽象类可以包含抽象方法和非抽象方法。。
final（非访问控制符），将一个类生命为最终（即非继承类），表示它不能被其他类继承。
注意：
1.protected 和 private 不能修饰外部类，是因为外部类放在包中，只有两种可能，包可见和包不可见。
2. final 和 abstract不能同时修饰外部类，因为该类要么能被继承要么不能被继承，二者只能选其一。
3.不能用static修饰类，因为类加载后才会加载静态成员变量。所以不能用static修饰类和接口，因为类还没加载，无法使用static关键字。

内部类修饰符

内部类与成员变量地位一样，所以可以public,protected、default和private，同时还可以用static修饰，表示嵌套内部类，不用实例化外部类，即可调用。

----下面赋值语句中正确的是（）

正确答案: A
double d=5.3e12;
float f=11.1;
int i=0.0;
Double oD=3;
解析：java中整型默认的是int,浮点默认的是double.
B: double类型的11.1 转成 float，是需要强制转换的
C: double类型的0.0 转成 int，也是需要强制转换的
D: int 转为 封装类型Double，是无法编译的
Double oD = 3.0， 会把double类型的3.0自动装箱为Double，没有问题。

----关于Java和C/C++的比较，下列哪个描述是错误的？
正确答案: C D
Java不支持指针，C/C++支持
Java程序不需要显式地关心内存释放，而C/C++需要
Java和C++一样，是纯编译型语言，因此它们的class都是在编译时静态联编(static binding)的
Java数组、字符串不可能溢出，C/C++数组、字符串则有可能溢出边界

解析：C，java不完全算是编译型语言，他编译的字节码文件运行时是解释执行的，其次，java和C++的类也不都完全是静态绑定的，比如C+++的虚函数，java的父类引用子类对象等情况。
D，java也可以数组溢出，溢出是会抛出异常，也就是ArrayIndexOutOfBoundsException

----
正确答案: C
程序运行输出只有In run
程序运行输出只有Leaving run
程序运行输出先有In run后有Leaving run
程序运行输出先有Leaving run后有In run
程序没有任何输出就退出了
程序将被挂起，只能强制退出
解析：Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。
yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。
结论：yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

----下面有关java的引用类型，说法正确的有？
正确答案: A B C D
对于一个对象来说，只要有强引用的存在，它就会一直存在于内存中
如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存
一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的空间
解析：
1、强引用：一个对象赋给一个引用就是强引用，比如new一个对象，一个对象被赋值一个对象。
2、软引用：用SoftReference类实现，一般不会轻易回收，只有内存不够才会回收。
3、弱引用：用WeekReference类实现，一旦垃圾回收已启动，就会回收。
4、虚引用：不能单独存在，必须和引用队列联合使用。主要作用是跟踪对象被回收的状态。

----2020/4/13

----为Test类的一个无形式参数无返回值的方法method书写方法头，使得使用类名Test作为前缀就可以调用它，该方法头的形式为( )

正确答案: A
static void method（）
public void method
protected void method（）
abstract void method（）
解析：A是静态方法，可以直接用如下形式调用 Test.method();
B是普通public方法，必须实例化类，Test test = new Test(); test.method();
C是protected方法，用法同B，只是对于其他的外部class，protected就变成private;
D是抽象方法，必须被子类继承并重写，然后调用的方式同B。

----以下关于继承的叙述正确的是
正确答案: A
在Java中类只允许单一继承
在Java中一个类不能同时继承一个类和实现一个接口
在Java中接口只允许单一继承
在Java中一个类只能实现一个接口

解析：类支持单继承，接口支持多继承。
1）接口可以继承接口，而且可以继承多个接口，但是不能实现接口，因为接口中的方法全部是抽象的，无法实现；
2）普通类可以实现接口，并且可以实现多个接口，但是只能继承一个类，这个类可以是抽象类也可以是普通类，如果继承抽象类，必须实现抽象类中的所有抽象方法，否则这个普通类必须设置为抽象类；
3）抽象类可以实现接口，可以继承具体类，可以继承抽象类，也可以继承有构造器的实体类。

----对于同一类中的两个方法 , 在判断它们是不是重载方法时 , 肯定不考虑（ ）

正确答案: C
参数个数
参数类型
返回值类型
参数顺序

解析:重载：类中可以创建多个方法，它们具有相同的名字，但具 有不同的参数和不同的定义。调用方法时通过传递 给它们的不同参数个数和参数类型 给它们的不同参数个数和参数类型 给它们的不同参数个数和参数类型 来决定具体使用哪个方法 , 这就是多态性。
重写 Overriding 是父类与子类之间多态性的一种表现， 在子类中定义某方法与其父类有相同的名称和参数。

----已知 boolean result = false，则下面哪个选项是合法的：

正确答案: B D
result=1
result=true;
if(result!=0) {//so something…}
if(result) {//do something…}

解析：1、boolean类型只有两个直接量值:true和false.
2、除成员变量会有默认初始值外，其他变量必须在第一次使用之前初始化

----下列关于final、finally、finalize说法正确的是（ ）
正确答案: A B D
final可以用来修饰类、方法、变量
finally是java保证重点代码一定要被执行的一种机制
变量被final修饰后不能再指向其他对象，但可以重写
finalize设计的目的是保证对象在被垃圾收集前完成特定资源的回收
解析：当final修饰一个基本数据类型时，表示该基本数据类型的值一旦在初始化后便不能发生变化；如果final修饰一个引用类型时，则在对其初始化之后便不能再让其指向其他对象了，但该引用所指向的对象的内容是可以发生变化的。

----下列正确的有（ ）
正确答案: A C D
call by value不会改变实际参数的数值
call by reference能改变实际参数的参考地址
call by reference不能改变实际参数的参考地址
call by reference能改变实际参数的内容

解析：引用数据类型是引用传递（call by reference），基本数据类型是值传递（call by value）。
值传递不可以改变原变量的内容和地址—》原因是java方法的形参传递都是传递原变量的副本，在方法中改变的是副本的值，而不适合原变量的。
引用传递不可以改变原变量的地址，但可以改变原变量的内容—》原因是当副本的引用改变时，原变量 的引用并没有发生变化，当副本改变内容时，由于副本引用指向的是原变量的地址空间，所以，原变量的内容发生变化。

----2020/4/17

----下列不属于访问控制符的是（）

正确答案: D
public
private
protected
static
解析：public 公有 private私有 protected受保护
static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块。

----如果希望某个变量只可以被类本身访问和调用，则应该使用下列哪一种访问控制修饰？

正确答案: B
public
private
private protected
protected

解析：public：public表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行调用
private：private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用，私有财产神圣不可侵犯嘛，即便是子女，朋友，都不可以使用。
protected：protected对于子女、朋友来说，就是public的，可以自由使用，没有任何限制，而对于其他的外部class，protected就变成private。

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

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

--------#####

正确答案: B
true
false
exception
无输出
解析：String str1 = “hello”;这里的str1指的是方法区的字符串常量池中的“hello”，编译时期就知道的； String str2 = “he” + new String(“llo”);这里的str2必须在运行时才知道str2是什么，所以它是指向的是堆里定义的字符串“hello”，所以这两个引用是不一样的。
如果用str1.equal(str2)，那么返回的是True；因为两个字符串的内容一样。

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

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

解析：1abstract类不能与final,static使用。final修饰方法，子类可以调用，但不能覆盖。
2最好不要有private因为私有和抽象放在一起，子类如果想重写父类的私有方法根本继承不过来，也就无法重写
3抽象类中可以有非抽象方法
4抽象类中可以都是非抽象的，但是抽象方法一定要在类和接口中

abstract是需要被继承使用的，所以它不能被final使用，所以A错
也可以有private属性，B错
也可以有普通方法 甚至所有都可以是普通方法，当然这样也就失去了abstract类的意义，C错
interface属于特殊的abstract类，也是abstract类，所以D对

----客户端要获取一个socket对象通过实例化，而服务器获得一个socket对象则通过什么方法的返回值？
正确答案: A
getRemoteSocketAddress()
getInputStream()
getOutputStream()
解析：1. 通过建立一个SocketAddress对象，可以在多次连接同一个服务器时使用这个SocketAddress对象。
2. 在Socket类中提供了两个方法：getRemoteSocketAddress和getLocalSocketAddress，通过这两个方法可以得到服务器和本机的网络地址。而且所得到的网络地址在相应的Socket对象关闭后任然可以使用。

----substring 方法将返回一个包含从 start 到最后（不包含 end ）的子字符串的字符串。

----如果要建立一个java.scut.computer的包，叙述正确的是？ ( )
正确答案: A
只需在代码中加入“package java.scut.computer;”一个语句，并且必须放在代码的第一行
只需在代码中加入“package java.scut;”一个语句
必须在代码中加入“package java.scut;”和“package java.scut.computer;”两个语句
在代码中，不一定是第一句，只要是类定义前，加入package语句即可
解析：实际上在Java语言规范中，不允许package name以“java”开头，不然会报一个java.lang.SecurityException 的错误。因为假如我们允许包名以java开头，那么我们完全可以编写和jdk标准包下一模一样的类，如Java.lang.Integer。因此在虚拟机进行类或接口解析时可能会发生冲突。一句话总结就是:假如允许包名以java开头，可能会导致命名空间污染的问题。

----列表(List)和集合(Set)下面说法正确的是？ ( )

正确答案: A
Set中至多只能有一个空元素
List中至多只能有一个空元素
List和Set都可以包含重复元素的有序集合
List和Set都是有序集合
解析：Set 不能有重复的元素，且是无序的，要有空值也就只能有一个。因为它不允许重复。 L ist 可以有重复元素，且是有序的，要有空值也可以有多个，因为它可重复。

----对于非运行时异常，程序中一般可不做处理，由java虚拟机自动进行处理。
正确答案: B
正确
错误
解析：运行异常，可以通过java虚拟机来自行处理。非运行异常，我们应该捕获或者抛出。

---

正确答案: A
Car
Vehicle
Compiler error at line 3
Compiler error at line 5
Exception thrown at runtime
解析：首先final声明的方法是不能被覆盖的，但是这里并不错误，因为方法是private的，也就是子类没有继承父类的run方法，因此子类的run方法跟父类的run方法无关，并不是覆盖。new Car().run()也是调用子类的run方法。

----java的跨平台特性是指它的源代码可以在多个平台运行。（）
正确答案: B
正确
错误
解析：Java的跨平台特性是因为JVM的存在， 它可以执行.class字节码文件，而不是.java源代码

---

正确答案: C
定义了声明式事务的配置模板
对get方法采用只读事务
缺少sessionFactory属性的注入
配置需要事务管理的bean的代理时，通过parent引用这个配置模板，代码如下：

解析：sessionFactory只有使用Hibernate才需要注入，并且是注入到事务管理器的，所以c错误

---

正确答案: B
编译错误
TRUE
FALSE
什么也没有输出
解析： if(flag = true)的时候flag已经是true了，所以输出true；
要是为if(flag == true)输出才为false

---

正确答案: D
编译错误，指明run方法没有定义
运行错误，run方法没有定义
编译通过并输出0到9
编译通过，但无输出
解析：对于线程而言，start是让线程从new变成runnable。run方法才是执行体的入口。
但是在Thread中，run方法是个空方法，没有具体实现。
Bground继承了Thread，但是没有重写run方法，那么调用run方法肯定是无输出。

----下面有关maven和ant的描述，描述错误的是？
正确答案: C
Ant 没有正式的约定如一个一般项目的目录结构，你必须明确的告诉 Ant 哪里去找源代码
Maven 拥有约定，因为你遵循了约定，它已经知道你的源代码在哪里
maven和ant都有“生命周期”的概念，当你输入一个命令后，maven或者ant会执行一系列的有序的步骤，直到到达你指定的生命周期
Ant构建文件默认命名为build.xml，Maven默认构建文件为pom.xml
解析：Ant和Maven都是基于Java的构建(build)工具。理论上来说，有些类似于（Unix）C中的make ，但没有make的缺陷。Ant是软件构建工具，Maven的定位是软件项目管理和理解工具。

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

----java用（）机制实现了进程之间的同步执行
正确答案: A
监视器
虚拟机
多个CPU
异步调用
解析：在jvm中 是使用监视器锁来实现不同线程的异步执行， 在语法的表现就是synchronized 。

---

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

---

正确答案: D
BD
DB
C
编译错误
解析：

---

正确答案: D
Base SonB
Son SonB
Base Son SonB
编译不通过

---

正确答案: D

解析：编译错误：The method bark() is undefined for the type Animal。Animal中没有定义bark()方法。
Dog继承自Animal。
当用Dog对象初始化Animal类对象时，完成了对Animal对象中方法与变量的覆盖与隐藏，也就是b.move()调用的是Dog中move()方法。而Animal中本身并没有bark()方法，不存在被覆盖的情况，亦无法访问，也就是b.bark()会报错。

----以下为 java 语法保留不能作为类名和方法名使用的是

正确答案: A B C D
default
int
implements
throws
解析：四个选项都是java的关键字，都不可以

----下面哪些可能是重载的基本条件（）（注意：是可能为重载的基本条件）
正确答案: A B D
参数的类型不同
参数的顺序不同
函数的返回值类型不同
参数的个数不同
解析：
重载（overload）
基本条件：
函数名必须相同；
函数参数必须不相同，可以是参数类型或者参数个数不同；
函数返回值可以相同，也可以不相同；

重写（override）
基本条件：
重写的函数和被重写的函数必须为virtual函数，分别位于基类和派生类中；
重写的函数和被重写的函数函数名和函数参数必须一致；
重写的函数和被重写的函数返回值相同，或者都返回指针或引用，并且派生类虚函数所返回的指针或引用的类型是基类中被替换的虚函数所返回的；
指针或引用的类型的子类型。

----对Collection和Collections描述正确的是
正确答案: B D
Collection是java.util下的类，它包含有各种有关集合操作的静态方法
Collection是java.util下的接口，它是各种集合结构的父接口
Collections是java.util下的接口，它是各种集合结构的父接口
Collections是java.util下的类，它包含有各种有关集合操作的静态方法
解析：java.util.Collection 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。
java.util.Collections 是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。

---

正确答案: C D E
(su)
(st)
(s.equals(t))
(s.equals(9))
(s.equals(new Integer(9))
解析：(s==u) ，因为， s 是 Integer 类型， u 是 Long 类型，两个不同类型的引用不能进行 == 比较。

(s==t) ， s 是指向一个 9 的引用，而 t 也是一个指向 9 的引用，虽然都是指向 9 ，但却是指向不同的 9 ，即是两个不同的引用。因此 == 比较返回的是假。

----Java程序的种类有（ ）
正确答案: B C D
类（Class）
Applet
Application
Servlet

解析：Java程序的种类有：

（a）内嵌于Web文件中，由浏览器来观看的_Applet

（b）可独立运行的 Application

（c）服务器端的 Servlets

----2020/4/20

----局部变量：方法定义中或者方法声明上。
局部变量：在内存的栈中。
局部变量：随方法的调用而存在，随着方法的调用完毕而消失。
局部变量：没有默认值，必须定义，赋值，然后才能使用

---

正确答案: A
12353514
12353513
12343514
12343513
解析：A. m++ 先输出在自加，++m 先自加在输出

----Which is not Java primitive types?
正确答案: B
short
Boolean
byte
float
解析：Java数据类型分为两大类：基本数据类型和引用数据类型（抽象数据类型）
基本数据类型（8种 ）:
整型：
byte 1字节 8位(0000 0000)
short 2字节
int 4字节
long 8字节
浮点型：
float 4字节
double 8字节
字符型：
char 2字节
布尔型：
boolean 长度有争议（true,false）
基本数据类型对应的包装类型首字符大写，除过int 和 char
int----->Integer
char---->Character
引用数据类型：（内存中的地址）
类，接口，数组

----正则表达式语法中 \d 匹配的是？（）

正确答案: A
数字
非数字
字母
空白字符
解析：\d 匹配一个数字字符。等价于 [0-9]。
\D 匹配一个非数字字符。等价于 [^0-9]。
\f 匹配一个换页符。等价于 \x0c 和 \cL。
\n 匹配一个换行符。等价于 \x0a 和 \cJ。
\r 匹配一个回车符。等价于 \x0d 和 \cM。
\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t 匹配一个制表符。等价于 \x09 和 \cI。
\v 匹配一个垂直制表符。等价于 \x0b 和 \cK。
\w 匹配字母、数字、下划线。等价于’[A-Za-z0-9_]’。
\W 匹配非字母、数字、下划线。等价于 ‘[^A-Za-z0-9_]’。

----下面关于垃圾收集的描述哪个是错误的？
正确答案: D
使用垃圾收集的程序不需要明确释放对象
现代垃圾收集能够处理循环引用问题
垃圾收集能提高程序员效率
使用垃圾收集的语言没有内在泄漏问题
解析：也会有内存泄露问题，例如访问资源文件，流不关闭，访问数据库等连接不关闭。
java的垃圾收集机制主要针对新生代和老年代的内存进行回收，不同的垃圾收集算法针对不同的区域。所以java的垃圾收集算法使用的是分代回收。

----要使某个类能被同一个包中的其他类访问，但不能被这个包以外的类访问，可以( )
正确答案: A
让该类不使用任何关键字
使用private关键字
使用protected关键字
使用void关键字
解析：default和protected的区别是：
前者只要是外部包，就不允许访问。
后者只要是子类就允许访问，即使子类位于外部包。
总结：default拒绝一切包外访问；protected接受包外的子类访问

----下面关于静态方法说明正确的是
正确答案: B
在静态方法中可用this来调用本类的类方法
在静态方法中调用本类的静态方法时可直接调用
在静态方法中只能调用本类中的静态方法
在静态方法中绝对不能调用实例方法
解析：A.静态成员随类的加载而加载，这个时候对象都还没有，this代表当前对象，所以this不能用于static方法中.C还可以调用静态变量D.可以通过对象.进行调用

----关于final说法正确的是？ ( )
正确答案: B
final类的方法肯定不能被同一个包的类访问
final类的方法能否被同一个包的类访问不是由final决定
final方法等同于private方法
final对象本身的引用和值都不能改变

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

----关于继承和实现说法正确的 是 ？ ( )
正确答案: A
类可以实现多个接口，接口可以继承（或扩展）多个接口
类可以实现多个接口，接口不能继承（或扩展）多个接口
类和接口都可以实现多个接口
类和接口都不可以实现多个接口

解析：java类是单继承的。 java接口可以多继承。 不允许类多重继承的主要原因是，如果A同时继承B和C，而B和C同时又有一个D方法，A如何决定该继承那一个呢？ 但接口不存在这样的问题，接口全都是抽象方法继承谁都无所谓，所以接口可以继承多个接口

----下面哪种情况会导致持久区jvm堆内存溢出？
正确答案: C
循环上万次的字符串处理
在一段代码内申请上百M甚至上G的内存
使用CGLib技术直接操作字节码运行，生成大量的动态类
不断创建对象

解析： java的堆内存分为两块:permantspace（持久带） 和 heap space。
持久带中主要存放用于存放静态类型数据，如 Java Class, Method 等， 与垃圾收集器要收集的Java对象关系不大。
而heapspace分为年轻带和年老带
年轻代的垃圾回收叫 Young GC， 年老代的垃圾回收叫 Full GC。
在年轻代中经历了N次（可配置）垃圾回收后仍然存活的对象，就会被复制到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象
年老代溢出原因有 循环上万次的字符串处理、创建上千万个对象、在一段代码内申请上百M甚至上G的内存，既A B D选项
持久代溢出原因 动态加载了大量Java类而导致溢出

----下列哪个说法是正确的（）
正确答案: D
ConcurrentHashMap使用synchronized关键字保证线程安全
HashMap实现了Collction接口
Array.asList方法返回java.util.ArrayList对象
SimpleDateFormat是线程不安全的
解析：A选项中，ConcurrentHashMap 使用segment来分段和管理锁，segment继承自ReentrantLock，因此ConcurrentHashMap使用ReentrantLock来保证线程安全。
B中，HashMap定义规则如下：

C中，应该是Arrays.asList()，其将一个数组转化为一个List对象，返回一个ArrayList类型的对象， 这个ArrayList类并非java.util.ArrayList类，而是Arrays类的内部类：

---

正确答案: B
0
1
出现异常
解析：

----下面哪些类实现或者继承了Collection接口？
正确答案: B C
HashMap
ArrayList
Vector
Iterator
解析：

----下面哪些情况下需要使用抽象类？
正确答案: A B D
当一个类的一个或多个方法是抽象方法时
当类是一个抽象类的子类，并且不能为任何抽象方法提供任何实现细节或方法体时
当一个类实现多个接口时
当一个类实现一个接口，并且不能为任何抽象方法提供实现细节或方法体时
解析：A项 一个类中有抽象方法则必须申明为抽象类
B项 抽象类中的抽象方法必须由其子类实现，若子类不能实现则子类也必须定义为抽象类
D项 一个类实现一个接口就必须实现其中所有的抽象方法，若该实现类不能实现接口中的所有方法则实现类定义为抽象类

----以下哪些内存区域属于JVM规范？（　　）
正确答案: A D E
方法区
实例变量
静态变量
程序计数器
虚拟机栈
解析：JVM内存区：程序计数器、虚拟机栈、本地方法栈、堆、方法区（包括常量池）。
不属于JVM内存区：直接内存（Direct Memory），用户I/O操作

----以下哪种方式实现的单例是线程安全的
正确答案: A B C D
枚举
静态内部类
双检锁模式
饿汉式
解析：1.饿汉式(线程安全，调用效率高，但是不能延时加载)； 2.懒汉式(线程安全，调用效率不高，但是能延时加载)； 3.Double CheckLock实现单例：DCL也就是双重锁判断机制（由于JVM底层模型原因，偶尔会出问题，不建议使用）； 4.静态内部类实现模式（线程安全，调用效率高，可以延时加载）； 5.枚举类（线程安全，调用效率高，不能延时加载，可以天然的防止反射和反序列化调用）。

---

正确答案: A C D
同一个对象，分别调用方法a和b，锁住的是同一个对象
同一个对象，分别调用方法a和c，锁住的是同一个对象
同一个对象，分别调用方法b和c，锁住的不是同一个对象
同一个对象，分别调用方法a、b、c，锁住的不是同一个对象
解析：修饰非静态方法 锁的是this 对象
修饰静态方法 锁的是class对象

----final、finally和finalize的区别中，下述说法正确的有？
正确答案: A B
final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源的回收，例如关闭文件等。
引用变量被final修饰之后，不能再指向其他对象，它指向的对象的内容也是不可变的。
解析：A，D考的一个知识点，final修饰变量，变量的引用（也就是指向的地址）不可变，但是引用的内容可以变（地址中的内容可变）。
B，finally表示总是执行。但是其实finally也有不执行的时候，但是这个题不要扣字眼。

1. 在try中调用System.exit(0)，强制退出了程序，finally块不执行。
2. 在进入try块前，出现了异常，finally块不执行。
   C，finalize方法，这个选项错就错在，这个方法一个对象只能执行一次，只能在第一次进入被回收的队列，而且对象所属于的类重写了finalize方法才会被执行。第二次进入回收队列的时候，不会再执行其finalize方法，而是直接被二次标记，在下一次GC的时候被GC。

----关于volatile关键字，下列描述不正确的是？
正确答案: B D
用volatile修饰的变量，每次更新对其他线程都是立即可见的。
对volatile变量的操作是原子性的。
对volatile变量的操作不会造成阻塞。
不依赖其他锁机制，多线程环境下的计数器可用volatile实现。
解析：一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。

2）禁止进行指令重排序。

volatile只提供了保证访问该变量时，每次都是从内存中读取最新值，并不会使用寄存器缓存该值——每次都会从内存中读取。

而对该变量的修改，volatile并不提供原子性的保证。

由于及时更新，很可能导致另一线程访问最新变量值，无法跳出循环的情况

多线程下计数器必须使用锁保护。

----关于ThreadLocal类 以下说法正确的是
正确答案: D E
ThreadLocal继承自Thread
ThreadLocal实现了Runnable接口
ThreadLocal重要作用在于多线程间的数据共享
ThreadLocal是采用哈希表的方式来为每个线程都提供一个变量的副本
ThreadLocal保证各个线程间数据安全，每个线程的数据不会被另外线程访问和破坏
解析：Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。

----2020/4/21
以下关于构造函数的描述错误的是 （ ）
正确答案: A
每个类有且只能有一个构造函数。
构造函数是类的一种特殊函数，它的方法名必须与类名相同
构造函数的主要作用是完成对类的对象的初始化工作
一般在创建新对象时，系统会自动调用构造函数
解析：一个类可以自定义无穷多个构造函数。

----对接口的描述正确的是()
正确答案: A
一个类可以实现多个接口
接口可以有非静态的成员变量
在jdk8之前，接口可以实现方法
实现接口的任何类，都需要实现接口的方法
解析：A，一个类只能有一个直接父类，但是继承是有传递性的。一个类可以实现多的接口。一个接口可以继承多个类。
B，接口中没有普通变量（普通成员变量），接口中都是常量，默认修饰符：public static final
C，JDK8之前，接口中的方法都是默认public abstract的，JDK8之后，接口中可以有static、default的修饰的方法，一旦被修饰，方法必须有方法体（抽象方法可是没有方法体的），接口中的方法都不能被private和protected修饰，同时外部接口、类只能被public修饰或者不写，但是内部接口、类可以被四个访问修饰符修饰。
D， 实现接口，其实就是需要重写接口中的abstract方法，一旦实现的类没有重写完，那么这个类必须是个抽象类（抽象类中可以没有抽象方法，但是有抽象方法的类必须是抽象类）。

----有程序片段如下，以下表达式结果为 true 的是（ ）

Float s=new Float(0.1f);

Float t=new Float(0.1f);

Double u=new Double(0.1);
正确答案: B
s==t
s.equals(t)
u.equals(s)
t.equals(u)
解析：

----关于抽象类和接口叙述正确的是？ ( )

正确答案: 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

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

正确答案: B
final
void
protected
static
解析：A. final可以用来修饰方法和变量，修饰变量就变成了常量
B. void只能用来修饰方法
C. protected表示修饰的变量方法只允许同包和子类方法
D. static修饰的变量为静态Field，也叫做类Field，在内存中只存在一份，所有对象共享

----下列表述错误的是？（）

正确答案: D
int是基本类型，直接存数值，Integer是对象，用一个引用指向这个对象。
在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过
封装的主要作用在于对外隐藏内部实现细节，可以增强程序的安全性
final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性。
解析：抽象类：子类继承重写
final：不允许重写

----
正确答案: B
Load B ->Create B->Load A -> Create A
Load B -> Load A ->Create B ->Create A
Load B -> Create B-> Create A -> Load A
Create B ->Create A ->Load B ->Load A
解析：初始化块在构造器执行之前执行，类初始化阶段先执行最顶层父类的静态初始化块，依次向下执行，最后执行当前类的静态初始化块；创建对象时，先调用顶层父类的构造方法，依次向下执行，最后调用本类的构造方法。
执行顺序：
父类静态代码块-》子类静态代码块-》父类构造代码块-》父类构造函数-》子类构造代码块-》子类构造函数

-----2020/4/22

----关于static说法不正确的是（ ）

正确答案: D
可以直接用类名来访问类中静态方法(public权限)
静态块仅在类加载时执行一次
static方法中不能有用this调用的方法
不可以用对象名来访问类中的静态方法(public权限)

解析：this表示当前类的对象，由static修饰的方法是由类直接调用，不需要创建对象，所以在static里不能用this.
A、静态方法属于类本身，可以使用类名调用。
B、静态块只执行一次。
C、static块和方法不能出现this和super
D、可以的，实例对象也可以调用静态方法。

----关于Float，下列说法错误的是()
正确答案: C
Float是一个类
Float在java.lang包中
Float a=1.0是正确的赋值方法
Float a= new Float(1.0)是正确的赋值方法

解析：Float是类，float不是类.
查看JDK源码就可以发现Byte，Character，Short，Integer，Long，Float，Double，Boolean都在java.lang包中.
Float正确复制方式是Float f=1.0f,若不加f会被识别成double型,double无法向float隐式转换.
Float a= new Float(1.0)是正确的赋值方法，但是在1.5及以上版本引入自动装箱拆箱后，会提示这是不必要的装箱的警告，通常直接使用Float f=1.0f.

Float a = new Float(1.0); 这个的东西能存在，是因为Float类中有形参是float和double的两个构造器。
Double d = new Double(1.0F);这个能成立的原因是float向上转型了。
Float a = 1.0；这个东西不成立是因为浮点型的默认类型是double，而double不会自动转成float，然后再装箱。
Double d = 1.0f；不成立的原因是因为Double类中的装箱方法，只有valueOf(String s)和valueOf(double d)；装箱本身可不会自动向上转型啊。

----下列关于异常处理的描述中，错误的是()。

正确答案: D
程序运行时异常由Java虚拟机自动进行处理
使用try-catch-finally语句捕获异常
可使用throw语句抛出异常
捕获到的异常只能在当前方法中处理，不能在其他方法中处理
解析：捕获到的异常不仅可以在当前方法中处理，还可以将异常抛给调用它的上一级方法来处理。

---

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

----关于 Socket 通信编程，以下描述正确的是：（ ）

正确答案: C
客户端通过new ServerSocket()创建TCP连接对象
客户端通过TCP连接对象调用accept()方法创建通信的Socket对象
客户端通过new Socket()方法创建通信的Socket对象
服务器端通过new ServerSocket()创建通信的Socket对象

解析：
客户端通过new Socket()方法创建通信的Socket对象
服务器端通过new ServerSocket()创建TCP连接对象 accept接纳客户端请求

----关于匿名内部类叙述正确的是？ ( )
正确答案: B
匿名内部类可以继承一个基类，不可以实现一个接口
匿名内部类不可以定义构造器
匿名内部类不能用于形参
以上说法都不正确
解析：由于构造器的名字必须与类名相同，而匿名类没有类名，所以匿名类不能有构造器。

----ArrayList list = new ArrayList(20);中的list扩充几次
正确答案: A
0
1
2
3
解析：在创建时直接分配了数组的大小，没有扩充

----
正确答案: B
2744
13
17
11
解析：^表示异或 就是相同是0 不同是1
14是1110
3是0011
所以14^3=1101，即13
按位或|
按位且&
按位取反~
按位异或^
逻辑与&&
逻辑或||
非!

----关于Java语言描述正确的是？ ( )
正确答案: B
java和C++都保留了指针
java和C++都有三个特征：封装、继承和多态
java的垃圾回收机制是指程序结束时系统自动回收内存
以上说法都不正确

解析：A，Java没有指针，只有引用。
C，并不是程序结束的时候进行GC，GC的时间是不确定的，且GC的过程需要经过可达性分析，一个对象只有被标记两次才会被GC。

----
正确答案: C
1
-(2⁶²⁺²61+2^60+1)
2⁶²⁺²61+2^60+1
2⁵⁹⁺⁽²55+2^54+…+22+2¹⁺²0)
解析：

----URL u =new URL(“http://www.123.com”);。如果www.123.com不存在，则返回______。
正确答案: A
http://www.123.com
””
null
抛出异常
解析：

----下面哪些具体实现类可以用于存储键，值对，并且方法调用提供了基本的多线程安全支持：()
正确答案: A E
java.util.ConcurrentHashMap
java.util.Map
java.util.TreeMap
java.util.SortMap
java.util.Hashtable
java.util.HashMap
解析：线程安全的map:HashTable,SynchronizedMap,ConcurrentHashMap

----如果进栈序列为e1，e2，e3，e4，则可能的出栈序列是()
注：一个元素进栈后可以马上出栈，不用等全部进栈
正确答案: B C
e3，e1，e4，e2
e2，e4，e3，e1
e2，e3，e4，e1
任意顺序都有可能

解析：栈的规则：先进后出
例如进栈序列为：1，2，3，4
全部进栈完成再出栈的序列则为：4，3，2，1
注：一个元素进栈后可以马上出栈，不用等全部进栈

例如：2这个元素一进就想出了，后面的3，4正常进栈再出栈。
那么出栈顺序就是：2，4，3，1 (1是第一个进的，进的时候也没有立刻出去，所以被压在栈底，最后才能出去）

例如：2这个元素一进就想出了，后面的3一进也想立刻想出去了，后面的4跟着进栈
那么出栈顺序就是：2，3，4，1 (2，3都进了立刻出 所以这时4压着的是1，所以出栈顺序是4在前面）

----下面有关Java的说法正确的是（ ）
正确答案: A C D F
一个类可以实现多个接口
抽象类必须有抽象方法
protected成员在子类可见性可以修改
通过super可以调用父类构造函数
final的成员方法实现中只能读取类的成员变量
String是不可修改的，且java运行环境中对string对象有一个对象池保存

解析：

A对：java类单继承，多实现
B错：被abstract修饰的类就是抽象类，有没有抽象方法无所谓
C错：描述有问题。
D对。
E错：final修饰的方法只是不能重写，static修饰的方法只能访问类的成员变量
F对。

----下面描述属于java虚拟机功能的是？
正确答案: A B C D
通过 ClassLoader 寻找和装载 class 文件
解释字节码成为指令并执行，提供 class 文件的运行环境
进行运行期间垃圾回收
提供与硬件交互的平台
解析：B中JVM将字节码转换成不同平台(OS)下可执行的机器码指令。D中说的与硬件交互是JVM机器指令与硬件的交互。

----java运行时内存分为“线程共享”和“线程私有”两部分，以下哪些属于“线程共享”部分
正确答案: B D
程序计算器
方法区
java虚拟机栈
java堆

解析：私有线程区域：
程序计数器、虚拟机栈、本地方法栈
线程共享区域：
堆、方法区

----
正确答案: B C D
语句2
语句1
语句3
语句4
解析：语句1错误：b3=(b1+b2);自动转为int，所以正确写法为b3=(byte)(b1+b2);或者将b3定义为int；
语句2正确：b6=b4+b5;b4、b5为final类型，不会自动提升，所以和的类型视左边变量类型而定，即b6可以是任意数值类型；
语句3错误：b8=(b1+b4);虽然b4不会自动提升，但b1仍会自动提升，所以结果需要强转，b8=(byte)(b1+b4);
语句4错误：b7=(b2+b5); 同上。同时注意b7是final修饰，即只可赋值一次，便不可再改变。

----2020/4/23

----@SuppressWarnings(“deprecation”)的功能是什么？
正确答案: A
屏蔽不赞同使用的类和方法的警告
屏蔽在强制类型转换的时候编译器给出的警告
关闭所有警告信息
当在可序列化的类上缺少serialVersionUID定义的警告

解析：1.Java三大注解分别是@Override @Deprecated @Suppresswarnings
2.@Override 注解表名子类中覆盖了超类中的某个方法，如果写错了覆盖形式，编译器会报错
3.@Deprecated 表明不希望别人在以后使用这个类，方法，变量等等
4.@Suppresswarnings 达到抑制编译器产生警告的目的，但是不建议使用，因为后期编码人员看不懂编译器提示的警告，不能更好的选择更好的类去完成任务

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

解析：
这道题严格来讲没有正确答案：
A、普通方法可以与类名相同，加上返回值表示这是一个普通方法，而不是一个构造方法。
B、该类没有声明有参构造，默认会提供一个无参构造。
C、这里说法有问题，该类并不是没有构造函数，而是没有声明一个int类型参数的有参构造，所以(3)这个地方会报错。
D、不解释了。

----
正确答案: A
ABDCBDCB
ABCDABCD
编译时出错
运行时抛出异常
解析：for（循环开始条件；判断条件；循环后条件）
按照执行顺序依次执行。

----假设 A 类有如下定义，设 a 是 A 类的一个实例，下列语句调用哪个是错误的？（）
public class A

{

public int i;

static String s;

void method1(){}

static void method2(){}

}
正确答案: C
System.out.println(a.i);
a.method1();
A.method1();
A.method2();

解析：静态成员和静态方法，可以直接通过类名进行调用；其他的成员和方法则需要进行实例化成对象之后，通过对象来调用。

----A 派生出子类 B ， B 派生出子类 C ，并且在 java 源代码有如下声明：

1. A a0=new A();

2. A a1=new B();

3. A a2=new C();

问以下哪个说法是正确的？（）
正确答案: D
只有第一行能通过编译
第1、2行能通过编译，但第3行编译出错
第1、2、3行能通过编译，但第2、3行运行时出错
第1行，第2行和第3行的声明都是正确的
解析：这道题的考点是Java的继承关系。B继承于A，C继承于B，所以A为B和C共同的父类。
4. A a0=new A();这种是正常和常见的声明。
5. A a1=new B();类型的向上提升。
6. A a2=new C();类型的向上提升。

---