Java习题解析

Java方向每日一题day02_4月13日

选择题

第一题

A 派生出子类 B ， B 派生出子类 C ，并且在 java 源代码有如下声明： 1. A a0=new A(); 2. A a1=new B(); 3. A a2=new C();

问以下哪个说法是正确的？（）

A 只有第一行能通过编译

B 第1、2行能通过编译，但第3行编译出错

C 第1、2、3行能通过编译，但第2、3行运行时出错

D 第1行，第2行和第3行的声明都是正确的

答案：D

解析：本题考查的是继承的传递性，A 作为父类，其引用可以指向子类的实例化对象

第二题

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 编译错误

答案：B false

本体考察的是引用地址问题，toLowerCase()会重新创建一个新的字符串，这样一来 “=="比较的就两个对象的地址，所以返回false

第三题

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

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，不能正常运行

答案：A

解析：因为 hello() 是一个类方法，不依附于对象，所以能够正常运行

第四题

在使用super和this关键字时，以下描述正确的是（）

A 在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过

B super（）和this（）不一定要放在构造方法内第一行

C this（）和super（）可以同时出现在一个构造函数中

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

答案：A

解析：

• this 和 super只能放在第一行
• this() 和 super() 不可以同时出现在一个构造函数中，因为你不能保证 this() 是否还会不会调用到 super()

第五题

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 运行时抛出异常

答案：B

解析：因为 Alpha 继承于 Base，所以在创建 Alpha 实例的时候会先执行父类的构造方法，打印了一次 Base，之后又实例了 Base 的对象，再次打印一次 Base

第六题

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

A 0

B 1

C 2

D 编译失败

答案：D

解析：static 不能够修饰局部变量

第七题

下列哪一种叙述是正确的（）

A abstract修饰符可修饰字段、方法和类

B 抽象方法的body部分必须用一对大括号{ }包住

C 声明抽象方法，大括号可有可无

D 声明抽象方法不可写出大括号

答案：D

解析：

A、abstract只能修饰方法和类，不能修饰字段

B、抽象方法没有body部分

C、抽象方法不能写出{ }，要以";"结尾

第八题

下列说法正确的有：（）

A class中的constructor不可省略

B constructor必须与class同名，但方法不能与class同名

C constructor在一个对象被new 时执行

D 一个class只能定义一个constructor

答案：C

解析：A 构造函数可以省略，默认为无参的构造函数

B 构造函数必须和类同名，但是方法是可以和class同名的，其余构造方法的唯一区别就是构造方法没有返回值

D 可以重载构造方法

第九题

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

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

答案：A

解析：

B、类体中只能定义变量和方法名，不能够有其他语句

C、与下面的方法重名，重载应该是参数不一样而不是返回类型不一样

D、抽象方法没有 { }

第十题

java 中哪个关键字可以对对象加互斥锁？

A transient

B synchronized

C serialize

D static

答案：B

解析：transient：序列化对象包含被 transient 修饰的实例变量时，java 虚拟机跳过该特定的变量

synchronized关键字：用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这个段代码

serialize：Java 对象序列化为二进制文件

编程题

第一题

标题：排序子序列

【排序子序列】牛牛定义排序子序列为一个数组中一段连续的子序列,并且这段子序列是非递增或者非递减排序的。牛牛有一个长度为n的整数数组A,他现在有一个任 务是把数组A分为若干段排序子序列,牛牛想知道他最少可以把这个数组分为几段排序子序列. 如样例所示,牛牛可以把数组A划分为[1,2,3]和[2,2,1]两个排序子序列,至少需要划分为2个排序子序列,所以输出2

输入描述：

输入的第一行为一个正整数n(1 ≤ n ≤ 10^5)

第二行包括n个整数A_i(1 ≤ A_i ≤ 10^9),表示数组A的每个数字。

输出描述：

输出一个整数表示牛牛可以将A最少划分为多少段排序子序列

示例1：

输入

6

1 2 3 2 2 1

输出

2

代码如下：

import java.util.Scanner;

public class Main {
 public static void main(String[] args) {
     //输入api
     Scanner scanner = new Scanner(System.in);
     //输入个数 n
     int n = scanner.nextInt();
     //创建数组来表示A
     int[] A = new int[n];
     for(int i = 0; i < n; i++){
         A[i] = scanner.nextInt();
     }
     //创建判断标志位以及子序列个数
     //使用 0 来表示开始判断子序列的标志
     //使用 1 来表示增序列
     //使用 -1 来表示减序列
     int flag = 0;
     //子序列个数，由于我们判断是否为子序列的标志是判断标志位从 1 或 -1重新标为 0
     //即从递增序列或者递减序列进入到递减序列或递增序列，所以子序列为 真实子序列数 - 1
     int result = 1;
     //循环判断
     for(int i = 1; i < n; i++){
         //如果当前数字大于前一个数字说明现在为递增序列
         if(A[i] > A[i - 1]) {
             //如果标志位为 0 表示刚刚开始，则将标志位置为 1 表示递增序列
             if(flag == 0){
                 flag = 1;
             }
             //如果标志位为 -1，说明之前的序列为递减序列，那么重置标志位为 0，并且子序列数 + 1
             //即数组序列是这样排列的情况 3 2 1 3
             if(flag == -1){
                 flag = 0;
                 result++;
             }
         }else if(A[i] < A[i - 1]){
             if(flag == 0){
                 flag = -1;
             }
             if(flag == 1){
                 flag = 0;
                 result++;
             }
         }
         //这里不判断相邻数字相等的情况是因为
         // 如果相邻数字相同则表示在还是在递增或者递减子序列中，因为判断标志位没变
     }
     System.out.println(result);
     scanner.close();
 }
}

第二题

标题：倒置字符串

【倒置字符串】将一句话的单词进行倒置，标点不倒置。比如 I like beijing. 经过函数后变为：beijing. like I 输入描述：

每个测试输入包含1个测试用例： I like beijing. 输入用例长度不超过100

输出描述：

依次输出倒置之后的字符串,以空格分割

示例1：

输入

I like beijing.

输出

beijing. like I

解析：遍历字符串，如果遇到的是空格则将字符串添加到顺序表中，如果不是则将字符加到string字符串中，注意：因为是遇到空格加到顺序表中，所以最后还要添加一次。

最后再将顺序表反向遍历输出.

代码如下：

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main{
    public static List<String> invert(String str){
        List<String> list = new ArrayList<>();
        String string = "";
        for(int i = 0; i < str.length(); i++){
            char ch = str.charAt(i);
            if(ch != ' '){
                string += ch;
            }else{
                list.add(string);
                string = "";
            }
        }
        if(string.length() > 0){
            list.add(string);
        }
        return list;
    }
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
        List<String> list = invert(str);
        for(int i = list.size() - 1; i >= 0; i--){
            if(i != 0){
                System.out.print(list.get(i) + " ");
            }else{
                System.out.print(list.get(i));
            }
            
        }
    }
}