一、选择

下面的程序编译运行后，在屏幕上显示的结果是（）

public class Test {

    public static void main(String args[]) {
        int x, y;
        x = 5 >> 2;
        y = x >>> 2;
        System.out.println(y);
    }
}

A 0
B 2
C 5
D 80

以下代码的输出结果是（）

public class foo {
    public static void main(String sgf[]) {

        StringBuffer a=new StringBuffer("A");

        StringBuffer b=new StringBuffer("B");

        operate(a,b);

        System.out.println(a+"."+b);
    }
    static void operate(StringBuffer x,StringBuffer y) {
        x.append(y);
        y=x;
    }
}

A 代码可以编译运行，输出“AB.AB”。
B 代码可以编译运行，输出“A.A”。
C 代码可以编译运行，输出“AB.B”。
D 代码可以编译运行，输出“A.B”。

在JAVA中，假设A有构造方法A(int a)，则在类A的其他构造方法中调用该构造方法和语句格式应该为（）

A this.A(x)
B this(x)
C super(x)
D A(x)

在java7中，下列不能做switch()的参数类型是？

A int型
B 枚举类型
C 字符串
D 浮点型

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

 //指出以下程序运行的结果是
 public class Example{
     String str=new String("good");
     char[]ch={'a','b','c'};
      public static void main(String args[]){
          Example ex=new Example();
          ex.change(ex.str,ex.ch);
          System.out.print(ex.str+" and ");
          System.out.print(ex.ch);
      }
      public void change(String str,char ch[]){
          str="test ok";
          ch[0]='g';
      }
  }

A good and abc
B good and gbc
C test ok and abc
D test ok and gbc

下列有关JAVA异常处理的叙述中正确的是（）

A finally是为确保一段代码不管是否捕获异常都会被执行的一段代码
B throws是用来声明一个成员方法可能抛出的各种非运行异常情况
C final用于可以声明属性和方法，分别表示属性的不可变及方法的不可继承
D throw是用来明确地抛出一个异常情况

二、编程

1. 统计回文

统计回文
“回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”等等就是回文串。花花非常喜欢这种拥有对称美的回文串，生日的时候她得到两个礼物分别是字符串A和字符串B。现在她非常好奇有没有办法将字符串B插入字符串A使产生的字符串是一个回文串。你接受花花的请求，帮助她寻找有多少种插入办可以使新串是一个回文串。如果字符串B插入的位置不同就考虑为不一样的办法。

✨ 2. 连续最大和[dp]

连续最大和
一个数组有 N 个元素，求连续子数组的最大和。
例如：[-1,2,1]，和最大的连续子数组为[2,1]，其和为 3。

答案

1. 选择

① >> 代表带有符号右移，当操作的数为负数时，右移后，高位补1；当操作的数为整数时，右移后，高位补0。
② >>> 代表无符号右移，不管正负数，右移后，高位都是补0。
③ >>：每右移一位就相当于除以2； <<：每左移一位就相当于乘以2（左移无有无符号之分）

so：
① 5>>2， 5的二进制为 0000 0000 0000 0101 ,右移2位，即： 0000 0000 0000 0001（高位补0）
② x>>>2, 即上面的结果，再右移2位，结果就成了 0000 0000 0000 0000，所以最终的结果是0。

故：选A

一定要画图！注意指向

故：选C

① this的作用其中一个就是在一个构造方法中调用另一个构造方法，格式为this(参数)；
② super是调用父类的方法；
③ A(a)这种形式是在new一个类时使用 or 在本类中静态方法调用。

A. this.A(x);这是调用普通方法的写法
C. super(x);此时显示调用父类构造方法
D. A(x); 调用该类中的静态方法

故：选B

switch语句后的控制表达式只能是short、char、int、long整数类型和枚举类型，不能是float，double和boolean类型。String类型是java7开始支持。

故：选D

只要涉及传参问题（尤其是引用类型），不确定时一定要画图！

故：选B

① 运行时异常：非受查异常，RunTimeException以及其子类对应的异常，都称为运行时异常。比如：NullPointerException、ArrayIndexOutOfBoundsException、ArithmeticException等
② 编译时异常：受查异常，一定要进行异常申明！！
③ final用于可以声明属性和方法，分别表示属性的不可变及方法的不可覆盖。不是方法的不可继承！！！

故：选ABD

① java中局部变量必须初始化，否则会报错！！（编译无法通过）
② 对引用变量的默认初始化均初始化为null。
① 标识符中可以包含：字母、数字以及下划线和 $ 符号等等。
② 注意：标识符不能以数字开头，也不能是关键字，且严格区分大小写。

2. 编程

统计回文
1）思路：
① 回文串也就是前后对称的字符串。
② 直接使用暴力求解方式计算即可：

① 遍历str1，将str2 insert进入str1的每个位置，判断是否是回文，这里注意的是，判断回文的时候，直接将字符串逆置，看是否相同就好了。是就++count。
② 需要注意的是这里不能 str1.insert(i,str2)，这样的话str1改变了，在进行下一次操作时就不再是原来的字符串了。所以每次使用str1重新给一个str作为临时变量，然后str.insert(i, str2)，再判断是否回文。
③ 注意：这里临时变量str是要进行字符串插入拼接的，所以直接使用StringBuffer类型就行！其中的insert方法是自带的，第一个参数是插入的起始位置，第二个参数是要插入的字符串。
④ 最后是判断插入后的字符串是不是回文字符串，所以在进行逆置的时候不能直接逆置，不然后期在进行比较的时候原来的字符串就会丢失，此时就需要一个临时变量来进行逆置操作。（逆置方法reverse是StringBuffer自带的）
⑤ 判断两个字符串是否相等使用equals，但是要toString！！

2）代码：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str1 = in.nextLine();
        String str2 = in.nextLine();
        // 开始进行回文判断
        int count = palindrome(str1,str2);
        System.out.println(count);
    }

    // 回文统计：
    // 将str2插入str1的每一个位置（但是str1要有临时变量来代替）
    private static int palindrome(String str1, String str2) {
        int count = 0;

        int len = str1.length();
        // 注意这里前后都可以取到：前后都可以插入！
        for (int i = 0; i <= len; i++) {
            // 每一次遍历代表每一次插入不同的位置，也就是每次都要有最开始传入的str1
            // 每插入一次就进行一次逆置+判断

            StringBuffer str = new StringBuffer(str1);
            // 然后进行插入
            str.insert(i,str2);
            // 逆置，但是不能直接逆置，因为直接逆置之后str本身会改变
            // 后面在进行回文串判断时比较的就是str与逆置后的字符串，所以这里需要一个临时变量进行逆置操作！
            StringBuffer tmp = new StringBuffer(str); // 注意这里创建方法，不是直接=str！
            tmp.reverse();
            // 进行回文判断:使用String判断！
            if(str.toString().equals(tmp.toString())) {
                count++;
            }
        }
        return count;
    }
}

连续最大和
这是一个经典的动归dp问题。
1）思路：

① 状态：dp[i] 就是以数组下标为 i 的数做为结尾的最大子序列和，其代表的数组其实就是[0,i]这个范围内的元素。
②状态方程：max( dp[ i ] ) = getMax( max( dp[ i -1 ] ) + arr[ i ] ,arr[ i ] ) ，其实意思就是：如果dp[i-1] +arr[i] <
arr[i]，那就是前面的数组元素和反而是拖累了后面的元素arr[i]，此时就更新当前最大值为arr[i] ；然后还要与此前记录的最大值比较来确定最终的最大值，一直到数组结束。
③ 初始值：arr[0]，所以循环从arr[1]开始，并且有sum和max！！

2）代码：

import java.util.Scanner;

// 正确版本
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = in.nextInt();
        }

        // 开始进行练习子数组求max
        int sum = arr[0];
        int max = arr[0];

        for (int i = 1; i < arr.length; i++) {
            // 更新sum的值,注意不是max，只有在比较厚才能确定max！
            sum = getMax(sum+arr[i],arr[i]);
            if(sum >= max) { // 大于等于都可以更新
                max = sum;
            }
        }

        System.out.println(max);
    }

    // 获取两个数中的较大值
    private static int getMax(int i, int j) {
        return (i>j)? i:j;
    }


}