文章目录

• 1. 单选题
• 2. 编程题

1. 单选题

1. 下列选项中关于 java 中 super 关键字的说法正确的是 ()

A： super 关键字是在子类对象内部指代父类对象的引用.

B ： super 关键字不仅可以指代子类的直接父类，还可以直接指代父类的父类.

C ： 子类通过 super 关键字只能调用父类的方法，而不能调用父类的属性.

D ： 子类通过 super 关键字只能调用父类的属性，而不能调用父类的方法 .

 
答案 ： A 正确 ，我们可以通过 super 访问父类的 方法和属性 以及 父类的构造函数

 
B ： 错误 ， super 直接指向子类的父类，而不能直线子类的爷爷辈 (父类的父类)
 
C , D 都错 ，super 关键字 可以访问 父类的属性和 方法

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

A a0=new A();  // 1
A a1=new B();  // 2 
A a2=new C();  // 3

 
以下哪个说法是正确的？

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

B : 第1,2,3行都能通过编译，但第2,3行运行时出错

C : 第1,2行能通过编译，但第3行编译出错

D : 只有第1行能通过编译

 
答案 ： 这里涉及到 继承 的知识 ， B 是 A 的子类 ， C 是 A 的子类 ， 看 第一行 A a0 = new A ()； 是没问题的 ， A 通过自己的构造函数 构造 a0 对象 ，
 
第二行 A a1 = new B()； 这也是没问题的 ， 这里涉及到了向上转型 . 父类引用引用了子类对象 关于 向上转型 我在多态的文章中说过 多态 不记得可以看看这个 .
 
第三行 同样也是没问题的 继承具有传递性 ， B 继承了 A ， C 又继承了 B ， 所以 C 是具有 A 的性质 ， A a3 = new C（） , 同样 也会触发 向上转型 .

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

 
A 数组是一个对象

B 数组不是一种原生类

C 数组的大小可以任意改变

D 在Java中，数组存储在堆中连续内存空间里

 
答案 ：
 
A ： 正确 数组是一个对象

B : 正确 数组不是一种原生类 而是数组是通过基本类型来定义的 ， 比如 ： int[] a = new int[100]; ,

C : 错误 数组一旦定义好了 就无法任意改变，没法自动扩容 ， 我们想要对数组扩容需要使用 copyOf 方法

 
将 arr 数组扩容 2 倍

D : 正确 数组 是通过 关键字 new 创建出来的 ， 通过 new 创建的 都是存放在 堆中的 ， 数组在堆中 占用的空间是连续的.

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

A : 11 17 34

B : 22 74 74

C : 6 7 7

D : 22 34 17

答案 ： D

图一 ：

 
图二 ：

 
图三 ：

 
图四 ：

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

 
A 如果程序发生错误及捕捉到异常情况了，才会执行finally部分

B 其他选项都不正确

C 当try区段的程序发生异常且被catch捕捉到时，才会执行catch区段的程序

D catch部分捕捉到异常情况时，才会执行finally部分

 
答案 ：
 
A ： finally 不管程序是否出现异常都会执行， 所以 A 错误

C : 正确

D ： 与 A 一样 ， D 错误

B : C 正确 ，所以 B 错误

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

A break

B return true

C return false

D 以上都不是

 
答案 ： 选 A , Array 可以看作 一个数组，我们相同过 forEach 遍历， 那么 就可以通过 break 来跳出 循环 ， 假设我们的 跳出 Array 的 forEach 循环再 一个 方法里 ，且返回值 不是 布尔类型，那么 B 和 C 是不是就报错了 ，那么 就无法跳出循环了.

 
7. 一个以”.java”为后缀的源文件
 
A 只能包含一个类，类名必须与文件名相同

B 只能包含与文件名相同的类以及其中的内部类

C 只能有一个与文件名相同的类，可以包含其他类

D 可以包含任意类

 
答案 ： 关于.java 文件 是可以 包含多个类的， 但是 只能存在一个 public 规定的类 ，且这个类必须和文件名相同

 
A 错误 ： 一个 .java 文件可以 包含多个 类 ，

B 错误 ： .java 文件 不仅可以 又内部类 ，还可以有其他的类 ，注意 只有 一个 public 修饰的类

C 正确

D 错误 : 只能存在 一个 被 public 修饰的类

 
8. 如下Java语句 ， 执行后， x的值是（）

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

A 3

B 0.6

C 0.4

D 0.75

 
答案 ： 这里 会先执行 --y , y 就变成 了 4 ，然后 3.0 / 4 就为 0.75

 
9. 下列代码运行后输出结果为（）

 
A cnt=5

B cnt=2

C cnt=3

D cnt=6

 
答案 ： A , 当前代码考察的是 静态代码块 执行顺序 , 关于静态代码块 ，代码块，构造方法的执行顺序在继承那篇文章是说过的

 
简单复习一下 ：

1、父类静态代码块优先于子类静态代码块执行，且是最早执行

2、父类实例代码块和父类构造方法紧接着执行

3、子类的实例代码块和子类构造方法紧接着再执行

4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

 
简单来说 就是 静态代码块 > 代码块 > 构造方法 ， 题目中的静态变量在 静态代码块之前，所以会先执行 静态变量 （定义） ，然后再进行静态代码块 最终结果 为 5

 
10. 以下程序的运行结果 :

 
A ： 666 B ： 667 C : 677 D: 676

 
答案 ： 本题很简单 ，就考了 一个 后置++ 的使用 ， 这里 第一个 print 语句 先将 6 打印 ，然后 第二个 print 语句 因为 这里是 后置 ++ ，会先使用 a 的值 ，再 ++ ，所以 第二个 print 语句打印的还是 6 ， 最后 一个print 语句打印的就是 7

2. 编程题

 
题目一 ： 两种排序方法_牛客题霸_牛客网 (nowcoder.com)

 
分析 ：

代码 ：

package T_j.T_3_15;import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int n = sc.nextInt();String[] str = new String[n];for (int i = 0; i < n; i++) {str[i] = sc.next();}// 1、 判断是否符合长度排序boolean flagLength = isSortLength(str);// 2. 判断是否符合字典序排序boolean flagZidian = isSortZidian(str);if (flagLength && flagZidian) {System.out.println("both");} else if (flagZidian) {System.out.println("lexicographically");} else if (flagLength) {System.out.println("lengths");} else {System.out.println("none");}}public static boolean isSortZidian(String[] str) {for (int i = 1; i < str.length; i++) {String ret1 = str[i - 1];String ret2 = str[i];int j = 0;for (; j < ret1.length() && j < ret2.length(); j++) {char a = ret1.charAt(j);char b = ret2.charAt(j);// 字符 本质上是 一个 ASCII 码值 所以可以直接比较if (a < b) {break;} else if (a > b) {return false;} else {// a == b 的情况continue;}}// 判断 ret1 和 ret2 前面的字符都相同  如果 ret1 的长度 大于 ret2 的长度 ，那么 不符合要求if (j >= ret2.length()) {return false;}}return true;}// 判断长度public static boolean isSortLength(String[] str) {for (int i = 1; i < str.length; i++) {if (str[i - 1].length() >= str[i].length()) {return false;}}return true;}}

 
其实这里 判断字典序排序 可以使用 一个方法 就可以代替我们 一个一个字符的比较 ， 这个方法就是 compareTo

 
将上面 判断是否按照字典序排序的方法换成下面这个 ， 一样可以通过.

public static boolean isSortZidian2(String[] str) {for (int i = 0; i < str.length - 1; i++) {// 用当前字符串和后一个字符比较 ， 如果字典序大于后一个，// 说明排序混乱直接返回 falseif (str[i].compareTo(str[i + 1]) > 0) {return false;}}return true;
}

题目二 : 求最小公倍数__牛客网 (nowcoder.com)

 
本道题 比较简单

 
第一种方法 : 假设是求 A 和 B 的最小公倍数 先求出最最大公约数 然后 通过 公式 : , A * B / （A 和 B 的最大公约数）

 
这里 求 最大公约数 就可以使用 辗转相除法 （通过 欧几里得算法得出来的）

 
规定 : (A,B) 表示 A 和 B 的最大公约数

 
(A,B) = (A * k + B , B) = (B , A) = (B * K + A , A)

 
简单解释一下上面 :

 
比如 我们想要求 10 和 6 的最大公约数 : (10 , 6) = (4 + 6 , 6) = (4，6) = (4, 4 + 2) = (4,2) = （2 +2 , 2) = (2,2) = (2 , 0 + 2) = (2,0) = 2

 
最终我们的 最大公约数 就是 2 .

 
辗转相除法 ：

m = 10 , n = 6 ,
 
m % n = 10 % 6 = 4
 
m = n = 6
 
n = 4
 
m % n = 6 % 4 = 2
 
m = 4
 
n = 2
 
m % n = 4 % 2 = 2
 
m = 2
 
n = 2
 
m % n = 2 % 2 = 0
 
m = n = 2
 
n = 0
 
此时我们的最大公约 就求出来了 ， 是不是 就与 欧几里得算法 有点像.

 
有了 最大公约数 ， 那么最小公倍数 不就有手机行

import java.util.Scanner;// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int m = sc.nextInt();int n = sc.nextInt();int mn = m * n;int c = m;while (n != 0) {c = m % n;m = n;n = c;}System.out.println(mn / m);}
}

 
另外 还有一种方法 ： m * n 得到最大的 公倍数 ， 然后 – ， 找到最小的 公倍数

    public static void main(String[] args) {// 最小公倍数Scanner sc = new Scanner(System.in);int a = sc.nextInt();int b = sc.nextInt();int c = a * b;int d = c;while(c != a && c != b){c--;if(c % a == 0 && c % b ==0){d = c;}}System.out.println(d);}