一、选择题

二、编程题

2.1井字棋

2.2密码强度等级

一、选择题

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

A. &&

B. <>

C. if

D. :=

逻辑与&&语法规则：表达式1&&表达式2，其中两个表达式都是布尔表达式，得到的结果也是布尔值。

所以正确答案是 A

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语句块

在try-catch-finally代码块中，catch代码块只有在捕捉到异常的时候才会执行，而finally代码块一定会执行，所以先执行finally代码块再进行返回。

所以正确答案是 C

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. 静态区、栈区、栈区

a是全局变量存放在堆区，b是局部变量也存放在堆区，c是String类型的变量是引用类型存放在栈区。

所以正确答案是 C

4.以下声明合法的是

A. default String s

B. public final static native int w( )

C. abstract double d

D. abstract final double hyperbolicCosine( )

属性的可访问控制符可以是public、protected、private、默认（即default）default修饰符不能直接写出·，所以A是错的。B中定义的是本地方法，从修饰符native可以看出来，被native修饰的方法，底层是C++。属性的非可访问控制符可以是static和final，没有abstract，所以C是错的。abstract不可以和static以及final连用，abstract是虚拟的动态的，但是static和final都是静态的所以D是错的。

所以正确答案是 B

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

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

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

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

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

this()和super()都必须写在第一行，所以两者不能那个写在一个构造函数中，并且两者都不能那个在静态环境中使用，是需要对象引用的。

所以正确答案是 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

在try-catch-finally代码块中，如果catch捕捉到了异常就会执行，在本题中就捕捉到了异常，除数不能为0的异常所以输出1，然后finally代码一定会执行，并且后面的代码块就不会再执行了，所以输出2。

所以正确答案是 D

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.运行期抛出异常

是第四行语句出现错误，从int转换到byte可能会有损失

所以正确答案是 C

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. 运行时抛出异常

在本题中创建了Object类对象，方法输出了true

所以正确答案是 B

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

在operator方法中，x是直接改变了引用对象，所以主方法中的a也会改变，y也就是b并没有实质性的改变

所以正确答案是 D

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

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

A. ArithmeticException

B. NullPointException

C. IOException

D.ArrayIndexOutOfBoundsException

本题中数组是有十个元素，下标从0-9是合法的，调用10下标即产生数组越界异常

所以正确答案是 D

二、编程题

2.1井字棋

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

在本题中有四种情况。

第一种是行成排，即i不变，j++，然后将每个board[i][j]值相加存储，如果结果==size，那么就成排。

第二种是列成排，即i不变，j++，然后将numboard[ j ][ i ]值相加存储，如果结果==size，那么就成排。

第三种是正的对角线，即i++，然后将numboard[ i ][ i ]值相加存储，如果结果==size，那么就成排。

第四种是反的对角线，即i++，然后将numboard[ i ][ size-i-1 ]值相加存储，如果结果==size，那么就成排。

public class Board {
    public boolean checkWon(int[][] board) {
        int size = board.length;
        int sum = 0;
        for(int i = 0;i<size;i++){
            sum = 0;
            for(int j = 0;j<size;j++){
                sum+=board[i][j];
            }
            if(sum==size){
                return true;
            }
        }
        for(int i = 0;i<size;i++){
            sum = 0;
            for(int j = 0;j<size;j++){
                sum+=board[j][i];
            }
            if(sum==size){
                return true;
            }
        }
        sum = 0;
        for(int i = 0;i<size;i++){
            sum+=board[i][i];
        }
        if(sum==size){
            return true;
        }
        sum = 0;
        for(int i = 0;i<size;i++){
            sum+=board[i][size-i-1];
        }
        if(sum==size){
            return true;
        }
        return false;
    }
}

2.2密码强度等级

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

一、密码长度:
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: 安全（Secure）
>= 70: 非常强
>= 60: 强（Strong）
>= 50: 一般（Average）
>= 25: 弱（Weak）
>= 0: 非常弱（Very_Weak）
对应输出为：
VERY_SECURE
SECURE
VERY_STRONG
STRONG
AVERAGE
WEAK
VERY_WEAK
请根据输入的密码字符串，进行安全评定。
注：
字母：a-z, A-Z
数字：0-9
符号包含如下： (ASCII码表可以在UltraEdit的菜单view->ASCII Table查看)
!"#$%&'()*+,-./ (ASCII码：0x21~0x2F)
:;<=>?@ (ASCII码：0x3A~0x40)
[\]^_` (ASCII码：0x5B~0x60)
{|}~ (ASCII码：0x7B~0x7E)

本题代码较长，但是逻辑很简单，就是将每一种规则都分成方法写出密码长度、字母、数字、符号以及奖励。然后在主方法中判断属于哪个等级即可。

public class Main {
     public static int length(String s){
        if(s.length()<5){
            return 5;
        }else if(s.length()<8){
            return 10;
        }else{
            return 25;
        }
    }
    public static int letters(String s){
        int c1 = 0;
        int c2 = 0;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if(c<='Z'&&c>='A'){
                c1++;
            }else if(c<='z'&&c>='a'){
                c2++;
            }
        }
        if(c1==0&&c2==0){
            return 0;
        }else if(c1!=0&&c2!=0){
            return 20;
        }else{
            return 10;
        }
    }
    public static int numbers(String s){
        int count = 0;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if(c>='0'&&c<='9'){
                count++;
            }
        }
        if(count==0){
            return 0;
        }else if(count==1){
            return 10;
        }else{
            return 20;
        }
    }
    public static int symbols(String s){
        int count = 0;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if(c>=0x21&&c<=0x2F||c<=0x40&&c>=0x3A||c<=0x60&&c>=0x5B||c<=0x7E&&c>=0x7B){
                count++;
            }
        }
        if(count==0){
            return 0;
        }else if(count==1){
            return 10;
        }else{
            return 25;
        }
    }
    public static int rewards(String s){
        int letters = letters(s);
        int numbers = numbers(s);
        int symbols = symbols(s);
        if(letters>0&&numbers>0&&symbols==0){
            return 2;
        }else if(letters==10&&numbers>0&&symbols>0){
            return 3;
        }else if(letters==20&&numbers>0&&symbols>0){
            return 5;
        }else return 0;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        int letters = letters(s);
        int numbers = numbers(s);
        int symbols = symbols(s);
        int length = length(s);
        int rewards = rewards(s);
        int count = letters+numbers+symbols+length+rewards;
        if(count>=90){
            System.out.println("VERY_SECURE");
        } else if (count>=80) {
            System.out.println("SECURE");
        } else if (count>=70) {
            System.out.println("VERY_STRONG");
        } else if (count>=60) {
            System.out.println("STRONG");
        } else if (count>=50) {
            System.out.println("AVERAGE");
        } else if (count>=25) {
            System.out.println("WEAK");
        }else {
            System.out.println("VERY_WEAK");
        }
    }
}