一、选择

关于抽象类与最终类，下列说法错误的是？

A 抽象类能被继承，最终类只能被实例化。
B 抽象类和最终类都可以被声明使用
C 抽象类中可以没有抽象方法，最终类中可以没有最终方法
D 抽象类和最终类被继承时，方法可以被子类覆盖

有六个元素6,5,4,3,2,1顺序入栈,问下列哪一个不是合法的出栈序列?()

A 5 4 3 6 2 1
B 4 5 3 1 2 6
C 3 4 6 5 2 1
D 2 3 4 1 5 6

阅读下列程序，选择哪一个是正确的输出结果（）

class HelloA{
public HelloA()
    {
        System.out.println("I’m A class ");
    }
    static
    {
    System.out.println("static A");
    }
}
public class HelloB extends HelloA{
    public HelloB()
    {
        System.out.println("I’m B class");
    }
    static{
        System.out.println("static B");
    }
    public static void main (String[] args){
        new HelloB();
    }
}

A static A I’m A class static B I’m B class
B I’m A class I’m B class static A static B
C static A static B I’m A class I’m B class
D I’m A class static A I’m B class static B

下列代码的输出结果是____

boolean b=true?false:true==true?false:true;
System.out.println(b);

A true
B false
C null
D 空字符串

在Java中下面Class的声明哪些是错误的？【多选】

A public abstract final class Test { abstract void method(); }
B public abstract class Test { abstract final void method(); }
C public abstract class Test { abstract void method() { } } D public class Test { final void method() { } }

java语言规定构造方法只能通过new自动调用。（判断正误）

二、编程

1. 不要二

不要二
二货小易有一个W*H的网格盒子，网格的行编号为0~ H-1，网格的列编号为0~W-1。每个格子至多可以放一
块蛋糕，任意两块蛋糕的欧几里得距离不能等于2。

对于两个格子坐标(x1,y1),(x2,y2)的欧几里得距离为:
( (x1-x2) * (x1-x2) + (y1-y2) * (y1-y2) ) 的算术平方根

小易想知道最多可以放多少块蛋糕在网格盒子里。

2. 把字符串转换成整数

把字符串转成整数
将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。数值为 0 或者字符串不是一个合法的数值则返回 0。

数据范围：字符串长度满足 0 <= n <= 100
进阶：空间复杂度 O(1) ，时间复杂度 O(n)

注意：
① 字符串中可能出现任意符号，出现除 +/- 以外符号时直接输出 0
②字符串中可能出现 +/- 且仅可能出现在字符串首位。

答案

1. 选择

首先要搞懂抽象类（abstract修饰）和最终类（final修饰）。

① 抽象类中可以有抽象方法，也可以没有抽象方法。
② 抽象类当然可以被继承，因为它就是用来继承的。
③ 继承抽象类，若有抽象方法，则子类必须将其抽象方法实现/重写。
④ 抽象类中的非抽象方法可以被重写。

最终类和抽象类正好相反。

⑤ 加上final的类就叫最终类，加上final的方法就叫最终方法。
⑥ 最终类中可以有最终方法，也可以没有。
⑦ 最终类不能有子类，最终方法不能被重写
⑧ final类不能被继承或修改，final方法可以被继承但不能被覆盖。
⑨ final类可以new实例。

故：选D

① 栈是先进后出。
② 并且不是一次性进栈后才出栈，可以边进栈边出栈。

故：选C

类的初始化顺序是：
① 初始化父类中的静态成员变量和静态代码块。
② 初始化子类中的静态成员变量和静态代码块。
③ 初始化父类中的普通成员变量和代码块，再执行父类中的构造方法。
④ 初始化子类中的普通成员变量和代码块，再执行子类中的构造方法。
[静态 -> 普通、父类 -> 子类]
⑤ static修饰的只初始化一次，并且最先输出。

故：选C

本题考察【优先级问题】
① 优先级：== 高于？：高于 =
优先级参考：操作符属性
② boolean b=true?false:true==true?false:true;

故：
① 第一步执行：true==true，结果为true。
② 此时表达式为boolean b = true?false:true?false:true
③ 第二步：执行三目运算符，三目运算符按照从右至左原则，true?false:false，结果为false 。
④ 此时表达式为boolean b = true?false:false;
⑤ 所以，最终结果为false

故：选B

【考察abstract】
抽象类
① 抽象方法不能是private，默认是public。（可以使用public、protected、default）
② 抽象方法不能被final和static修饰，因为抽象方法要被子类重写
③ 抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用 abstract 修饰
④ 抽象类不能实例化
⑤ 抽象方法没有方法体

故：选ABC

① 在类的 其他构造方法中可以用this(参数) 的方式调用其他构造方法；
② 在类的子类中则可以通过super(参数)调用父类中指定的构造方法；
③ 在反射中可以使用 newInstance() 的方式调用。

故：错误×

访问修饰符作用范围由大到小排列：public > protected > default > private
无路如何，如果有finally，一定要执行finally后才可以进行方法的返回！！ 然后再去接着执行方法后面的内容。

2. 编程

不要二
1）思路：

① 关键：一个坐标位置放了蛋糕，跟其欧几里得距离为2的位置不能放蛋糕，这个就是关键点。
② 也就是说：如果(x1,y1)放了蛋糕，则满足 ( (x1-x2) * (x1-x2) + (y1-y2) * (y1-y2) ) == 4的(x2,y2)不能放蛋糕。【注：sqrt(x)是x开算术平方根】
③ 但是注意分析：因为平方保证了结果的非负性，则只可能存在0+4=4,1+3=4，2+2=4,3+1=4,4+0=4这五种情况；再者，(x1-x2）的结果只能是整数，所以在平方之后对结果是有要求的。所以：最终只可能存在0+4=4，4+0=4两种结果。
④ 即：(x1==x2)&&(|y1-y2|==2) 或者 (|x1-x2|==2)&&(y1==y2)。
⑤ 使用标记法：先全部初始化为0，不能存放蛋糕的位置修改为1.【不能存放蛋糕的位置是针对0的位置来寻找的】
⑥ 使用遍历的方法。

2）代码：

import java.util.Scanner;

// 只能是长相差2 或者 宽相差2
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int pow = in.nextInt();
        int col = in.nextInt();

        // 计算能放多少cake
        int[][] cake = new int[pow][col];
        int count = 0;
        // 进行遍历
        for (int i = 0; i < pow; i++) {
            for (int j = 0; j < col; j++) {
                if(cake[i][j] == 0) {
                    count++;
                    // 进行行、列不能存放蛋糕位置的标记
                    // 但是一定要注意：标记一定是针对可以存放蛋糕的位置来标记找不能存放位置的！
                    if(i+2 < pow) {
                        cake[i+2][j] = 1;
                    }
                    if(j+2<col) {
                        cake[i][j+2] = 1;
                    }
                }
            }
        }

        // 此时已经计算出结果
        System.out.println(count);
    }
}

把字符串转换成整数
1）思路：

① 其实就是从左往右，上次计算的结果*10，相当于10进制进位，然后加当前位的值。
如：123：sum=0, sum=sum *10+1, sum=sum * 10+2, sum=sum *10+3
② 本题的关键其实就是边界值问题：
空字符串、正负号处理以及数字串中存在非法字符。
③ 方法：将字符串转为数组。
④ 计算的时候再注意一个点：数字=字符-'0'

2）代码：

public class Solution {
    public int StrToInt(String str) {
        // 首先将字符串转为数组
        char[] ch = str.toCharArray();
        // 判空
        if(str.isEmpty()) {
            return 0;
        }
        // 正负号处理
        int symbol = 1; // 记录正负数情况，默认是正数
        if(ch[0] == '+') {
            symbol = 1;
            ch[0] = '0';  // 该位是决定正负数的，使用完之后就置零,便于后续计算值
        }
        if(ch[0] == '-') {
            symbol = -1;
            ch[0] = '0';  // 该位是决定正负数的，使用完之后就置零，便于后续计算值
        }

        // 进行遍历求整数，同时判断是否有非法字符
        int sum = 0;
        // 注意，循环还必须从0开始，因为不确定首尾到底是不是符号位
        for (int i = 0; i < ch.length; i++) {
            if(ch[i]<'0' || ch[i]>'9') {
                // 这里是不合法的情况
                sum = 0;
                break;
            }
            // 这里是合法的，那就进行整数计算
            // 是从左到右的，每次*10+当前数就行
            // 还要注意一个点：ch[i]的元素类型是char，要以整数方式需要每个字符-'0'
            sum = sum*10 + ch[i] - '0';
        }


        // 最后返回结果
        sum = sum * symbol; // 千万不要忘记符号！
        return sum;
    }
}