目录

⛳选择题

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

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

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

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

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

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

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

8.下列说法正确的有：（        ）

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

10.在使用 interface 声明一个外部接口时，只可以使用（     ）修饰符修饰该接口。

🔥编程题

1.倒置字符串

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

🙈大家觉得答案是什么呢

---

🙉答案是 D 啦~

🔎思路解析：根据题目可以写出代码

class A {

}
class B extends A { //A 派生出子类 B

}
class C extends B { //B 派生出子类 C

}
public class Test {

    public static void main(String[] args) {
        A a0=new A();

        A a1=new B();//父类引用，引用子类对象

        A a2=new C();//此时A虽然不是C的直接父类，但是C依然间接继承了A的内容的，此时可以发生向上转型的。
    }
}

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

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 啦~

🔎思路解析：上述代码为 调用 admin 函数，传入“Admin” ，此时 userId 拿到的就是 Admin 

toLowerCase：将大写变成小写

❗❗注意：toLowerCase 在进行大写变小写的时候会产生一个新的对象，此时再与“admin”比较是拿到这个新的对象与之比较，所以最终结果为 false

例如：

        String s1 = "abcd";
        String s2 = s1.toLowerCase();
        System.out.println(s1 == s2);//true
        System.out.println(s1.toLowerCase() == "abcd");//true

✅此时就是因为 s1 在进行大小写转换的时候，它本身就是一个小写，这时候小写转换为小写的时候，就不会 new 一个新的对象，这时候的结果就是TRUE

🔥总结：在使用 toLowerCase 进行比较的时候：

如果是发生了从大写变成小写的时候：toLowerCase 会 new 一个新的对象，这时候比较就是 false

如果原本就是小写，使用 toLowerCase 再变成小写：这时候t oLowerCase 就不会 new 一个新的对象，这时候比较就是 true

3.阅读如下代码。 请问，对语句行 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 啦~

🔎思路解析：

Test test=null;//引用null，不指向任何对象

理论上这个代码应该会发生一个空指针异常， 但是此时的 hello 是一个静态方法 (静态方法的调用不依赖任何对象)，因此这个代码可以正常运行

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

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

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

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

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

🙈大家觉得答案是什么呢

---

🙉答案是 A 啦~

🔎思路解析：super（）和this（）一定要放在构造方法内第一行

对于super（）和this（）的理解，可以看我的博客： 继承的博客链接

✅【相同点】

1. 都是 Java 中的关键字
2. 只能在类的非静态方法中使用，用来访问非静态成员方法和字段
3. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在
❎【不同点】

1. this 是当前对象的引用，当前对象即调用实例方法的对象， super 相当于是子类对象中从父类继承下来部分成员的引用

 2. 在非静态成员方法中， this 用来访问本类的方法和属性， super 用来访问父类继承下来的方法和属性
3. 在构造方法中： this(...) 用于调用本类构造方法， super(...) 用于调用父类构造方法，两种调用不能同时在构造方法中出现
4. 构造方法中一定会存在 super(...) 的调用，用户没有写编译器也会增加，但是 this(...) 用户不写则没有

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

🙈大家觉得答案是什么呢

---

🙉答案是 B 啦~

🔎思路解析：本题主要考察继承关系上的执行顺序。

当子类继承父类之后，在实例化子类对象的时候，先要调用父类的构造方法，来帮助父类初始化。上述代码相当于如下代码：

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

编译器会默认提供如上的子类的构造方法。所以，注释1处输出的结果为Base，注释2处输出的结果为：Base    最终结果是BaseBase。故：选择B

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

A 0                       B 1                          C 2                          D 编译失败

🙈大家觉得答案是什么呢

---

🙉答案是 D 啦~

🔎思路解析：

static 在定义的时候，不能定义局部变量，static 定义的静态变量一定是成员变量

在普通方法的内部，一定不可以出现 static

在静态方法的内部，也不可以出现 static (一个变量被静态变量修饰，这个变量叫做类变量，属于类，是不能放在方法内部)

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

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

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

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

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

🙈大家觉得答案是什么呢

---

🙉答案是 D 啦~

🔎思路解析：

A、abstract 不可以修饰符可修饰字段

B、抽象方法的body部分不可以用一对大括号{ }包住，{ }包住就变成了一个具体的实现

public abstract void func();//抽象方法

C、声明抽象方法，大括号必须没有

8.下列说法正确的有：（        ）

A class中的constructor不可省略

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

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

D 一个class只能定义一个constructor

🙈大家觉得答案是什么呢

---

🙉答案是 C 啦~

🔎思路解析：

A、class 中的 constructor 可以省略，这时候编译器会默认提供一个不带参数的构造方法

B、方法可以与class同名

D、一个class可以定义多个constructor

9.选项中哪一行代码可以替换 //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 啦~

🔎分析代码：这是一个抽象类，定义了一个成员变量=5，并且写了一个方法

A、A的方法与原来的方法构成重载

B、成员变量的运算一定要放在方法里边

C、普通方法应该有大括号，对于C的代码如果加上 abstract，这个代码也是错误的，与原方法同名

D、抽象方法不可以有大括号

10.在使用 interface 声明一个外部接口时，只可以使用（     ）修饰符修饰该接口。

A private              B protected                   C private protected                 D public

🙈大家觉得答案是什么呢

---

🙉答案是 D 啦~

🔎思路解析：接口一定要被实现，默认为 public 修饰

🔥编程题

1.倒置字符串

牛客网链接：倒置字符串

题目：将一句话的单词进行倒置，标点不倒置。比如 I like beijing. 经过函数后变为：beijing. like I

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

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

示例1

输入：I like beijing.

输出：beijing. like I

思路：1.整体逆置                           2.每一部分逆置

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    //逆置
    public static void reverse(char[] arr, int start, int end) {
        while (start < end) {
            char tmp = arr[start];
            arr[start] = arr[end];
            arr[end] = tmp;
            start++;
            end--;
        }
    }


    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
        //转换字符串为数组
        char[] arr = str.toCharArray();
        //整体倒置    I like beijing.  -->  .gnijieb ekil I
        reverse(arr, 0, arr.length - 1);

        int start = 0;//开始的位置

        while (start < arr.length) {
            int end = start;
            //j < arr.length——防止越界
            while (end < arr.length &&  arr[end] != ' ') {
                end++;
            }
            //不是最后一个单词
            if (end < arr.length) {
                reverse(arr, start, end-1);
                start = end + 1;//此时下一个开始的位置为空格+1(end+1)
            } else {//是最后一个单词
                reverse(arr, start, end-1);
                start = end;//此时开始=结尾，结束
            }
        }
        //转化为字符串
        String ret = new String(arr);
        System.out.println(ret);
    }
}

 2.排序子序列

 牛客网链接：排序子序列

牛牛定义排序子序列为一个数组中一段连续的子序列,并且这段子序列是非递增或者非递减排序的。牛牛有一个长度为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;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    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) {
            //三种情况
            //1.非递减序列
            if (arr[i] < arr[i + 1]) {
                while (i < n && arr[i] < arr[i + 1]) {
                    i++;
                }
                //此时为一个序列
                count++;
                i++;
            } else if (arr[i] == arr[i + 1]) {
                {
                    //2.相等既可以是非递增也可以是非递减，所以可以不处理,直接加一
                    i++;
                }
            } else {
                while (i < n && arr[i] >= arr[i + 1]) {
                    i++;
                }
                //此时为一个序列
                count++;
                i++;
            }
        }
        System.out.println(count);
    }
}