2021-10-12每日一练

一丶java选择题

1. “先进先出”的容器是：( )
   正确答案: B 你的答案: B (正确)
   堆栈(Stack)
   队列（Queue）
   字符串(String)
   迭代器(Iterator)

堆栈(Stack) ： 如子弹入弹夹一样 先进后出
队列（Queue）：如排队过隧道 先进先出

2. 以下（）不是合法的标识符？
   正确答案: C 你的答案: C (正确)
   STRING
   x3x
   void
   deSf

void属于java中的关键字
[1]Java标识符只能由数字、字母、下划线“_”或“$”符号以及Unicode字符集组成[2]Java标识符必须以字母、下划线{“}_{”}或“$”符号以及Unicode字符集开头
[3]Java标识符不可以是Java关键字、保留字（const、goto）和字面量（true、false、null）
[4]Java标识符区分大小写，是大小写敏感的

标识符就是变量的意思

3. 通过HttpServletRequest. getParameter获取的参数.
   正确答案: C 你的答案: C (正确)
   总是采用UTF-8编码
   总是采用lS08859-1编码
   由客户端浏览器和Web容器配置共同决定编码
   由服务器所在的操作系统决定编码

乱码问题之所以一直存在，就是由于编码的灵活性，也就是说，编码与其他工作是解耦的。此外，Web 的编码问题与服务器所在的操作系统无关，Web 容器诸如Tomcat可以配置默认编码方式，例如，Tomcat 的默认编码方式是 iso8859-1。乱码的解决之道就是直接或间接的使客户端与Web 容器编码方式兼容。

4. 有以下类定义：
   abstract class Animal{
   abstract void say();
   }
   public class Cat extends Animal{
   public Cat(){
   System.out.printf(“I am a cat”);
   }
   public static void main(String[] args) {
   Cat cat=new Cat();
   }
   }
   运行后：
   正确答案: B 你的答案: B (正确)
   I am a cat
   Animal能编译，Cat不能编译
   Animal不能编译，Cat能编译
   编译能通过，但是没有输出结果

包含抽象方法的类称为抽象类，但并不意味着抽象类中只能有抽象方法，它和普通类一样，同样可以拥有成员变量和普通的成员方法。注意，抽象类和普通类的主要有三点区别：

1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public。

2）抽象类不能用来创建对象；

3）如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。

在其他方面，抽象类和普通的类并没有区别。

5. public class TestThread {
   public static void main(String[] args) {
   Runnable runner = new Runnable() {

    	@Override
    	public void run() {
    		System.out.print("foo");
    		
    	}
    	
    };
    Thread t = new Thread(runner);
    t.run();		
    System.out.print("bar");
   

   }
   }
   正确答案: A 你的答案: A (正确)
   foobar
   barfoo
   foobar或者barfoo都有可能
   Bar
   Foo
   程序无法正常运行

答案是 A foobar 这道题是考线程的调用情况，线程的启动方式只能通过start这种方式启动才能真正的实现多线程的效果，如果是手动调用run方法和普通方法调用没有区别，所以这个还是按照顺序执行首先执行run方法之后，执行输出语句所以最终得到结果foobar.

6. 子类A继承父类B, A a = new A(); 则父类B构造函数、父类B静态代码块、父类B非静态代码块、子类A构造函数、子类A静态代码块、子类A非静态代码块 执行的先后顺序是？
   正确答案: C 你的答案: B (错误)
   父类Ｂ静态代码块->父类Ｂ构造函数->子类Ａ静态代码块->父类Ｂ非静态代码块->子类Ａ构造函数->子类Ａ非静态代码块
   父类Ｂ静态代码块->父类Ｂ构造函数->父类Ｂ非静态代码块->子类Ａ静态代码块->子类Ａ构造函数->子类Ａ非静态代码块
   父类Ｂ静态代码块->子类Ａ静态代码块->父类Ｂ非静态代码块->父类Ｂ构造函数->子类Ａ非静态代码块->子类Ａ构造函数
   父类Ｂ构造函数->父类Ｂ静态代码块->父类Ｂ非静态代码块->子类Ａ静态代码块->子类Ａ构造函数->子类Ａ非静态代码块

正确的执行顺序是:父类Ｂ静态代码块->子类Ａ静态代码块->父类Ｂ非静态代码块->父类Ｂ构造函数->子类Ａ非静态代码块->子类Ａ构造函数
也就是说非静态初始化块的执行顺序要在构造函数之前。

7. 以下代码执行后输出结果为（ ）
   public class Test {
   public static void main(String[] args) {
   System.out.println("return value of getValue(): " +
   getValue());
   }
   public static int getValue() {
   try {
   return 0;
   } finally {
   return 1;
   }
   }
   }
   正确答案: A 你的答案: C (错误)
   return value of getValue(): 1
   return value of getValue(): 0
   return value of getValue(): 0return value of getValue(): 1
   return value of getValue(): 1return value of getValue(): 0

根据官方的JVM规范：
如果try语句里有return，返回的是try语句块中变量值。
详细执行过程如下：

如果有返回值，就把返回值保存到局部变量中；
执行jsr指令跳到finally语句里执行；
执行完finally语句后，返回之前保存在局部变量表里的值。
如果try，finally语句里均有return，忽略try的return，而使用finally的return.

8. 以下程序的执行结果是：
   static boolean foo(char c){
   System.out.print©;
   return true;
   }
   public static void main(String[] args) {
   int i =0;
   for(foo(‘A’);foo(‘B’)&&(i<2);foo(‘C’)){
   i++;
   foo(‘D’);
   }
   }
   正确答案: A 你的答案: A (正确)
   ABDCBDCB
   ABCDABCD
   编译时出错
   运行时抛出异常

1.其实foo(‘A’);就是初始化条件，只会执行一次，所以第一个打印的肯定是A
2.因为i=0;循环条件是i<2 （由此可知循环i等于2的时候就会停止循环，)所有0<2满足条件，接着会输出B，然后执行i++；i就变成1了，再输出D，再最后输出C，一次循环后的结果是：ABDC
3.第二次循环的开始是foo(‘A’);是初始条件所以不会执行，直接从foo(‘B’)开始，输出B，然后i为1，且小于2，此时循环体内再次执行i++；i的值为2了，再次输出D，最后输出C
第二次循环输出：BDC
4.*然后循环再次执行for(foo(‘A’);foo(‘B’)&&(i<2);foo(‘C’))
直接输出B，***i的值在第二轮循环后的值变成了2，2<2不成立，终止循环，输出B

9. 以下代码的输出的正确结果是
   public class Test {
   public static void main(String args[]) {
   String s = “祝你考出好成绩！”;
   System.out.println(s.length());
   }
   }
   正确答案: D 你的答案: D (正确)
   24
   16
   15
   8

java的String底层是char数组，它的length()返回数组大小，而unicode中一个汉字是可以用一个char表示的

一个汉字等于一个字符　　 字符 是char
一个汉字也等于二个字节，字节 是byte

10. 下面哪种流可以用于字符输入：
    正确答案: C 你的答案: C (正确)
    java.io.inputStream
    java.io.outputStream
    java.io.inputStreamReader
    java.io.outputStreamReader

首先B和D排除，题目是要求输入。
A和C之间，inputStream是字节流输入流；而inputStreamReader是对字符流的处理，inputStreamReader将字符流处理成字节流，题目要求是用于处理字符输入，所以选C。

11. 下列哪个对访问修饰符作用范围由大到小排列是正确的？
    正确答案: D 你的答案: B (错误)
    private>default>protected>public
    public>default>protected>private
    private>protected>default>public
    public>protected>default>private
    

12. 关于下列程序段的输出结果，说法正确的是：（ ）
    public class MyClass{
    static int i;
    public static void main(String argv[]){
    System.out.println(i);
    }
    }
    正确答案: D 你的答案: A (错误)
    有错误，变量i没有初始化。
    null
    1
    0

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

13. 在Java中，HashMap中是用哪些方法来解决哈希冲突的？
    正确答案: C 你的答案: A (错误)
    开放地址法
    二次哈希法
    链地址法
    建立一个公共溢出区

以上方法都是解决哈希填冲突的策略，但是在java.util.HashMap中，总体来说是使用的链地址法来解决冲突的。
当然了，使用链地址***导致get的效率从o（1）降至o（n），所以在Java8中，使用的是平衡树来解决提高效率的。

14. 关于以下application,说法正确是什么？
    public class Test {
    static int x=10;
    static {x+=5;}
    public static void main(String[] args) //4
    {
    System.out.println(“x=”+x);
    }
    static{x/=3;};
    }//9
    正确答案: B 你的答案: B (正确)
    4行与9行不能通过编译，因为缺少方法名和返回类型
    编译通过，执行结果是：x=5
    编译通过，执行结果是：x=3
    9行不能通过编译，因为只能有一个静态初始化器

静态代码块先于主方法执行，静态代码块之间遵从代码顺序执行。

15. 关于protected 修饰的成员变量，以下说法正确的是
    正确答案: A 你的答案: B (错误)
    可以被该类自身、与它在同一个包中的其它类、在其它包中的该类的子类所访问
    只能被该类本身和该类的所有的子类访问
    只能被该类自身所访问
    只能被同一个包中的类访问
16. 下列代码编译和运行的结果是：（）
    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
    代码正常运行，但是无输出
17. 根据以下接口和类的定义，要使代码没有语法错误，则类Hero中应该定义方法( )。
    interface Action{
    void fly();
    }
    class Hero implements Action{ //…… }
    正确答案: D 你的答案: B (错误)
    private void fly(){}
    void fly(){}
    protected void fly(){}
    public void fly(){}

接口中的方法默认是public abstract,且子类的访问权限不能低于父类

18. 在java中，下列说法正确的是（）
    正确答案: D 你的答案: C (错误)
    一个类可以继承多个父类
    修饰符可维protected的属性不能被其子类访问
    抽象类可以实例化对象
    无public修饰的类，不能被非同一文件夹中的类和非同一包中的类访问
19. 下列哪个选项是正确计算42度（角度）的余弦值？
    正确答案: C 你的答案: D (错误)
    double d = Math.cos(42)
    double d = Math.cosine(42)
    double d = Math.cos(Math.toRadians(42))
    double d = Math.cos(Math.toDegrees(42))

Math.cos为计算弧度的余弦值，Math.toRadians函数讲角度转换为弧度
20.正则表达式中，表示匹配非数字字符的字符是（）？
正确答案: D 你的答案: D (正确)
\b
\d
\B
\D
大写表示“非”，d表示digit数字。非数字就是\D, w表示word，非单词就是\W

20. 给定includel.isp文件代码片段，如下：
    <% pageContext.setAttribute(“User”,”HAHA”);%>
    ______ // 此处填写代码
    给定include2.jsp文件代码片段如下：
    <%=pageContext.getAttribute(“User”)%>
    要求运行include1.jsp时，浏览器上输出：HAHA
    正确答案: B 你的答案: D (错误)
    <jsp:include page=”include2.jsp” flash=”true”>
    <%@include file=”include2.jsp”%>
    <jsp:forward page=”include2.jsp”>
    <% response.sendRedirect(“include2.jsp”); %>
21. java8中，下面哪个类用到了解决哈希冲突的开放定址法
    正确答案: C 你的答案: A (错误)
    LinkedHashSet
    HashMap
    ThreadLocal
    TreeMap

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

22. 以下程序的输出结果为
    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
编译错误

子类构造方法在调用时必须先调用父类的，由于父类没有无参构造，必须在子类中显式调用，修改子类构造方法如下即可：
public Derived(String s){
super(“s”);
System.out.print(“D”);
}

24. 下面哪些类实现或继承了 Collection 接口？
    正确答案: B C 你的答案: A B (错误)
    HashMap
    ArrayList
    Vector
    Iterator
25. 下面哪些Java中的流对象是字节流?
    正确答案: A B C D 你的答案: B D (错误)
    FileInputStream
    BufferedInputStream
    PushbackInputStream
    ByteArrayInputStream

stream结尾都是字节流，reader和writer结尾都是字符流 两者的区别就是读写的时候一个是按字节读写，一个是按字符。 实际使用通常差不多。 在读写文件需要对内容按行处理，比如比较特定字符，处理某一行数据的时候一般会选择字符流。 只是读写文件，和文件内容无关的，一般选择字节流。

26. 下面哪些情况会引发异常：
    正确答案: A B C 你的答案: A C D (错误)
    数组越界
    指定URL不存在
    使用throw语句抛出
    使用throws语句

1、throws出现在方法头，throw出现在方法体 2、throws表示出现异常的一种可能性，并不一定会发生异常；throw则是抛出了异常，执行throw则一定抛出了某种异常。 3、两者都是消极的异常处理方式，只是抛出或者可能抛出异常，是不会由函数处理，真正的处理异常由它的上层调用处理。

27. 给出下面的代码段:
    public class Base{
    int w, x, y ,z;
    public Base(int a,int b)
    {
    x=a; y=b;
    }
    public Base(int a, int b, int c, int d)
    {
    // assignment x=a, y=b
    w=d;z=c;
    }}
    在代码说明// assignment x=a, y=b处写入如下哪几个代码是正确的？（）
    正确答案: C D 你的答案: C D (正确)
    Base(a,b);
    x=a, y=b;
    x=a; y=b;
    this(a,b);
28. 下列那些方法是线程安全的(所调用的方法都存在)
    正确答案: A C D 你的答案: D (错误)
    public class MyServlet implements Servlet {
    public void service (ServletRequest req, ServletResponse resp) {
    BigInteger I = extractFromRequest(req);
    encodeIntoResponse(resp,factors);
    }
    }
    public class MyServlet implements Servlet {
    private long count =0;
    public long getCount() {
    return count;
    }
    public void service (ServletRequest req, ServletResponse resp) {
    BigInteger I = extractFromRequest(req);
    BigInteger[] factors = factor(i);
    count ++;
    encodeIntoResponse(resp,factors);
    }
    }
    public class MyClass {
    private int value;
    public synchronized int get() {
    return value;
    }
    public synchronized void set (int value) {
    this.value = value;
    }
    }
    public class Factorizer implements Servlet {
    private volatile MyCache cache = new MyCache(null,null);
    public void service(ServletRequest req, ServletResponse resp) {
    BigInteger i = extractFromRequest(req);
    BigInteger[] factors = cache.getFactors(i);
    if (factors == null) {
    factors = factor(i);
    cache = new MyCache(i,factors);
    }
    encodeIntoResponse(resp,factors);
    }
29. 以下哪些类是线程安全的（）
    正确答案: A D E 你的答案: C D (错误)
    Vector
    HashMap
    ArrayList
    StringBuffer
    Properties
30. 关于Java中的ClassLoader下面的哪些描述是错误的：( )
    正确答案: B D F 你的答案: B D E (错误)
    默认情况下，Java应用启动过程涉及三个ClassLoader: Boostrap, Extension, System
    一般的情况不同ClassLoader装载的类是不相同的，但接口类例外，对于同一接口所有类装载器装载所获得的类是相同的
    类装载器需要保证类装载过程的线程安全
    ClassLoader的loadClass在装载一个类时，如果该类不存在它将返回null
    ClassLoader的父子结构中，默认装载采用了父优先
    所有ClassLoader装载的类都来自CLASSPATH环境指定的路径