Java题目

最新推荐文章于 2024-03-29 10:08:47 发布

THECCCSM

最新推荐文章于 2024-03-29 10:08:47 发布

阅读量3.1k

点赞数 2

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/weixin_45972870/article/details/123077072

版权

Java 专栏收录该内容

7 篇文章 1 订阅

订阅专栏

Java题目

1.18日记录

1、以下类定义中的错误是什么？

2、分析一下 “ == ” 和 equals 的区别？

首先，我们看一下源码

    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

注解：

this 关键字

首选：this关键字指向的是当前对象的引用

作用：this.属性名称

指的是访问类中的成员变量，用来区分成员变量和局部变量（重名问题）

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

1月23日

第一

ArrayList和Vector主要区别是什么？

Vector 和 ArrayList 的主要区别？

1、同步性：Vector是线程安全的，也就是线程同步的，而ArrayList是线程不安全的，不是同步的
2、数据增长：当需要增长时，Vector默认增长为原来一倍，而ArrayList却是原来的50%，这样，ArrayList就有利于节约内存空间。如果涉及到堆栈，队列等操作，应该考虑用Vector，如果需要快速随机访问元素，应该使用ArrayList。
拓展知识：
- 1、Hashtable 和 HashMap
  - Hashtable的方法是同步的，而HashMa的不是
- 2、ArrayList 和 LinkedList
  - ArrayList的内部实现是基于内部数组Object[],所以从概念上讲,它更象数组，但LinkedList的内部实现是基于一组连接的记录，所以，它更象一个链表结构，所以，它们在性能上有很大的差别：
    从上面的分析可知,在ArrayList的前面或中间插入数据时,你必须将其后的所有数据相应的后移,这样必然要花费较多时间，所以,当你的操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；而访问链表中的某个元素时,就必须从链表的一端开始沿着连接方向一个一个元素地去查找,直到找到所需的元素为止，所以,当你的操作是在一列数据的前面或中间添加或删除数据，并且按照顺序访问其中的元素时，就应该使用LinkedList了。

Java中下面哪些是Object类的方法（）

1、clone（）创建并返回一个对象的拷贝
2、equals（）比较两个对象是否相等
3、finalize（）。当GC确定不存在对该对象有更多的引用时，由对象的垃圾回收器调用此方法
4、getClass（）获取对象的运行时对象的类
5、notify（） notifyAll（）唤醒在该对象上等待的线程
6、hashCode（）获取该对象的hash值
7、toString（）返回对象的字符串的表示形式
8、wait（）让线程处于等待状态，直到其他线程上调用此对象的notify 或 notifyAll方法，或者通过参数设置timeout时间

知识点

Java表达式转型规则由低到高转换：

1、所有的btye、short、char值将被提升到int型
2、如果有一个操作数时long型，计算结果时long型
3、如果有一个操作数时float型，计算结果时float型
4、如果有一个操作数时double型，计算结果时double型
5、被final修饰的变量不会自动改变类型，当2个final修饰相操作时，结果会根据左边的变量的类型而转换。

在运行时，由java解释器自动引入，而不用import语句引入的包是（）

1、java.lang 是java语言的核心包 lang是language的缩写定义了一些基本的类型，包括Integer、String至类的，是java 程序必备的包，有解释器子哦那个引入，无需手动引入
2、java.io 各种输入输出流，需要手动引入
3、java.util java的工具包，需要手动引入

在java中属于整数类型变量的是（）

java中的四类八种基本数据类型：

第一类：整数类型 byte short int long
第二类：浮点型 float double
第三类：逻辑性 boolean 布尔型只有两个值可以取 true false
第四类：字符类 char

list是一个ArrayList的对象，哪个选项的代码填到//todo delete处，可以在Iterator遍历的过程中正确并安全的删除一个list中保存的对象？（）

源码是这样描述的：ArrayList继承了AbstractList，其中AbstractList中有个modCount代表了集合修改的次数。在ArrayList的iterator方法中会判断expectedModCount与modCount是否相等，如果相等继续执行，不想等报错，只有iterator的remove方法在调用自身的remove之后让expectedModCount与modCount再相等，所以是安全的。

在J2EE中，使用Servlet过滤器，需要在web.xml中配置()元素

Servlet过滤器的配置包括两部分

第一部分是过滤器在Web应用中的定义，由元素表示，包括和两个必须的子元素

第二部分是过滤器映射的定义，由元素表示，可以将一个过滤器映射到一个或这多个Servler或JSP文件，也可以采用url-patern将过滤器映射到任意特征的URL。

关于ASCLL码和ANSI码，以下说法不正确的是（）

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

A、标准ASCII只使用7个bit，扩展的ASCII使用8个bit。

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

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

D、ASCII码包含一些特殊空字符

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

在static方法中是不能访问非静态变量a的，需要将a声明为static，答案才是0，否则编译出错

一般情况下，以下哪个选项不是关系数据模型与对象模型模型之间匹配关系？

一般关系数据模型和对象模型之间有以下对应关系：表对应类，记录对应对象，表的字段对应类的属性

java运行时内存分为“线程共享”和“线程私有”两部分，以下哪些属于“线程共享”部分？

私有：java虚拟机，程序计数器，本地方法栈共享：java堆，方法区

共享的资源有：

1、堆由于堆是在进程空间中开辟出来的，所以它是理所当然地被共享的；因此new出来的都是共享的
2、全局变量它是与具体某一函数无关，所以也与特定线程无关，因此也是共享的
3、静态变量虽然对于局部变量来说，它在代码中是“放”在某一函数中的，但是其存在位置和全局变量一样，存在堆中开辟的.bss 和 .data段，是共享的
4、文件等公用资源这个是共享的，使用这些公共资源的线程必须同步。

独享的资源：

1、栈栈是独享的
2、寄存器计数器PC

正则表达式的知识点

1、普通字符

字母、数字、汉字、下划线、以及后边章节中没有特殊定义的标点符号，都是“普通字符”。表达式中的普通字符，在匹配一个字符串的时候，匹配与之相同的一个字符。

2、简单的转义字符

一些不便书写的字符，采用在前面加“"的方法，这些字符其实我们都已经熟知了。

表达式	可匹配
\r,\n	代表回车和换行符
\t	制表符
/	代表"/"本身

还有其他一些在后边章节中有特殊用处的标点符号，在前面加“\”后，就代表该符号本身，比如：^, $ 都有特殊意义，如果要想匹配字符串中 “^” 和 “ $KaTeX parse error: Undefined control sequence: \* at position 19: …符，则表达式就需要写成 "**\̲*̲*^" 和 "**\**$ ”。

3、能够与“多种字符”匹配的表达式

正则表达式中的一些表示方法，可以匹配“多种字符”其中的任意一个字符。比如，表达式“/d”可以匹配人意一个数字。虽然可以匹配其中任意字符，但是只能是一个不能是多个。

4、自定义能够匹配‘多种字符’的表达式

使用方括号[]包含一系列字符，能够匹配其中任意一个字符。用[^]包含一系列字符，则能够匹配其中字符之外的任意一个字符。同样的道理，虽然可以匹配其中任意一个，但只能是一个，不是多个。

5、修饰匹配次数的特殊符号

关于异常的编程，一下描述错误的是：（）

1、在有除法存在的代码处，为了防止分母为0，必须抛出异常
2、int i = Integer.parseInt(“123a”);将产生NumberFormatException
3、int a[]=null; a[0]=1; 将产生NullPointerException
4、输入输出流编程中，读和写时都要抛出IOException

java的异常分为两种，一种是运行时异常(RuntimeException)，一种是非运行时异常也叫做检查式异常(CheckedException)

1、运行时异常不需要程序员去处理，当异常出现时，JVM会帮助处理。常见的运行时异常有：
- ClassCastException（类转换异常）
- ClassNotFoundException
- IndexOutOfBoundException（数组越界异常）
- NullPointerException（空指针异常）
- ArrayStoreException(数组存储异常，即数组存储类型不一致)
- 还有IO操作的BufferOverflowException
2、非运行异常需要程序员手动去捕获或抛出异常进行显示的处理，因为java认为Checked异常都是可以被修复的异常。常见的异常有：
- IOException
- SqlException

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k236uloG-1645534258260)(/Users/chenshimiao/Library/Application Support/typora-user-images/image-20220128163151437.png)]

线程局部存储TLS（thread local storage）

TLS技术：

同一全局变量或者静态变量每个线程访问的是同一变量，多个线程同时访问同一全局变量或者静态变量时会导致冲突，尤其是多个线程同时需要修改这一个变量时。

通过TSL机制，为每一个使用该全局变量的线程都提供一个变量值的副本，每一个线程均可以独立地改变自己的副本，而不会和其它线程的副本冲突。

1、解决多线程中的对同一变量的访问冲突的一种技术

2、TLS会为每一个线程维护一个和该线程绑定的变量的副本

3、JAVA平台的java.long.ThreadLocal是TLS技术的一种实现。

ThreadLocal：

ThreadLocal存放的值是线程封闭的，线程间互斥；

ThreadLocal是采用哈希表的方式来为每个线程都提供一个变量的副本

主要用于线程内共享一些数据，避免通过参数来传递

ThreadLocal保证每个线程间数据安全，每个线程的数据不会被另外线程访问和破坏

Synchronized用于线程

下面哪个Set类是按元素排好序的？

A、LinkedHashSet
B、TreeSet
C、HashSet
D、AbstarctSet

TreeSet自然排序，LinkedHashSet按添加顺序排序

LinkedHashSet继承于HashSet、又基于LinkedHashMap来实现

TreeSet

使用二叉树的原理对新add()的对象按照指定的顺序排序(生序、降序)，没增加一个对象都会进行排序，将对象插入的二叉树枝顶的位置

HashSet

存储元素的顺序并不是按照存入时的顺序（和List显然不同）而是按照哈希值来存的所以取数据也是按照哈希值取得

不能用来修饰interface的有() （仅限外部接口）

1、抽闲类中的抽象方法（其前有abstarct修饰）不能用private、static、synchronized、native访问修饰符修饰。原因如下：抽象方法没有方法体，是用来继承的，所以不能用private修饰；static修饰的方法可以通过类名来访问该方法（即该方法的方法体），抽象方法用static修饰没有意义；使用synchronized关键字是该方法加一个锁。而如果该关键字修饰的方法是static方法，则使用的锁就是class变量的锁。如果是修饰类方法，则使用this变量锁。但是抽闲类不能实例化对象，因为该方法不是在该抽象类中实现的。是在其子类实现的。所以，锁应该归期子类所有。所以，抽象方法也就不能用synchronized关键字修饰了；native，这个东西本身就和abstract冲突，他们都是方法的声明，只是一个把方法实现交给子类，另一个移交给本地操作系统。如果同时出现，就相当于把实现移交给子类，又把实现移交给本地操作系统，那到底谁来实现具体方法呢？

2、接口是一种特殊的抽象类，接口中的方法全部都是抽象方法(但其前边的abstarct可以省略)，所以抽象类中的抽象方法不能用的访问修饰符这里也不能使用。而且proteced访问修饰符也不能使用，因为接口可以让所有的类取实现，不只是其子类，但是要用public去修饰。接口可以去继承一个已有的接口。

关于Java内存区域下面说法不正确的有哪些？

一、程序计数器

一块较小的内存空间，可以看作是当前线程所执行的字节码的信号指示器。在虚拟机的概念模型里面，字节码解释器工作时就是通过改变这个计数器的值来选去下一条需要执行的字节码指令，它是程序控制流的指示器，分支、循环、跳转、异常处理、线程恢复等基础功能都需要以这个计数器完成。

由于Java虚拟机的多线程是通过线程轮流切换、分配处理器时间的方式来实现，在任何一个确定的时刻，一个处理器（对于多核处理器来说就是一个内核）都只会执行一条线程中的指令。因此，为了线程切换后能恢复到正常的执行位置，每条线程都需要有一个独立的程序计数器，各条线程之间的计数器互不影响，独立存储，我们称这类内存区域为“线程私有”的内存。

如果线程正在执行的是一个Java方法，计数器记录的是正在执行的虚拟机字节码指令的地址；如果正在执行的是本地方法，计数器值应为空。

二、Java虚拟机栈

与程序计数器一样，他也是线程私有的。

Java虚拟机栈描述的是Java方法执行的线程内存模式。

每个方法被执行的时候，Java虚拟机都会同步创建一个栈帧用于存储局部变量表、操作数栈、动态连接、方法出口等信息。每一个方法被调用直至执行完毕的过程，就对应着一个帧栈在虚拟机栈中从入栈到出栈的过程。

三、Java堆

Java堆（Java Heap）虚拟机管理的内存中最大的一块。Java堆是被所有线程共享的一块内存区域，在虚拟机启动时创建。

此内存的唯一目的就是：存放对象实例

因此，Java堆也是垃圾收集器管理的内存区域。

四、方法区

与Java堆一样，方法区市各个线程共享的内存区域，用于存储已经被虚拟机加载的类型信息、常量、静态变量、即时编译器编译后的代码缓存等数据。

内部类（也叫成员内部类）可以有4种访问权限。

关于下面代码 int[] x = new int[25];描述正确的是（）

x[24]存的是默认值0 （java中没有’\0’这一说）

以下代码执行的结果显示是多少（）？

finally一定会在return之前执行，但是如果finally使用了return或者throw语句，将会使try catch中的return或throw失效

int result = 2/4; result 结果为0

在java7中，下面哪个说法是正确的？

A、ConcurrentHashMap 使用 synchronized关键字保证线程安全
B、HashMap实现Collention接口
C、Arrays.asList方法返回java.util.ArrayList对象
D、SimpleDateFormat对象是线程不安全的

hashMap在单线程中使用大大提高效率，在多线程的情况下使用hashTable来确保安全。hashTable使用synchronized关键字来实现安全机制，但是synchronized是对整张hash表进行锁定即让线程独享整张hash表，在安全同时造成了浪费。concurrentHashMap采用分段加锁的机制来确保安全。

Arrays.asList()

将一个数组转化为一个List对象，这个方***返回一个ArrayList类型的对象，这个ArrayList类并非java.util.ArrayList类，**而是Arrays类的静态内部类！**用这个对象对列表进行添加删除更新操作，就会报UnsupportedOperationException异常。

@SupperssWarnings(“deprecation”) 的功能是什么？

A、屏蔽不赞同使用的类和方法的警告
B、屏蔽在强制类型转换的时候编译器给出的警告
C、关闭所有警告信息
D、当在可序列化的类上缺少serialVersionUID定义的警告

本题考查注解编程，对java三大注解是否了解：

@SupperssWarnings这是java三大注解之一，主要功能是屏蔽相应的警告

里面的deprecation修饰符则是最java中已经过时或者废弃方法的警告

@Override 注解表明子类中覆盖了超类中的某个方法，如果写错了覆盖形式，编译器就会报错

@Deprecated 表明不希望别人在以后使用这个类，方法，变量等等

以下哪些继承自Collection接口（）

A、List
B、Set
C、Map
D、Array

正确答案：A B

Collection接口：

1、List接口：内容允许重复
1、ArrayList 2、LinkedList，也实现了Queue接口 3、Vector

区别：

1、ArrayList是Array（动态数组）的数据结构，LinkedList是link（链表）的数据结构
2、当随机访问list（get和set操作）时，ArrayList比LinkedList的效率要高，因为LinkedList是线性的数据存储方法，所以需要移动指针从前往后依次查找。
3、

下面的对象创建方法中哪些会调用构造方法（）？

A、new语句创建对象
B、调用Java.io.ObjectInputStream的readObject方法
C、Java反射机制使用java.lang.class或java.lang.reflect.Constructor的newInstance（）方法
D、调用对象的clone（）方法

构造函数的作用是完成对象的初始化。当程序执行到new操作符时，首先去看new操作符后面的类型，因为知道了类型，才知道要分配多大的内存空间。分配完内存之后，填充对象的各个域，这一步叫做对象的初始化。

题目的四个选项是构造方法new，序列化对象，反射，克隆分别创建一个对象的方法，只有new和反射用到了构造方法。

以下关于final关键字说法错误的是（）

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

A：接口和抽闲类不能是final的，它们需要被实现和继承

C：重载和重写要区分开，父子之间是重写，同一个类里面是重载，final修饰的子类没法重写，而不是重载

定义如下：

A、1
B、1f
C、运行报错
D、编译报错

在这一题之前，我们首先了解一下什么叫自动装箱和拆箱

1、自动装箱，自动拆箱

装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型。

java的数据类型

基本数据类型：

1、数值型：分为整型和浮点
- 整型：byte，short，int，long
- 浮点：float，double

简单类型	二进制位数	封装类型
int	32	Integer
byte	8	Byte
long	64	Long
float	32	Float
double	64	Double
char	16	Character
boolean	1	Boolean

自动装箱：

public static void main(String[] args) {
    int a = 3;
    //定义一个基本数据类型的变量a赋值3
    Integer b = a;
    //b是Integer类定义的对象，直接用int类型的a赋值
    System.out.println(b);
    //打印结果为3
}

最主要的就是Integer b = a;这行代码执行了什么？其实就是自动装箱的过程；上边程序在执行Integer b = a；的时候就调用了Integer.valueof(int i)方法，Integer b = a 相当于 Integer b = Integer.valueOf(a)

自动拆箱：

public static void main(String[] args) {
    //自动拆箱
    Integer a = new Integer(3);
    int b = a;
    System.out.println(b);
}

其实int a = b,这段代码等价于：int b = a.intValue()

intValue函数：

public int intValue(){
  return value;
}

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

类的初始化过程也就是方法执行的过程。

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

要导入java/awt/event下面的所有类，叙述正确的是（）

答案：只能是import java.awt.event.*

导包只可以导到当前层，不可以再导入包里面的包中的类

好比穿了衣服不一定穿了内衣，你也不能证明你穿了内衣，要穿内衣还是需要特别说明一下已经穿过内衣了。

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

public class Test{
  public static void main(String args[]){
    int i = -5;
    i = ++(i++);
    System.out.println(i);
  }
}

A、-7
B、-3
C、编译错误
D、-5

答案是这里是编译错误

这题编译错误在于这一句： i = ++（i++);

++（）括号里面必须是一个变量，而i ++是一个字面量

下面说法正确的是（）

A、在类方法中可用this来调用本类的类方法
B、在类方法中调用本类的类方法可以直接调用
C、在类方法中只能调用本类中的类方法
D、在类方法中绝对不能调用实例方法

在了解这个题目之前，我们首先来了解一下什么叫做类方法和实例方法？

1、声明方法时，方法类型前面不使用static修饰的是实例方法，用static修饰的方法是类方法。与实例无关

例如：

class Student{
  //实例方法
	int sum(int a,int b){
    return a + b;
  }
  //类方法
  static void run(){
    .....
  }
}

解释：Student类中包含有两个方法，其中sum方法是实例对象，run方法是类方法，也称静态方法。在声明类方法时，需要将static修饰符放在类型的前面。

实例方法和类方法的区别

1、使用对象调用实例类型方法

2、使用类名调用方法类

在类方法中不能有this关键字,直接调用类方法即可。

在类方法中可以通过创建实例对象调用类的实例方法

程序

class Foo{
  final int i;
  int j;
  public void doSomething(){
   	System.out.println(++j + i);
  }
}

A、0
B、1
C、2
D、不能执行，因为编译有错

解析：final类型的变量一定要初始化，因为final的变量不可更改。

File类的一下常用方法和说明

File类能操作文件本身，但不能对文件内容进行修改

2022年2月11日

关于访问权限说法正确的是（）？

A、外部类定义前面可以修饰public、protected和private
B、局部内部类前面可以修饰public、protected和private
C、匿名内部类前面可以修饰public、protected和private
D、以上说法都不正确

在java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类，广泛意义上的内部类一般包括四种：成员内部类、局部内部类、匿名内部类、静态内部类。

1、成员内部类

（1）该类像是外部类的一个成员，可以无条件的访问外部类的所有成员属性和成员方法（包括private成员和静态成员）；

（2）成员内部类拥有与外部类同名的成员变量时，会发生隐藏现象，即默认情况下访问的是成员内部类中的成员。如果要访问外部类中的成员，需要以下形式访问：【外部类.this.成员变量或外部类.this.成员方法】；

（3）在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问；

（4）成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象；

（5）内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。如果成员内部类用private修饰，则只能在外部类的内部访问；如果用public修饰，则任何地方都能访问；如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。外部类只能被public和包访问两种权限修饰。

2.局部内部类

（1）局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内；

（2）局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

3.匿名内部类

（1）一般使用匿名内部类的方法来编写事件监听代码；

（2）匿名内部类是不能有访问修饰符和static修饰符的；

（3）匿名内部类是唯一一种没有构造器的类；

（4）匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。

4.内部静态类

（1）静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似；

（2）不能使用外部类的非static成员变量或者方法。

外部类前可以修饰：public、default、abstract、final

内部类前可以修饰：public、protected、default、private、abstract、final、static

局部内部类前可以修饰：abstract、final

byte + byte = int ,低级向高级是隐式类型转换，高级向低级必须强制类型转换，byte < char < short < int < long < float < double

默认RMI采用的是什么通讯协议？

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

已知如下类说明：

public class NewBull1 {

    //首先说明一个浮点型的数据
    private float f = 1.0f;
    int m = 12;
    static int n = 1;

    public static void main(String[] args) {
        NewBull1 newBull1 = new NewBull1();
        /**
         * 测试
         *  t.f = 1.0
         *      首先，这个1.0是一个浮点型，但是浮点型的默认值是double型，则从double转换到float，是从高精度（double）向低精度（float）转型，
         *  所以会报错 但是若是float f = 1；这里是默认类型是int类型，精度由低（int）向高精度（float）不会丢失精度不会报错
         *  this.n
         *      this的使用时针对方法内部使局部变量等值与实例变量而使用的一个关键字，此处的n是静态变量而非实例变量，所以this会在此处报错
         *  Test.m
         *      m是实例变量，什么是实例变量，就是需要new一个对象出来才能使用的，这里直接用类名就调用了，jvm怎么知道m是谁？
         */
    }
}

下面这段Java代码，当T分别是引用类型和值类型的时候，分别产生了多少个T对象和T类型的值？

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

A、1 1
B、2 1
C、2 2
D、1 2

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

Java中值类型和引用类型的不同？

引用类型表示你操作的数据是同一个，也就是说当你传一个参数给另一个方法时，你在另一个方法中改变这个变量的值

那么调用这个方法是传入的变量的值也将改变。

值类型表示复制一个当前变量传给方法，当你在这个方法中改变这个变量的值时，最初生命的变量的值不会变。

2月12日

jre判断程序是否执行结束的标准是（）

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

其实这个题，就是说守护线程和非守护线程（用户线程）的问题。后台线程就是守护线程，前台线程就是用户线程。

守护线程：是指在程序运行时在后台提供一种通用服务的线程，这种线程并不是必须的。同时守护线程的线程优先级都很低的。JVM中的GC线程就是一个守护线程，只要JVM启动，GC线程就启动了。

对Collection和Collections描述正确的是

A、Collection是java.util下的类，它包含有各种有关集合操作的静态方法
B、Collection是java.util下的接口，它是各种集合结构的父接口
C、Collections是java.util下的接口，它是各种集合结构的父接口
D、Collections是java.util下的类，它包含各种有关集合操作的静态方法

java.util.Collection 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java类库中有很多具体的实习。Collection接口的意义就是为各种具体的集合提供了最大化的统一操作方式。

java.util.Collection是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就想一个工具类，服务与java的Collection框架。

在JDK1.7中，下面说法中抽象类与接口的区别与联系正确的有哪些？

A、抽象类中可以有普通成员变量，接口中没有普通成员变量。
B、抽象类和接口中都可以包含静态成员常量。
C、一个类可以实现多个接口，但只能继承一个抽象类
D、抽象类中可以包含非抽象的普通方法，接口中的方法必须是抽象的，不能有非抽象的普通方法

接口(interface)可以说成是抽象类的一种特例，接口中的所有方法必须是抽象的。接口中的方法定义默认为public abstarct类型，接口中的成员变量默认为public static final。另外，接口和抽象类在方法上有区别：

1、抽象类可以有构造方法，接口中不能有构造方法。

注解：关于构造方法

Java中的构造方法是一种特殊的方法，用于初始化对象。Java构造函数在对象创建时被调用。它构造值，即提供对象的数据。

创建Java构造函数的规则

构造函数基本上定义了两个规则。分别如下：

构造函数名必须与其类名称相同
构造函数必须没有显式返回类型

Java构造函数类型

有两种类型的构造函数

默认构造函数（无参数构造函数）
参数化构造函数

1.Java默认构造函数

没有参数的构造函数称为默认构造函数。默认构造函数的语法如下：

<class_name>(){}

默认构造函数的示例：

在这个例子中，在Bike类中创建了无参数(no-arg)构造函数。它将在对象创建时被调用。
class Bike1{
Bike1(){
   System.out.println("This is a GouZaoHanShu");
}
public static void main(String[] args) {
   Bike1 bike  = new Bike1();     
}
}
默认构造函数的目的是为对象提供默认值，如：0，null等。

显示默认值的默认构造函数示例
      class Student3 {
          int id;
          String name;
          void display(){
              System.out.println(id + " " + name);
          }
      }
在上边代码中我们并没有为其提供构造函数，但是我们在输出是会发现其是有值的，这就是在上边的类中，代码中并没创建任何构造函数，但编译器自动提供了一个默认构造函数。默认构造函数分别为字段：id和name分别提供了0和null

2.Java参数化构造函数

参数化构造函数用于为不同对象提供不同初始化的值。

示例：

在构造函数中我们可以添加任意多少的参数
  int id;
  String name;

  GouZaoHanShu2(int id,String name){
      this.id = id;
      this.name = name;
  }

  void display(){
      System.out.println(id + " " + name);
  }

  public static void main(String[] args) {
      GouZaoHanShu2 g1 = new GouZaoHanShu2(111,"zhangsan");
      GouZaoHanShu2 g2 = new GouZaoHanShu2(222,"lisi");

      g1.display();
      g2.display();
  }
3.Java构造函数重载

构造方法重载是Java中的一种技术，一个类可以有任何数量的参数列表不同的构造函数。编译器通过构造函数参数列表中的参数数量以及其类型来区分这些构造函数。

特点抽象类接口
构造方法有无
普通成员变量有无
普通方法可以有非抽象的必须是抽象的
抽象方法的访问类型 public、protected和默认只能是public的，默认public abstract
静态方法可以有无
静态成员变量有有 public static final的
其他类只能继承一个抽象类可以实现多个接口
应用场景模块之间通信契约代码重用

抽象类简介

将抽象类定义为“包含抽象方法的类”，但是后面发现如果一个类中不包含抽象方法，只是用abstract修饰的话也是抽象类。也就是活抽象类不一定必须含有抽象方法。
public abstarct class ClassName {
abstarct void fun();
}

特点	抽象类	接口
构造方法	有	无
普通成员变量	有	无
普通方法	可以有非抽象的	必须是抽象的
抽象方法的访问类型	public、protected和默认	只能是public的，默认public abstract
静态方法	可以有	无
静态成员变量	有	有 public static final的
其他类	只能继承一个抽象类	可以实现多个接口
应用场景	模块之间通信契约	代码重用

2021年2月13日

下面有关maven和ant的描述，描述错误的是？

A、Ant没有正式的约定如一个一般项目的目录结构，你必须明确告诉Ant哪里去找源代码
B、Maven拥有约定，因为你遵循了约定，它已经知道你的源代码在哪里
C、Maven和Ant都有”生命周期”的概念，当你输入一个命令后，Maven和Ant会执行一系列的有序的步骤，直到到达你指定的生命周期
D、Ant构建文件默认名称为build.xml，Maven默认构建文件为pom.xml

Ant和Maven都是基于Java的构建工具。理论上说，有些类似于（Unix）C中的make。但没有make的缺陷。Ant是软件构建工具，Maven的定位是软件项目管理和理解工具。

Ant特点：

没有一个约定的目录结构，必须明确让ant做什么，什么时候做，然后编译，打包没有生命周期，必须定义目标及其实现的任务序列没有继承以来管理

Maven特点：

拥有约定，知道你的代码在哪里，放到哪里去拥有一个生命周期，例如执行 mvn install 就可以自动执行编译，测试，打包等构建过程只需要定义一个pom.xml，然后把源码放到默认的目录，Maven帮你处理其它事情拥有以来管理，仓库管理

下面有关Java final的基本规则，描述错误的是？

A、final修饰的类不能被继承
B、final修饰的成员变量只允许赋值一次，且只能在类方法赋值
C、final修饰的局部变量即为常量，只能赋值一次
D、final修饰的方法不允许被子类覆盖

final修饰的引用类型，不能再指向别的东西，但是可以改变其中的内容

在Java7中，下列不能做swith()的参数类型是？

A、int型
B、枚举类型
C、字符串
D、浮点型

在switch(expr1)中，expr1只能是一个整数型表达式或者枚举类型，整数表达式可以是int基本类型或Integer包装类型，由于，byte、short、char都可以隐含转换为int，所以，这些类型以及这些类型的包装类型也是可以的。显然，long、float、double类型不符合switch的语法规定，并且不能隐式转为int类型，所以，它们不能做用于switch语句中。

注意：String类型是Java7开始支持的

在为传统面向对象语言的程序做单元测试的时候，经常用到mock对象。Mock对象通过反射数。请问反射最大程度破坏了面向对象的以下哪个对象？

A、封装
B、多态
C、继承
D、抽象

mock对象：也称为伪对象，在测试中利用mock对象来替代真实对象，方便测试的进行。

Java的封装性：指的是将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，通过该类提供的方法实现对内部信息的操作访问。

反射机制：在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能调用它的任意一个方法和属性

String s = new String(“xyz”)；创建了几个StringObject？

A、两个或一个都有可能
B、两个
C、一个
D、三个

通过new实例的方法创建字符串时，我们都知道会在堆上创建对象。我们也知道还有字符串常量池这个东西，但是很多人不知道的是你在new字符串jvm会去检查常量池是否有这个对象。如果存在，它只会在堆上创建一个对象。如果不存在，它会在常量池和堆上同时创建一个对象，也就是两个对象。

2022年2月14日

下列程序段的输出结构是：()

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

答案：false

此题考查的运算符优先级，题中符号的优先级排序是:’>’,’<’,’&&’,’||’

即 b=(x>50&&y>60)||(x>50&&y<-60)||(x<-50&&y>60)||(x<-50&&y<-60);

x>50结果为0，x<-50结果为0，所以括号中的表达式结果都为0，四个0或的结果0。

b为boolean类型，所以输出为false。

一般情况下，以下哪个选项不是关系数据模型与对象模型之间匹配关系？

A、表对应类
B、记录对应对象
C、表的字段对应类的属性
D、表之间的参考关系对应类之间的依赖关系

一般对应关系：表对应类、记录对应对象、表的字段对应类的属性

建立Statement对象的作用是？

A、连接数据库
B、声明数据库
C、执行SQL语句
D、保存查询结果

Statement对象用于执行不带参数的简单SQL语句

Prepared Statement对象用于执行预编译SQL语句

Callable Statement对象用于执行对象存储过程的调用

Test.main()函数执行后的输出是()

class Test {
    public static void main(String[] args) {
        System.out.println(new B().getValue());
    }
    static class A {
        protected int value;
        public A (int v) {
            setValue(v);
        }
        public void setValue(int value) {
            this.value= value;
        }
        public int getValue() {
            try {
                value ++;
                return value;
            } finally {
                this.setValue(value);
                System.out.println(value);
            }
        }
    }
    static class B extends A {
        public B () {
            super(5);
            setValue(getValue()- 3);
        }
        public void setValue(int value) {
            super.setValue(2 * value);
        }
    }
}

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

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

答案是：P is init
123

解析

不会初始化子类的几种：

1、调用的是父类的static方法或者字段

2、调用的是父类的final方法或者字段

3、通过数组来引用

一个以“.java”为后缀的源文件，哪些说法是正确的？

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

解析：

一个与文件名相同的public的类敏感词类可以随意多个。

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

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

答案：编译错误会将在(3)处发生，因为该类没有构造函数，该构造函数接受一个int类型的参数

这个题目在(1)处，MyClass方法并不是构造参数，而是返回类型为void的普通方法，普通方法自然需要实例化对象然后区调用它，所以124不对，第三个是正确的，因为没有带参数的构造器，所以自然不能传一个int进去。

关于下面程序Test.java说法正确的是()

public class Test {
    static String x="1";
    static int y=1;
    public static void main(String args[]) {
        static int z=2;
        System.out.println(x+y+z);
    }
}

A、3
B、112
C、13
D、程序有编译错误

被static修饰的变量称为静态变量，静态变量属于整个类，而局部变量属于方法，只在该方法内有效，所以static不能修饰局部变量。

以下代码执行的结果显示是多少？

A、num * count = 505000
B、num * count = 0
C、运行时错误
D、num * count = 5050

count = count ++

count 先赋值再++ count 一直都是0

temp = count

count = count + 1

count = temp

关于AOP错误的是？

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

AOP和OOP都是一套方法论，也可以说成设计模式、思维方式、理论规则等等。

正确答案：

C OOP不能替代OOP

以下JAVA程序代码的输出是

public static void main(String args[]){
  System.out.println(14^3);
}

A、2744
B、13
C、17
D、11

^表示异或就是相同是0 不同是1

14表示1110

3是0011

所以14^3 = 1101,即13

有如下代码：请写出程序的输出结果。

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

A、432
B、531
C、421
D、523

分析：

首先明确：&& ｜｜ & ｜的区别

**&&：**符号若第一项为false，则判别为false，若为true，则判断下一项。‘｜｜’和‘&&’原理相同。
 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);
 }
&:

无论左边的条件是true还是false，&右边都会执行

｜｜：

左边条件为false才会执行右边，&&左边条件为true右边不会执行

|:

无论左边条件为false或者true，｜右边都不会执行

当z=0时候，执行++2 > 2，不成立，&&后边就不再执行了，此时 x = 1，y = 0，k = 0

2022年2月18日

在你面前有一个n阶的楼梯，你一步智能上1阶或2阶。请问，当N=11时，你可以采用多少中不同的方式爬完这个楼梯()?当N=9时呢？

A、11
B、144
C、55
D、89

答案：B、C

分析：这是一个动态规划的算法题目。首先，你一步只能上1阶或者2阶，那么当N=11时：

a(11) = a(10) + a(9) = 144

a(10) = a(9) + a(8) = 89

a(9) = a(8) + a(7) = 55

…

a(2) = 2

a(1) = 1

代码：

public class SolutionBy {

    public static int a(int n){
        if(n == 1){
            return 1;
        }else if(n == 2){
            return 2;
        }else {
            return a(n - 1) + a(n - 2);
        }
    }

    public static void main(String[] args) {
        System.out.println(a(11) + "   " + a(9));
    }
}

下列说法正确的是()

A、在类方法中可用this来调用本类的类方法
B、在类方法中调用本类的类方法时可以直接调用
C、在类方法中只能调用本类中的类方法
D、在类方法中绝对不能调用实例方法

先要理解什么是类的方法，所谓类的方法就是指类中用static修饰的方法(非static修饰为实例方法)，比如main方法，那么可以main方法为例，可直接调用其他类的方法，必须通过实例调用实例方法，this关键字不是这么使用的。this关键字指的是当前对象，类方法依附于类而不是对象。

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

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

方法重写原则：两同两小一大原则

1、两同：方法名和参数类标相同
2、两小：返回值或生命异常比父类小(或相同)
3、一大：访问修饰符比父类的大(或相同)

下列哪些描述是正确的是：()

public class Test {
    public static class A {
        private B ref;
        public void setB(B b) {
            ref = b;
        }
    }
    public static Class B {
        private A ref;
        public void setA(A a) {
            ref = a;
        }
    }
    public static void main(String args[]) {
    …
        start();
    ….
    }
    public static void start() { A a = new A();
        B b = new B();
        a.setB(b);
        b = null; //
        a = null;
    …
    }
}

A、b = null 执行后b可以被垃圾回收
B、a = null执行后b可以被垃圾回收
C、a = null执行后a可以被垃圾回收
D、a,b必须在整个程序结束后才能被垃圾回收
E、类A和类B在设计上有循环引用，会导致内存泄露
F、a, b 必须在start方法执行完毕才能被垃圾回收

正确答案：B、C

2022年2月19日

关于下列程序段的输出结果，说法正确的是()

public class MyClass{
   static int i;
   public static void main(String argv[]){
       System.out.println(i);
   }
}

A、有错误，变量i没有初始化
B、null
C、1
D、0

类变量在不设置初始化，会进行默认值赋值，而局部方法生命的变量必须进行初始化，他不会进行默认值赋值。

静态变量会默认赋初始值，局部变量和final声明的变量必须手动赋初值

2022年2月21日

对于文件的描述正确的是()

A、文本文件是以".txt"为后缀名的文件，其他后缀名的文件是二进制文件
B、File类是Java中对文件进行读写操作的基本类
C、无论文本文件还是二进制文件，读到文件末尾都会抛出EOFException
D、Java中对于文本文件和二进制文件，都可以当作二进制文件进行操作。

正确答案：D

A、文件分为文本文件和二进制文件，计算机只认识二进制，所以实际上都是二进制的不同解释方法。文本文件是以不同编码格式显示的字符，例如：Ascill、Unicode等，window中文本文件的后缀名有”.txt“，”.log“，各种编程语言的源码文件等；二进制文件就是用文本文档打开是看不懂乱码，只要能用文本打开的文件都可以算是文本文件，只是显示的结果不是你想要的，二进制文件只有用特殊的应用才能看懂的文件，例如：“.png”，“.bmp”等，计算机中大部分的文件还是二进制文件。

B、File类是文件整体或者文件属性操作的类，例如创建文件、删除文件、查看文件是否存在等功能，不能操作文件内容；文件内容是用IO柳操作的。

C、当输入过程中意外到达文件或流的末尾时，抛出EOFException异常,正常情况下读取到文件末尾时，返回一个特殊值表示文件读取完成，例如read()返回-1表示文件读取完成。

D、上面A选项已经说了，不论是文本文件还是二进制文件，在计算机中都是以二进制形式存储的，所以都当作二进制文件读取。

下面对静态数据成员的描述中，正确的是

A、静态数据成员可以在类体内进行初始化
B、静态数据成员不可以被类的对象调用
C、静态数据成员不受private控制符的作用
D、静态数据成员可以直接用类名调用

正确答案：A

D选项的问题是被private static修饰的属性仅仅可以被静态方法调用，但是只能被本类中的方法(可以是非静态的)调用，在外部类创建这个类的对象或者直接使用这个类是访问都是非法的。

下面哪些操作会使线程释放锁资源？

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

正确答案：B、C

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

下列关于JAVA多线程的叙述正确的是()

A、调用start()方法和run()都可以启动一个线程
B、CyclicBarrier和CountDownLatch都可以让一组线程等待其他线程
C、Callable类的call()方法可以返回值和抛出异常
D、新建的线程调用start()方法就能立即进行运行状态

正确答案：B、C

A、start是开启线程，run是线程的执行体，run是线程执行的入口

B、CyclicBarrier和CountDownLatch都可以让一组线程等待其他线程。前者是让一组线程相互等待到某一个状态再执行。后者是一个线程等待其他线程结束再执行。

C、Callable中的call比Runnable中的run厉害就厉害在有返回值和可以抛出异常。同时这个返回值和线程池一起用的时候可以返回一个异步对象Future。

D、start是把线程从new变成了runnable

下列代码输出结果为()

class Animal{
    public void move(){
        System.out.println("动物可以移动");
    }
}
class Dog extends Animal{
    public void move(){
        System.out.println("狗可以跑和走");
    }
    public void bark(){
        System.out.println("狗可以吠叫");
    }
}
public class TestDog{
    public static void main(String args[]){
        Animal a = new Animal();
        Animal b = new Dog(); 
        a.move();
        b.move();
        b.bark();
    }
}

A、动物可以移动狗可以跑和走狗可以吠叫
B、动物可以移动动物可以移动狗可以吠叫
C、运行错误
D、编译错误

编译看左边，运行看右边。也就是编译的时候会把它当作左边的类型，运行的时候看右边类型的方法体。这个题动物类没有另一个方法，而b调用了，所以编译器会认为b是一个动物类，所以报错。

以下哪些代码段能正确执行？

public static void main(String args[]) {
byte a = 3;
byte b = 2;
b = a + b;
System.out.println(b);
}

public static void main(String args[]) {
byte a = 127;
byte b = 126;
b = a + b;
System.out.println(b);
}

public static void main(String args[]) {
byte a = 3;
byte b = 2;
a+=b;
System.out.println(b);
}

public static void main(String args[]) {
byte a = 127;
byte b = 127;
a+=b;
System.out.println(b);
}

byte类型的变量在做运算时会被转换成为int类型的值，故A、B左为byte，右int，会报错；而C、D语句中用的是a+=b的语句，此语句会将被赋值的变量自动强制转化为相对应的类型。

引子：

你知道计算机中以什么形式存储整数吗？是符号位加值位吗？值位是按照正常的二进制方式存储吗？

正数的补码等于原码；负数的补码等于反码加1，而反码等于原码符号为不变，其他各位置取反

对文件名为Test.java的Java代码描述正确的是()

class Person {
	String name = "No name";
	public Person(String nm) {
		name = nm;
	}
}
class Employee extends Person {
	String empID = "0000";
	public Employee(String id) {
		empID = id;
	}
}
public class Test {
	public static void main(String args[]) {
		Employee e = new Employee("123");
		System.out.println(e.empID);
	}
}

A、输出：0000
B、输出：123
C、编译报错
D、输出：No Name

子类的构造方法总是先调用父类的构造方法，如果子类的构造方法没有明显地指明父类的哪个构造方法，子类就调用父类不带参数的构造方法。

而父类没有无参的构造函数，所以子类需要在自己的构造函数中显示的调用父类的构造函数。

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

public class Test {
    public static void main(String args[]) {
        int x = -5;
        int y = -12;
        System.out.println(y % x);
    }
}

A、-1
B、2
C、1
D、-2

正确答案：D

当X和Y的正负相同时，取余和取模结果相同。

当X和Y的正负不同时，取余结果的符号和X相同，取模结果的符号和

有如下一段代码，请选择其运行结果()

public class StringDemo{
  private static final String MESSAGE="taobao";
  public static void main(String [] args) {
    String a ="tao"+"bao";
    String b="tao";
    String c="bao";
    System.out.println(a==MESSAGE);
    System.out.println((b+c)==MESSAGE);
  }
}

A、true true
B、false false
C、true false
D、false true

答案：C

要注意两个问题：

1、字符串在Java中存储在字符串常量区中

2、==判断的是对象引用是否同一个引用，判断字符串香等要用equals方法、

首先判断a==MESSAGE 同一份字符串常量在内存中只有一份，因此是同一地址，返回true

再次比较(b+c)= =MESSAGE 这相当于 new String(b+c)= =MESSAGE 这里new了一个String对象，所以返回false

验证如下：

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

public class Example {  
  String str = new String("good");  
  char[] ch = {'a','b','c'};  
  public static void main(String[] args) {  
     Example ex = new Example();  
     ex.change(ex.str, ex.ch);  
     System.out.print(ex.str +"and");  
     System.out.print(ex.ch);   
  }  
   
  public void change(String str, char ch[]){  
     str= "test ok";  
     ch[0]= 'g';  
  }  
}

A、test okandabc
B、test okandgbc
C、goodandabc
D、goodandgbc

正确答案：D

Java中String类型是不可变的，一旦初始化，其引用指向的内容是不可变的。

首先，我们先进入mian方法。new一个Example，会在栈中有一个ex的引用指向堆中的Example对象，同时str和ch也会指向该对象中对应的String和Char[]，然后执行change方法，此时会在栈中生成两个局部变量，str和ch[]，其中ch[]指向的是Example对象的数组，str此时的值以及hashCode均发生改变。

下面字段声明中哪一个在interface主体内是合法的？()

A、private final static int answer = 42;
B、public static int answer = 42;
C、final static answer = 42;
D、int answer;

正确答案：B

在接口中，属性默认都是public static final修饰的，所以

A、不能用private修饰
B、在接口中，属性默认public static final，这三个关键字可以省略
C、没写属性的类型
D、final修饰的属性必须赋值

在Java8中，下面哪个类用到了解决哈希冲突的开放定址法

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

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

THECCCSM

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Java题目

Java题目1.18日记录1、以下类定义中的错误是什么？2、分析一下 “ == ” 和 equals 的区别？首先，我们看一下源码 public boolean equals(Object anObject) { if (this == anObject) { return true; } if (anObject instanceof String) { String anotherStri
复制链接

扫一扫

专栏目录