【java】笔试强训Day2【​倒置字符串​与排序子序列】

目录

⛳选择题

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);//trueSystem.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 stubTest 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 herepublic 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 Ireverse(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);}
}