整理（一）

1.执行如下程序，输出结果是（C ）

class Test
{
    private int data;
    int result = 0;
    public void m()
    {
        result += 2;
        data += 2;
        System.out.print(result + " " + data);
    }
}
class ThreadExample extends Thread
{
    private Test mv;
    public ThreadExample(Test mv)
    {
        this.mv = mv;
    }
    public void run()
    {
        synchronized(mv)
        {
            mv.m();
        }
    }
}
public class ThreadTest {

    public static void main(String args[])
    {
        Test mv = new Test();
        Thread t1 = new ThreadExample(mv);
        Thread t2 = new ThreadExample(mv);
        Thread t3 = new ThreadExample(mv);
        t1.start();
        t2.start();
        t3.start();
    }
}

A .0 22 44 6
B. 2 42 42 4
C .2 24 46 6
D. 4 44 46 6

使用了synchronized关键字，所以三次new出来的对象依次进入线程开始执行
t1、t2、t3进入线程顺序不一定，但是对最终结果没有影响
第一次start()：result=2;data=2，输出为2 2
第二次start()：result=4;data=4，输出为4 4
第三次start()：result=6;data=6，输出为6 6
由于没有换行，所以最终结果为2 24 46 6
2.要使对象具有序列化能力，则其类应该实现如下哪个接口(A)

A java.io.Serializable
B java.lang.Cloneable
C java.lang.CharSequence
D java.lang.Comparable

类的序列化由实现java.io.Serializable接口的类启用。 序列化接口没有方法或字段，仅用于标识可串行化的语义。
一个类实现Cloneable接口，以指示Object.clone()方法，该方法对于该类的实例进行现场复制是合法的。
CharSequence是char值的可读序列。 该界面提供统一的，只读访问许多不同类型的char序列。
该接口对实现它的每个类的对象强加一个整体排序。 这个排序被称为类的自然排序 ，类的compareTo方法被称为其自然比较方法 。
3.假设 A 类有如下定义，设 a 是 A 类的一个实例，下列语句调用哪个是错误的？（C）

public class A
{
    public int i;
    static String s;
    void method1(){}
    static void method2(){}
}

A System.out.println(a.i);
B a.method1();
C A.method1();
D A.method2();

static修饰的成员变量和方法，既可以直接通过类名进行调用，也可以通过实例(也就是对象)调用。
无static修饰的只能通过实例(也就是对象)调用
4.【统计回文】“回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”等等就是回文串。花花非常喜欢这种拥有对称美的回文串，生日的时候她得到两个礼物分别是字符串A和字符串B。现在她非常好奇有没有办法将字符串B插入字符串A使产生的字符串是一个回文串。你接受花花的请求，帮助她寻找有多少种插入办法可以使新串是一个回文串。如果字符串B插入的位置不同就考虑为不一样的办法。
例如：
A = “aba”，B = “b”。这里有4种把B插入A的办法：
在A的第一个字母之前: “baba” 不是回文
在第一个字母‘a’之后: “abba” 是回文
在字母‘b’之后: “abba” 是回文
在第二个字母’a’之后 “abab” 不是回文
所以满足条件的答案为2

输入描述

每组输入数据共两行。
第一行为字符串A
第二行为字符串B
字符串长度均小于100且只包含小写字母

输出描述

输出一个数字，表示把字符串B插入字符串A之后构成一个回文串的方法数

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str1 = scanner.nextLine();
        String str2 = scanner.nextLine();
        int count = 0;
        for (int i = 0; i <= str1.length(); i++) {
            StringBuilder sb = new StringBuilder(str1);
            sb.insert(i,str2);
            if (isHuiWen(sb.toString())){
                count++;
            }
        }
        System.out.println(count);
    }

    public static boolean isHuiWen(String str){
        int i = 0;
        int j = str.length()-1;
        while (i<j){
            if (str.charAt(i) != str.charAt(j)){
                return false;
            }
            i++;
            j--;
        }
        return true;
    }
}