public class Sample {
    int x; // 1
    long y = x; // 2
    
    public void f(int n) {
        int m; // 3
        int t = n + m; // 4
        m = 20;
    }

    public static void main(String[] args) {
        Sample t = new Sample();
        t.f(5);
        System.out.println(t.x);
    }
}

public class Overload {
    Overload(int m) {}

    Overload(double m) {}

    int Overload(int m) {
        return 23;
    }

    void Overload(double m) {}
}

class A {
    int value;
    static A a1 = new A(1);

    public A(int i) {
        System.out.println("initialize A" + i);
        value = i;
    }

    public A(A a) {
        System.out.println("copy from A" + a.value);
        value = a.value;
    }

    static A a2 = new A(2);

}

class B {
    A a8;
    // A a7 = new A(a6);
    A a6 = new A(6);
    static A a3 = new A(3);
    static A a4;

    static {
        a4 = new A(4);
    }

    static A a5 = new A(5);

    public B(int i) {
        System.out.println("initialize B" + i);
        a8 = new A(8);
    }

    A a7 = new A(a6);
}

public class Initialization {
    static B b1 = new B(1);
    static B b2;

    public static void main(String[] args) {
        System.out.println("main begins");
        A a9 = new A(9);
        b2 = new B(2);
        System.out.println("main ends");
    }
}

/**
 * Singleton 一个最简单的单例模式的实现
 */
public class Singleton {
    private static final Singleton uniqueInstance = new Singleton();


    private Singleton() {
    }

    public static Singleton getInstance() {
        return uniqueInstance;
    }

    public void foo() {
        System.out.println("Aha!");
    }
}

目录名为：Question11（或者你自己的命名）
文件名有：(如果你放了一个项目进来，则说明你的项目结构以及入口位置)

目录名为：Question12 （或者你自己的命名）
文件名有：(如果你放了一个项目进来，则说明你的项目结构以及入口位置)

解答：

1. 类的定义

Question 1

1. 标记的第4行会出现编译错误，错误与第3行的定义也有关。错误截图：

   

   原因是标记的第三行定义m时并没有完成初始化，而m为局部变量，必须进行初始化才能使用。而第四行进行t = n + m操作时调用了没有初始化的m，导致编译错误。

2. m需要初始化才能使用，x不需要初始化。因为m是一个局部变量，Java 中规定局部变量必须在使用前被初始化；而x是类Sample里面的一个成员变量，这种变量在创建时有默认初始值，比如x默认为0，所以不初始化也可以使用。

2. 函数重载

Question 2

• a. 正确
• b. 正确
• c. 正确
• d. 错误。当类里面有自己写的构造方法时，编译时就不会添加默认构造方法，所以Overload类里面只有写出来的2种构造方法。

3. 初始化（Initialization）

Question 3

initialize A1
initialize A2
initialize A3
initialize A4
initialize A5
initialize A6
copy from A6
initialize B1
initialize A8
main begins
initialize A9
initialize A6
copy from A6
initialize B2
initialize A8
main ends

Question 4

1. 可以证明“在属性定义处初始化的属性，比在方法中初始化的属性先被初始化”。比如main方法里面执行b2 = new B(2)时，程序先输出的initialize A6和copy from A6，再输出的initialize A8，说明属性定义处的a6比方法中初始化的a8更先被初始化。
2. 可以证明“在属性定义处初始化的属性，初始化顺序等同于他们在类定义中出现的顺序”。在class B里面，a6比a7在类中定义出现的更靠前，事实上程序也先输出initialize A6，再输出copy from A6，证明初始化的顺序也是如此。

Question 5

对于静态属性，它的初始化有以下方式：

• 在属性定义处显式初始化（如 a1、a2、a3、a5）
• 在 static 初始化块中初始化（如a4）

它的初始化顺序如下：

• 所有的属性定义处初始化和static块初始化的属性，初始化顺序等同于他们在类定义中出现的顺序。

Question 6

1. 不能证明具体是被构造、或类的静态属性和静态方法第一次被访问时JVM进行类加载，只可以看出来在执行static B b1 = new B(1);和A a6 = new A(6);这些构造时发生了类加载。

   修改代码：

   • 证明第一次被构造时类加载：（仅修改Initialization主类）

     public class Initialization {
         public static void main(String[] args) {
             System.out.println("main begins");
             new A(114514);
             System.out.println("main ends");
         }
     }

     运行结果：

     

   • 证明第一次访问类的静态属性进行类加载：

     class C{
         static{System.out.println("initialize C");}
         static int oop = 114514;
     }
     
     public class Initialization {
         public static void main(String[] args) {
             System.out.println("main begins");
             System.out.println("C.oop is " + C.oop); 
             System.out.println("main ends");
         }
     }

     运行结果：

     

   • 证明第一次访问类的静态方法进行类加载：

     class C{
         static{System.out.println("initialize C");}
         static void nb(){
             System.out.println("114514 from nb()");
         }
     }
     
     public class Initialization {
         public static void main(String[] args) {
             System.out.println("main begins");
             C.nb();
             System.out.println("main ends");
         }
     }

     运行结果：

     

2. 带有static关键字的方法、变量、代码块可以调用同类中的静态成员（静态字段、静态方法，带static），不可以直接访问实例成员（如实例字段、实例方法，不带static），因为它们属于对象，需要先有实例才可以调用。

   不带有static关键字的方法、变量、代码这些都可以调用。

4. 单例模式（Singleton Pattern）

Question 7

不可以。因为其构造函数是private权限的，任何其他外部类都无法访问。

Question 8

首先由Q7，任何外部类都无法通过构造函数构造一个新的Singleton变量，所以该实例只能在Singleton自己的类里面被实例化。

而Singleton类里面只有private static final Singleton uniqueInstance = new Singleton();初始化了一个实例，只有这里有一个实例可以用。

这个唯一的实例在第一次访问或使用Singleton的静态方法（getInstance()）时发生类的初始化，此时实例被构造。

Question 9

public class qst9 {
    public static void main(String[] args) {
        Singleton inst = Singleton.getInstance();
        inst.foo();
    }
}

5. 修饰符

Question 10

6. 编程题

Question 11

• 目录名为：Question11
• 文件名有：Person.java、TestPerson.java

输出结果：

Question 12

• 目录名为：Question11
• 文件名有：Main.java

代码

Q11

Person.java:

package Question11;

public class Person {
    private String name;
    private int age;
    private String sex;

    public Person() {
    }

    public Person(String name, int age, String sex) {
        this.name = name;
        this.sex = sex;
        if(age>130 || age<0){
            System.out.println("您的年龄不合法！年龄必须为0-130的整数");
            System.out.println("您已成功创建对象，但是目前没有年龄数值，需要手动设定年龄！");
            return;
        }
        this.age = age;
        System.out.println("创建对象成功！");
    }

    public void work(){
        System.out.println("working");
    }

    public void showAge(){
        System.out.println(age);
    }


    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getSex() {
        return sex;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        if(age>130 || age<0){
            System.out.println("您的年龄不合法！年龄必须为0-130的整数");
            return;
        }
        this.age = age;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}

TestPerson.java:

package Question11;

public class TestPerson {
    public static void main(String[] args) {
        Person li = new Person("李四", 10, "男");
        li.setAge(114514);
        li.setAge(100);
        System.out.println(li.getName() + "的年龄为" + li.getAge());
        Person wang = new Person("王五", 99, "沃尔玛购物袋");
        wang.setAge(114514);
        wang.setAge(100);
        System.out.println(wang.getName() + "的年龄为" + wang.getAge());
    }
}

Q12

Main.java:

package Question12;

import java.util.Scanner;

public class Main {
    static String str;

    // 判断是否为无符号整数
    public static boolean is_shu(){
        int len = str.length();
        if(len < 1){
            System.out.println("输入长度不符合要求！");
            return false;
        }
        for(int i = 0; i < len; i++){
            if(str.charAt(i) > '9' || str.charAt(i) < '0'){
                System.out.println("您输入的不是一个无符号整数呢~");
                return false;
            }
        }
        return true;
    }

    // 判断是否没有前导0
    public static boolean not_has_pre_zero(){
        int len = str.length();
        if(len == 1) return true;
        if(str.charAt(0) == '0') return false;
        return true;
    }

    // 判断是否为回文数
    public static boolean is_huiwen(){
        int len = str.length();
        if(len == 1) return true;
        int mid = (len - 1) / 2;
        for(int i = 0; i <= mid; i++){
            if(str.charAt(i) != str.charAt(len - i - 1)) return false;
        }
        return true;
    }

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        if(s.hasNextLine()) str = s.nextLine();
        if(!is_shu()){
            System.out.println("您的输入不合法，程序已结束");
            return;
        }

        if(!not_has_pre_zero()){
            System.out.println("您的输入为一个前导 0 的无符号整数");
            System.out.println("程序已结束");
            return;
        }else System.out.println("您的输入为一个没有前导 0 的无符号整数");

        if(is_huiwen()) System.out.println("您的输入为回文数");
        else System.out.println("您的输入不是回文数");
        System.out.println("程序已结束");
    }
}