Java经典笔试题—day10

🔎选择题
🔎编程题
- 🥝井字棋
- 🥝密码强度等级
🔎结尾

🔎选择题

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

A.&&
B.<>
C.if
D.:=

A

B. 泛型的标志, 例如 <T>
C. if 表示关键字

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


public class Test{	
    public int add(int a,int b){	
         try {	
             return a+b;		
         } 
        catch (Exception e) {	
            System.out.print("catch语句块 ");	
         }	
         finally{	
             System.out.print("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

先去执行 finally, 输出 finally语句块
再去执行 return a+b, 输出 和是: 43

(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. 默认的访问权限修饰符是什么都不加, 不是 default. 例如 String s, 这就是默认的访问权限修饰符
C. 变量不能被声明为抽象类型
D. 抽象方法默认是需要被重写的, final 修饰代表不能重写, 因此不能这样搭配

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

A.在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过
B.super（）和this（）不一定要放在构造方法内第一行
C.this（）和super（）可以同时出现在一个构造函数中
D.this（）和super（）可以在static环境中使用，包括static方法和static语句块

A

A. Java 语言规定, 在执行该类构造方法之前必须先执行父类的构造方法, 直到 Object 类的构造方法
B. super() 和 this() 一定要放在构造方法内第一行

C. this() 和super() 不可以同时出现在一个构造函数中

D.this（）和super（）不可以在static环境中使用
因为 this() 和 super() 指代的是对象(在构造方法中使用), static 修饰指代的是类

(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

除法运算中, 要求分母不能为 0
因此 catch() 会捕获到异常, 打印1
最后执行 finally, 打印2

(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

b4, b5 属于 byte 类型, 当执行到 b4 + b5 时, 遇见 + 号 byte 会升级成 int
但 b4, b5 被 final 所修饰, 因此 b4, b5 仍然是 byte 类型
当执行到 b1 + b2 时, byte 类型的 b1, b2 会升级为 int b1, b2, 因此会发生编译错误

(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

Object 是所有类的父类
Fred 是 String类型, String 类型继承自 Object
因此调用 Object 类的 equals 方法, 返回 true

(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

通过 operate() 方法传入 StringBuffer a, StringBuffer b
x.append(y) 对 x 的值进行了修改, 也就意味着 a 的值进行了修改
y=x, 将 x 的地址赋值给 y, 此时 y 指向了 x, 并不会影响 b 的值

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

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

A.ArithmeticException
B.NullPointException
C.IOException
D.ArrayIndexOutOfBoundsException

D

数组下标越界异常

🔎编程题

🥝井字棋

题目描述

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

在这里插入图片描述

解题思路

根据题意进行简单模拟即可
不要想复杂

朴素解法

枚举每一行, 判断该行是否连成排
枚举每一列, 判断该列是否连成排
枚举对角线, 判断该对角线是否连成排

在这里插入图片描述

public boolean checkWon(int[][] board) {
        // write code here
        // 判断行
        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;
}

📢题目链接
链接: link

🥝密码强度等级

题目描述

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

一、密码长度:

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)

提示:
1 <= 字符串的长度<= 300

输入描述

输入一个string的密码

输出描述

输出密码等级

在这里插入图片描述

解题思路

根据题意进行简单模拟即可

//密码强度等级
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        while (scan.hasNextLine()) {
            //输入的string密码
            String str = scan.nextLine();
            String safeGrade = safeGrade(str);
            System.out.println(safeGrade);
        }
    }

    private static String safeGrade(String str) {

        int ret = 0;
        ret += getLen(str);

        int character = getCharacter(str);
        int num = getNum(str);
        int asc = getAsc(str);
        ret += character + num + asc;

        //字母和数字
        if (character != 0 && num != 0) {
            if (asc == 0) {
                ret += 2;
            } else {//字母,数字和符号
                if (character != 20) {
                    ret += 3;
                } else {//大小写字母,数字和符号
                    ret += 5;
                }
            }
        }
        return func(ret);
    }


    private static String func(int ret) {
        if (ret >= 90) return "VERY_SECURE";
        else if (ret >= 80) return "SECURE";
        else if (ret >= 70) return "VERY_STRONG";
        else if (ret >= 60) return "STRONG";
        else if (ret >= 50) return "AVERAGE";
        else if (ret >= 25) return "WEAK";
        else return "VERY_WEAK";
    }

    //判断长度
    private static int getLen(String str) {
        int n = str.length();
        if (n <= 4) {
            return 5;
        } else if (n <= 7) {
            return 10;
        } else {
            return 25;
        }
    }
    //判断字母
    private static int getCharacter(String str) {
        //flg1 --> 小写字母 flg2 --> 大写字母
        boolean flg1 = false, flg2 = false;

        char[] chs = str.toCharArray();
        int n = chs.length;
        for (char c : chs) {
            if (c >= 'A' && c <= 'Z') {
                flg1 = true;
            }
            if (c >= 'a' && c <= 'z') {
                flg2 = true;
            }
        }

        if (!flg1 && !flg2) return 0;
        if (flg1 && flg2) return 20;
        return 10;
    }
    //判断数字
    private static int getNum(String str) {
        char[] chs = str.toCharArray();
        int ret = 0;

        for (char c : chs) {
            int x = c - '0';
            if (x >= 0 && x <= 9) ret++;
        }

        if (ret == 0) return 0;
        return ret == 1 ? 10 : 20;
    }
    //判断符号
    private static int getAsc(String str) {
        char[] chs = str.toCharArray();
        //0x21 ~ 0x2F (33 ~ 47)
        //0x3A ~ 0x40 (58 ~ 64)
        //0x5B ~ 0x60 (91 ~ 96)
        //0x7B ~ 0X7E (123 ~ 126)
        int ret = 0;
        for (char c : chs) {
            int x = c;
            if (x >= 33 && x <= 47) ret++;
            else if (x >= 58 && x <= 64) ret++;
            else if (x >= 91 && x <= 96) ret++;
            else if (x >= 123 && x <= 126) ret++;
        }

        if (ret == 0) return 0;
        return ret == 1 ? 10 : 25;
    }
}