牛客网Java错题整理

练习

题目一（数据结构）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sAPyfR0X-1660309083032)(C:\Users\xuezihan123\AppData\Roaming\Typora\typora-user-images\image-20220713211001089.png)]

抽象类有构造方法，但是不能new一个对象；包含抽象方法的类必须定义为抽象类； 抽象类不一定包含抽象方法，也可以包含普通方法； 抽象类只支持单继承。

length返回当前长度，如果字符串长度没有初始化长度大，capacity返回初始化的长度，如果append后的字符串长度超过初始化长度，capacity返回增长后的长度

题目二 List Set

ArrayList LineList HashMap HashSet：

Collecton接口常用的子接口有：List接口、Set接口

List接口常用的子类有：ArrayList类、LinkedList类（链表）

Set接口常用的子类有：HashSet类、LinkedHashSet类

List允许有重复的元素，有序。

Set不予许有重复元素，无序。

题目三 值传递和引用传递：💖

又错了的人来回答一下：

String a = “a”;

String b = “a”;

这样定义的a和b指向的是字符串常量区变量，地址是一样的，即用equals为true，用==也为true。

但是

String a =new String( “a”);

String b = new String( “a”);

这样是定义了两个堆内存对象，只能equals，不能==

例题：

String s1=new String（ ” xyz ” ）;

String s2=new String（ ” xyz ” ）;//在堆中建了两个“xyz”，不是同一个

Boolean b1=s1.equals(s2);

Boolean b2=(s1==s2);

System .out.print(b1+ ” ” +b2);

答案：

TRUE FALSE

题目四 同步异步

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ETJmuWuE-1660309083033)(C:\Users\xuezihan123\AppData\Roaming\Typora\typora-user-images\image-20220715092234861.png)]

synchronized是Java中的关键字，是一种同步锁。

它修饰的对象有以下几种：

1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；

2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；

3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；

4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

题目五 throw和throws

1、throws出现在方法头，throw出现在方法体

2、throws表示出现异常的一种可能性，并不一定会发生异常；throw则是抛出了异常，执行throw则一定抛出了某种异常。

3、两者都是消极的异常处理方式，只是抛出或者可能抛出异常，是不会由函数处理，真正的处理异常由它的上层调用处理。

题目六 String知识

1.String对象的两种创建方式:
第一种方式: String str1 = “aaa”; 是在常量池中获取对象(“aaa” 属于字符串字面量，因此编译时期会在常量池中创建一个字符串对象)，

第二种方式: String str2 = new String(“aaa”) ; 一共会创建两个字符串对象一个在堆中，一个在常量池中（前提是常量池中还没有 “aaa” 字符串对象）。

System.out.println(str1==str2);//false

2.String类型的常量池比较特殊。它的主要使用方法有两种：
直接使用双引号声明出来的String对象会直接存储在常量池中。
如果不是用双引号声明的String对象,可以使用 String 提供的 intern 方法。 String.intern() 是一个 Native 方法，它的作用是： 如果运行时常量池中已经包含一个等于此 String 对象内容的字符串，则返回常量池中该字符串的引用； 如果没有，则在常量池中创建与此 String 内容相同的字符串，并返回常量池中创建的字符串的引用。
String s1 = new String(“AAA”);
String s2 = s1.intern();
String s3 = “AAA”;
System.out.println(s2);//AAA
System.out.println(s1 == s2);//false，因为一个是堆内存中的String对象一个是常量池中的String对象，
System.out.println(s2 == s3);//true， s2,s3指向常量池中的”AAA“

需要的单词记住： Stack：栈 Heap：堆 Queue：队列

题目八 典型线程垃圾回收题

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

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l5mcrOIN-1660309083034)(D:\思途笔记\笔记\图片存放\165701207_1586336189484_802A6FE5D8D89EC50285B88F46C488F4.png)]

题目九 英语翻译题

下面哪个不对 ©

​ A RuntimeException is the superclass of those exceptions that must be thrown during the normal operation of the JVM

​ B A method is not required to declare in its throws clause any subclasses of RuntimeExeption that might be thrown during the execution of the method but not caught.

​ C An RuntimeException is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch.

​ D NullPointerException is one kind of RuntimeException

题目十 Arrarylist和Linkedlist两者的区别

Arraylist在内存中基于数组实现，可以通过为止找到地址查找快，增加删除需要修改其后面的所以元素所以慢。（查找快 修改慢）

LinkedList在内存中基于链表存放，所以查找慢，修改快。（查找慢 修改快）

题目十一 Integer的比较

Integer i01 = 59;
int i02 = 59;
Integer i03 =Integer.valueOf(59);
Integer i04 = new Integer(59);

System.out.println(i01 == i02);// true
System.out.println(i01 == i03);// true
System.out.println(i03 == i04);// false
System.out.println(i02 == i04);// true

//JVM中一个字节以下的整型数据会在JVM启动的时候加载进内存，除非用new Integer()显式的创建对象，否则都是同一个对象
//所有只有i04是一个新对象，其他都是同一个对象。所有A，B选项为true
//C选项i03和i04是两个不同的对象，返回false
//D选项i02是基本数据类型，比较的时候比较的是数值，返回true 基本类型比较的是数值！！！！！

题目十二 default修饰类型使用

要使某个类能被同一个包中的其他类访问，但不能被这个包以外的类访问，可以使用(default)

解析：default 不能在包外引用

题目十三 servlet的生存周期的方法

下面有关servlet中init,service,destroy方法错误的是（D）

init()方法是servlet生命的起点。一旦加载了某个servlet，服务器将立即调用它的init()方法
service()方法处理客户机发出的所有请求
destroy()方法标志servlet生命周期的结束
    
servlet在多线程下使用了同步机制，因此，在并发编程下servlet是线程安全的// 错误的

题目十四 java编译

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

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

A 错误 运行命令是 java + 你的 Java 程序的名字但是不加后缀 所以这道题错在多了 .class这个后缀

B 正确

C javac 是编译命令，后跟 你的 Java 程序名字加后缀，也就是 YourClassName.java 所以答案正确

D JVM （Java 虚拟机）运行的是编译后的字节码文件（以.class为后缀的文件），也就是 YourClassName.class 所以答案正确

题目十五 spring事务传播

下面有关SPRING的事务传播特性，说法错误的是？

A	PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行// (supports:支持)
B	PROPAGATION_REQUIRED：支持当前事务，如果当前没有事务，就抛出异常	// 错误(required:必须要)
C	PROPAGATION_REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起// (requires_new:必须新事物)
D	PROPAGATION_NESTED：支持当前事务，新增Savepoint点，与当前事务同步提交或回滚
    // D：(nested:表示如果当前事务存在，则方法应该运行在一个嵌套事务中。否则，它看起来和 PROPAGATION_REQUIRED 看起来没什么俩样)

题目十六 在子类中的重载（广义重载）

class A{
    public A foo() {
        return this;
    }
}
class B extends A {
    public A foo(){
        return this;
    }
}
class C extends B {
    _______// 在此处可以填写：public A foo(B b){return b;}
}

重写 要求两同两小一大原则， 方法名相同，参数类型相同，子类返回类型小于等于父类方法返回类型， 子类抛出异常小于等于父类方法抛出异常， 子类访问权限大于等于父类方法访问权限。［注意：这里的返回类型必须要在有继承关系的前提下比较］

重载 方法名必须相同，参数类型必须不同，包括但不限于一项，参数数目，参数类型，参数顺序

题目十七 hashmap和concurrenthashmap

在java7中,下列哪个说法是正确的:

ConcurrentHashMap使用synchronized关键字保证线程安全
HashMap实现了Collection接口
Arrays.asList方法返回java.util.ArrayList对象
SimpleDateFormat对象是线程不安全的// 正确

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

题目十八 JVM的各部分

下面有关JVM内存，说法错误的是？

程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行到了第几行，是线程隔离的
虚拟机栈描述的是Java方法执行的内存模型，用于存储局部变量，操作数栈，动态链接，方法出口等信息，是线程隔离的
方法区用于存储JVM加载的类信息、常量、静态变量、以及编译器编译后的代码等数据，是线程隔离的// 错误
原则上讲，所有的对象都在堆区上分配内存，是线程之间共享的

解析：大多数 JVM 将内存区域划分为 Method Area（Non-Heap）（方法区） ,Heap（堆） , Program Counter Register（程序计数器） , VM Stack（虚拟机栈，也有翻译成JAVA 方法栈的）,Native Method Stack （ 本地方法栈 ），其中Method Area 和 Heap 是线程共享的 ，VM Stack，Native Method Stack 和Program Counter Register 是非线程共享的。为什么分为 线程共享和非线程共享的呢?请继续往下看。

首先我们熟悉一下一个一般性的 Java 程序的工作过程。一个 Java 源程序文件，会被编译为字节码文件（以 class 为扩展名），每个java程序都需要运行在自己的JVM上，然后告知 JVM 程序的运行入口，再被 JVM 通过字节码解释器加载运行。那么程序开始运行后，都是如何涉及到各内存区域的呢？

概括地说来，JVM初始运行的时候都会分配好 Method Area（方法区） 和Heap（堆） ，而JVM 每遇到一个线程，就为其分配一个 Program Counter Register（程序计数器） , VM Stack（虚拟机栈）和Native Method Stack （本地方法栈）， 当线程终止时，三者（虚拟机栈，本地方法栈和程序计数器）所占用的内存空间也会被释放掉。这也是为什么我把内存区域分为线程共享和非线程共享的原因，非线程共享的那三个区域的生命周期与所属线程相同，而线程共享的区域与JAVA程序运行的生命周期相同，所以这也是系统垃圾回收的场所只发生在线程共享的区域（实际上对大部分虚拟机来说知发生在Heap上）的原因。

题目十九 两个现场同时使用一个全局变量

假设 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);``}

-1
-2
0
1// 正确

解析：不管怎样线程对a的操作就是+1后-2

1.线程1执行完再线程2执行，1-2+1-2=-2

2.线程1和2同时+1，再-2不同时，1-2-2=-3

3.线程1和2不同时+1，同时-2，1+1-2=0

4.线程1和2既同时+1又同时-2，1-2=-1

没有结果为1的情况

题目二十

​ 答案是ABDC

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uGc3cpT5-1660309083034)(D:\思途笔记\笔记\图片存放\624288791_1595596652709_2ACE7E0DDC324F941D9408346EC00132.jpg)]

题目二十一 Thread中的方法

调用Thread的sleep()方法会释放锁，调用wait()方法不释放锁
一个线程调用yield方法，可以使具有相同优先级线程获得处理器// 正确
在Java中，高优先级的可运行的线程会抢占低优先级线程的资源// 正确
java中，线程可以调用yield方法使比自己低优先级的线程运行

解析：sleep()方法（休眠）是线程类（Thread）的静态方法，调用此方法会让当前线程暂停执行指定的时间，将执行机会（CPU）让给其他线程，但是对象的锁依然保持，因此休眠时间结束后会自动恢复（线程回到就绪状态，请参考第66题中的线程状态转换图）。wait()是Object类的方法，调用对象的wait()方法导致当前线程放弃对象的锁（线程暂停执行），进入对象的等待池（wait pool），只有调用对象的notify()方法（或notifyAll()方法）时才能唤醒等待池中的线程进入等锁池（lock pool），如果线程重新获得对象的锁就可以进入就绪状态。

题目二十二 Synchronized

记住一句话，synchronized很强大，既可以保证可见性，又可以保证原子性，而volatile不能保证原子性！

题目二十三 ThreadLocal类

关于ThreadLocal类 以下说法正确的是

ThreadLocal是采用哈希表的方式来为每个线程都提供一个变量的副本
ThreadLocal保证各个线程间数据安全，每个线程的数据不会被另外线程访问和破坏

选DE.
1、ThreadLocal的类声明：
public class ThreadLocal<T>
可以看出ThreadLocal并没有继承自Thread，也没有实现Runnable接口。所以AB都不对。
2、ThreadLocal类为每一个线程都维护了自己独有的变量拷贝。每个线程都拥有了自己独立的一个变量。
所以ThreadLocal重要作用并不在于多线程间的数据共享，而是数据的独立，C选项错。
由于每个线程在访问该变量时，读取和修改的，都是自己独有的那一份变量拷贝，不会被其他线程访问，
变量被彻底封闭在每个访问的线程中。所以E对。
3、ThreadLocal中定义了一个哈希表用于为每个线程都提供一个变量的副本：
 static class ThreadLocalMap {

        static class Entry extends WeakReference<ThreadLocal> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }

        /**
         * The table, resized as necessary.
         * table.length MUST always be a power of two.
         */
        private Entry[] table;
}
所以D对。

题目二十四 super和this关键字

在使用super和this关键字时，以下描述错误的是（BCD）

A	在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过
B	super()和this()不一定要放在构造方法内第一行
C	this()和super()可以同时出现在一个构造函数中
D	this()和super()可以在static环境中使用，包括static方法和static语句块

解析：A选项正确，B选项，super()必须在第一行的原因是: 子类是有可能访问父类对象的, 比如在构造函数中使用父类对象的成员函数和变量, 在成员初始化使用了父类, 在代码块中使用了父类等等, 所以为保证在子类可以访问父类对象之前，一定要完成对父类对象的初始化。　　 关于this()必须在第一行的原因，我们假设这样一种情况,，类B是类A的子类， 如果this()可以在构造函数的任意行使用, 那么当程序运行到构造函数B()的第一行,发现没有调用this()和super()，那么就会自动在第一行补齐super() 来完成对父类对象的初始化, 然后返回子类的构造函数继续执行, 当运行到构造函数B()的"this() ;"时, 调用B类对象的构造函数, 还会对父类对象再次初始化!，这就造成了资源的浪费，以及某些意想不到的错误。也正因如此C选项错误。

D选项，无论是this()还是super()指的都是对象，而static环境中是无法使用非静态变量的。因此D选项错误。

题目二十五 Object类是所有类的父类

关于Java以下描述正确的有(CD)

A	Class类是Object类的超类
B	Object类是一个final类
C	String类是一个final类
D	Class类可以装载其它类

解析：Object类是所有类的父类，所以Object类不能用final修饰（因为被final修饰的类不能被继承）

String类是一个不变类，只有String是不可变的，才实现字符串常量池，节省空间，提高效率，同一个字符串常量被多个线程共享，实现线程安全

题目二十六 start启动线程

public class NameList
{
    private List names = new ArrayList();
    public synchronized void add(String name)
    {
        names.add(name);
    }
    public synchronized void printAll() {
        for (int i = 0; i < names.size(); i++)
        {
            System.out.print(names.get(i) + "");
        }
    }
 
    public static void main(String[]args)
    {
        final NameList sl = new NameList();
        for (int i = 0; i < 2; i++)
        {
            new Thread()
            {
                public void run()
                {
                    sl.add("A");
                    sl.add("B");
                    sl.add("C");
                    sl.printAll();
                }
            } .start();
        }
    }
}

会输出这两串代码
代码输出"A B C A B C A B C "

代码输出"A B C A A B C A B C "

解析：首先，我们要知道题中的集合s1是不可变的

然后按照正常思维来讲，第一次线程t1运行，添加然后打印ABC,然后执行第二个线程添加ABC，此时s1中就有两个ABC了，打印出ABCABC. 结果就是ABCABCABC。这应该是没有疑问的

但是由于线程之间执行顺序的不确定性

可以在t1添加完ABC后，要执行打印之前，t2执行了一次（可以是一次到三次）添加操作A

那么此时s1中就有ABCA 打印出的也就是ABCA

然后t1之行结束，t2继续执行添加BC.然后s1变成ABCABC。所以打印处ABCABC，总的结果就是ABCAABCABC

以上是根据结果来判断，总结一下的话可以得出：

第一次打印的长度不可变，但是在3~6之间

第二次打印集合中一定是6个元素，长度也就是6

至于具体的顺序排列组合我也不能全部列举

题目二十七 if语句判断

What is the result of compiling and executing the following fragment of code:

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

Answer：The text“true” is displayed.

Boolean修饰的变量为包装类型，初始化值为false,进行赋值时会调用Boolean.valueOf(boolean b)方法自动拆箱为基本数据类型，因此赋值后flag值为true，输出文本true。 如果使用==比较,则输出文本false。if的语句比较，除boolean外的其他类型都不能使用赋值语句，否则会提示无法转成布尔值。

题目二十八 事务隔离级别的实现

事务隔离级别是由谁实现的？（数据库系统）

Java应用程序
Hibernate
数据库系统
JDBC驱动程序

A，我们写java程序的时候只是设定事物的隔离级别，而不是去实现它

B，Hibernate是一个java的数据持久化框架，方便数据库的访问

C，事物隔离级别由数据库系统实现，是数据库系统本身的一个功能

D，JDBC是java database connector，也就是java访问数据库的驱动

题目二十九 赋值语句的判断

下列哪个语句语法正确？（ ）

byte y = 11; byte x = y +y;
String x = new Object();
Object x = new String(“Hellow”);
int a [11] = new int [11];

正确答案是C

解析：对于A，前一半语句赋值是没有问题的，问题是后半句，在对byte型的变量进行相加时，会先自动转换为int型进行计算，所以计算结果也是int型的，int型赋值给byte需要强制转换，所以A会出错

对于B，因为object是String的父类，所以不能这样使用，不能把父类对象赋值给子类，只能是Object x = new String();

对于C，因为String是Object的子类，所以可以将子类赋值给父类。

对于D，因为在声明变量时不需要指定容量，例如int a[] = new int[11];这样是正确的，但是像D选项这样是错误的

题目三十 编写多线程使用的方法

在java语言中，如果你编写一个多线程序，可以使用的方法是（AB）

A、扩展类Thread
B、实现Runnable接口
C、扩展类 Runnable
D、实现接口Thread

解析：

​ 1.继承Thread类（Override它的run方法）
​ 2.实现Runnable接口（实现run方法）
​ 3.使用ExecutorService、Callable、Future实现有返回结果的多线程

题目三十一 servlet的层级结构

下面有关servlet的层级结构和常用的类，说法正确的有?

GenericServlet类：抽象类，定义一个通用的、独立于底层协议的Servlet。
大多数Servlet通过从GenericServlet或HttpServlet类进行扩展来实现
ServletConfig接口定义了在Servlet初始化的过程中由Servlet容器传递给Servlet得配置信息对象
HttpServletRequest接口扩展ServletRequest接口，为HTTP Servlet提供HTTP请求信息

题目三十二 String、StringBuffer、StringBuilder

为Final类型的类型为String、StringBuffer，StringBuilder。

解析：StringBuilder , StringBuffer ,String 都是 final 的，但是为什么StringBuilder , StringBuffer可以进行修改呢，因为不可变包括的是，引用不可变以及对象不可变，而这三个都是属于引用不可变，（也就是地址不要变，里面的内容随心所欲），而StringBuilder , StringBuffer 中都包含右append方法，可对对象中的内容进行增加。

而String a=“123”+new String(“456”);实际上底层是用了一个StringBuffer 进行append；

题目三十三 可以被继承的类！

下面哪些类可以被继承？ Java.lang.Thread、java.lang.Number、java.lang.Double、java.lang.Math、 java.lang.ClassLoader

Thread// true
Number// true
Double// false
Math// false
ClassLoader// true

解析：答案：ABE

A，Thread可以被继承，用于创建新的线程

B，Number类可以被继承，Integer，Float，Double等都继承自Number类

C，Double类的声明为

public final class Doubleextends Numberimplements Comparable<Double>

final生明的类不能被继承

D，Math类的声明为

public final class Mathextends Object

不能被继承

E，ClassLoader可以被继承，用户可以自定义类加载器

题目三十四 servlet和service的描述

下面有关servlet service描述错误的是？

不管是post还是get方法提交过来的连接，都会在service中处理
doGet/doPost 则是在 javax.servlet.GenericServlet 中实现的// false
service()是在javax.servlet.Servlet接口中定义的
service判断请求类型，决定是调用doGet还是doPost方法

解析：doGet/doPost 则是在 javax.servlet.http.HttpServlet 中实现的

题目三十五 AWT和Swing

关于AWT和Swing说法正确的是？

正确答案: D 你的答案: C (错误)

Swing是AWT的子类
AWT在不同操作系统中显示相同的风格
AWT不支持事件类型，Swing支持事件模型
Swing在不同的操作系统中显示相同的风格

解析：AWT，抽象窗口工具包，是Java提供的建立图形用户界面的工具集，可用于生成现代的、鼠标控制的图形应用接口，且无需修改，就可以在各种软硬件平台上运行。

而swing是Java语言在编写图形用户界面方面的新技术，Swing采用模型-视图-控制设计范式，Swing可以使Java程序在同一个平台上运行时能够有不同外观以供用户选择。

两者不同在于一个是初代工具集，一个是进化版的工具集，用户不会再满足于初始的功能，而是更加注重于附加价值，明显从这点上，Swing是比AWT要好很多。

写法上，Swing的头文件引用包需要用到Javax，组件调用时也需要在AWT的基础上加上“J”。

题目三十六 创建线程的方法

一般有两种用于创建线程的方法,一是(B),二是(D)。

从Java.lang.Thread类派生一个新的线程类，重写它的runnable()方法
从Java.lang.Thread类派生一个新的线程类，重写它的run()方法// true
实现Thread接口，重写Thread接口中的run()方法
实现Runnable接口，重写Runnable接口中的run()方法// true

解析：创建线程对象两种方式：

1.继承Thread类，重载run方法；

2.实现Runnable接口，实现run方法

题目三十七 多线程

下列关于JAVA多线程的叙述正确的是（）

正确答案: B C

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

解析：

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

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

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

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

题目三十八 超类是父类

class类是Object的派生类

B.每个类都使用Object类作为超类，而final修饰的类不能被继承

C.[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fR5WEGGV-1660309083035)(https://uploadfiles.nowcoder.com/images/20190806/725155193_1565055261736_F175D98577CF36270EDCF0CF75CE5ADA)]

D.Class类中的forName()方法返回与带有给定字符串名的类或接口相关联的Class对象（装载其他类）

题目三十九 Collection接口下的子类或实现类

实现或继承了Collection接口的是（）

正确答案: B C E

Map
List// true
Vector// true
Iterator
Set// true

题目四十 脑力题

在你面前有一个n阶的楼梯，你一步只能上1阶或2阶。请问，当N=11时，你可以采用多少种不同的方式爬完这个楼梯（144）,当N=9时呢呢（55）？

解析：

你需要爬11楼的时候，你倒回去一步只能待在第10楼或者第9楼。换句话说就是到达第9楼的方法次数加上第10楼的方法次数。

如果你待在第10楼，就得待在第9楼或者第8楼

如果你待在第9楼，就得待在第8楼或者第7楼

…

如果你待在第3楼，就得待在第1楼或者第2楼

爬1楼一种方法，

爬2楼两种方法。

爬3楼就是爬1楼方法次数加2楼的方法次数。

用数学表达就是：

a（11）=a（10）+a（9）=144

a（10）=a（9）+a（8）=89

a（9）=a（8）+a（7）=55

a（8）=a（7）+a（6）=34

a（7）=a（6）+a（5）=21

a（6）=a（5）+a（4）=13

a（5）=a（4）+a（3）=8

a（4）=a（3）+a（2）=5

a（3）=a（2）+a（1）=3

a（2）=2

a（1）=1

题目四十一 java创建对象

Java创建对象的说法正确的有（全部正确）

用new语句创建对象，是最常见的创建对象的方法。
运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。
调用对象的clone()方法。
运用反序列化手段，调用java.io.ObjectInputStream对象的 readObject()方法。

题目四十二 ClassLoader类加载器

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

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

解析：Java语言系统自带有三个类加载器:

- Bootstrap ClassLoader 最顶层的加载类，主要加载核心类库，%JRE_HOME%\lib下的rt.jar、resources.jar、charsets.jar和class等。另外需要注意的是可以通过启动jvm时指定-Xbootclasspath和路径来改变Bootstrap ClassLoader的加载目录。比如java -Xbootclasspath/a:path被指定的文件追加到默认的bootstrap路径中。我们可以打开我的电脑，在上面的目录下查看，看看这些jar包是不是存在于这个目录。
- Extention ClassLoader 扩展的类加载器，加载目录%JRE_HOME%\lib\ext目录下的jar包和class文件。还可以加载-D java.ext.dirs选项指定的目录。

- Appclass Loader也称为SystemAppClass 加载当前应用的classpath的所有类。

加载顺序：

**1. Bootstrap CLassloder **

**2. Extention ClassLoader **

3. AppClassLoader

题目四十三 数据域

数据域可以是基本类型变量，也可以是一个对象

题目四十四 访问权限控制

访问权限控制从最大权限到最小权限依次为：public>protected>默认(包访问权限)>private，因为protected除了可以被同一包访问，还可以被包外的子类所访问

题目四十五 ArrayList默认数组大小为10

Arraylist默认数组大小是10，扩容后的大小是扩容前的1.5倍，最大值小于Integer 的最大值减8，如果新创建的集合有带初始值，默认就是传入的大小，也就不会扩容

题目四十六 判断进制

以下哪个式子有可能在某个进制下成立（）
A：（1*n+3）*(1*n+4)=2*n^2+4;//   n=-1或n=8;  其中n=8成立

题目四十七 TCP监听端口 使用socket如何创建

如果希望监听TCP端口9000，服务器端应该怎样创建socket? new ServerSocket(9000);

题目四十八 HttpServlet结构图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uSQMRDzr-1660309083035)(D:\思途笔记\笔记\图片存放\servlet加载过程.png)]

题目四十九 重写方法遵循的规则

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

访问修饰符的限制一定要大于被重写方法的访问修饰符// 错在不应该一定大于，也可以等于
可以有不同的访问修饰符// 正确
参数列表必须完全与被重写的方法相同// 正确
必须具有不同的参数列表

题目五十 定制HTTP回应头

下面HttpServletResponse方法调用，那些给客户端回应了一个定制的HTTP回应头：( )

response.setHeader("X-MyHeader", "34");
response.addHeader("X-MyHeader", "34");

题目五十一 object中没有copy方法

java object类中没有copy（）方法。

题目五十二 jsp页面的代码填写

给定includel.isp文件代码片段，如下：
<% pageContext.setAttribute(“User”,”HAHA”);%>
__________________________// 此处填写代码
给定include2.jsp文件代码片段如下：
<%=pageContext.getAttribute(“User”)%>
要求运行include1.jsp时，浏览器上输出：HAHA

<%@include file=”include2.jsp”%>

B选项是静态包含，相当于不include2.jsp页面内容拷贝到此处，因此可以输出User属性值

D选项是转发重定向，转发的时候pageContent内的属性值不能被传递，因此得不到User属性值

题目五十三 AWT和Swing

关于AWT和Swing说法正确的是？

Swing在不同的操作系统中显示相同的风格

题目五十四 反射获取static属性的值

通过以下哪些方法可反射获取到User对象中static属性的值？ 全对

User. class. getDeclaredField ("name"). get (null);
User. class. getField ("name"). get (null);
User user=new User(); return user. getClass(). getField ("name")．get (user);
User user=new User(): return user. getClass(). getDeclaredField ("name"）. get (user);

题目五十五 对面向对象的理解

下面关于面向对象的一些理解哪些是错误的( )⭐️⭐️⭐️

面向对象的最重要的特性是支持继承、封装和多态
系统设计应该遵循开闭原则，系统应该稳定不可修改，但应支持通过继承、组合等方式进行扩展
面向对象设计时，每个类的职责应该单一，不要再一个类中引入过多的接口
过程式语言和面向对象的语言各有其优势，过程式语言更加灵活，面向对象语言更加强调抽象和封装
Java和C++都是静态类型的面向对象编程语言

题目五十六 外部类的定义

下列外部类定义中，不正确的是：（C）

class x { .... }
class x extends y { .... }
static class x implements y1,y2 { .... }// 错误
public class x extends Applet { .... }

内部类可以是静态static的，也可用public，default，protected和private修饰，

外部类的修饰符只能是public，abstract，final

题目五十七 方法加锁synchronized

class Test
{
   private int data;
   int result =  0;
   public void m()
   {
     result += 2 ;
     data += 2;
     System.out.print(result + " "+ data);
   }
 }
 class ThreadExample extends Thread
 {
   private Test mv;
   public ThreadExample(Test mv)
   {
     this.mv = mv;
   }
   public void run()
   {
     synchronized (mv)
     {
       mv.m();
     }
   }
 }
 class ThreadTest
 {
   public static void main(String args[])
  
     Test mv = new Test();
     Thread t1 = new ThreadExample(mv);
     Thread t2 = new ThreadExample(mv);
     Thread t3 = new ThreadExample(mv);
     t1.start();
     t2.start();
     t3.start();
   }
 }
//执行结果是：2 24 46 6

解析：t1,t2,t3线程使用同一个对象mv,

synchronized(mv) 对象锁（实例锁）

当多个并发线程访问同步synchronized（this）同步代码块时， 某一时刻仅能有一个线程能执行同步，其他线程必须等待。也就是说虽然不能确认t1、t2、t3哪一个线程先执行，但它确实是排队执行的，不会出现变量的覆盖。所以输出结果为分别为2 2、4 4、6 6。正确答案为C。

题目五十八 finally中的return

如果finally块中有return语句的话，它将覆盖掉函数中其他return语句。

题目五十九 服务器之间的通信方式

在一个基于分布式的游戏服务器系统中，不同的服务器之间，哪种通信方式是不可行的（）？

管道// 错误
消息队列
高速缓存数据库
套接字

解析：**管道( pipe )：**管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。

既然是不同的服务器之间进行通信，怎么可能会是具有亲缘关系的进程呢？

题目六十 static执行顺序

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();
    }
}
//  构造块 构造块 静态块 构造块

题目六十一 继承有关问题

如果Child extends Parent，那么正确的有（）？

如果Child是interface，那么Parent必然是interface
如果Child是interface，那么Child可以同时extends Parent1，Parent2等多个interface
如果Child是class，并且没有显示声明任何构造函数，那么此时仍然会调用Parent的构造函数

解析：

A、子类的构造器第一行默认都是super()，默认调用直接父类的无参构造，一旦直接父类没有无参构造，那么子类必须显式的声明要调用父类或者自己的哪一个构造器。

BC、接口只能继承接口，但是可以多继承。类都是单继承，但是继承有传递性。

D、一个类一旦没有显式的定义任何构造，那么JVM会默认给你一个无参构造。无参构造的第一行依然默认是super()。

题目六十二 没有线程参与的垃圾回收阶段

CMS垃圾回收器在那些阶段是没用用户线程参与的（A C）

初始标记// true
并发标记
重新标记// true
并发清理

CMS的基础算法是：标记—清除。

它的过程可以分为以下6个步骤：

1. 初始标记(STW initial mark)
2. 并发标记(Concurrent marking)
3. 并发预清理(Concurrent precleaning)
4. 重新标记(STW remark)
5. 并发清理(Concurrent sweeping)
6. 并发重置(Concurrent reset)[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZC7qUO5s-1660309083036)(D:\思途笔记\笔记\图片存放\CMS垃圾回收用户线程.png)]

题目六十三 赋值语句的问题

下面的Java赋值语句哪些是有错误的 （B F）

int i =1000;
float f = 45.0;// FALSE
char s = ‘\u0639’;
Object o = ‘f’;
String s = "hello,world\0";
Double d = 100;// FALSE

**解析：**b：小数如果不加 f 后缀，默认是double类型。double转成float向下转换，意味着精度丢失，所以要进行强制类型转换。

c：是使用unicode表示的字符。

d：‘f’ 字符会自动装箱成包装类，就可以向上转型成Object了。

f：整数默认是int类型，int类型不能转型为Double，最多通过自动装箱变为Integer但是Integer与Double没有继承关系，也没法进行转型。

题目六十四 正则表达式 身份证号的表示

关于身份证号，以下正确的正则表达式为（A C）

isIDCard=/^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$/;
isIDCard=/^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{4}$/;

题目六十五 Hashtable和HashMap的区别

Hashtable 和 HashMap 的区别是：

HashMap 是内部基于哈希表实现，该类继承AbstractMap，实现Map接口
Hashtable 线程安全的，而 HashMap 是线程不安全的
Properties 类 继承了 Hashtable 类，而 Hashtable 类则继承Dictionary 类
HashMap允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许。

解析：Hashtable：

（1）Hashtable 是一个散列表，它存储的内容是键值对(key-value)映射。

（2）Hashtable 的函数都是同步的，这意味着它是线程安全的。它的key、value都不可以为null。

（3）HashTable直接使用对象的hashCode。

HashMap：

（1）由数组+链表组成的，基于哈希表的Map实现，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的。

（2）不是线程安全的，HashMap可以接受为null的键(key)和值(value)。

（3）HashMap重新计算hash值

Hashtable,HashMap,Properties继承关系如下：

public class Hashtable<K,V> extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable
 
public class HashMap<K,V>extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable

java.lang.Objecct
  java.util.Dictionary<K,V>
    java.util.Hashtable<Object,Object>
      java.util.Properties 

题目六十六 接口和抽象类

jdk1.8版本之前的前提下，接口和抽象类描述正确的有（ ）

接口没有构造函数
抽象类不允许多继承

题目六十七 处理流

下列流当中，属于处理流的是：（）

DatalnputStream
BufferedlnputStream

题目六十八 会话跟踪

有关会话跟踪技术描述正确的是（）

Cookie是Web服务器发送给客户端的一小段信息，客户端请求时，可以读取该信息发送到服务器端
关闭浏览器意味着临时会话ID丢失，但所有与原会话关联的会话数据仍保留在服务器上，直至会话过期
在禁用Cookie时可以使用URL重写技术跟踪会话

题目六十九 ~为取反符号

1. 公式-n=_n+1可推出n=-n-1，所以~10=-11再加5结果为-6
2. 为二进制取反时，是将1变为0,0变为1.

题目七十

存储的内容是键值对(key-value)映射。

（2）Hashtable 的函数都是同步的，这意味着它是线程安全的。它的key、value都不可以为null。

（3）HashTable直接使用对象的hashCode。

HashMap：

（1）由数组+链表组成的，基于哈希表的Map实现，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的。

（2）不是线程安全的，HashMap可以接受为null的键(key)和值(value)。

（3）HashMap重新计算hash值

Hashtable,HashMap,Properties继承关系如下：

public class Hashtable<K,V> extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable
 
public class HashMap<K,V>extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable

java.lang.Objecct
  java.util.Dictionary<K,V>
    java.util.Hashtable<Object,Object>
      java.util.Properties 

题目六十六 接口和抽象类

jdk1.8版本之前的前提下，接口和抽象类描述正确的有（ ）

接口没有构造函数
抽象类不允许多继承

题目六十七 处理流

下列流当中，属于处理流的是：（）

DatalnputStream
BufferedlnputStream

题目六十八 会话跟踪

有关会话跟踪技术描述正确的是（）

Cookie是Web服务器发送给客户端的一小段信息，客户端请求时，可以读取该信息发送到服务器端
关闭浏览器意味着临时会话ID丢失，但所有与原会话关联的会话数据仍保留在服务器上，直至会话过期
在禁用Cookie时可以使用URL重写技术跟踪会话

题目六十九 ~为取反符号

1. 公式-n=_n+1可推出n=-n-1，所以~10=-11再加5结果为-6
2. 为二进制取反时，是将1变为0,0变为1.

题目七十