每日一练Day10

一. 单选

1. 下列运算符合法的是（ ）

A &&

B <>

C if

D :=

答案

A

解析：&& 与，Java 逻辑运算符，同真则真；<> sql 中常用的不等于，Java 中不等于用 != 表示；if 是一个判定语句，不属于运算符；在 go 语言中 := 是声明并赋值，并且系统自动推断类型，不需要var 关键字 例如：d := 100

---

2. 下面代码运行结果是（）

public class Test{
    public int add(int a,int b){
        try {
            return a+b;
        }
        catch (Exception e) {
            System.out.println("catch语句块");
        }
        finally{
            System.out.println("finally语句块");
        }
        return 0;
    }
    public static void main(String argv[]){
        Test test =new Test();
        System.out.println("和是："+test.add(9, 34));
    }
}

A catch语句块 和是：43

B 编译异常

C finally语句块 和是：43

D 和是：43 finally语句块

答案

C

解析：try 中带有 return ,注意：finally 中没有 return

private int testReturn1() {
 int i = 1;
 try {
     i++;
     System.out.println("try:" + i);
     return i;
 } catch (Exception e) {
     i++;
     System.out.println("catch:" + i);
 } finally {
     i++;
     System.out.println("finally:" + i);
 }
 return i;
}

输入结果为：

try:2
finally:3

调用此函数将返回：2

因为当 try 中带有 return 时，会先执行 return 前的代码，然后暂时保存需要 return 的信息，再执行 finally 中的代码，最后再通过 return 返回之前保存的信息

---

3. 下列Java代码中的变量a、b、c分别在内存的____存储区存放。

class A {
    private String a = "aa";
    public boolean methodB() {
        String b = "bb";
        final String c = "cc";
    }
}

A 堆区、堆区、堆区

B 堆区、栈区、堆区

C 堆区、栈区、栈区

D 堆区、堆区、栈区

E 静态区、栈区、堆区

F 静态区、栈区、栈区

答案

C

解析：

a 是类中的成员变量，存放在堆区

b、c都是方法中的局部变量，存放在栈区

---

4. 以下声明合法的是

A default String s

B public final static native int w( )

C abstract double d

D abstract final double hyperbolicCosine( )

答案

B

A：属性的可访问控制符可以是 public、protected、private、默认（如果不写的话，被认为是 friendly，但是写上 friendly 会报错），没有 default 修饰符，所以 A 错误

B：定义的是本地方法，从修饰符 native 可以看出来，被 native 修饰的方法，底层是 C++，表 明这个方法采用的是JNI技术（Java Native Interface）完成想要的功能，JNI 技术上层规范 是 JNA （Java Native Access），JNI技术其实也是实现了 Java 语言与其他语言的通信，比 如 这次就是 C++，很多的方法采用的都是native修饰符，比如 Object 中 hashCode()、 clone()、 notify()、wait()、以及System中的arraycopy()，所以 B 正确

C：属性的非可访问控制符可以是 static 和 final，没有 abstract，所以 C 错误

D：方法的非可访问控制符可以是 abstract、static、final，但是 abstract 不可以和 static 以及 final 连用，毕竟abstract是虚拟的动态的，但是 static 和 final 都是静态的，不过 static 和 final 可以连用，毕竟两个都是静态的

---

5. 在使用super 和this关键字时，以下描述正确的是

A 在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一 行，否则编译不通过

B super（）和this（）不一定要放在构造方法内第一行

C this（）和super（）可以同时出现在一个构造函数中

D this（）和super（）可以在static环境中使用，包括static方法和static语句块

答案

A

---

6. 下面代码的输出结果是什么？

public class ZeroTest {
    public static void main(String[] args) {
        try{
            int i = 100 / 0;
            System.out.print(i);
        }catch(Exception e){
            System.out.print(1);
            throw new RuntimeException();
        }finally{
            System.out.print(2);
        }
        System.out.print(3);
    }
}

A 3

B 123

C 1

D 12

答案

D

解析：int i = 100 / 0;抛出 ArithmeticException 被 catch 捕获

---

7. 有代码片段如下：

byte b1=1,b2=2,b3,b6;
final byte b4=4,b5=6;
b6=b4+b5;
b3=(b1+b2);
System.out.println(b3+b6);

关于上面代码片段叙述正确的是（）

A 输出结果：13

B 语句：b6=b4+b5编译出错

C 语句：b3=b1+b2编译出错

D 运行期抛出异常

答案

C

解析：

• 被 final 修饰的变量是常量，这里的 b6=b4+b5 可以看成是 b6=10；在编译时就已经变为b6=10 了
• 而 b1 和 b2 是 byte 类型，java 中进行计算时候将他们提升为 int 类型，再进行计算，b1+b2 计算后已经是int类型，赋值给 b3，b3 是 byt e类型，类型不匹配，编译不会通过，需要进行强制转换。
• Java 中的 byte，short，char 进行计算时都会提升为 int 类型。

---

8. 以下java程序代码，执行后的结果是（）

public class Test {
    public static void main(String[] args) {
        Object o = new Object() {
            public boolean equals(Object obj) {
                return true;
            }
        };
        System.out.println(o.equals("Fred"));
    }
}

A Fred

B true

C 编译错误

D 运行时抛出异常

答案

B

解析：String 是 Object 的一个子类

---

9. 执行以下程序后的输出结果是（）

public class Test {
    public static void main(String[] args) {
        StringBuffer a = new StringBuffer("A");
        StringBuffer b = new StringBuffer("B");
        operator(a, b);
        System.out.println(a + "," + b);
    }
    public static void operator(StringBuffer x, StringBuffer y) {
        x.append(y); y = x;
    }
}

A A,A

B A,B

C B,B

D AB,B

答案

D

解析：stringBuffer 是一个引用类型，所以操作的时候，操作的是变量的引用，所以x.append(y);之后 x=ab,y=x; 则 y=ab 但是这个地方的y只是局部变量表的值，当方法结束的时候，变量局部表内存释放，所以y的引用值没有变化。

---

10. 下面所示的java代码，运行时，会产生（）类型的异常

int Arry_a[] = new int[10];
System.out.println(Arry_a[10]);

A ArithmeticException

B NullPointException

C IOException

D ArrayIndexOutOfBoundsException

答案

D

二. 编程

1. 完善核心代码 标题：井字棋 | 时间限制：3秒 | 内存限制：32768K | 语言限制：[Python, C++, C#, Java]

给定一个二维数组 board，代表棋盘，其中元素为 1 的代表是当前玩家的棋子，0 表示没有棋子，-1代表是对 方玩家的棋子。当一方棋子在横竖斜方向上有连成排的及获胜（及井字棋规则），返回当前玩家是否胜出。

测试样例：

[[1,0,1],[1,-1,-1],[1,-1,0]]

返回：true

答案

逐行逐列检查

import java.util.*;

public class Board {
    public boolean checkWon(int[][] board) {
        for(int i = 0;i < 3 ;i ++){
            if(board[i][0]+board[i][1]+board[i][2] == 3){
                return true; // 检查行
            }
        }
        for(int i = 0;i < 3;i++){
            if(board[0][i]+board[1][i]+board[2][i] == 3){
                return true; // 检查列
            }
        }
        // 检查两斜
        if(board[0][0]+board[1][1]+board[2][2] == 3)return true;
        if(board[0][2]+board[1][1]+board[2][0] == 3)return true;
        return false;
    }
}

判断 n 行

import java.util.*;

public class Board {
    public boolean checkWon(int[][] board) {
        int len = board.length;
        // 判断行
        for(int i = 0;i=0;i--){
            sum += board[i][i];

        }
        if(sum == len){
            return true;
        }
        return false;
    }
}

2. ACM编程题 标题：密码强度等级 | 时间限制：1秒 | 内存限制：32768K

密码按如下规则进行计分，并根据不同的得分为密码进行安全等级划分

现公司要开发一个业务管理系统，要求注册环节的密码需要提示用户其安全等级，密码按如下规则进行计分，并根据不同的得分为密码进行安全等级划分。

一、密码长度:

5 分: 小于等于4 个字符

10 分: 5 到7 字符

25 分: 大于等于8 个字符

二、字母:

0 分: 没有字母

10 分: 全都是小（大）写字母

20 分: 大小写混合字母

三、数字:

0 分: 没有数字

10 分: 1 个数字

20 分: 大于1 个数字

四、符号:

0 分: 没有符号

10 分: 1 个符号

25 分: 大于1 个符号

五、奖励:

2 分: 字母和数字

3 分: 字母、数字和符号

5 分: 大小写字母、数字和符号

最后的评分标准:

大于等于90: 非常安全

大于等于80: 安全

大于等于70: 非常强

大于等于 60: 强

大于等于 50: 一般

大于等于 25: 弱

大于等于0: 非常弱

注：

字母：a-z, A-Z

数字：0-9

符号包含如下： (ASCII码表可以在UltraEdit的菜单view->ASCII Table查看)

!"#$%&'()*+,-./ (ASCII码：0x21~0x2F)

:;<=>?@ (ASCII码：0x3A~0x40)

[\]^_` (ASCII码：0x5B~0x60)

{|}~ (ASCII码：0x7B~0x7E)

对应输出为：

VERY_WEAK,

WEAK,

AVERAGE,

STRONG,

VERY_STRONG,

SECURE,

VERY_SECURE

输入描述：

输入一个自定义密码

输出描述：

输出对应安全等级

示例1:

输入

38$@NoNoN

输出

VERY_SECURE

答案

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int res=0;
        String str = sc.next();
        int len = str.length();
        if(len <= 4)res+=5;
        else if(len <= 7)res+=10;
        else res+=25;
        int flag1=0,flag2=0,flag3=0,flag4=0;
        for(int i = 0;i < len;i++ ){
            if(str.charAt(i) >= '0' && str.charAt(i) <= '9' )flag1++; // 数字
            else if(str.charAt(i) >= 'a' && str.charAt(i) <= 'z' )flag2++; // 小写字母
            else if(str.charAt(i) >= 'A' && str.charAt(i) <= 'Z' )flag3++; // 大写字母
            else flag4++; // 其它符号
        }
        res+=((flag1==0)?0:((flag1==1)?10:20));
        res+=(flag2==0&&flag3==0)?0:((flag2>0&&flag3==0||flag3>0&&flag2==0)?10:20);   
        res+=flag4==0?0:((flag4==1)?10:25);
        res+=flag1>0&&(flag2>0||flag3>0)?2:0;
        res+=flag1>0&&(flag2>0||flag3>0)&&flag4>0?3:0;
        res+=flag1>0&&(flag2>0&&flag3>0)&&flag4>0?5:0;
        if(res>=90)System.out.println("VERY_SECURE");
        else if(res>=80)System.out.println("SECURE");
        else if(res>=70)System.out.println("VERY_STRONG");
        else if(res>=60)System.out.println("STRONG");
        else if(res>=50)System.out.println("AVERAGE");
        else if(res>=25)System.out.println("WEAK");
        else System.out.println("VERY_WEAK");  
    } 
}