2021-10-21每日一练

一丶java选择题

1. Java Application 源程序的主类是指包含有（ ）方法的类。
   正确答案: A 你的答案: A (正确)
   public static void main方法
   toString方法
   init方法
   actionPerfromed方法
2. 下面叙述错误的是 ( )
   正确答案: C 你的答案: C (正确)
   一个类可以有多个构造方法
   最终类不能派生子类，最终方法不能被覆盖
   如果一个类中没有定义构造方法，则Java在生成这个类的实例时不会调用构造方法。
   数组一旦创建之后，就不能再改变其长度

A.一个类可以有多个构造方法，实际上就是方法的重载，正确
B.用final修饰的类不能被继承，方法不能被覆盖，正确
C.如果没有构造方法，编译器会自动添加一个空参构造方法，错误
D.由源码可知，数组内部采用字符数组存储，该字符数组用final修饰，长度一旦确定不可再变，正确

3. 以下说法错误的是（）
   正确答案: C 你的答案: C (正确)
   数组是一个对象
   数组不是一种原生类
   数组的大小可以任意改变
   在Java中，数组存储在堆中连续内存空间里

Java中数组是对象，不是基本数据类型（原生类），大小不可变且连续存储，因为是对象所以存在堆中。

基本数据类型（原生类）：byte short int float double long boolean char

4. 执行语句“int a= ’ 2 ’ ”后，a的值是（ ）
   正确答案: B 你的答案: B (正确)
   2
   50
   49
   0

空格:32 0:48 A:65 a:97

常见字符的ASCII码值如下：空格的ASCII码值为32；数字0到9的ASCII码值分别为48到57；大写字母“A”到“Z”的ASCII码值分别为65到90；小写字母“a”到“z”的ASCII码值分别为97到到122。

ASCII码值如下：
空格 ：32
0-9 ： 48~57
A-Z : 65~90
a-z : 97~122

5. 下列代码编译和运行的结果是：（）
   public class Threads4{
   public static void main(String[] args){
   new Threads4().go();
   }
   public void go(){
   Runnable r=new Runnable(){
   public void run(){
   System.out.print(“foo”);
   }
   };
   Thread t=new Thread®;
   t.start();
   }
   }
   正确答案: C 你的答案: C (正确)
   编译错误
   抛出运行时异常
   输出：foo
   代码正常运行，但是无输出

在java多线程中实现多线程的方式有两种①extends Thread ②implements Runnable。这两种情况是我们最常见的，还有一种是由第二种变形而来的直接new Runnable(){}，我们都知道java的接口是不可以实例化的，但代码中的new Runnable(){xxx}确是实例化了，为什么？ 接口和抽象类不可以实例化是对的，这个是java语法规范来的，而new Runnable(){}其实不是实例化Runnable接口来的，实际上一种内部类的一种简写 在这里：
①首先构造了一个”implements Runnable “的无名local内部类(方法内的内部类)
②然后构造了这个无名local内部类的一个实例
③然后用Runnable来表示这个无名local内部类的type(OO多态)。 例如上面这段代码编译后你会看到其实是编译了两个类来的，如下：
其中Text2$1就是无名local内部内类，这个也就很好地解释了为什么在main（）方法中new Runnable(){xxx}里面的调用main()方法中的变量的时候要用final关键字来修饰

6. try块后必须有catch块。（）
   正确答案: B 你的答案: A (错误)
   正确
   错误

try的形式有三种：

try-catch
try-finally
try-catch-finally

7. 用户不能调用构造方法，只能通过new关键字自动调用。（）
   正确答案: B 你的答案: A (错误)
   正确
   错误

1. 在类内部可以用户可以使用关键字this.构造方法名()调用（参数决定调用的是本类对应的构造方法）
2. 在子类中用户可以通过关键字super.父类构造方法名()调用（参数决定调用的是父类对应的构造方法。）
3. 反射机制对于任意一个类，都能够使用newInstance()的方式调用，知道这个类的所有属性和方法，包括类的构造方法。

8. 以下是java concurrent包下的4个类，选出差别最大的一个
   正确答案: C 你的答案: C (正确)
   Semaphore
   ReentrantLock
   Future
   CountDownLatch

A、Semaphore：类，控制某个资源可被同时访问的个数;
B、ReentrantLock：类，具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大；
C、 Future：接口，表示异步计算的结果；
D、 CountDownLatch： 类，可以用来在一个线程中等待多个线程完成任务的类。

9. 下面哪个关键字可以用于Java的构造方法上？
   正确答案: E 你的答案: E (正确)
   final
   static
   synchronized
   native
   None of these.

构造方法不能被子类继承，所以用final修饰没有意义。构造方法用于创建一个新的对象，不能作为类的静态方法，所以用static修饰没有意义。此外，Java语言不支持native或synchronized的构造方法。

1：构造方法可以被重载，一个构造方法可以通过this关键字调用另一个构造方法，this语句必须位于构造方法的第一行；
重载：方法的重载(overload)：重载构成的条件：方法的名称相同，但参数类型或参数个数不同，才能构成方法的重载。
2 当一个类中没有定义任何构造方法，Java将自动提供一个缺省构造方法；
3 子类通过super关键字调用父类的一个构造方法；
4 当子类的某个构造方法没有通过super关键字调用父类的构造方法，通过这个构造方法创建子类对象时，会自动先调用父类的缺省构造方法
5 构造方法不能被static、final、synchronized、abstract、native修饰，但可以被public、private、protected修饰；
6 构造方法不是类的成员方法；
7 构造方法不能被继承。

10. 执行以下程序后的输出结果是（）
    public class Test {
    public static void main(String[] args) {
    StringBuffer a = new StringBuffer(“A”);
    StringBuffer b = new StringBuffer(“B”);
    operator(a, b);
    System.out.println(a + “,” + b);
    }
    public static void operator(StringBuffer x, StringBuffer y) {
    x.append(y); y = x;
    }
    }
    正确答案: D 你的答案: D (正确)
    A,A
    A,B
    B,B
    AB,B
11. 下列叙述中，错误的是（ ）
    正确答案: B 你的答案: C (错误)
    File类能够存储文件属性
    File类能够读写文件
    File类能够建立文件
    File类能够获取文件目录信息

能够读写文件的是数据流

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

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

12. 以下代码段执行后的输出结果为
    public class Test {
    public static void main(String[] args) {
    System.out.println(test());

    }
    private static int test() {
    int temp = 1;
    try {
    System.out.println(temp);
    return ++temp;
    } catch (Exception e) {
    System.out.println(temp);
    return ++temp;
    } finally {
    ++temp;
    System.out.println(temp);
    }
    }
    }
    正确答案: D 你的答案: B (错误)
    1,2,2
    1,2,3
    1,3,3
    1,3,2

执行顺序为：
输出try里面的初始temp：1；
temp=2；
保存return里面temp的值：2；
执行finally的语句temp：3，输出temp：3；
返回try中的return语句，返回存在里面的temp的值：2；
输出temp：2。

13. 检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。
    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 你的答案: B (错误)
    0
    1
    2
    3

i++ 先赋值在计算结果；
++i 先计算结果再赋值。
int i = 0;
i = i ++; // 左边这个i其实是障眼法，就是一个中间变量，可以和下行的i合并；
System.out.println(i); 这里等价于:
int i = 0;
System.out.println(i++); 这下再看，先赋值(先将i传给println函数打印出来,在计算表达式结果)
所以打印出来的是0，实际上整个表达式的结果已经是1了，只是没有打印出整个表达式的结果。
所以我们知道如下结论：
1、无论怎么变，i++和++i的整个表达式的结果都是1.
2、有时我们打印的是表达式的结果(System.out.println(++i)),
有时我们打印的只是一个中间变量(System.out.println(i++))。

15. 假设 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 你的答案: B (错误)
    -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的情况

16. 下列描述错误的是?
    正确答案: B D 你的答案: B D (正确)
    类只能继承一个父类，但是可以实现多个接口
    抽象类自身可以定义成员而接口不可以
    抽象类和接口都不能被实例化(忽略匿名内部类)
    一个类可以有多个父类和多个基接口

A、java为单继承，多实现。可以实现多个接口。
B、接口允许定义成员，但必须是常量。
C、抽象类和接口类的无法实例化，任何编译器中直接使用new会报错。
D、同A，单继承，多实现。

17. java中提供了哪两种用于多态的机制
    正确答案: A B 你的答案: B D (错误)
    通过子类对父类方法的覆盖实现多态
    利用重载来实现多态.即在同一个类中定义多个同名的不同方法来实现多态。
    利用覆盖来实现多态.即在同一个类中定义多个同名的不同方法来实现多态。
    通过子类对父类方法的重载实现多态

Java通过方法重写和方法重载实现多态
方法重写是指子类重写了父类的同名方法
方法重载是指在同一个类中，方法的名字相同，但是参数列表不同

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

先进后出，如同弹夹

19. 如果Child extends Parent，那么正确的有（）？
    正确答案: B C D 你的答案: B C (错误)
    如果Child是class，且只有一个有参数的构造函数，那么必然会调用Parent中相同参数的构造函数
    如果Child是interface，那么Parent必然是interface
    如果Child是interface，那么Child可以同时extends Parent1，Parent2等多个interface
    如果Child是class，并且没有显示声明任何构造函数，那么此时仍然会调用Parent的构造函数

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

20. 以下关于final关键字说法错误的是（）
    正确答案: A C 你的答案: B C D (错误)
    final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性
    final修饰的类肯定不能被继承
    final修饰的方法不能被重载
    final修饰的变量不允许被再次赋值

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

21. 在J2EE中，使用Servlet过滤器，需要在web.xml中配置（）元素
    正确答案: A B 你的答案: D (错误)
    
    
    
    

Servlet过滤器的配置包括两部分：
第一部分是过滤器在Web应用中的定义，由元素表示，包括和两个必需的子元素
第二部分是过滤器映射的定义，由元素表示,可以将一个过滤器映射到一个或者多个Servlet或JSP文件，也可以采用url-pattern将过滤器映射到任意特征的URL。

22. 在你面前有一个n阶的楼梯，你一步只能上1阶或2阶。请问，当N=11时，你可以采用多少种不同的方式爬完这个楼梯（）；当N=9时呢？
    正确答案: B C 你的答案: B C (正确)
    11
    144
    55
    89
23. 关于Java内存区域下列说法不正确的有哪些
    正确答案: B C 你的答案: A C (错误)
    程序计数器是一块较小的内存空间，它的作用可以看做是当前线程所执行的字节码的信号指示器，每个线程都需要一个独立的程序计数器.
    Java虚拟机栈描述的是java方法执行的内存模型，每个方法被执行的时候都会创建一个栈帧，用于存储局部变量表、类信息、动态链接等信息
    Java堆是java虚拟机所管理的内存中最大的一块，每个线程都拥有一块内存区域，所有的对象实例以及数组都在这里分配内存。
    方法区是各个线程共享的内存区域，它用于存储已经被虚拟机加载的常量、即时编译器编译后的代码、静态变量等数据。

B.类信息不是存储在java虚拟机栈中，而是存储在方法区中；
C.java堆是被所有线程共享的一块内存区域，而不是每个线程都拥有一块内存区域。

24. 下面有关java的引用类型，说法正确的有？
    正确答案: A B C D 你的答案: A C (错误)
    对于一个对象来说，只要有强引用的存在，它就会一直存在于内存中
    如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
    如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存
    一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的空间

四种引用类型
JDK1.2 之前，一个对象只有“已被引用”和"未被引用"两种状态，这将无法描述某些特殊情况下的对象，比如，当内存充足时需要保留，而内存紧张时才需要被抛弃的一类对象。
所以在 JDK.1.2 之后，Java 对引用的概念进行了扩充，将引用分为了：强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）、虚引用（Phantom Reference）4 种，这 4 种引用的强度依次减弱。
一，强引用
Object obj = new Object(); //只要obj还指向Object对象，Object对象就不会被回收 obj = null; //手动置null
只要强引用存在，垃圾回收器将永远不会回收被引用的对象，哪怕内存不足时，JVM也会直接抛出OutOfMemoryError，不会去回收。如果想中断强引用与对象之间的联系，可以显示的将强引用赋值为null，这样一来，JVM就可以适时的回收对象了
二，软引用
软引用是用来描述一些非必需但仍有用的对象。在内存足够的时候，软引用对象不会被回收，只有在内存不足时，系统则会回收软引用对象，如果回收了软引用对象之后仍然没有足够的内存，才会抛出内存溢出异常。这种特性常常被用来实现缓存技术，比如网页缓存，图片缓存等。
在 JDK1.2 之后，用java.lang.ref.SoftReference类来表示软引用。
三，弱引用
弱引用的引用强度比软引用要更弱一些，无论内存是否足够，只要 JVM 开始进行垃圾回收，那些被弱引用关联的对象都会被回收。在 JDK1.2 之后，用 java.lang.ref.WeakReference 来表示弱引用。
四，虚引用
虚引用是最弱的一种引用关系，如果一个对象仅持有虚引用，那么它就和没有任何引用一样，它随时可能会被回收，在 JDK1.2 之后，用 PhantomReference 类来表示，通过查看这个类的源码，发现它只有一个构造函数和一个 get() 方法，而且它的 get() 方法仅仅是返回一个null，也就是说将永远无法通过虚引用来获取对象，虚引用必须要和 ReferenceQueue 引用队列一起使用。

25. 以下说法错误的是（）
    正确答案: B C D 你的答案: B C (错误)
    其他选项均不正确
    java线程类优先级相同
    Thread和Runnable接口没有区别
    如果一个类继承了某个类，只能使用Runnable实现线程

B选项，在java中线程是有分优先等级的所以优先级不能相同，错误
C选项，Thread实现了Runnable接口是一个类不是接口，错误
D选项，实现多线程的三种方式，一种是继承Thread类使用此方式就不能继承其他的类了。还有两种是实现Runnable接口或者实现Callable接口
，所以D错误。
A选项，综上A说其余三项都是错误的，所以A选项所述为真，不是错误的。

26. 以下各类中哪几个是线程安全的？( )
    正确答案: B C D 你的答案: B D (错误)
    ArrayList
    Vector
    Hashtable
    Stack
27. 关于java中的数组，下面的一些描述，哪些描述是准确的：（）
    正确答案: A C F 你的答案: A C E (错误)
    数组是一个对象，不同类型的数组具有不同的类
    数组长度是可以动态调整的
    数组是一个连续的存储结构
    一个固定长度的数组可类似这样定义：int array[100]
    两个数组用Object 里equals方法比较时，会逐个遍历其中的元素，对每个元素进行比较
    java中不存在 int *a这样的东西做数组的形参
28. 以下语句返回值为 true 的是（）
    
    正确答案: A B 你的答案: A B (正确)
    a1a2
    d1d2
    b1b2
    c1c2
29. 下列流当中，属于处理流的是：（）
    正确答案: C D 你的答案: A B C D (错误)
    FilelnputStream
    lnputStream
    DatalnputStream
    BufferedlnputStream
30. 下面有关值类型和引用类型描述正确的是（）？
    正确答案: A B C 你的答案: B D (错误)
    值类型的变量赋值只是进行数据复制，创建一个同值的新对象，而引用类型变量赋值，仅仅是把对象的引用的指针赋值给变量，使它们共用一个内存地址。
    值类型数据是在栈上分配内存空间，它的变量直接包含变量的实例，使用效率相对较高。而引用类型数据是分配在堆上，引用类型的变量通常包含一个指向实例的指针，变量通过指针来引用实例。
    引用类型一般都具有继承性，但是值类型一般都是封装的，因此值类型不能作为其他任何类型的基类。
    值类型变量的作用域主要是在栈上分配内存空间内，而引用类型变量作用域主要在分配的堆上。