笔试强训3.14

一、选择题

1.以下说法错误的是（C）

A.数组是一个对象

B.数组不是一种原生类

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

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

​ 相关知识点：原生/内置数组是那八个，其他的都是引用的，借助基础类型定义的

C可以任意改变错，不能自动扩容

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

public class Test {public static void main(String [] args){System.out.println(new B().getValue());}static class A{protected int value;public A(int v) {setValue(v);}public void setValue(int value){this.value = value;}public int getValue(){try{value++;return value;} catch(Exception e){System.out.println(e.toString());} finally {this.setValue(value);System.out.println(value);}return value;}}static class B extends A{public B() {super(5);setValue(getValue() - 3);}public void setValue(int value){super.setValue(2 * value);}}}

A.11 17 34

B.22 74 74

C.6 7 7

D.22 34 17

​ 相关知识点：继承、内部类【重新调整格式，写一遍|放到idea里边】、

try catch、动态绑定、继承setValue发生了动态绑定

这类题：小心！！！【画图!!!】

1.下列选项中关于Java中super关键字的说法正确的是（A）

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

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

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

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

​ 相关知识点：通过super关键字，可以访问直接父类的属性和方法

​ 通过super，不能访问父类的父类

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

A a0=new A();
A a1=new B();
A a2=new C();

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

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

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

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

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

​ 相关知识点：继承具有传递性，若B继承A，C继承B，则可以用A的对象变量接收C的对象

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

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

B.其他选项都不正确

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

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

​ 相关知识点：异常、try-catch

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

不管程序是否发生错误及捕捉到异常情况了，都会执行finally部分

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

A.break

B.return true

C.return false

D.以上都不是

​ 相关知识点：跳转语句。方法里的返回值不一定是boolean类型

5.C

一个以”.java”为后缀的源文件

A.只能包含一个类，类名必须与文件名相同

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

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

D.可以包含任意类

​ 相关知识点：一个java文件可以包含多个类，但是public权限的必须和文件名相同，且只能有一个。

6.如下Java语句

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

执行后， x的值是（D）

A.3

B.0.6

C.0.4

D.0.75

​ 相关知识点：隐式类型转换

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

public class Test1 {
    static int cnt = 6;
    static {
        cnt += 9;
    }
    public static void main(String[] args) {
        System.out.println("cnt =" + cnt);
    }
    static {
        cnt /= 3;
    }
}

​ 相关知识点：静态变量、静态代码块、类里边的执行顺序：静态成员（变量，静态代码块，静态方法）》实例成员（普通成员变量的定义、实例代码块）》构造方法

8.以下程序的运行结果是（B）

public class Increment
{
    public static void main(String args[])
    {
        int a;
        a = 6;
        System.out.print(a);
        System.out.print(a++);
        System.out.print(a);
    }
}

A.666

B.667

C.677

D.676

相关知识点：前置加加、后置加加、输出格式

二、编程题

两种排序方式

几个解题的关键点

1. String类已经重写了compareTo方法，比较依据是字典序
2. nextInt读完之后，要吞一个nextLine，再开始读字符串数组

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int n = in.nextInt();
            in.nextLine();
            String[] str = new String[n];
            for (int i = 0; i < n; i++) {
                str[i] = in.nextLine();
            }
            if (isSortedDic(str) && isSortedLen(str)) {
                System.out.println("both");
            } else if (isSortedLen(str)) {
                System.out.println("lengths");
            } else if (isSortedDic(str)) {
                System.out.println("lexicographically");
            } else {
                System.out.println("none");
            }
        }
    }
    public static boolean isSortedDic(String[] str) {
        for (int i = 0; i < str.length - 1; i++) {
            if (str[i].compareTo(str[i + 1]) > 0) {
                return false;
            }
        }
        return true;
    }
    public static boolean isSortedLen(String[] str) {
        for (int i = 0; i < str.length - 1; i++) {
            if (str[i].length() > str[i + 1].length()) {
                return false;
            }
        }
        return true;
    }
}

求最小公倍数

解题关键点：

1. 辗转相除法算最大公约数与交换两个变量的值类似
2. 只不过这里的tmp=a%b，那么是直接tmp=a

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        while(sc.hasNextInt()){
            int a=sc.nextInt();
            int b=sc.nextInt();
            int tmp=mod(a,b);
            if(tmp==0){
                System.out.println(a*b);
            }else{
                System.out.println(a*b/tmp);
            }
             
            
        }
    }
    private static int mod(int a,int b){
        if(a<b){
            int tmp=a;
            a=b;
            b=tmp;
        }
        while(b!=0){
            int tmp=a%b;
            a=b;
            b=tmp;
        }
        return a;
    }
}