【每日选择题】 1~10天选择题汇总

最新推荐文章于 2023-03-24 20:33:10 发布

printf("不要熬夜!")

最新推荐文章于 2023-03-24 20:33:10 发布

阅读量232

点赞数

分类专栏：每日一题

本文链接：https://blog.csdn.net/zhangxxin/article/details/116213851

版权

每日一题专栏收录该内容

55 篇文章 2 订阅

订阅专栏

学习目标：

目标：熟练运用Java所学知识

学习内容：

本文内容：每日选择题

day 01 4 月12 日测验

1.执行如下程序，输出结果是（ C ）

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

A 0 22 44 6
B 2 42 42 4
C 2 24 46 6
D 4 44 46 6

2.要使对象具有序列化能力，则其类应该实现如下哪个接口(A)。

A java.io.Serializable
B java.lang.Cloneable,
C java.lang.CharSequence
D java.lang.Comparable

java.io.Serializable ：使代码序列化
java.lang.Cloneable : 克隆
java.lang.CharSequence ：描述字符串
java.lang.Comparable ：排序接口

3.下列选项中属于面向对象设计方法主要特征的是（ A）。
A 继承 B 自顶向下 C 模块化 D 逐步求精

面向对象设计的特征有：类、实例、消息、抽象、封装、继承、组合、多态等。

4.关于下列程序段的输出结果，说法正确的是：（ D）

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

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

局部变量必须初始化，成员变量可以不初始化，不初始化会有默认值,默认值为：

整型（byte、short、int、long）：0
浮点型(float、double)：0.0
布尔型( boolean )： false
字符型(char)： \u0000
引用类型(例如String )： null

5.下列代码的执行结果是：（ B）

public class Test3{
    public static void main(String args[]){
        System.out.println(100%3);
        System.out.println(100%3.0);
    }
}

A 1和1
B 1和1.0
C 1.0和1
D 1.0和1.0

整型和整型之间运算结果为整型，整型和整型之间运算结果为浮点型
%为取模运算

6.在基本 JAVA 类型中，如果不明确指定，整数型的默认是 __ 类型，带小数的默认是 __ 类型？ ( B)
A int float
B int double
C long float
D long double

整数默认是 int ，浮点型默认是 double

7.方法通常存储在进程中的哪一区（D）
A 堆区
B 栈区
C 全局区
D 方法区

8.不考虑反射，关于私有访问控制符 private 修饰的成员变量，以下说法正确的是（C）
A 可以三种类所引用：该类自身、与它在同一包中的其他类，在其他包中的该类的子类
B 可以被两种类访问和引用：该类本身、该类的所有子类
C 只能被该类自身所访问和修改
D. 只能被同一个包中的类访问

private ：只能被自身的类访问
protected：只能被所在包的类访问
public：可以被任何类访问

9.Math.round(11.5) 等于多少 (). Math.round(-11.5) 等于多少 ( C).
A 11 ,-11
B 11 ,-12
C 12 ,-11
D 12 ,-12

Math.round(11.5) 为四舍五入方法，不管正负号

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

public class A
{
    public int i;
    static String s;
    void method1(){}
    static void method2(){}
}

A System.out.println(a.i);
B a.method1();
C A.method1();
D A.method2();

System.out.println(a.i);其中 i 是实例变量，可以被类的对象访问
B a.method1(); method1()是实例方法，能被对象访问，不能被类名访问
A.method2()：method2()是类变量，可以被类名访问
Java中类的方法分为类方法（用static修饰，也叫静态方法）和实例方法（没有用static修饰，也叫非静态方法）

在类方法中不能引用实例变量
在类方法中不能使用super和this关键字
类方法中不能调用实例方法
实例方法可以引用类变量和实例变量
实例方法可以使用super和this关键字
实例方法中可以调用类方法

day 02 4 月13 日测验

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

A a0=new A();
A a1=new B();
A a2=new C();

问以下哪个说法是正确的？（D）
A 只有第一行能通过编译
B 第1、2行能通过编译，但第3行编译出错
C 第1、2、3行能通过编译，但第2、3行运行时出错
D 第1行，第2行和第3行的声明都是正确的

第一行代码属于正常的创建对象
第二行、第三行为向上转型对象(父类引用指向子类实例)

2.下面代码将输出什么内容：（B）

public class SystemUtil{
    public static boolean isAdmin(String userId){
        return userId.toLowerCase()=="admin";
    }
    public static void main(String[] args){
        System.out.println(isAdmin("Admin"));
    }
}

A true
B false
C 1
D 编译错误

（1）toLowerCase()将字符串全部转化成小写字母
（2）toUpperCase()将字符串全部转化成大写字母
字符串属于引用类型，对于字符串使用这个操作userId.toLowerCase()==“admin”;比较的是引用地址，不会比较字符串内容，所以返回false，使用equals方法才会比较内容

3.阅读如下代码。请问，对语句行 test.hello(). 描述正确的有（A）

package NowCoder;
class Test {
    public static void hello() {
        System.out.println("hello");
    }
}
public class MyApplication {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Test test=null;
        test.hello();
    }
}

A 能编译通过，并正确运行
B 因为使用了未初始化的变量，所以不能编译通过
C 以错误的方式访问了静态方法
D 能编译通过，但因变量为null ，不能正常运行

hello方法使用static修饰，是类方法，可以通过类名调用，也可以通过对象调用

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

调用super（）、this（）必须放在子类构造方法的第一行，否则编译不通过，每个子类的构造方法第一句都是隐含的调用super（），如果父类没有这种形式的构造函数。那么在编译时会报错
super()和this()区别：super()是在子类中调用父类构造方法，this()是在同一类中调用其他构造方法
super（）、this（）都指的是对象，所以均不能在static环境中使用

5.如下代码的结果是什么 ?

class Base {
    Base() {
        System.out.print("Base");
    }
}
public class Alpha extends Base {
    public static void main( String[] args ) {
        new Alpha();
        //调用父类无参的构造方法
        new Base();
    }
}

A Base
B BaseBase
C 编译失败
D 代码运行但没有输出
E 运行时抛出异常

创建Alpha对象时会调用父类构造方法，打印Base，创建Base对象时，调用Base构造方法，再次打印Base

6.如下代码的输出结果是什么？(编译失败)

public class Test {
    public int aMethod(){
        static int i = 0;
        i++;
        return i;
    }
    public static void main(String args[]){
        Test test = new Test();
        test.aMethod();
        int j = test.aMethod();
        System.out.println( j);
    }
}

static 修饰的变量不能出现在方法中

7.下列哪一种叙述是正确的（D）
A abstract修饰符可修饰字段、方法和类
B 抽象方法的body部分必须用一对大括号{ }包住
C 声明抽象方法，大括号可有可无
D 声明抽象方法不可写出大括号

abstract修饰类和方法，修饰的类是抽象类，抽象类只能被继承，修饰的方法为抽象方法，抽象方法不能有方法体

8.下列说法正确的有：（C）
A class中的constructor不可省略
B constructor必须与class同名，但方法不能与class同名
C constructor在一个对象被new 时执行
D 一个class只能定义一个constructor

9.选项中哪一行代码可以替换 //add code here 而不产生编译错误(A)

public abstract class MyClass {
    public int constInt = 5;
    //add code here
    public void method() {
    }
}

A public abstract void method(int a);
B consInt=constInt+5;
C public int method();
D public abstract void anotherMethod(){}

抽象方法没有方法体，排除D
抽象类中可以有普通方法，普通方法应有方法体
类中不能对成员变量进行运算操作

10.java 中哪个关键字可以对对象加互斥锁？ (B)
A transient
B synchronized
C serialize
D static

transient : 将不需要序列化的属性前添加关键字transient ，序列化对象的时候，这个属性就不会被序列化.
synchronized : 同步锁、互斥锁
serialize ：序列化

day 03 4 月14 日测验

1.以下代码运行输出的是（C）

public class Person{
    private String name = "Person";
        int age=0;
    }
    public class Child extends Person{
        public String grade;
        public static void main(String[] args){
            Person p = new Child();
            System.out.println(p.name);
    }
}

A 输出：Person
B 没有输出
C 编译出错
D 运行出错

私有变量只能本类中使用

2.以下程序的输出结果为（D）

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

A BD
B DB
C C
D 编译错误

子类创建含参构造函数，必须使用super()显示的调用父类含参构造函数,正确的为
  public Derived(String s) {
       super(s);
     System.out.print("D");
}

3.下面关于构造方法的说法不正确的是 (B)
A 构造方法也属于类的方法，可以创建对象的时候给成员变量赋值
B 构造方法不可以重载
C 构造方法没有返回值
D 构造方法一定要和类名相同

构造方法可以重载

4.在异常处理中，以下描述不正确的有（D）
A try块不可以省略
B 可以使用多重catch块
C finally块可以省略
D catch块和finally块可以同时省略

异常处理中try 、catch不能省略

5.下列描述中，错误的是（C）
A SQL语言又称为结构化查询语言
B java中”static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问
C 面向对象开发中，引用传递意味着传递的并不是实际的对象，而是对象的引用，因此，外部对引用对象所做的改变不会反映到所引用的对象上
D java是强类型语言，javascript是弱类型语言
E 面向对象的三大特性包括：封装，继承，多态

引用传递后，新的引用和就得引用都指向该对象，所以新的引用对对象的改变会映射到对象上

6.下列哪种说法是正确的？（C）
A 实例方法可直接调用超类的实例方法
B 实例方法可直接调用超类的类方法
C 实例方法可直接调用本类的类方法
D 实例方法可直接调用其他类的实例方法

当超类中的方法是private修饰的时候，实例方法不可以直接调用；

7.有以下代码片段：

String str1="hello";
String str2="he"+ new String("llo");
System.out.println(str1==str2);

请问输出的结果是：（D）
A true
B 都不对
C null
D false

在引用类型中 == 操作比较的是地址
equals（）方法比较的是内容

8.程序读入用户输入的一个值，要求创建一个自定义的异常，如果输入值大于 10 ，使用 throw 语句显式地引发异常，异常输出信息为 ”something’swrong!” ，语句为（A）
A if(i>10)throw new Exception(“something’swrong!”);
B if(i>10)throw Exception e(“something’swrong!”);
C if(i>10) throw new Exception e(“something’swrong!”);
D if(i>10)throw Exception( “something’swrong!”);

9.以下关于集合类ArrayList 、LinkedList 、HashMap 描述错误的是：（C）
A HashMap 实现Map 接口，它允许任何类型的键和值对象，并允许将null 用作键或值
B ArrayList 和LinkedList 均实现了List 接口
C 添加和删除元素时， ArrayList 的表现更佳
D ArrayList 的访问速度比LinkedList 快

10.关于 Java 线程，下面说法错误的是（C）。
A 创建线程可以通过实现Runnable接口和继承Thread类
B java利用线程使整个系统成为异步
C 新线程一旦被创建，它将自动开始运行

新的线程创建后，需要调用start 方法才能运行。

day 04 4 月15日测验

1.下列与队列结构有关联的是（D）

A 函数的递归调用
B 数组元素的引用
C 多重循环的执行
D 先到先服务的作业调度

队列先进先出，栈先进后出

2.下面属于黑盒测试方的是（C）

A 语句覆盖
B 逻辑覆盖
C 边界值分析
D 路径覆盖

黑盒测试的方法：边界值、等价类、错误推测法、场景法、因果图法、判定表组成法、正交实验设计

3.下列不能用作存储容量单位的是（C ）。

A Byte
B GB
C MIPS
D KB

计算机存储信息的最小单位，称之为位（bit ，又称比特），存储器中所包含存储单元的数量称为存储容量，其计量基本单位是字节（Byte ，简称B ），
8 个二进制位称为1 个字节，此外还有KB 、MB 、GB 、TB 等。
MIPS 即Million Instruction Per Second 的简写－－计算机每秒钟执行的百万指令数，是衡量计算机速度的指标。

4.一个教师可讲授多门课程，一门课程可由多个教师讲授。则实体教师和课程间的联系是（ D）。

A 1：1联系
B 1：m联系
C m：1联系
D m：n联系

因为一个教师可讲授多门课程，而一门课程又能由多个老师讲授所以他们之间是多对多的关系，可以表示为 m ： n 。

5.下列关于栈叙述正确的是（ D）。

A 算法就是程序
B 设计算法时只需要考虑数据结构的设计
C 设计算法时只需要考虑结果的可靠性
D 以上三种说法都不对

算法是指解题方案的准确而完整的描述，算法不等于程序，也不等于计算方法，所以 A 错误。设计算法时不仅要考虑对数据对象的运算和操作，还要考虑算法的控制结构。

6.java语言的下面几种数组复制方法中，哪个效率最高？（B）

A for 循环逐一复制
B System.arraycopy
C Array.copyOf
D 使用clone方法

效率： System.arraycopy > clone > Array.copyOf > for 循环

7.结构化程序的三种基本结构是（C ）

A 递归、迭代和回溯
B 过程、函数和子程序
C 顺序、选择和循环
D 调用、返回和选择

仅使用顺序、选择、循环三种基本控制结构就足以表达出各种其他形式结构的程序设计方法

8.下面属于软件定义阶段任务的是(A)
A 需求分析 B 软件测试 C 详细设计 D 系统维护

软件生命周期分为3 个阶段：
• 软件定义阶段，任务是确定软件开发工作必须完成的目标，确定工程的可行性；
• 软件开发阶段，任务是具体完成设计和实现定义阶段所定义的软件，通常包括总体设计、详细设计、编码和测试；
• 软件维护阶段，任务是使软件在运行中持久地满足用户的需要。
需求分析属于软件定义阶段的任务。

9. 1GB 的准确值是（ C）。

A 1024×1024 Bytes
B 1024 KB
C 1024 MB
D 1000×1000 KB

1GB=1024MB=1024 × 1024KB=1024 × 1024 × 1024B 。

10.关于 Socket 通信编程，以下描述错误的是：（ D）

A 服务器端通过new ServerSocket()创建TCP连接对象
B 服务器端通过TCP连接对象调用accept()方法创建通信的Socket对象
C 客户端通过new Socket()方法创建通信的Socket对象
D 客户端通过new ServerSocket()创建TCP连接对象

客户端通过new Socket() 创建TCP 连接对象

day 05 4 月16 日测验

1下面的程序编译运行后，在屏幕上显示的结果是（A）

public class test {
    public static void main(String args[]) {
        int x,y;
        x=5>>2;
        y=x>>>2;
        System.out.println(y);
    }
}

A 0
B 2
C 5
D 80

>>为右移操作，相当于除以2。正数右移往左侧添加0，负数右移添加1

<<为左移操作，相当于乘2，左移往右侧添加0

>>>为无符号右移，忽视负数的符号位，无符号右移时往左侧添加0

2.以下代码结果是什么？(C)

public class foo {
    public static void main(String sgf[]) {
        StringBuffer a=new StringBuffer(“A”);
        StringBuffer b=new StringBuffer(“B”);
        operate(a,b);
        System.out.println(a+”.”+b);
    }
    static void operate(StringBuffer x,StringBuffer y) {
        x.append(y);
        y=x;
    }
}

A 代码可以编译运行，输出“AB.AB”。
B 代码可以编译运行，输出“A.A”。
C 代码可以编译运行，输出“AB.B”。
D 代码可以编译运行，输出“A.B”。

StringBuffer为引用类型，a和b中保存的是A、B在内存中的地址;

执行operate后差创建了两个新变量x，y分别指向A、B;

执行x.append(y)之后，将x指向的"A"添加上"B",变成"AB"

y=x将y指向x指向的对象

operate执行结束之后，x，y被销毁

a 指向的buffer 对象为"AB" ， b 指向的buffer 对象为"B" （引用b 从头至尾没变过，其指向的对象也没变过）.

3.在JAVA中，假设A有构造方法A(int a)，则在类A的其他构造方法中调用该构造方法和语句格式应该为（B）

A this.A(x)
B this(x)
C super(x)
D A(x)

this()调用本类中的其他构造方法

super()调用父类的构造方法

A 调用当前类的其他实例方法
C 调用父类的构造方法
D 调用当前类的其他类方法

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

public static void main(String[] args){
    String s;
    System.out.println("s="+s);
}

A 代码编程成功，并输出”s=”
B 代码编译成功，并输出”s=null”
C 由于String s没有初始化，代码不能编译通过。
D 代码编译成功，但捕获到NullPointException异常

局部变量必须初始化，类变量不需要初始化

5.装箱、拆箱操作发生在: (C)

A 类与对象之间
B 对象与对象之间
C 引用类型与值类型之间
D 引用类型与引用类型之间

引用类型和值类型之间的转换，int和Integer类的转换

值类型转换成引用类型就是装箱，int->Integer

引用类型转换成值类型就是拆箱，Intger->int

6.一个以”.java”为后缀的源文件(C)

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

.java文件可以包含多个类，但是只能有一个public类，并且必须与文件名相同

7.下列哪个说法是正确的（D）
A ConcurrentHashMap使用synchronized关键字保证线程安全
B HashMap实现了Collction接口
C Array.asList方法返回java.util.ArrayList对象
D SimpleDateFormat是线程不安全的

ConcurrentHashMap 使用Synchronized + CAS 实现粒度更加细的锁保证线程安全

HashMap实现了Map、Cloneable、Serializable接口

Arrays.asList 方法返回java.util.Arrays.ArrayList 对象

8.以下说法错误的是(D)
A 虚拟机中没有泛型，只有普通类和普通方法
B 所有泛型类的类型参数在编译时都会被擦除
C 创建泛型对象时请指明类型，让编译器尽早的做参数检查
D 泛型的类型擦除机制意味着不能在运行时动态获取List<T> 中T 的实际类型

1、创建泛型对象的时候，一定要指出类型变量T 的具体类型。争取让编译器检查出错误，而不是留给JVM 运行的时候抛出类不匹配的异常。
2、JVM 如何理解泛型概念——类型擦除。事实上，JVM 并不知道泛型，所有的泛型在编译阶段就已经被处理成了普通类和方法。处理方法很简单，
我们叫做类型变量T 的擦除(erased) 。
总结：泛型代码与JVM

虚拟机中没有泛型，只有普通类和方法。
在编译阶段，所有泛型类的类型参数都会被Object 或者它们的限定边界来替换。(类型擦除)
在继承泛型类型的时候，桥方法的合成是为了避免类型变量擦除所带来的多态灾难。无论我们如何定义一个泛型类型，相应的都会有一个原始类型被自动提供。原始类型的名字就是擦除类型参数的泛型类型的名字。

Java 泛型是使用擦除来实现的，这意味着当你在使用泛型时，任何具体的类型信息都被擦除了，你唯一知道的就是你在使用一个对象。因此List<String> 和List<Integer> 运行时实际上是相同的类型。这两种类型都被擦除成它们的“原生”类型，即List 。

9.下列代码执行结果为（A）

public static void main(String args[])throws InterruptedException{
    Thread t=new Thread(new Runnable() {
        public void run() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.print("2");
    }
    })；
    t.start();
    t.join();
    System.out.print("1");
}

A 21
B 12
C 可能为12，也可能为21
D 以上答案都不对

join 方法的主要作用就是同步，它可以使得线程之间的并行执行变为串行执行。在A 线程中调用了B 线程的join() 方法时，表示只有当B线程执行完毕时，A 线程才能继续执行。

10.以下程序运行的结果是( B )

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 good and abc
B good and gbc
C test ok and abc
D test ok and gbc

调用change 的方法时，向该方法的str 传入了"good" 的地址，向该方法的数组传入了{'a','b','c'} 的地址，修改str ，将其指
向"test ok" ，但此时ex.str 依旧指向的是"good" .
修改ch 指向的数组的元素， ex.ch 指向的也是该数组，所以看到的是跟着变。

day 06 4 月17 日测验

1.下面哪段程序能够正确的实现了GBK编码字节流到UTF-8编码字节流的转换：(B)

byte[] src,dst;

A dst=String.frombytes(src,"GBK").getbytes("UTF-8")
B dst=new String (src,"GBK").getbytes("UTF-8")
C dst=new String ("GBK", src).getbytes()
D dst=String.encode(String.decode(src,"GBK")), “"UTF-8"

getBytes(String charsetName) ：将字符串以指定的编码转为字节数组
new String(byte[] bytes,String charsetName); ：按照指定的编码将字节数组转换为字符串

2.下列关于java 并发的说法中正确的是：(B)
A copyonwritearraylist 适用于写多读少的并发场景
B readwritelock 适用于读多写少的并发场景
C concurrenthashmap 的写操作不需要加锁，读操作需要加锁
D 只要在定义int 类型的成员变量i 的时候加上volatile 关键字，那么多线程并发执行i++ 这
样的操作的时候就是线程安全的了

copyonwritearraylist 适用于写少读多的并发场景
readwritelock : 读写锁，要求写写互斥、读写互斥，读读可以并发执行，在读多写少的情况下可以提高效率
concurrenthashmap 是同步的HashMap ，读写都需要加锁
volatile 只保证多线程操作的可见性，不保证原子性

3.以下关于集合类ArrayList 、LinkedList 、HashMap 描述错误的是：(C)
A HashMap 实现Map 接口，它允许任何类型的键和值对象，并允许将null 用作键或值
B ArrayList 和LinkedList 均实现了List 接口
C 添加和删除元素时， ArrayList 的表现更佳
D ArrayList 的访问速度比LinkedList 快

添加和删除元素时， ArrayList 需要将该元素后边的元素进行挪动，效率并没有提高。

4.下列哪个对访问修饰符作用范围由大到小排列是正确的？(D)
A private > default > protected > public
B public > default > protected > private
C private > protected > default > public
D public > protected > default > private

private : 类级权限，只能在当前类中使用。
无修饰符：包级权限，可以被同一包中的所有类进行访问。
protected : 包级权限，既可以被同一包中的所有类进行访问, 也可被子类进行访问（不管与子类是否在同一包中）。
public : 可以被任意的类访问。

5.在Java 中， HashMap 中是用哪些方法来解决哈希冲突的(C)

A 开放地址法

B 二次哈希法

C 链地址法

D 建立一个公共溢出区

6.阅读下列程序，选择哪一个是正确的输出结果(C)

class HelloA{
    public HelloA()
    {
        System.out.println("I’m A class ");
    }
    static
    {
        System.out.println("static A");
    }
    }
    public class HelloB extends HelloA{
        public HelloB()
    {
        System.out.println("I’m B class");
    }
    static{
        System.out.println("static B");
    }
    public static void main (String[] args){
        new HelloB();
    }
}

A static A I’m A class static B I’m B class
B I’m A class I’m B class static A static B
C static A static B I’m A class I’m B class
D I’m A class static A I’m B class static B

静态代码块是类加载的时候执行的，所以会最先执行

创建子类实例时，会先构造父类的实例

父类实例的初始化顺序，就地初始化和普通代码块按顺序执行，最后执行构造方法

7.执行下列代码的输出结果是( C)

public class Demo {
    public static void main(String args[]) {
        int num = 10;
        System.out.println(test(num));
    }

    public static int test(int b) {
        try {
            b += 10;
            return b;
        } catch (RuntimeException e) {
        } catch (Exception e2) {
        } finally {
            b += 10;
            return b;
        }
    }
}

A 10
B 20
C 30
D 40

Java 处理异常代码的执行顺序：

执行try 中的代码，如果遇到异常且被catch 捕获到，则执行对应的catch 语句，无论是否执行catch ， finally 块一定会被执行到。
如果try 或catch 中含有return ，当代码执行到return 时，先把此处要返回的值保存到当前的栈帧中，然后执行finally 语句，
如果finally 中没有return 语句，则执行完finally 后回到刚刚的return 处返回刚才栈帧中保存的要返回的值，如果finally 中有return 语句，则从此处返回，不再执行try 或catch 中的return

本题中：执行到第11 行时，遇到了return ，此时b 是20，把20 保存到当前的栈帧中，然后执行finally 语句， b 变为30， finally 中
有return 语句，则从此处返回b ：30。若finally 中没有return 语句，则返回的是刚才栈帧中保存的值20，而非30

8.以下是java concurrent 包下的4 个类，选出差别最大的一个(C)
A Semaphore

B ReentrantLock

C Future

D CountDownLatch

Semaphore : 控制某个资源可被同时访问的个数;
ReentrantLock 具有与使用synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大；
Future 接口，表示异步计算的结果；表示获取一个正在指定的线程的结果。对该线程有取消和判断是否执行完毕等操作。
CountDownLatch 可以用来在一个线程中等待多个线程完成任务的类。是个锁存器，他表示我要占用给定的多少个线程且我优先执行，我执行完之前其他要使用该资源的都要等待。

9.关于sleep 和wait , 以下描述错误的是(D)
A sleep 是线程类的方法， wait 是object 的方法
B sleep 不释放对象锁， wait 放弃对象锁
C sleep 暂停线程，但监控状态依然保持，结束后会自动恢复
D wait 进入等待锁定池，只有针对此对象发出notify 方法获得对象锁进入运行状态

wait 进入等待锁定池，只有针对此对象发出notify 方法获得对象锁进入“就绪”状态即准备获取对象锁进入运行状态。而不是立即获得。

10.下列代码的输出结果是( false )

 boolean b=true?false:true==true?false:true;
 System.out.println(b);

day 07 4 月19 日测验

1.JAVA属于（D ）。

A 操作系统
B 办公软件
C 数据库系统
D 计算机语言

2.类声明中，声明抽象类的关键字是 (B )
A public B abstract C final D class

3.在使用 interface 声明一个接口时，只可以使用（D）修饰符修饰该接口
A.private B protected C private D public

接口的限定访问修饰符只有public

4. Math.round(11.5) 等于：(C)

A 11
B 11.5
C 12
D 12.5

5，以下对继承的描述错误的是（A）
A Java中的继承允许一个子类继承多个父类
B 父类更具有通用性，子类更具体
C Java中的继承存在着传递性
D 当实例化子类时会递归调用父类中的构造方法

Java中只能单继承，一个子类只能继承一个父类，但可以实现多个接口

6.在 java 中 , 一个类（B）
A 可以继承多个类
B 可以实现多个接口
C 在一个程序中只能有一个子类
D 只能实现一个接口

7.关于以下程序代码的说明正确的(D)

class HasStatic{
    private static int x = 100;
    public static void main(String args[ ]){
        HasStatic hs1 = new HasStatic();
        hs1.x++;
        HasStatic hs2 = new HasStatic();
        hs2.x++;
        hs1=new HasStatic();
        hs1.x++;
        HasStatic.x--;
        System.out.println( "x=" +x);
    }
}

A 5行不能通过编译，因为引用了私有静态变量
B 10行不能通过编译，因为x是私有静态变量
C 程序通过编译，输出结果为：x=103
D 程序通过编译，输出结果为：x=102

类变量可以通过对象访问，也可以通过类名访问

8.以下 _____ 不是 Object 类的方法 (D)

A clone（）
B finalize()
C toString()
D hasNext()

Object类方法
Object是所有类的父类，任何类都默认继承Object。Object类到底实现了哪些方法？
（1）clone方法
保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。
（2）getClass方法
final方法，获得运行时类型。
（3）toString方法

该方法用得比较多，一般子类都有覆盖。
（4）finalize方法
该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。
（5）equals方法
该方法是非常重要的一个方法。一般equals和==是不一样的，但是在Object中两者是一样的。子类一般都要重写这个方法
（6）hashCode方法
该方法用于哈希查找，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。
一般必须满足obj1.equals(obj2)==true。可以推出obj1.hash- Code()==obj2.hashCode()，但是hashCode相等不一定就满足equals。不过为了提高效率，应该尽量使上面两个条件接近等价。
（7）wait方法
wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。
调用该方法后当前线程进入睡眠状态，直到以下事件发生。
（1）其他线程调用了该对象的notify方法。
（2）其他线程调用了该对象的notifyAll方法。
（3）其他线程调用了interrupt中断该线程。
（4）时间间隔到了。
此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。
（8）notify方法
该方法唤醒在该对象上等待的某个线程。
（9）notifyAll方法
该方法唤醒在该对象上等待的所有线程。

9.下面哪一项不是 java 类访问控制关键字（B）

A public
B this
C private
D protected

10.java 语言使用的字符码集是(D)
A ASCII
B BCD
C DCB
D Unicode

day 08 4 月20 日测验

1.java中关于内存回收的正确说法是（B）

A 程序员必须创建一个线程来释放内存
B 内存回收程序负责释放无用内存
C 内存回收程序允许程序员直接释放内存
D 内存回收程序可以在指定的时间释放内存对象

2.A派生出子类B，B派生出子类C，并且在java源代码中有如下声明：（A）

A a0=new A();
A a1=new B();
A a2=new C();

3.以下说法错误的是（C）

A 数组是一个对象
B 数组不是一种原生类
C 数组的大小可以任意改变
D 在Java中，数组存储在堆中连续内存空间里

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

public 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;
            } catch (Exception e) {
                System.out.println(e.toString());
            } finally {
                this.setValue(value);
                System.out.println(value);
            }
            return value;
        }
    }

    static class B extends A {
        public B() {
            super(5);
            setValue(getValue() - 3);
        }

        public void setValue(int value) {
            super.setValue(2 * value);
        }
    }
}

5.关于Java的异常处理机制的叙述哪些正确？(C)

A 如果程序发生错误及捕捉到异常情况了，才会执行finally部分
B 其他选项都不正确
C 当try区段的程序发生异常且被catch捕捉到时，才会执行catch区段的程序
D catch部分捕捉到异常情况时，才会执行finally部分

fianlly部分一定会执行，当try被catch捕获到异常时，才会执行catch部分

6.如何跳出Array的forEach循环？（ A）

A break B return true C return false D 以上都不是

跳出本次循环进入下一轮循环： continue
跳出循环： break 或者return 语句，但后者必须放在函数中，且return 的值类型要和函数的值类型一致

7.一个以.java 为后缀的源文件(C)
A 只能包含一个类，类名必须与文件名相同
B 只能包含与文件名相同的类以及其中的内部类
C 只能有一个与文件名相同的类，可以包含其他类
D 可以包含任意类

8.如下Java语句

double x= 3.0;
int y=5;
x/=--y;

执行后， x的值是（D）
A 3
B 0.6
C 0.4
D 0.75

public class Test{
    static int cnt = 6;
    static{
        cnt += 9;
    }
    public static void main(String[] args）{
        System.out.println（“cnt =” + cnt);
    }
    static{
        cnt /=3;
    };
}

cnt的值是(A)

A cnt=5
B cnt=2
C cnt=3
D cnt=6

10.JUnit主要用来完成什么(D)

A 发送HTTP请求
B 建立TCP连接
C 集成测试
D 单元测试

day09 4 月21 日测验

1.下面程序的输出是:(D

String x="fmn";
x.toUpperCase();
String y=x.replace('f','F');
y=y+"wxy";
System.out.println(y);

A FmNwxy
B fmnwxy
C wxyfmn
D Fmnwxy

字符串属于不可变对象，对字符串进行修改实际上是创建了新的字符串，第二行虽然调用了转大写方法但是x还是指向原来的“fmn”，第三行也是创建了新的字符串"Fmn",y指向了这个新的字符串，第四行也是创建了新的字符串"Fmnxyz"，y指向新的字符串

2.以下多线程对int型变量x的操作,哪个不需要进行同步(D)
A ++x
B x=y
C x++
D x=1

3.关于 JAVA 堆,下面说法错误的是(D)
A 所有类的实例和数组都是在堆上分配内存的
B 对象所占的堆内存是由自动内存管理系统回收
C 堆内存由存活和死亡的对象,空闲碎片区组成
D 数组是分配在栈中的

堆内存用来存放由new创建的对象和数组，在堆中分配内存，有 Java虚拟机的自动垃圾回收器来管理

4,一个以“.java”为后缀的源文件（C）
A 只能包含一个public类，类名必须与文件名相同
B 只能包含与文件名相同的public类以及其中的内部类
C 只能有一个与文件名相同的public类，可以包含其他非public类（不考虑内部类）
D 可以包含任意public类

5.JAVA语言的下面几种数组复制方法中，哪个效率最高？
A for循环逐一复制
B System.arraycopy
C Arrays.copyOf
D 使用clone方法

效率： System.arraycopy > clone > Array.copyOf > for 循环

6.下面那些情况可以终止当前线程的运行(B)
A 当一个优先级高的线程进入就绪状态时
B 抛出一个异常时
C 当该线程调用sleep() 方法时
D 当创建一个新线程时

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

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

子类继承父类，当子类父类都只有含参构造方法时，子类需要显示的使用super()调用父类的含参构造方法

8.有关下述Java代码描述正确的选项是____。（F）

public class TestClass {
    private static void testMethod(){
        System.out.println("testMethod");
    }
    public static void main(String[] args) {
        ((TestClass)null).testMethod();
    }
}

A 编译不通过
B 编译通过，运行异常，报NullPointerException
C 编译通过，运行异常，报IllegalArgumentException
D 编译通过，运行异常，报NoSuchMethodException
E 编译通过，运行异常，报Exception
F 运行正常，输出testMethod

将null强制转化成TestClass类型，可以调用TestClass中的方法

9.下列java程序的输出结果为____。（B）

public class Example{
    String str=new String("hello");
    char[]ch={'a','b'};
    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]='c';
    }
}

A hello and ab
B hello and cb
C hello and a
D test ok and ab
E test ok and cb
F test ok and c

10.在jdk1.5之后，下列 java 程序输出结果为______。（B）

int i=0;
Integer j = new Integer(0);
System.out.println(i==j);
System.out.println( j.equals(i));

A true,false
B true,true
C false,true
D false,false
E 对于不同的环境结果不同
F 程序无法执行

Integer与int做运算会自动拆箱，所以此处比较的都是值

day 10 4 月20 日测验

1.结构型模式中最体现扩展性的模式是（A）
A 装饰模式
B 合成模式
C 桥接模式
D 适配器

结构型模式是描述如何将类对象结合在一起，形成一个更大的结构，结构模式描述两种不同的东西：类与类的实例。故可以分为类结构模式和对象结构
模式。
在GoF 设计模式中，结构型模式有：

1. 适配器模式Adapter

适配器模式是将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
两个成熟的类需要通信，但是接口不同，由于开闭原则，我们不能去修改这两个类的接口，所以就需要一个适配器来完成衔接过程。
2. 桥接模式Bridge
桥接模式将抽象部分与它的实现部分分离，是它们都可以独立地变化。它很好的支持了开闭原则和组合锯和复用原则。实现系统可能有多角度分类，
每一种分类都有可能变化，那么就把这些多角度分离出来让他们独立变化，减少他们之间的耦合。
3. 组合模式Composite
组合模式将对象组合成树形结构以表示部分-整体的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。
4. 装饰模式Decorator
装饰模式动态地给一个对象添加一些额外的职责，就增加功能来说，它比生成子类更灵活。也可以这样说，装饰模式把复杂类中的核心职责和装饰功能
区分开了，这样既简化了复杂类，有去除了相关类中重复的装饰逻辑。装饰模式没有通过继承原有类来扩展功能，但却达到了一样的目的，而且比继承更加
灵活，所以可以说装饰模式是继承关系的一种替代方案。
5. 外观模式Facade
外观模式为子系统中的一组接口提供了同意的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
外观模式中，客户对各个具体的子系统是不了解的，所以对这些子系统进行了封装，对外只提供了用户所明白的单一而简单的接口，用户直接使用这个
接口就可以完成操作，而不用去理睬具体的过程，而且子系统的变化不会影响到用户，这样就做到了信息隐蔽。
6. 享元模式Flyweight
享元模式为运用共享技术有效的支持大量细粒度的对象。因为它可以通过共享大幅度地减少单个实例的数目，避免了大量非常相似类的开销。
享元模式是一个类别的多个对象共享这个类别的一个对象，而不是各自再实例化各自的对象。这样就达到了节省内存的目的。

2.下面代码运行结果是（C）

public class Test{
    public int add(int a,int b){
        try {
            return a+b;
        }
        catch (Exception e) {
            System.out.println("catch语句块");  
        }
        finally{
            System.out.println("finally语句块");
        }
        return 0;
    }
    public static void main(String argv[]){
        Test test =new Test();
            System.out.println("和是："+test.add(9, 34));
        }
}

A catch语句块和是：43
B 编译异常
C finally语句块和是：43
D 和是：43 finally语句块

执行try语句，如果遇到异常且被catch捕获到，则会执行catch语句块，fianlly一定会执行
当try或catch中含有return时，当代码执行到return，先把此处要返回的结果保存到栈帧中，然后执行finally语句，如果finally中没有return语句，则执行完finally语句，然后返回刚保存到栈帧中的结果，如果finally中有return，则执行此处的return，不执行try或catch中的return

本题中try中有return语句，catch没有捕获到异常，不执行catch语句，执行finally语句打印“finally语句块”，然后程序返回try中的return 43

3.下列Java代码中的变量a、b、c分别在内存的____存储区存放。(C)

class A {
    private String a = “aa”;
    public boolean methodB() {
        String b = “bb”;
        final String c = “cc”;
    }
}

A 堆区、堆区、堆区
B 堆区、栈区、堆区
C 堆区、栈区、栈区
D 堆区、堆区、栈区
E 静态区、栈区、堆区
F 静态区、栈区、栈区

a是A的成员变量，会随着创建类A的对象a是被创建出来，new出来的对象在堆区，随意a也在堆区

b和c都是局部变量，在methodB方法被调用的时候在栈中创建，方法调用结束，局部变量会被销毁

4.以下声明合法的是(B)
A default String s
B public final static native int w( )
C abstract double d
D abstract final double hyperbolicCosine( )

default 使用场景： switch case 语句中，接口中修饰非抽象方法
abstract 只能修饰类和方法
abstract 修饰方法表明继承此类的方法需要重写该方法，而final 修饰表示该方法不能被重写。两者冲突，即不能同时修饰一个方法

5.在使用super 和this关键字时，以下描述正确的是(A)
A 在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过
B super（）和this（）不一定要放在构造方法内第一行
C this（）和super（）可以同时出现在一个构造函数中

D this（）和super（）可以在static环境中使用，包括static方法和static语句块

6.下面代码的输出结果是什么？(D)

public class ZeroTest {
    public static void main(String[] args) {
        try{
            int i = 100 / 0;
            System.out.print(i);
        }catch(Exception e){
            System.out.print(1);
            throw new RuntimeException();
        }finally{
            System.out.print(2);
        }
        System.out.print(3);
    }
}

A 3
B 123
C 1
D 12

执行100/0出现异常，被catch捕获，执行catch中的代码，打印1，遇到throw语句先执行finally语句，打印2，然后回到throw打印异常，程序结束

7.代码片段：

byte b1=1,b2=2,b3,b6;
final byte b4=4,b5=6;
b6=b4+b5;
b3=(b1+b2);
System.out.println(b3+b6);

关于上面代码片段叙述正确的是（C）
A 输出结果：13
B 语句：b6=b4+b5编译出错
C 语句：b3=b1+b2编译出错
D 运行期抛出异常

cpu在进行计算式，会进行整型提升，把byte提升为int后进行计算，第四行左边是byte类型，右边是int类型，所以或出错

8.以下java程序代码，执行后的结果是（B）

public class Test {
    public static void main(String[] args) {
        Object o = new Object() {
            public boolean equals(Object obj) {
            return true;
            }
        };
        System.out.println(o.equals("Fred"));
    }
}

A Fred
B true
C 编译错误
D 运行时抛出异常

重写了Object中的equals方法，使得所有类型与o进行比较都是true

9.执行以下程序后的输出结果是（D）

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

A A,A
B A,B
C B,B
D AB,B

1. 运行程序， a 指向的buffer 对象为"A" , b 指向的buffer 对象为"B" .
2. 执行方法， x 指向的buffer 对象为"A" , y 指向的buffer 对象为"B" .
3. a 和x 指向的对象位于内存的同一区域（即同一个对象）， b 和y 指向的对象位于内存的同一区域（即同一个对象）
4. 执行方法append , x 指向的对象加上字符"B" ，变为"AB" .(引用a 指向该对象)
5. y=x ，把引用y 指向x 指向的对象。
6. operate 执行完毕，局部变量x 、y 被销毁。
7. a 指向的buffer 对象为"AB" （第四步的结果）， b 指向的buffer 对象为"B" （引用b 从头至尾没变过，其指向的对象也没变过）.

10.下面所示的java代码，运行时，会产生（）类型的异常(D)

int Arry_a[] = new int[10];
System.out.println(Arry_a[10]);

A ArithmeticException
B NullPointException
C IOException
D ArrayIndexOutOfBoundsException

数组的上界为9，所以会产生下标越界异常

printf("不要熬夜!")

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
【每日选择题】 1~10天选择题汇总

学习目标：目标：熟练运用Java所学知识学习内容：本文内容：每日选择题目录学习目标：学习内容：day 01day 03day 011.执行如下程序，输出结果是（ C ）class Test{ private int data; int result = 0; public void m() { result += 2; data += 2; System.out.prin...
复制链接

扫一扫

专栏目录