笔试强训3.14

冷不防 2024-03-25 21:00 6阅读 0赞

### 一、选择题 ###

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