类型 标识符 = 右值;

修饰符 返回值类型 标识符(参数类型 标识符 ...) throws 异常... {
    ...
}

try {
    String s = processFile(“C:\\test.txt”);
    // 一切正常会继续执行 try 中的部分
    
    throw new Exception(); // 自行抛出异常
} catch (FileNotFoundException e) {
    // 文件未找到
 
    e.printStackTrace(); // 打印异常栈信息
} catch (SecurityException e) {
    // 没有读取权限
 
    throw new RuntimeException(e); // 包装后再次抛出
} catch (IOException | NumberFormatException e) {
    // io 错误
} catch (Exception e) {
    // 其他错误
    // 越基础的基类需要越靠后，不然作为基类被捕获后永远不会被作为子类捕获
} finally {
    // 无论前面的代码块正常还是错误，最终都会执行，即使有 return
}

class Person {
    String name; // 引用类型默认初始化为 null
    public int age; // 基本类型有各自默认值，int 默认初始化为 0，boolean 初始化为 false
 
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 参数类型不同，方法重载，调用时会自动区分
    public Person(String name) {
        this.name = name;
        this.age = 12;
    }
    
    public String getName() {
        return this.name;
    }
 
    public int getAge() {
        return this.age;
    }
}
 
class Student extends Person {
    private int score;
    protected int grade;
 
    public int getScore() {
        return score;
    }
 
    // 覆盖父类相同签名方法，加 `@Override` 让编译器帮忙检查是否进行了正确的覆盖
    @Override
    public String getName() {
        return "Stu: " + super.getName();
    }
}

abstract class AbstractClass {
    String v;
    public void name() {
    };
 
    // 允许没有具体实现的方法，必须由非抽象子类完成实现
    abstract void fun();
 
    // 不允许静态抽象方法，可用的修饰符只有 public 和 protected
    // 以下语句会报错
    // static abstract void test();
}
 
interface ITest {
    // 接口只允许定义抽象实例方法，没有实例字段
    // 接口中定义的字段，即使不带 static 和 final 也是静态和引用不可变的。
    String StaticConstant = "";
 
    void run();
 
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }
}
 
class RealClass extends AbstractClass implements ITest {
    void fun() {    }
 
    public void run() {
        this.v.hashCode();
        RealClass.StaticConstant.hashCode();
    }
}

public class TestThread {
    Object lock = new Object();
    public void testMethod() {
        // 只能锁住引用类型
        synchronized (lock) {
            ...
        }
        ...
        // 作为修饰符的 synchronized 实际是下面代码的语法糖
        synchronized (this) {
            ...
        }
    }
    public synchronized void syncMethod() { ... }
}

class Point {
    int x;
    int y;
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}
 
final Point p = new Point(0, 0);
// p = new Point(1, 0);
p.x = 1;

public class ArrayList<T> implements List<T> {
    ...
}
 
// <> 外可以使用父类进行声明，尖括号内不行
List<String> list = new ArrayList<String>();
 
// 创建ArrayList<Integer>类型：
ArrayList<Integer> integerList = new ArrayList<Integer>();
// 添加一个Integer：
integerList.add(new Integer(123));
// “向上转型”为ArrayList<Number>：
ArrayList<Number> numberList = integerList;
// 添加一个Float，因为Float也是Number：
numberList.add(new Float(12.34));
// 从ArrayList<Integer>获取索引为1的元素（即添加的Float）：
Integer n = integerList.get(1); // ClassCastException!
 
// 在接口中定义泛型
public interface Comparable<T> {
    int compareTo(T o);
}
 
public interface Iterable<T> {
    Iterator<T> iterator();
}
 
// 在类中定义泛型
public class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() { ... }
    public T getLast() { ... }
 
    // 静态泛型方法应该使用其他类型区分:
    public static <K> Pair<K> create(K first, K last) {
        return new Pair<K>(first, last);
    }
}

// 虚拟机实际执行的代码
public class Pair {
    private Object first;
    private Object last;
    public Pair(Object first, Object last) {
        this.first = first;
        this.last = last;
    }
    public Object getFirst() {
        return first;
    }
    public Object getLast() {
        return last;
    }
}

// 定义注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Controller {
    String name() default "";
}

// 获取类作为 Class 类型的实例，方法 1
Class cls = String.class;
// 方法 2
String s = "Hello";
Class cls = s.getClass();
// 方法 3
Class cls = Class.forName("java.lang.String");
 
// 直接比较 class 和使用 instanceof 的差别
Integer n = new Integer(123);
n instanceof Integer; // true，因为n是Integer类型
n instanceof Number; // true，因为n是Number类型的子类
 
n.getClass() == Integer.class; // true，因为n.getClass()返回Integer.class
n.getClass() == Number.class; // false，因为Integer.class!=Number.class
 
Integer.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Integer
Number.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Number
Object.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Object
 
Class s = Integer.class.getSuperclass();
Class[] is = s.getInterfaces();