Java面向对象编程（8）

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

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

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

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

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

答案：A

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

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

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

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

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

答案：A

以下说法错误的是（）

A.数组是一个对象

B.数组不是一种原生类

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

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

答案：C

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

1. public class Test {
2. public static void main(String [] args){
3. System.out.println(new B().getValue());
4. }
5. static class A{
6. protected int value;
7. public A(int v) {
8. setValue(v);
9. }
10. public void setValue(int value){
11. this.value = value;
12. }
13. public int getValue(){
14. try{
15. value++;
16. return value;
17. } catch(Exception e){
18. System.out.println(e.toString());
19. } finally {
20. this.setValue(value);
21. System.out.println(value);
22. }
23. return value;
24. }
25. }
26. static class B extends A{
27. public B() {
28. super(5);
29. setValue(getValue() - 3);
30. }
31. public void setValue(int value){
32. super.setValue(2 * value);
33. }
34. }
35. }

A.11 17 34

B.22 74 74

C.6 7 7

D.22 34 17

答案：D

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

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

B.其他选项都不正确

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

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

答案：C

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

A.break

B.return true

C.return false

D.以上都不是

答案：A

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

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

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

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

D.可以包含任意类

答案：C

如下Java语句

double x= 3.0;

int y=5;

x/=--y;

执行后， x的值是（）

A.3

B.0.6

C.0.4

D.0.75

答案：D

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

public class Test1 {

   static int cnt = 6;

   static {

       cnt += 9;

   }

   public static void main(String[] args) {

       System.out.println("cnt =" + cnt);

   }

   static {

       cnt /= 3;

   }

}

A.cnt=5

B.cnt=2

C.cnt=3

D.cnt=6

答案：A

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

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

答案：B

两种排序方法：

考拉有n个字符串字符串，任意两个字符串长度都是不同的。考拉最近学习到有两种字符

串的排序方法:·1.根据字符串的字典序排序。例如:↓

"car" .< ."carriage" .<."cats" .< ."doggies-<-"koala"

⒉.根据字符串的长度排序。例如:↓

"car".< ."cats" .< ."koala".<."doggies".<."carriage"

考拉想知道自己的这些字符串排列顺序是否满足这两种排序方法，考拉要忙着吃树叶，所

以需要你来帮忙验证。

输入第一行为字符串个数n(n ≤-100)·接下来的n行,每行一个字符串,字符串长度均小于

100，均由小写字母组成-

输出描述:如果这些字符串是根据字典序排列而不是根据长度排列输出"Iexicographically" ,如果根据长度排列而不是字典序排列输出"lengths",

如果两种方式都符合输出"both"，否则输出"none"

public class Main12 {
    public static void main(String[] args) throws IOException {
        //BufferedReader从字符流中读取文本并且缓存
        BufferedReader bi=new BufferedReader(new InputStreamReader(System.in));
        int n=Integer.parseInt(bi.readLine());
        String[] str=new String[n];
        for (int i = 0; i < n; i++) {
            str[i]=bi.readLine();
        }
        //进行判断
        if (isSortZiDian(str) && isSortLength(str)){
            System.out.println("both");
        }else if (isSortZiDian(str)){
            System.out.println("lexicographically");
        }else if (isSortLength(str)){
            System.out.println("lengths");
        }else {
            System.out.println("none");
        }
    }
    //根据长度进行排序
    public static Boolean isSortLength(String[] str){
        for (int i = 0; i < str.length-1; i++) {
            //如果当前字符串的长度大于后一个字符串的长度，那么，排序混乱，返回false
            if (str[i].length() > str[i+1].length()){
                return false;
            }
        }
        return true;
    }
    //根据字典序进行排序
    public static Boolean isSortZiDian(String[] str){
        for (int i = 0; i < str.length-1; i++) {
            //用当前的字符串和最后一个字符串进行比较，如果字典序大于后一个
            //那么，排序混乱，直接返回false
            if (str[i].compareTo(str[i+1]) > 0){
                return false;
            }
        }
        return true;
    }
}

求最小公倍数

正整数A和正整数B的最小公倍数是指能被A和B整除的最小的正整数值，设计一个算法，求输入A和B的最小公倍数。

public class Main {
    //最小公倍数
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int a=scanner.nextInt();
        int b=scanner.nextInt();
        int max=a;
        if(max<b ){
            max=b;
        }
        //此时找到最大值了！
        //从最大值开始到a*b之间遍历
        for (int i = max; i <= a*b ; i++) {
            if (i % a==0 && i% b==0){
                System.out.println(i);
                break;
            }
        }
    }
}

A和B的最小公倍数=A*B/（A和B的最大公约数）

public class Main13 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int m=scanner.nextInt();
        int n=scanner.nextInt();
        int mn=gbc(m,n);
        System.out.println(m*n/mn);
    }
    public static int gbc(int m ,int n){
        if (m==n){
            return m;
        }
        //将m赋值为m与n 直接的最大值！
        if (m<n){
            int tmp=m;
            m=n;
            n=tmp;
        }
        //辗转相除法
        int r=0;
        while ((r=m%n) > 0){
            m=n;
            n=r;
        }
        return n;
    }
}