java每日一练(2)

java每日一练(2)

 

单选部分

 

1.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行的声明都是正确的

 

复习文章 ： 继承 Inheritance_

 
答案 ： D
 
C 的父类 是 B ， B的父类是 A ，所以 A 的父类一定是C的父类 , 根据父类引用引用子类对象 推出 3行代码是可以执行的

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

 
这里就考到了我们的 toLowerCaSe 方法最后会创建一个新的对象， == 比较的是否为同一个对象， 所以这里就会返回一个 false

 
复习文章 ： String类 — 上篇_

 

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

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

 
答案 ： 这里我们的 Test3 test = null, 此时 test 指向任何 对象，如果使用就会出现空指针异常，但是 看到我们的 hello() 方法是被 static 修饰 不依赖对象 所以这里 是可以通过 test.hello() 调用， 另外我们要注意这里样调用是不推荐的，这里一般都是直接通过类名调用也就是 Test3.hello()

 
运行后也能验证我们的答案

复习文章 ： 类和对象

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

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

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

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

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

 
答案 ： A
 
B ： super 和 this 必须放在 构造方法的第一行
 
C ： super 和 this 不能同时出现， 如果能 那么谁放在第一行呢？
 
D ：this 和 super 是不能 在 static 方法 和 static 语句块的，因为 被static 修饰是不需要对象的，而 super 和 this 是需要对象。

 
复习文章 ： 继承 Inheritance_

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

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

 

这里主要考构造方法，我们new子类对象的时候会先去帮助父类构造(调用父类的构造方法 通过 supser() ) ,所以new Alpha 会先调用 Base的构造方法 ，打印一个 Base ，接下来执行到 new Base ，他自己调用字节的构造方法 又打印了一个 Base ，因为 是 print 没有换行 所以 答案 就是 BaseBase

 
6.如下代码的输出结果是什么？

 
A 0 B 1 C 2 D 编译失败

这里我直接放在 idea上了 很明显 直接编译错误 ， 这里如何来真正的判断 ，其实我们的 static定义的变量是不能放在方法里面 ， 这里 static 修饰的 是属于类的，而不是属于方法的。 所以 这里直接会报错。另外 定义在 static 修饰的方法里面同样是不能的，同理.

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

 
答案 ： abstract是不能 修饰 字段的 , 抽象方法不需要大括号{} 包住的， 写了就是具体实现. 所以答案就是我们的 D

 

复习文章 ： 抽象类 or 接口_

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

 
这里 constructor 就是构造器的意思 ：
 
A constructor 是可以省略的，编译器是会默认提供一个不带参数的
 
B 可以看到我们的构造方法就可以跟类同名， 注意构造方法同样也是 方法

 
C 正确
 
D 错误我们的构造方法可为多个构造重载

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

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

 
A : 可以
 
B ： 这里对成员变量的赋值只能放在方法的内部

 
C ： method 不是抽象方法， 所以 不能省略{}

 
D : 这里我们被 abstract 修饰 所以 是一个抽象方法，这里就可以省略{}

所以答案 A

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

所以答案是 D

 

编程题

 

题目一 : 排序子序列_牛客笔试题_牛客网 (nowcoder.com)

 

图一 ：

 

图二 ：

 

图三 ：

 

附上代码 ：

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        // 注意这里后面我们会修改这里 
        int[] arr = new int[n + 1];
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }

        int i = 0;
        int count = 0;
        while (i < n) {
            if (arr[i] < arr[i + 1]) {
                while (i < n && arr[i] < arr[i + 1]) {
                    i++;
                }
                // 此时 相当于 出现了 arr[i] >= arr[i+1] 的情况
                // 相当于结束了递增的情况 ， 那么 让计数器++, 让 i++到新的起点
                count++;
                i++;
            } else if (arr[i] == arr[i + 1]) {
                i++;
            } else {
                // arr[i] > arr[i + 1]
                while (i < n&& arr[i] > arr[i + 1]) {
                    i++;
                }
                count++;
                i++;
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

 

题目二 ： 倒置字符串__牛客网 (nowcoder.com)

 
图一 ：

 
附上法二代码 ：

  public static void reverse(char[] c, int start, int end) {
        while (start < end) {
            char tmp = c[start];
            c[start] = c[end];
            c[end] = tmp;
            start++;
            end--;
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
//        System.out.println(str);
        char[] c = str.toCharArray();
        int n = str.length() ;
        reverse(c, 0, str.length() - 1);
//        System.out.println(Arrays.toString(c));
        int i = 0;
        while (i < n) {
            // i 用来保留 翻转的首字母
            int j = i;
            // j 用来找空格
            while (j < n && c[j] != ' ') {
                // 此时 没找到
                j++;
            }
            // 另外这里最后一组的情况 a b c d e 后面是遇不到空格的 那么我们的 j 就会 == n
            // 此时我们同样是 对 i 到 j - 1 进行 翻转，所以这里可以省略

            // 此时找到了那么我们对当前 i - j - 1 进行翻转
            reverse(c, i, j - 1);
            //此时更新新的翻转起点 j下标为空格
            i = j + 1;

        }
        str = new String(c);
        System.out.println(str);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39