public class Hallo_world {
  public static void main(String[] args) {
    System.out.println("Hello world!");
  }
}
/* Hi! */
// I'm so great.

public class Hallo_world {
  

  
}

public class Hallo_world {
  

  
}

  public static void main(String[] args) {
   
  }

public class Hello_world {
  public static void main(String[] args) {
   
  }
}

  
    System.out.println("Hello world!");
  

  
    
  

/* Hi! */
// I'm so great.

'\n' // 換行
'\\' // 輸出 \
'\t' // 相當一個 Tab
'\'' // 輸出 '
'\"' // 輸出 "

變數型別 變數名稱;
變數型別 變數名稱 = 初始值;
變數型別 變數名稱1, 變數名稱2;
變數型別 變數名稱1 = 初始值, 變數名稱2 = 初始值;

public class Main {
  public static void main(String[] args) {
    byte by = 1;
    short sht = 666;
    int i = 214748354;
    long l = 999999999999l;
    char c = 'C';
    char ck = '帥';
    char unicode = '\u5a8b';
    boolean b = true;
    String str = "666我好棒";
    float f = 0.87f;
    double d = 0.8787878;
  }
}

public class Main {
  public static void main(String[] args) {
    int a = 0;
    a = a + 1;
    System.out.print(a);
  }
}

public class Main {
  public static void main(String[] args) {
    int a = 0;
    a += 1;
    System.out.println(a);
  }
}

public class Main {
  public static void main(String[] argv) {
    int i = 0,j;
    j = (i++) * 10; // 後置遞增
    System.out.println("後置遞增");
    System.out.println("變數 i 的內容是：" + i);
    System.out.println("變數 j 的內容是：" + j);

    i = 0;
    j = (++i) * 10; // 前置遞增
    System.out.println("前置遞增");
    System.out.println("變數 i 的內容是：" + i);
    System.out.println("變數 j 的內容是：" + j);
  }
}

public class Main {
  public static void main(String[] argv) {
    float a = 3.14;
    int b = (int)a; // 強制轉型
    System.out.println("a = " + a);
    System.out.println("b = " + b);
  }
}

public class Main {
  public static void main(String[] argv) {
    System.out.println(5 / 2 == 5 / 2.0);
  }
}

public class Main {
  public static void main(String[] argv) {
    double a = 3;
    int c = 1;
    double b = a + c; // 隱式轉型
    System.out.println("a = " + a);
    System.out.println("b = " + b);
  }
}

public class Main {
  public static void main(String[] argv) {
    double a = 3;
    float c = 1;
    double b = a + c; // 隱式轉型
    System.out.println("a = " + a);
    System.out.println("b = " + b);
  }
}

public class Main {
  public static void main(String[] argv) {
    byte a = 3;
    long c = 1;
    long b = a + c; // 隱式轉型
    System.out.println("a = " + a);
    System.out.println("b = " + b);
  }
}

public class Main {
  public static void main(String[] argv) {
    byte a = 3;
    short c = 1;
    int b = a + c; // 隱式轉型
    System.out.println("a = " + a);
    System.out.println("b = " + b);
  }
}

public class Main {
  public static void main(String[] argv) {
    char a = 87;
    short c = 1;
    char b = a + c; // 隱式轉型
    System.out.println("a = " + a);
    System.out.println("b = " + b);
  }
}

public class Main {
  public static void main(String[] argv) {
    float a = 3.14;
    int b = (int)a; // 強制轉型
    System.out.println("a = " + a);
    System.out.println("b = " + b);
  }
}

public class Main {
  public static void main(String[] argv) {
    float a = 3.14;
    int b = (int)a; // 強制轉型
    System.out.println("a = " + a);
    System.out.println("b = " + b);
  }
}

import java.util.Scanner;

public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int a = sc.nextInt();
    System.out.println(a);
  }
}

if (條件式) 敘述;
if (條件式)
{
    敘述1;
    敘述2;
    .
    .
    .
}

if (scord >= 60) System.out.println("及格了!");
if (scord < 60)
{
    System.out.println("哈哈哈，重補修吧!");
    restart();
}

if (scord >= 60) System.out.println("及格了!");
else if (scord < 60)
{
    System.out.println("哈哈哈，重補修吧!");
    restart();
}

int a = 10;
if (a >= 10) System.out.println("A");
if (a < 60)
{
    System.out.println("AA");
}

int a = 10;
if (a >= 10) System.out.println("A");
else if (a < 60)
{
    System.out.println("AA");
}

if (scord == 100) System.out.println("學霸求帶飛")
else if (scord >= 60) System.out.println("及格了!");
else
{
    System.out.println("哈哈哈，重補修吧!");
    restart();
}

if (有錢)
{
    if (是資本家)
    {
    	if (開資訊科技公司)
        {
            if (Windows是他的)
            {
            	System.out.println("他一定是比爾蓋茲");
            }
        }
    }
}

switch (變數)
{
    case 值:
        敘述1;
        敘述2;
        .
        .
        .
        break;
    case 值:
        敘述1;
        敘述2;
        .
        .
        .
        break;
}

char scord = 'A'
switch (scord)
{
    case 'A':
        System.out.println("Great!");
        break;
    case 'B':
        System.out.println("Not bad");
        break;
}

char scord = 'A'
switch (scord)
{
    case 'A':
        System.out.println("Great!");
        break;
    case 'B':
        System.out.println("Not bad");
        break;
    default:
    	System.out.println("Brush");
}

char scord = 'A'
switch (scord)
{
    default:
    	System.out.println("Brush");
        break;
    case 'A':
        System.out.println("Great!");
        break;
    case 'B':
        System.out.println("Not bad");
}

char scord = 'B';
switch (scord)
{
    case 'A':
        System.out.println("Great!");
    case 'B':
        System.out.println("Not bad");
    default:
    	System.out.println("Brush");
}

char scord = 'A'
switch (scord)
{
    case 'A':
        System.out.println("Great!");
        break;
    case 'B':
        System.out.println("Not bad");
        break;
    default:
    	System.out.println("Brush");
}

for (初始值; 終止條件; 每次回圈的變化值;) 敘述;
for (初始值; 終止條件; 每次回圈的變化值;)
{
    敘述1;
    敘述2;
}

public class Test {
    public static void main(String[] args) {
        for (int a = 0; a < 10; a++) System.out.println(a);
    }
}

public class Test {
    public static void main(String[] args) {
        for (int a = 1; a <= 10; a++)
        {
            for (int i = 0; i < a; i++)
                System.out.print('*');
            System.out.println();
        }
    }
}

public class Test {
    public static void main(String[] args) {
        for (int a = 1; a <= 10; a++)
        {
            if (a != 5) System.out.println(a);
            else break;
        }
    }
}

public class Test {
    public static void main(String[] args) {
        for (int a = 1; a <= 10; a++)
        {
            if (a != 5) System.out.println(a);
            else continue;
            System.out.println("hi");
        }
    }
}

while (終止條件;) 敘述;
while (終止條件;)
{
    敘述1;
    敘述2;
}

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int ans = 666, input = sc.nextInt();
        while (ans != input) input = sc.nextInt();
        System.out.println("NiceTry!(NT)");
    }
}

變數(物件)型態[] 陣列名稱;

String[] texts;
int[] As;

陣列名稱 = new 陣列型態[陣列大小];

String[] texts;
int[] As;

texts = new String[6];
As = new int[10];

double[] DD = new double[666];

public class Test {
    public static void main(String[] args) {
        int[] scord = {100, 95, 87, 66, 78};
        for (int i = 0; i < scord.length; i++)
            System.out.println("學生" + i + 1 + "的成績: " + scord[i]);
    }
}

public class Test {
    public static void main(String[] args) {
        int[] scord = {100, 95, 87, 66, 78};
        System.out.println(scord[5]);
    }
}

public class Test {
    public static void main(String[] args) {
        int[] scord = {100, 95, 87, 66, 78};
        for (int i : scord)
            System.out.println(i);
    }
}

int[][][] a = new int[3][2];

int[][][] a = new int[3][][];
a[0] = new int[3][1];
a[1] = new int[2][2];
a[2] = new int[666][777];

int[][][] b = new int[][6][] // 錯誤示範
int[][][] c = new int[666][][] // 正確示範
int[][][][] d = new int[777][666][][] // 正確示範
int[][][][] e = new int[9][][6][] // 錯誤示範

int[][] a = {{1, 2},
             {3, 4, 5}}; //這樣排方便閱讀

public class Test {
  public static void main(String[] argv) {
    int[][] a = {{1,2,3,4},
                 {5,6,7}};
                 
    System.out.println("a共有" + a.length + "個元素");

    for(int i = 0;i< a.length;i++) {
      System.out.println("a[" + i + "]共有" + a[i].length + "個元素");

      for(int j = 0;j < a[i].length;j++)
        System.out.println("a[" + i + "][" + j +  "]: " + a[i][j]);
    }
  }
}

public class Test {
    public static void main(String[] argv) {
        int[][] a = {{1,2,3,4},
                   {5,6,7,8}};
        for(int i[] : a) {
            for(int j : i)
                System.out.print(j + " ");
            System.out.println();
        }
    }
}

public class BubbleSort { // 經典排序法: 氣泡排序法
  public static void main(String[] argv) {
    int[] data = {50, 87, 78, 66, 100, 90}; // 未排序的資料
    int temp; // 用來交換元素的暫存變數

    for(int i = 0;i < data.length - 1;i++) {
      // 共需進行元素個數-1輪
      for(int j = 0;j < data.length - 1 - i;j++ ) {
        // 第i輪比對到倒數第i+1個元素
        if(data[j] > data[j + 1]) {
          temp = data[j];
          data[j] = data[j + 1];
          data[j + 1] = temp;
        }
      }
      System.out.println("");
    }
    for (int i : data)
        System.out.println(i);
  }
}

int a[] = {1, 2, 3};
a[2] = 666;

int a[] = new int[99999];
a[20823] = 666;

public class Test {
  public static void main(String[] argv) {
    int[] god = {20, 30, 40};
    int[] me = god; // 將 god 的內容指定給 me

    me[2] = 100; // 更改陣列 me 的內容

    System.out.print("陣列 god 的元素:");
    for(int i : god)
      System.out.print(" " + i);

    System.out.print("\n陣列 me 的元素:");
    for(int i : me)
      System.out.print(" " + i);
  }
}

{20, 30, 40}

{20, 30, 100}

{20, 30, 100}

public class Test {
  public static void main(String[] argv) {
    int[] a = {20, 30, 40};  // 原本是 3 個元素的陣列

    System.out.print("陣列a:");
    for(int i : a)
      System.out.print(" " + i);

    a = new int[5]; // 重新配置陣列
    a[0] = 100;
    a[1] = 200;

    System.out.print("\n重新配置陣列a:");
    for(int i : a)
      System.out.print(" " + i);
  }
}

public class Test {
  public static void main(String[] argv) {
    int[] a = {20, 30, 40};  // 原本是 3 個元素的陣列

    System.out.print("陣列a:");
    for(int i : a)
      System.out.print(" " + i);

    a = {100, 200, 0, 0, 0}; // 這好嗎?這不好

    System.out.print("\n重新配置陣列a:");
    for(int i : a)
      System.out.print(" " + i);
  }
}

public class Test {
  public static void main(String[] argv) {
    int[] a;
    while(true) {
      a = new int[666];
    }
  }
}

public class Test {
  public static void main(String[] argv) {
    int[] god = {20, 30, 40};
    int[] me = god; // 將 god 的內容指定給 me，{20, 30, 40} 陣列參照計數 +1

    me[2] = 100; // 更改陣列 me 的內容

    System.out.print("陣列 god 的元素:");
    for(int i : god)
      System.out.print(" " + i);

    System.out.print("\n陣列 me 的元素:");
    for(int i : me)
      System.out.print(" " + i);
  }
}

public class Test {
  public static void main(String[] argv) {
    int[] a;
    a = new int[666];
    a = null; // int[666] 將會在系統覺得可以的時間消失!
  }
}

public class Test {
    public static void main(String argv[]) {
        for (int i = 0; i < 10; i++)
            Say();
    }
    
    public static void Say(){
        System.out.println("Hi!");
    }
}

public class Test {
    public static void main(String argv[]) {
        for (int i = 0; i < 10; i++)
            Say();
    }
    
    public static void Say(){
        System.out.println("Hi!");
    }
}

// 方法宣告在這裡不行

public class Test { // main() 的類別，方法一定要宣告在這裡面
    public static void main(String argv[]) {
        方法名稱();
    }
    
    public static 回傳值型態 方法名稱(){
        敘述1;
        敘述2;
        .
        .
        .
    }
}
// 方法宣告在這裡也不行

public class Test { // main() 的類別，方法一定要宣告在這裡面
    public static void main(String argv[]) {
        Say("hi"); // 將 "hi" 當 String 型態參數傳入 Say() 中
    }
    
    public static void Say(String text){
        System.out.println(text);
    }
}

public class Test { // main() 的類別，方法一定要宣告在這裡面
    public static void main(String argv[]) {
        int[] s = {60, 60, 60, 60, 60};
        Say("我的英文快裂開了", 16, true, s);
    }
    
    public static void Say(String name, int age, boolean DD, int[] scord){
        System.out.print("Hi, my name is " + name + 
                      ".\nI'm " + age + " years old.\nAnd I'm " + 
                      (DD ? "a DD." : "not a DD.") + "\nMy socord:");
        for(int i : scord)
           System.out.print(" " + i);
    }
}

public class Test { // main() 的類別，方法一定要宣告在這裡面
    public static void main(String argv[]) {
        int[] s = {60, 60, 60, 60, 60};
        int sum = Sum(s);
        System.out.println(sum);
    }
    
    public static int/*在這裡指定回傳型態!*/ Sum(int[] array){
        int i = 0;
        for (int j : array)
           i += j;
        return i; // i 必須是 int 型態!
    }
}

public class Test { // main() 的類別，方法一定要宣告在這裡面
    public static void main(String argv[]) {
        int[] s = {60, 60, 60, 60, 60};
        System.out.println(Sum(s)); // 把 Sum() 的回傳值當參數用
    }
    
    public static int/*在這裡指定回傳型態!*/ Sum(int[] array){
        int i = 0;
        for (int j : array)
           i += j;
        return i; // i 必須是 int 型態!
    }
}

public class Test {
    public static void main(String argv[]) {
        for (int i = 0; i < 10; i++)
            Say();
    }
    
    public static void Say(){
        System.out.println("Hi!");
    }
}

public class Test {
    public static void main(String argv[]) {
        for (int i = 0; i < 10; i++)
            Say();
    }
    
    public static void Say(){
        System.out.println("Hi!");
    }
    public static void Say(int i){
        System.out.println(i);
    }
    public static void Say(String i){
        System.out.println(i);
    }
    public static void Say(String i, int b){
        System.out.println(i + b);
    }
}

public class Argument {
  public static void main(String[] argv){
    int i = 20;

    System.out.println("前 i = " + i);
    changePara(i);   // 傳入 i
    System.out.println("後 i = " + i);
  }

  public static void changePara(int x) { // 會修改參數值的方法
    System.out.println("...方法參數 x = "+ x);
    System.out.println("...修改中");
    x++;   // 更改接收到的參數值
    System.out.println("...現在參數 x = "+ x);
  }
}

public class Test {
    public static void main(String argv[]) {
        int[] i = {10, 100};
        Set(0, 2, i); // 將 i[0] 設為 2
        for(int j : i)
            System.out.print(j + " ");
    }
    
    public static void Set(int a, int b, int[] data){
        data[a] = b; // 修改
    }
}

public class Test {
    public static void main(String argv[]) {
        for (int i = 0; i < 10; i++)
            Say();
    }
    
    public static void Say(){
        System.out.println("Hi!");
        Say(666);
    }
    public static void Say(int i){
        System.out.println(i);
    }
}

public class Test {
    public static void main(String argv[]) {
        Say(1);
    }
    
    public void Say(int i){
        System.out.println(i);
        Say(i);
    }
}

public class Test {
    public static void main(String argv[]) {
        System.out.println(Factorial(5));
    }
    
    public long Factorial(int i){
        if (i == 1) return 1;
        else return Factorial(i - 1) * i;
    }
}

import java.util.Scanner;

public class Test {
  public static void main(String[] argv) {
    int[] data = new int[10];
      Scanner sc = new Scanner(System.in);

    for(int i = 0;i < data.length;i++)
      data[i] = sc.nextInt();
  
    // 排序
    quickSort(0, data.length - 1, data);
	
    show(data);
  }
  static void quickSort(int start, int end, int[] data) {
    // 如果只有一個元素，直接返回
    if(start >= end) {
       return;
    }
  
    // 取得中間元素的值
    int mid = data[(start + end) / 2];
  
    int left = start;
    int right = end;
    while(left < right) { // 還未相遇
    // 往尾端搜尋
      while((left < end) && (data[left] < mid)) {
        left++;
      }
  
    // 往前端搜尋
      while((right > start) && (data[right] > mid)) {
        right--;
      }
  
    // 還未交錯
      if(left <= right) {
        int temp = data[left]; // 交換元素
        data[left] = data[right];
        data[right] = temp;
        left++; // 往尾端移動
        right--; // 往前端移動
      }
    }
    
    // 遞迴排序前後兩段
    quickSort(start, right, data);
    quickSort(left, end, data);
  }
  static void show(int[] data) {
    for(int i:data) {
      System.out.print(i +" ");
    }
    System.out.println("");
  }
}

class 名稱{
    屬性1;
    屬性2;
    .
    .
    .
    行為1(){
    }
    行為2(){
    }
    .
    .
    .
}

class person{
    int age;
    String name;
    
    void Say(){
        System.out.println("My name is " + name);
    }
    void Ask(){
        System.out.println("How old are you?");
    }
}

public class Main {
    public static void main(String[] argv){
    }
}

類別名稱 物件名稱 = new 類別名稱();

public class Main {
    public static void main(String[] argv){
        person asadfggle = new person();
        asadfggle.age = 16;
        asadfggle.name = "Minecraft God";
        asadfgglie.Say();
        asadfgglie.Ask();
    }
}

class person{
    int age;
    String name;
    
    void Say(){
        System.out.println("My name is " + name);
    }
    void Ask(){
        System.out.println("How old are you?");
    }
}

public class Main {
    public static void main(String[] argv){
        person man = new person(), female = new person();
        man.age = 16;
        man.name = "man";
        female.age = 12;
        female.name = "female";
        man.Say();
        female.Say();
    }
}
class person{
    int age;
    String name;
    
    void Say(){
        System.out.println("My name is " + name);
    }
    void Ask(){
        System.out.println("How old are you?");
    }
}

class Test { // 測試類別
  int x = 3; // 設定初始值

  void show() {
    System.out.println("x = " + x);
  }
}

public class Main {

  public static void main(String[] argv){
    Test a,b,c;

    a = new Test();  // 建立 2 個物件並做比較
    b = new Test();
    System.out.println("a == b ? " + (a == b));

    c = b;           // 讓 c 和 b 參照到同一物件
    c.x = 10;
    System.out.println("c == b ? " + (c == b));
    System.out.print("a.");
    a.show();
    System.out.print("b.");
    b.show();
    System.out.print("c.");
    c.show();
  }
}

class Card {  // 代表卡的類別
  long id;      // 卡號
  int money;    // 餘額

  void show() {  // 顯示卡片資訊的方法
    System.out.print("卡號 "+ id);
    System.out.println(", 餘額 " + money + " 元 ");
  }
}

public class Main {
  public static void main(String[] argv) {
    Card[] Cards = new Card[6];     // 建立物件陣列

    for(int i = 0; i < Cards.length; i++) {
      Cards[i] = new Card();         // 要記得建立物件
      Cards[i].id = 0x666666AB + i;  // 0x來表示16進位的數字，還記得嗎?
      Cards[i].money = 666 + i * 123;
    }

    for(Card c : Cards)  // 也可以用 For-each 迴圈
      c.show();      // 呼叫方法
  }
}

class Test {
    long id;

    void set(long value) {
        id = value;
    }
}
  
public class Main {
    public static void main(String[] argv) {
      Test tmp = new Test();
      tmp.set(666);
      System.out.println(tmp.id);
    }
}

class Test {
    long id;

    void set(long id) {
        id = id;
    }
}
  
public class Main {
    public static void main(String[] argv) {
      Test tmp = new Test();
      tmp.set(666);
      System.out.println(tmp.id);
    }
}

class Test {
    long id;

    void set(long id) {
        this.id = id;
    }
}
  
public class Main {
    public static void main(String[] argv) {
      Test tmp = new Test();
      tmp.set(666);
      System.out.println(tmp.id);
    }
}

class Test {
    void show(String[] text) {
        for(String t:text)
            System.out.println(t);
    }
}
  
public class Main {
    public static void main(String[] argv) {
      Test tmp = new Test();
      tmp.show(new String[]{"666","777","888"});
    }
}

class Test {
    void show(String[] text) {
        for(String t:text)
            System.out.println(t);
    }
    void show(int i){
        System.out.println(i);
    }
}
  
public class Main {
    public static void main(String[] argv) {
      Test tmp = new Test();
      tmp.show(new String[]{"666k","777k","888k"});
      tmp.show(123)
    }
}

public class Main {
    public static void main(String[] argv){
        person man = new person(), female = new person();
        man.age = 16;
        man.name = "man";
        female.age = 12;
        female.name = "female";
        man.Say();
        female.Say();
    }
}
class person{
    int age;
    String name;
    
    void Say(){
        System.out.println("My name is " + name);
    }
    void Ask(){
        System.out.println("How old are you?");
    }
}

class person{
    int age;
    String name;
    
    void Say(){
        System.out.println("My name is " + name);
    }
    void Ask(){
        System.out.println("How old are you?");
    }
    person(int age, String name){
        this.age = age;
        this.name = name;
    }
}
public class Main {
    public static void main(String[] argv){
        person man = new person(16, "man"), female = new person(12, "female");
        man.Say();
        female.Say();
    }
}

class person{
    int age;
    String name;
    
    void Say(){
        System.out.println("My name is " + name);
    }
    void Ask(){
        System.out.println("How old are you?");
    }
    person(int age, String name){
        this.age = age;
        this.name = name;
    }
    person(int age){
        this.age = age;
        this.name = "I don\'t have a name. QQ :(";
    }
}
public class Main {
    public static void main(String[] argv){
        person man = new person(16, "man"), female = new person(12);
        man.Say();
        female.Say();
    }
}

class person{
    int age;
    String name;
    
    void Say(){
        System.out.println("My name is " + name);
    }
    void Ask(){
        System.out.println("How old are you?");
    }
    person(int age, String name){
        this.age = age;
        this.name = name;
    }
    person(int age){
        this.age = age;
        this.name = "I don\'t have a name. QQ :(";
    }
}
public class Main {
    public static void main(String[] argv){
        person man = new person(16, "man"), female = new person(12);
        man.Say();
        female.Say();
    }
}

class person{
    int age;
    String name;
    
    void Say(){
        System.out.println("My name is " + name);
    }
    void Ask(){
        System.out.println("How old are you?");
    }
    person(int age, String name){
        this.age = age;
        this.name = name;
    }
    person(int age){
        this(age, "I don\'t have a name. QQ :(");
    }
}
public class Main {
    public static void main(String[] argv){
        person man = new person(16, "man"), female = new person(12);
        man.Say();
        female.Say();
    }
}

class person{
  private int age;
  String name;
  person(int age){
      this.age = age;
  }  
}
public class Test {
  public static void main(String[] argv){
      person female = new person(12);
      System.out.println(female.age);
  }
}

class person{
  public int age;
  String name;
  person(int age){
      this.age = age;
  }  
}
public class Test {
  public static void main(String[] argv){
      person man = new person(12);
      System.out.println(man.age);
  }
}

class person{
  private int age;
  String name;
  person(int age){
      this.age = age;
  }

  private int get_age(){
      return this.age;
  }
}
public class Test {
  public static void main(String[] argv){
      person female = new person(12);
      System.out.println(female.get_age());
  }
}

class person{
  private int age;
  String name;
  person(int age){
      this.age = age;
  }

  public int get_age(){
      return this.age;
  }
}
public class Test {
  public static void main(String[] argv){
      person female = new person(12);
      System.out.println(female.get_age());
  }
}

class person{
  private int age;
  String name;
  private person(int age){
      this.age = age;
  }
}
public class Test {
  public static void main(String[] argv){
      person female = new person(12); // Oh, new 不出來的可憐人
      System.out.println(female.name);
  }
}

class Point {   // 點
  private double x,y;

  public void set_x(double x) {
    this.x = x;
  }

  public void set_y(double y) {
    this.y = y;
  }

  public String toString() { // 將物件資訊轉成字串
    return "(" + x + "," + y + ")";
  }

  public Point(double x,double y) {
    this.x = x;
    this.y = y;
  }

  public Point() {
    x = y = 0;
  }
}

class Circle {       // 圓
  private Point p;   // 圓心
  private double r;  // 半徑

  public Point get_p() {
    return p;        // 直接傳回成員物件
  }

  Circle(double x,double y,double r) {
    p = new Point(x,y);
    this.r = r;
  }

  Circle() {
    this(0,0,1);
  }

  public String toString() {  // 將物件資訊轉成字串
    return "圓心：" + p.toString() + " 半徑：" + r;
  }
}

public class SettingPrivateMember {
  public static void main(String[] argv) {
    Circle c = new Circle(3,4,5);  // 圓心 (3,4), 半徑 5

    Point p = c.get_p();            // 取得圓心的參照
    p.set_x(6);                     // 變更圓心座標
    System.out.println(c.toString());
  }
}

class Point {   // 點
  private double x,y;

  public void set_x(double x) {
    this.x = x;
  }

  public void set_y(double y) {
    this.y = y;
  }

  public String toString() { // 將物件資訊轉成字串
    return "(" + x + "," + y + ")";
  }

  public Point(double x,double y) {
    this.x = x;
    this.y = y;
  }

  public Point() {
    x = y = 0;
  }
  public Point(Point p){ // 複製物件用的建構子
    this(p.x, p.y);
  }
}

class Circle {       // 圓
  private Point p;   // 圓心
  private double r;  // 半徑

  public Point get_p() {
    Point tmp = new Point(p); // 複製一個複製品
    return tmp;               // 再傳回複製的成員物件
  }

  Circle(double x,double y,double r) {
    p = new Point(x,y);
    this.r = r;
  }

  Circle() {
    this(0,0,1);
  }

  public String toString() {  // 將物件資訊轉成字串
    return "圓心：" + p.toString() + " 半徑：" + this.r;
  }
}

public class SettingPrivateMember {
  public static void main(String[] argv) {
    Circle c = new Circle(3,4,5);     // 圓心 (3,4), 半徑 5

    Point p = c.get_p();              // 取得圓心的參照
    p.set_x(6);                       // 變更圓心座標
    System.out.println(c.toString()); // 顆顆，改不了了吧
  }
}

class hi{
  public static int h;
}

public class SettingPrivateMember {
  public static void main(String[] argv) {
    hi c = new hi();
    hi p = new hi();
    p.h = 666;              // 將p.h設為666
    System.out.println(c.h);// Isn't it cool?
  }
}

class hi{
  public static int h;
}

public class SettingPrivateMember {
  public static void main(String[] argv) {
    hi.h = 777;              // 將hi的static變數設為666
    hi p = new hi();
    System.out.println(p.h);
  }
}

class hi{
  public static void haha(){
    System.out.println(666);
  }
}

public class SettingPrivateMember {
  public static void main(String[] argv) {
    hi.haha();
  }
}

class hi{
  public static void haha(){
    System.out.println(666);
  }
}

public class SettingPrivateMember {
  public static void main(String[] argv) {
    hi tmp = new hi();
    tmp.haha();
  }
}

class hi{
  static int i = 789;
  public static void haha(){
    System.out.println(i); // i 必須是 static 才行!
  }
}

public class SettingPrivateMember {
  public static void main(String[] argv) {
    hi.haha();
  }
}

class person{
  static int age;

  static{
    age = 666;
  }
  
  public person(){}

}
public class Test {
  public static void main(String[] argv){
      person man = new person(); 
      System.out.println(man.age);
  }
}

public class Test {

  public static void main(String[] argv) {

    char[] test = {'這','是','個','測','試','字','串'};
    String a = new String();         // 空字串
    String b = new String(test);     // "這是個測試字串"
    String c = new String(test,2,3); // "個測試"
    String d = new String(b);        // b 字串的副本

    System.out.println("a：" + a);
    System.out.println("b：" + b);
    System.out.println("c：" + c);
    System.out.println("d：" + d);

    // d 是 b 的副本
    System.out.println("b == d ?" + (b == d)); // 兩者參照不同
  }
}

public class Test {
  public static void main(String[] argv) {
    // 為何 a 可以這樣定義?
    String a = "Look that move!\nLook that move!\nWhat was that!\nFaker!";
    System.out.println(a);
  }
}

public class ConstructString {
  public static void main(String[] argv) {
    System.out.println("a".equals("a"));
  }
}

public class ConstructString {
  public static void main(String[] argv) {
    System.out.println("a" + "a");
  }
}

public class ConstructString {
  public static void main(String[] argv) {
    String a = "a";
    String tmp = a; // 取得 a 的參照
    a += ""; // 做字串加法
    System.out.println(a == tmp); // 比較兩個字串的參照
  }
}

class TestString {
  public String toString() {
    return "666";
  }
}

public class Test {       
  public static void main(String[] argv) {
    TestString t = new TestString();
    String a = "測試字串";
    String b = a + t; // 等同 String b = a + t.toString();

    System.out.println("a：" + a);
    System.out.println("b：" + b);
  }
}

public class Test {
  public static void main(String[] argv) {
    String a = "abcd";
    System.out.println(a.equals("ab"));
  }
}

public class Test {
  public static void main(String[] argv) {
    String a = "abcd";
    System.out.println(a.compareTo("abcb"));
    System.out.println(a.compareTo("abcd"));
    System.out.println(a.compareTo("abce"));
    System.out.println(a.compareTo("abcde"));
    System.out.println(a.compareTo("Abcd"));
  }
}

public class Test {       
  public static void main(String[] argv) {
    String a = "測試字串";
    System.out.println(a.charAt(2));
  }
}

public class Test {       
  public static void main(String[] argv) {
    String a = "878kk";
    System.out.println(a.length());
  }
}

public class Test {       
  public static void main(String[] argv) {
    String a = "878kk";
    System.out.println(a.toUpperCase());
    System.out.println(a);
  }
}

public class Test {       
  public static void main(String[] argv) {
    String a = "878ABl";
    System.out.println(a.toLowerCase());
    System.out.println(a);
  }
}

public class CompareTo {
  public static void main(String[] argv) {
    String a = "abcd";
    System.out.println(a.contains("ab"));
    System.out.println(a.contains("abc"));
    System.out.println(a.contains("abcd"));
    System.out.println(a.contains("abcde"));
    System.out.println(a.contains("Abcd"));
  }
}

public class Test {       
  public static void main(String[] argv) {
    String a = "878kk";
    System.out.println(a.startsWith("87"));
  }
}

public class Test {       
  public static void main(String[] argv) {
    String a = "878kk";
    System.out.println(a.endsWith("kk"));
  }
}

public class Test {       
  public static void main(String[] argv) {
    String a = "\t878ABl666878   ";
    System.out.println("..." + a.trim() + "??");
    System.out.println("..." + a + "??");
  }
}

public class Test {       
  public static void main(String[] argv) {
    String a = "878kk";
    System.out.println(a.indexOf('8', 1));
    System.out.println(a.indexOf("8k", 1));
  }
}

class person{
  static final int age;

  static{
    age = 666;
  }

  public person(){}

}
public class Test {
  public static void main(String[] argv){
      person man = new person(); 
      System.out.println(man.age);
  }
}

class Pet{
  boolean isCute = true;
  String name;
}
class Dog{
  boolean isCute = true;
  String name;

  public void Say(){
    System.out.println("汪");
  }
  public void touchMe(){
    System.out.println("我要討摸摸!");
  }
  boolean isMammals = true;
}
public class Test{       
  public static void main(String[] argv) {
  }
}

class Dog{
  boolean isCute = true;
  String name;

  public void Say(){
    System.out.println("汪");
  }
  public void touchMe(){
    System.out.println("我要討摸摸!");
  }
  boolean isMammals = true;
}
class Cat{
  boolean isCute = true;
  String name;

  public void Say(){
    System.out.println("Meow");
  }
  public void touchMe(){
    System.out.println("我要討摸摸!");
  }
  
    boolean isMammals = true;

  private String emotion;
}
class Rabbbit{
  boolean isCute = true;
  String name;

  public void Say(){
    System.out.println("咭!");
  }
  public void touchMe(){
    System.out.println("我要討摸摸!");
  }
  boolean isMammals = true;

  boolean peko;
}
class Turtle{
  boolean isCute = true;
  String name;

  boolean isMammals = false;

  boolean Zzzzz;
}
public class Test{       
  public static void main(String[] argv) {
  }
}

class Pet{
  boolean isCute = true;
  String name;
  boolean isMammals = true;
}
class Dog extends Pet{
  public void Say(){
    System.out.println("汪");
  }
  public void touchMe(){
    System.out.println("我要討摸摸!");
  }
}
class Cat extends Pet{
  public void Say(){
    System.out.println("Meow");
  }
  public void touchMe(){
    System.out.println("我要討摸摸!");
  }
  private String emotion;
}
class Rabbbit extends Pet{
  public void Say(){
    System.out.println("咭!");
  }
  public void touchMe(){
    System.out.println("我要討摸摸!");
  }
  boolean peko;
}
class Turtle extends Pet{
  boolean Zzzzz;
  Turtle(){
    this.isMammals = false;
  }
}
public class Test{       
  public static void main(String[] argv) {
  }
}

class Parent{
  Parent(){
    System.out.println("Call me Dady!");
  }
  Parent(String text){
    System.out.println(text);
  }
}
class Child extends Parent{
  Child(){
    System.out.println("I want money, Dad.");
  }
}
public class Test{       
  public static void main(String[] argv) {
    Child son = new Child();
  }
}

class Parent{
  Parent(){
    System.out.println("Call me Dady!");
  }
  Parent(String text){
    System.out.println(text);
  }
}
class Child extends Parent{
  Child(){
    super("666");
    System.out.println("I want money, Dad.");
  }
}
public class Test{       
  public static void main(String[] argv) {
    Child son = new Child();
  }
}

class Parent{
  Parent(){
    System.out.println("Call me Dady!");
  }
  Parent(String text){
    System.out.println(text);
  }
  protected String name;
}
class Child extends Parent{
  Child(String text){
    super(text);
    System.out.println("I want money, Dad.");
    name = text;
  }
}
public class Test{       
  public static void main(String[] argv) {
    Child son = new Child("gg");
  }
}

class Grandma{
  Grandma(){
    System.out.println("Call me Grandma.");
  }
  Grandma(String text){
    System.out.println(text);
  }
  protected String name;
}
class Mom extends Grandma{
  Mom(){
    System.out.println("Call me Mom!");
  }
  Mom(String text){
    System.out.println(text);
  }
}
class Child extends Mom{
  Child(String text){
    super(text);
    System.out.println("I want money, mom.");
    name = text;
  }
}
public class Test{       
  public static void main(String[] argv) {
    Child son = new Child("gg");
  }
}

class Mom{
  Mom(){
  }
  int age = 30;
}
class Child extends Mom{
  int age;
  Child(int age){
    this.age = age;
  }
}
public class Test{       
  public static void main(String[] argv) {
    Child son = new Child(18);
    System.out.println(son.age);
    System.out.println();
    System.out.println(new Mom().age);
  }
}

class Mom{
  Mom(){
  }
  void Say(){
    System.out.println("Say Mom");
  }
}
class Child extends Mom{
  Child(){
  }
  void Say(){
    System.out.println("Say Hi");
  }
}
public class Test{       
  public static void main(String[] argv) {
    Child son = new Child();
    Mom mom = new Mom();
    mom.Say();
    son.Say();
  }
}

class Mom{
  Mom(){
  }
  void Say(){
    System.out.println("Say Mom");
  }
}
class Child extends Mom{
  Child(){
  }
  @Override
  void Say(){
    System.out.println("Say Hi");
  }
}
public class Test{       
  public static void main(String[] argv) {
    Child son = new Child();
    Mom mom = new Mom();
    mom.Say();
    son.Say();
  }
}

class Mom{
  Mom(){
  }
  final void Say(){
    System.out.println("Say Mom");
  }
}
class Child extends Mom{
  Child(){
  }
  void Say(){ // 不可以 Override
    System.out.println("Say Hi");
  }
}
public class Test{       
  public static void main(String[] argv) {
    Child son = new Child();
    Mom mom = new Mom();
    mom.Say();
    son.Say();
  }
}

/*
 * Copyright (c) 1994, 2012, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package java.lang;

/**
 * Class {@code Object} is the root of the class hierarchy.
 * Every class has {@code Object} as a superclass. All objects,
 * including arrays, implement the methods of this class.
 *
 * @author  unascribed
 * @see     java.lang.Class
 * @since   JDK1.0
 */
public class Object {

    private static native void registerNatives();
    static {
        registerNatives();
    }

    /**
     * Returns the runtime class of this {@code Object}. The returned
     * {@code Class} object is the object that is locked by {@code
     * static synchronized} methods of the represented class.
     *
     * <p><b>The actual result type is {@code Class<? extends |X|>}
     * where {@code |X|} is the erasure of the static type of the
     * expression on which {@code getClass} is called.</b> For
     * example, no cast is required in this code fragment:</p>
     *
     * <p>
     * {@code Number n = 0;                             }<br>
     * {@code Class<? extends Number> c = n.getClass(); }
     * </p>
     *
     * @return The {@code Class} object that represents the runtime
     *         class of this object.
     * @jls 15.8.2 Class Literals
     */
    public final native Class<?> getClass();

    /**
     * Returns a hash code value for the object. This method is
     * supported for the benefit of hash tables such as those provided by
     * {@link java.util.HashMap}.
     * <p>
     * The general contract of {@code hashCode} is:
     * <ul>
     * <li>Whenever it is invoked on the same object more than once during
     *     an execution of a Java application, the {@code hashCode} method
     *     must consistently return the same integer, provided no information
     *     used in {@code equals} comparisons on the object is modified.
     *     This integer need not remain consistent from one execution of an
     *     application to another execution of the same application.
     * <li>If two objects are equal according to the {@code equals(Object)}
     *     method, then calling the {@code hashCode} method on each of
     *     the two objects must produce the same integer result.
     * <li>It is <em>not</em> required that if two objects are unequal
     *     according to the {@link java.lang.Object#equals(java.lang.Object)}
     *     method, then calling the {@code hashCode} method on each of the
     *     two objects must produce distinct integer results.  However, the
     *     programmer should be aware that producing distinct integer results
     *     for unequal objects may improve the performance of hash tables.
     * </ul>
     * <p>
     * As much as is reasonably practical, the hashCode method defined by
     * class {@code Object} does return distinct integers for distinct
     * objects. (This is typically implemented by converting the internal
     * address of the object into an integer, but this implementation
     * technique is not required by the
     * Java&trade; programming language.)
     *
     * @return  a hash code value for this object.
     * @see     java.lang.Object#equals(java.lang.Object)
     * @see     java.lang.System#identityHashCode
     */
    public native int hashCode();

    /**
     * Indicates whether some other object is "equal to" this one.
     * <p>
     * The {@code equals} method implements an equivalence relation
     * on non-null object references:
     * <ul>
     * <li>It is <i>reflexive</i>: for any non-null reference value
     *     {@code x}, {@code x.equals(x)} should return
     *     {@code true}.
     * <li>It is <i>symmetric</i>: for any non-null reference values
     *     {@code x} and {@code y}, {@code x.equals(y)}
     *     should return {@code true} if and only if
     *     {@code y.equals(x)} returns {@code true}.
     * <li>It is <i>transitive</i>: for any non-null reference values
     *     {@code x}, {@code y}, and {@code z}, if
     *     {@code x.equals(y)} returns {@code true} and
     *     {@code y.equals(z)} returns {@code true}, then
     *     {@code x.equals(z)} should return {@code true}.
     * <li>It is <i>consistent</i>: for any non-null reference values
     *     {@code x} and {@code y}, multiple invocations of
     *     {@code x.equals(y)} consistently return {@code true}
     *     or consistently return {@code false}, provided no
     *     information used in {@code equals} comparisons on the
     *     objects is modified.
     * <li>For any non-null reference value {@code x},
     *     {@code x.equals(null)} should return {@code false}.
     * </ul>
     * <p>
     * The {@code equals} method for class {@code Object} implements
     * the most discriminating possible equivalence relation on objects;
     * that is, for any non-null reference values {@code x} and
     * {@code y}, this method returns {@code true} if and only
     * if {@code x} and {@code y} refer to the same object
     * ({@code x == y} has the value {@code true}).
     * <p>
     * Note that it is generally necessary to override the {@code hashCode}
     * method whenever this method is overridden, so as to maintain the
     * general contract for the {@code hashCode} method, which states
     * that equal objects must have equal hash codes.
     *
     * @param   obj   the reference object with which to compare.
     * @return  {@code true} if this object is the same as the obj
     *          argument; {@code false} otherwise.
     * @see     #hashCode()
     * @see     java.util.HashMap
     */
    public boolean equals(Object obj) {
        return (this == obj);
    }

    /**
     * Creates and returns a copy of this object.  The precise meaning
     * of "copy" may depend on the class of the object. The general
     * intent is that, for any object {@code x}, the expression:
     * <blockquote>
     * <pre>
     * x.clone() != x</pre></blockquote>
     * will be true, and that the expression:
     * <blockquote>
     * <pre>
     * x.clone().getClass() == x.getClass()</pre></blockquote>
     * will be {@code true}, but these are not absolute requirements.
     * While it is typically the case that:
     * <blockquote>
     * <pre>
     * x.clone().equals(x)</pre></blockquote>
     * will be {@code true}, this is not an absolute requirement.
     * <p>
     * By convention, the returned object should be obtained by calling
     * {@code super.clone}.  If a class and all of its superclasses (except
     * {@code Object}) obey this convention, it will be the case that
     * {@code x.clone().getClass() == x.getClass()}.
     * <p>
     * By convention, the object returned by this method should be independent
     * of this object (which is being cloned).  To achieve this independence,
     * it may be necessary to modify one or more fields of the object returned
     * by {@code super.clone} before returning it.  Typically, this means
     * copying any mutable objects that comprise the internal "deep structure"
     * of the object being cloned and replacing the references to these
     * objects with references to the copies.  If a class contains only
     * primitive fields or references to immutable objects, then it is usually
     * the case that no fields in the object returned by {@code super.clone}
     * need to be modified.
     * <p>
     * The method {@code clone} for class {@code Object} performs a
     * specific cloning operation. First, if the class of this object does
     * not implement the interface {@code Cloneable}, then a
     * {@code CloneNotSupportedException} is thrown. Note that all arrays
     * are considered to implement the interface {@code Cloneable} and that
     * the return type of the {@code clone} method of an array type {@code T[]}
     * is {@code T[]} where T is any reference or primitive type.
     * Otherwise, this method creates a new instance of the class of this
     * object and initializes all its fields with exactly the contents of
     * the corresponding fields of this object, as if by assignment; the
     * contents of the fields are not themselves cloned. Thus, this method
     * performs a "shallow copy" of this object, not a "deep copy" operation.
     * <p>
     * The class {@code Object} does not itself implement the interface
     * {@code Cloneable}, so calling the {@code clone} method on an object
     * whose class is {@code Object} will result in throwing an
     * exception at run time.
     *
     * @return     a clone of this instance.
     * @throws  CloneNotSupportedException  if the object's class does not
     *               support the {@code Cloneable} interface. Subclasses
     *               that override the {@code clone} method can also
     *               throw this exception to indicate that an instance cannot
     *               be cloned.
     * @see java.lang.Cloneable
     */
    protected native Object clone() throws CloneNotSupportedException;

    /**
     * Returns a string representation of the object. In general, the
     * {@code toString} method returns a string that
     * "textually represents" this object. The result should
     * be a concise but informative representation that is easy for a
     * person to read.
     * It is recommended that all subclasses override this method.
     * <p>
     * The {@code toString} method for class {@code Object}
     * returns a string consisting of the name of the class of which the
     * object is an instance, the at-sign character `{@code @}', and
     * the unsigned hexadecimal representation of the hash code of the
     * object. In other words, this method returns a string equal to the
     * value of:
     * <blockquote>
     * <pre>
     * getClass().getName() + '@' + Integer.toHexString(hashCode())
     * </pre></blockquote>
     *
     * @return  a string representation of the object.
     */
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

    /**
     * Wakes up a single thread that is waiting on this object's
     * monitor. If any threads are waiting on this object, one of them
     * is chosen to be awakened. The choice is arbitrary and occurs at
     * the discretion of the implementation. A thread waits on an object's
     * monitor by calling one of the {@code wait} methods.
     * <p>
     * The awakened thread will not be able to proceed until the current
     * thread relinquishes the lock on this object. The awakened thread will
     * compete in the usual manner with any other threads that might be
     * actively competing to synchronize on this object; for example, the
     * awakened thread enjoys no reliable privilege or disadvantage in being
     * the next thread to lock this object.
     * <p>
     * This method should only be called by a thread that is the owner
     * of this object's monitor. A thread becomes the owner of the
     * object's monitor in one of three ways:
     * <ul>
     * <li>By executing a synchronized instance method of that object.
     * <li>By executing the body of a {@code synchronized} statement
     *     that synchronizes on the object.
     * <li>For objects of type {@code Class,} by executing a
     *     synchronized static method of that class.
     * </ul>
     * <p>
     * Only one thread at a time can own an object's monitor.
     *
     * @throws  IllegalMonitorStateException  if the current thread is not
     *               the owner of this object's monitor.
     * @see        java.lang.Object#notifyAll()
     * @see        java.lang.Object#wait()
     */
    public final native void notify();

    /**
     * Wakes up all threads that are waiting on this object's monitor. A
     * thread waits on an object's monitor by calling one of the
     * {@code wait} methods.
     * <p>
     * The awakened threads will not be able to proceed until the current
     * thread relinquishes the lock on this object. The awakened threads
     * will compete in the usual manner with any other threads that might
     * be actively competing to synchronize on this object; for example,
     * the awakened threads enjoy no reliable privilege or disadvantage in
     * being the next thread to lock this object.
     * <p>
     * This method should only be called by a thread that is the owner
     * of this object's monitor. See the {@code notify} method for a
     * description of the ways in which a thread can become the owner of
     * a monitor.
     *
     * @throws  IllegalMonitorStateException  if the current thread is not
     *               the owner of this object's monitor.
     * @see        java.lang.Object#notify()
     * @see        java.lang.Object#wait()
     */
    public final native void notifyAll();

    /**
     * Causes the current thread to wait until either another thread invokes the
     * {@link java.lang.Object#notify()} method or the
     * {@link java.lang.Object#notifyAll()} method for this object, or a
     * specified amount of time has elapsed.
     * <p>
     * The current thread must own this object's monitor.
     * <p>
     * This method causes the current thread (call it <var>T</var>) to
     * place itself in the wait set for this object and then to relinquish
     * any and all synchronization claims on this object. Thread <var>T</var>
     * becomes disabled for thread scheduling purposes and lies dormant
     * until one of four things happens:
     * <ul>
     * <li>Some other thread invokes the {@code notify} method for this
     * object and thread <var>T</var> happens to be arbitrarily chosen as
     * the thread to be awakened.
     * <li>Some other thread invokes the {@code notifyAll} method for this
     * object.
     * <li>Some other thread {@linkplain Thread#interrupt() interrupts}
     * thread <var>T</var>.
     * <li>The specified amount of real time has elapsed, more or less.  If
     * {@code timeout} is zero, however, then real time is not taken into
     * consideration and the thread simply waits until notified.
     * </ul>
     * The thread <var>T</var> is then removed from the wait set for this
     * object and re-enabled for thread scheduling. It then competes in the
     * usual manner with other threads for the right to synchronize on the
     * object; once it has gained control of the object, all its
     * synchronization claims on the object are restored to the status quo
     * ante - that is, to the situation as of the time that the {@code wait}
     * method was invoked. Thread <var>T</var> then returns from the
     * invocation of the {@code wait} method. Thus, on return from the
     * {@code wait} method, the synchronization state of the object and of
     * thread {@code T} is exactly as it was when the {@code wait} method
     * was invoked.
     * <p>
     * A thread can also wake up without being notified, interrupted, or
     * timing out, a so-called <i>spurious wakeup</i>.  While this will rarely
     * occur in practice, applications must guard against it by testing for
     * the condition that should have caused the thread to be awakened, and
     * continuing to wait if the condition is not satisfied.  In other words,
     * waits should always occur in loops, like this one:
     * <pre>
     *     synchronized (obj) {
     *         while (&lt;condition does not hold&gt;)
     *             obj.wait(timeout);
     *         ... // Perform action appropriate to condition
     *     }
     * </pre>
     * (For more information on this topic, see Section 3.2.3 in Doug Lea's
     * "Concurrent Programming in Java (Second Edition)" (Addison-Wesley,
     * 2000), or Item 50 in Joshua Bloch's "Effective Java Programming
     * Language Guide" (Addison-Wesley, 2001).
     *
     * <p>If the current thread is {@linkplain java.lang.Thread#interrupt()
     * interrupted} by any thread before or while it is waiting, then an
     * {@code InterruptedException} is thrown.  This exception is not
     * thrown until the lock status of this object has been restored as
     * described above.
     *
     * <p>
     * Note that the {@code wait} method, as it places the current thread
     * into the wait set for this object, unlocks only this object; any
     * other objects on which the current thread may be synchronized remain
     * locked while the thread waits.
     * <p>
     * This method should only be called by a thread that is the owner
     * of this object's monitor. See the {@code notify} method for a
     * description of the ways in which a thread can become the owner of
     * a monitor.
     *
     * @param      timeout   the maximum time to wait in milliseconds.
     * @throws  IllegalArgumentException      if the value of timeout is
     *               negative.
     * @throws  IllegalMonitorStateException  if the current thread is not
     *               the owner of the object's monitor.
     * @throws  InterruptedException if any thread interrupted the
     *             current thread before or while the current thread
     *             was waiting for a notification.  The <i>interrupted
     *             status</i> of the current thread is cleared when
     *             this exception is thrown.
     * @see        java.lang.Object#notify()
     * @see        java.lang.Object#notifyAll()
     */
    public final native void wait(long timeout) throws InterruptedException;

    /**
     * Causes the current thread to wait until another thread invokes the
     * {@link java.lang.Object#notify()} method or the
     * {@link java.lang.Object#notifyAll()} method for this object, or
     * some other thread interrupts the current thread, or a certain
     * amount of real time has elapsed.
     * <p>
     * This method is similar to the {@code wait} method of one
     * argument, but it allows finer control over the amount of time to
     * wait for a notification before giving up. The amount of real time,
     * measured in nanoseconds, is given by:
     * <blockquote>
     * <pre>
     * 1000000*timeout+nanos</pre></blockquote>
     * <p>
     * In all other respects, this method does the same thing as the
     * method {@link #wait(long)} of one argument. In particular,
     * {@code wait(0, 0)} means the same thing as {@code wait(0)}.
     * <p>
     * The current thread must own this object's monitor. The thread
     * releases ownership of this monitor and waits until either of the
     * following two conditions has occurred:
     * <ul>
     * <li>Another thread notifies threads waiting on this object's monitor
     *     to wake up either through a call to the {@code notify} method
     *     or the {@code notifyAll} method.
     * <li>The timeout period, specified by {@code timeout}
     *     milliseconds plus {@code nanos} nanoseconds arguments, has
     *     elapsed.
     * </ul>
     * <p>
     * The thread then waits until it can re-obtain ownership of the
     * monitor and resumes execution.
     * <p>
     * As in the one argument version, interrupts and spurious wakeups are
     * possible, and this method should always be used in a loop:
     * <pre>
     *     synchronized (obj) {
     *         while (&lt;condition does not hold&gt;)
     *             obj.wait(timeout, nanos);
     *         ... // Perform action appropriate to condition
     *     }
     * </pre>
     * This method should only be called by a thread that is the owner
     * of this object's monitor. See the {@code notify} method for a
     * description of the ways in which a thread can become the owner of
     * a monitor.
     *
     * @param      timeout   the maximum time to wait in milliseconds.
     * @param      nanos      additional time, in nanoseconds range
     *                       0-999999.
     * @throws  IllegalArgumentException      if the value of timeout is
     *                      negative or the value of nanos is
     *                      not in the range 0-999999.
     * @throws  IllegalMonitorStateException  if the current thread is not
     *               the owner of this object's monitor.
     * @throws  InterruptedException if any thread interrupted the
     *             current thread before or while the current thread
     *             was waiting for a notification.  The <i>interrupted
     *             status</i> of the current thread is cleared when
     *             this exception is thrown.
     */
    public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos > 0) {
            timeout++;
        }

        wait(timeout);
    }

    /**
     * Causes the current thread to wait until another thread invokes the
     * {@link java.lang.Object#notify()} method or the
     * {@link java.lang.Object#notifyAll()} method for this object.
     * In other words, this method behaves exactly as if it simply
     * performs the call {@code wait(0)}.
     * <p>
     * The current thread must own this object's monitor. The thread
     * releases ownership of this monitor and waits until another thread
     * notifies threads waiting on this object's monitor to wake up
     * either through a call to the {@code notify} method or the
     * {@code notifyAll} method. The thread then waits until it can
     * re-obtain ownership of the monitor and resumes execution.
     * <p>
     * As in the one argument version, interrupts and spurious wakeups are
     * possible, and this method should always be used in a loop:
     * <pre>
     *     synchronized (obj) {
     *         while (&lt;condition does not hold&gt;)
     *             obj.wait();
     *         ... // Perform action appropriate to condition
     *     }
     * </pre>
     * This method should only be called by a thread that is the owner
     * of this object's monitor. See the {@code notify} method for a
     * description of the ways in which a thread can become the owner of
     * a monitor.
     *
     * @throws  IllegalMonitorStateException  if the current thread is not
     *               the owner of the object's monitor.
     * @throws  InterruptedException if any thread interrupted the
     *             current thread before or while the current thread
     *             was waiting for a notification.  The <i>interrupted
     *             status</i> of the current thread is cleared when
     *             this exception is thrown.
     * @see        java.lang.Object#notify()
     * @see        java.lang.Object#notifyAll()
     */
    public final void wait() throws InterruptedException {
        wait(0);
    }

    /**
     * Called by the garbage collector on an object when garbage collection
     * determines that there are no more references to the object.
     * A subclass overrides the {@code finalize} method to dispose of
     * system resources or to perform other cleanup.
     * <p>
     * The general contract of {@code finalize} is that it is invoked
     * if and when the Java&trade; virtual
     * machine has determined that there is no longer any
     * means by which this object can be accessed by any thread that has
     * not yet died, except as a result of an action taken by the
     * finalization of some other object or class which is ready to be
     * finalized. The {@code finalize} method may take any action, including
     * making this object available again to other threads; the usual purpose
     * of {@code finalize}, however, is to perform cleanup actions before
     * the object is irrevocably discarded. For example, the finalize method
     * for an object that represents an input/output connection might perform
     * explicit I/O transactions to break the connection before the object is
     * permanently discarded.
     * <p>
     * The {@code finalize} method of class {@code Object} performs no
     * special action; it simply returns normally. Subclasses of
     * {@code Object} may override this definition.
     * <p>
     * The Java programming language does not guarantee which thread will
     * invoke the {@code finalize} method for any given object. It is
     * guaranteed, however, that the thread that invokes finalize will not
     * be holding any user-visible synchronization locks when finalize is
     * invoked. If an uncaught exception is thrown by the finalize method,
     * the exception is ignored and finalization of that object terminates.
     * <p>
     * After the {@code finalize} method has been invoked for an object, no
     * further action is taken until the Java virtual machine has again
     * determined that there is no longer any means by which this object can
     * be accessed by any thread that has not yet died, including possible
     * actions by other objects or classes which are ready to be finalized,
     * at which point the object may be discarded.
     * <p>
     * The {@code finalize} method is never invoked more than once by a Java
     * virtual machine for any given object.
     * <p>
     * Any exception thrown by the {@code finalize} method causes
     * the finalization of this object to be halted, but is otherwise
     * ignored.
     *
     * @throws Throwable the {@code Exception} raised by this method
     * @see java.lang.ref.WeakReference
     * @see java.lang.ref.PhantomReference
     * @jls 12.6 Finalization of Class Instances
     */
    protected void finalize() throws Throwable { }
}

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

public boolean equals(Object obj) {
    return (this == obj);
}

class Mom{
  Mom(){
  }
  void Say(){
    System.out.println("Say Mom");
  }
}
final class Child extends Mom{ // 斷子絕孫!
  Child(){
  }
  @Override
  void Say(){
    System.out.println("Say Hi");
  }
}
public class Test{       
  public static void main(String[] argv) {
    Child son = new Child();
    Mom mom = new Mom();
    mom.Say();
    son.Say();
  }
}

class Mammalia{
  void breastFeeding(){
    System.out.println("我會哺乳");
  }
}
class Human extends Mammalia{
  @Override
  void breastFeeding(){
    System.out.println("我是人類，我會哺乳");
  }
}
public class Test{       
  public static void main(String[] argv) {
    Human person = new Human();
    Mammalia Mammalia = person;
    Mammalia.breastFeeding();
    // 呼叫 Mammalia 類別的方法還是 Human 類別的方法?
  }
}

class Mammalia{
  void breastFeeding(){
    System.out.println("我會哺乳");
  }
}
class Human extends Mammalia{
  void breastFeeding(String text){ // Overloading(多載父類別方法)
    System.out.println(text + "我會哺乳");
  }
  // 沒有定義 breastFeeding() 無參數的方法
}
public class Test{       
  public static void main(String[] argv) {
    Human person = new Human();
    Mammalia Mammalia = person;
    Mammalia.breastFeeding();
    // 呼叫 Mammalia 類別的方法還是 Human 類別的方法?
  }
}

class Mammalia{
  void breastFeeding(){
    System.out.println("我會哺乳");
  }
}
class Human extends Mammalia{
  void breastFeeding(String text){ // Overloading(多載父類別方法)
    System.out.println(text + "我會哺乳");
  }
}
public class Test{       
  public static void main(String[] argv) {
    Human person = new Human();
    Mammalia Mammalia = person;
    Mammalia.breastFeeding("666");
    // 可以編譯嗎?
    // 如果可以，是呼叫 Mammalia 類別的方法還是 Human 類別的方法?
  }
}

class shape{
    double area(){return 0;}
    // 僅僅用於存在，使多型成立
}
class cicyle extends shape{
    double r;

    cicyle(double r){
        this.r = r;
    }
    
    @Override
    double area(){
        return r * r * Math.PI;
    }
}
class rectangle extends shape{
    double h, w;

    rectangle(double h, double w){
        this.h = h;
        this.w = w;
    }

    @Override
    double area(){
        return h * w;
    }
}
public class Test{
    public static void main(String[] args) {
        cicyle c = new cicyle(5);
        rectangle rect1 = new rectangle(3, 5);
        rectangle rect2 = new rectangle(3, 2);

        System.out.println(sumArea(new shape[]{rect1, rect2})); // 傳入 rectangle class 的陣列
        System.out.println(sumArea(new shape[]{c, rect1})); // 傳入有 cicyle class 和 rectangle class 的陣列
    }
    static double sumArea(shape[] shapeList){
        double sum = 0;
        for (shape shape : shapeList) {
            sum += shape.area(); // 顆顆，多行無情計算，都不需要管傳入了什麼物件
        }
        return sum;
    }
}

class shape{
    double area(){return 0;}
    // 僅僅用於存在，使多型成立
}
class cicyle extends shape{
    double r;

    cicyle(double r){
        this.r = r;
    }
    
    @Override
    double area(){
        return r * r * Math.PI;
    }
}
class rectangle extends shape{
    double h, w;

    rectangle(double h, double w){
        this.h = h;
        this.w = w;
    }

    @Override
    double area(){
        return h * w;
    }
}
public class Test{
    public static void main(String[] args) {
        shape s;
        cicyle c = new cicyle(5);
        rectangle rect = new rectangle(3, 5);

        s = c;
        System.out.println(s instanceof cicyle);
        s = rect;
        System.out.println(s instanceof cicyle);
    }
}

class shape{
    double area(){return 0;}
    // 僅僅用於存在，使多型成立
}
class cicyle extends shape{
    double r;

    cicyle(double r){
        this.r = r;
    }
    
    @Override
    double area(){
        return r * r * Math.PI;
    }
}
class rectangle extends shape{
    double h, w;

    rectangle(double h, double w){
        this.h = h;
        this.w = w;
    }

    @Override
    double area(){
        return h * w;
    }
}
public class Test{
    public static void main(String[] args) {
        shape s;
        cicyle c = new cicyle(5);
        rectangle rect = new rectangle(3, 5);

        s = c;
        System.out.println(s instanceof cicyle);
        s = rect;
        System.out.println(s instanceof cicyle);
        rectangle another = (rectangle)s;
        System.out.println(another == rect); // 參照還是一樣
        System.out.println(s instanceof rectangle);
    }
}

class shape{
    double area(){return 0;}
    // 僅僅用於存在，使多型成立
}
class cicyle extends shape{
    double r;

    cicyle(double r){
        this.r = r;
    }
    
    @Override
    double area(){
        return r * r * Math.PI;
    }
}
class rectangle extends shape{
    double h, w;

    rectangle(double h, double w){
        this.h = h;
        this.w = w;
    }

    @Override
    double area(){
        return h * w;
    }
}
public class Test{
    public static void main(String[] args) {
        shape s;
        cicyle c = new cicyle(5);
        rectangle rect = new rectangle(3, 5);

        s = c;
        System.out.println(s instanceof cicyle);
        s = rect;
        System.out.println(s instanceof cicyle);
        s = (shape)s;
        System.out.println(s.h); // error
    }
}

class shape{
    double area(){return 0;}
    // 僅僅用於存在，使多型成立
}
class cicyle extends shape{
    double r;

    cicyle(double r){
        this.r = r;
    }
    
    @Override
    double area(){
        return r * r * Math.PI;
    }
}
class rectangle extends shape{
    double h, w;

    rectangle(double h, double w){
        this.h = h;
        this.w = w;
    }

    @Override
    double area(){
        return h * w;
    }
}
public class Test{
    public static void main(String[] args) {
        shape s = new shape();
        cicyle c = new cicyle(5);
        rectangle rect = new rectangle(3, 5);
        test(s);
        System.out.println("==========");
        test(c);
        System.out.println("==========");
        test(rect);
    }
    static void test(Object obj){
        System.out.println(obj);
        if(obj instanceof cicyle){
            cicyle c = (cicyle)obj;
            System.out.println(c.r);
            System.out.println(c.area());
        }
        else if(obj instanceof rectangle){
            rectangle r = (rectangle)obj;
            System.out.println(r.h);
            System.out.println(r.w);
            System.out.println(r.area());
        }
        else if(obj instanceof shape){
            shape s = (shape)obj;
            System.out.println(s.area());
        }
    }
}

class shape{
    double area(){return 0;}
    // 僅僅用於存在，使多型成立
}
class cicyle extends shape{
    double r;

    cicyle(double r){
        this.r = r;
    }
    
    @Override
    double area(){
        return r * r * Math.PI;
    }
}
class rectangle extends shape{
    double h, w;

    rectangle(double h, double w){
        this.h = h;
        this.w = w;
    }

    @Override
    double area(){
        return h * w;
    }
}
public class Test{
    public static void main(String[] args) {
        cicyle c = new cicyle(5);
        rectangle rect1 = new rectangle(3, 5);
        rectangle rect2 = new rectangle(3, 2);

        System.out.println(sumArea(new shape[]{rect1, rect2})); // 傳入 rectangle class 的陣列
        System.out.println(sumArea(new shape[]{c, rect1})); // 傳入有 cicyle class 和 rectangle class 的陣列
    }
    static double sumArea(shape[] shapeList){
        double sum = 0;
        for (shape shape : shapeList) {
            sum += shape.area(); // 顆顆，多行無情計算，都不需要管傳入了什麼物件
        }
        return sum;
    }
}

abstract class shape{
    double area(){return 0;}
    // 僅僅用於存在，使多型成立
}
class cicyle extends shape{
    double r;

    cicyle(double r){
        this.r = r;
    }
    
    @Override
    double area(){
        return r * r * Math.PI;
    }
}
class rectangle extends shape{
    double h, w;

    rectangle(double h, double w){
        this.h = h;
        this.w = w;
    }

    @Override
    double area(){
        return h * w;
    }
}
public class Test{
    public static void main(String[] args) {
        cicyle c = new cicyle(5);
        rectangle rect1 = new rectangle(3, 5);
        rectangle rect2 = new rectangle(3, 2);

        System.out.println(sumArea(new shape[]{rect1, rect2})); // 傳入 rectangle class 的陣列
        System.out.println(sumArea(new shape[]{c, rect1})); // 傳入有 cicyle class 和 rectangle class 的陣列
    }
    static double sumArea(shape[] shapeList){
        double sum = 0;
        for (shape shape : shapeList) {
            sum += shape.area(); // 顆顆，多行無情計算，都不需要管傳入了什麼物件
        }
        return sum;
    }
}

abstract class shape{
    abstract double area();
    // 僅僅用於存在，使多型成立
}
class cicyle extends shape{
    double r;

    cicyle(double r){
        this.r = r;
    }
    
    @Override
    double area(){
        return r * r * Math.PI;
    }
}
class rectangle extends shape{
    double h, w;

    rectangle(double h, double w){
        this.h = h;
        this.w = w;
    }

    @Override
    double area(){
        return h * w;
    }
}
public class Test{
    public static void main(String[] args) {
        cicyle c = new cicyle(5);
        rectangle rect1 = new rectangle(3, 5);
        rectangle rect2 = new rectangle(3, 2);

        System.out.println(sumArea(new shape[]{rect1, rect2})); // 傳入 rectangle class 的陣列
        System.out.println(sumArea(new shape[]{c, rect1})); // 傳入有 cicyle class 和 rectangle class 的陣列
    }
    static double sumArea(shape[] shapeList){
        double sum = 0;
        for (shape shape : shapeList) {
            sum += shape.area(); // 顆顆，多行無情計算，都不需要管傳入了什麼物件
        }
        return sum;
    }
}

abstract class shape{
    String name;
    shape(String name){
        this.name = name;
    }
    abstract double area();
    // 僅僅用於存在，使多型成立
}
class cicyle extends shape{
    double r;

    cicyle(double r){
        super("cicyle");
        this.r = r;
    }
    
    @Override
    double area(){
        return r * r * Math.PI;
    }
}
class rectangle extends shape{
    double h, w;

    rectangle(double h, double w){
        super("rectangle");
        this.h = h;
        this.w = w;
    }

    @Override
    double area(){
        return h * w;
    }
}
public class Test{
    public static void main(String[] args) {
        cicyle c = new cicyle(5);
        rectangle rect1 = new rectangle(3, 5);
        rectangle rect2 = new rectangle(3, 2);

        System.out.println(sumArea(new shape[]{rect1, rect2})); // 傳入 rectangle class 的陣列
        System.out.println(sumArea(new shape[]{c, rect1})); // 傳入有 cicyle class 和 rectangle class 的陣列
    }
    static double sumArea(shape[] shapeList){
        double sum = 0;
        for (shape shape : shapeList) {
            sum += shape.area(); // 顆顆，多行無情計算，都不需要管傳入了什麼物件
        }
        return sum;
    }
}

abstract class Parent{
    abstract void show();
}
abstract class Child extends Parent{
    // 沒有實作show，必須成為抽象類別
}
class Grandson extends Child{
    void show(){
        System.out.println("666");
    }
}
public class Test{
    public static void main(String[] args) {
        Grandson g = new Grandson();
        g.show();
    }
}

interface Flying{
    void Fly();
    // 等同 public abstract void Fly();
}

interface Flying{
    void Fly();
    // 等同 public abstract void Fly();
}
class plane implements Flying{
    @Override
    public void Fly() {
        System.out.println("飛機飛，飛飛飛");
    }
}
class bird implements Flying{
    @Override
    public void Fly(){
        System.out.println("鳥鳥飛，鳥鳥飛");
    }
}
public class Test{
    public static void main(String[] args) {
        plane p = new plane();
        bird b = new bird();
        p.Fly();
        b.Fly();
    }
}

interface Flying{
    void Fly();
    // 等同 public abstract void Fly();
    int KILOMETE = 1000;
    // 等同 public static final int KILOMETE = 1000;
}
class plane implements Flying{
    @Override
    public void Fly() {
        System.out.println("飛機飛，飛飛飛");
    }
}
class bird implements Flying{
    @Override
    public void Fly(){
        System.out.println("鳥鳥飛，鳥鳥飛");
    }
}
public class Test{
    public static void main(String[] args) {
        plane p = new plane();
        bird b = new bird();
        p.Fly();
        b.Fly();
        System.out.println(Flying.KILOMETE);
    }
}

package net.minecraft.item;

public class Item extends net.minecraftforge.registries.ForgeRegistryEntry<Item> implements IItemProvider, net.minecraftforge.common.extensions.IForgeItem {
   public static final Map<Block, Item> BLOCK_TO_ITEM = net.minecraftforge.registries.GameData.getBlockItemMap();
   protected static final UUID ATTACK_DAMAGE_MODIFIER = UUID.fromString("CB3F55D3-645C-4F38-A497-9C13A33DB5CF");
   protected static final UUID ATTACK_SPEED_MODIFIER = UUID.fromString("FA233E1C-4180-4865-B01B-BCCE9785ACA3");
   protected static final Random random = new Random();
   protected final ItemGroup group;
   private final Rarity rarity;
   private final int maxStackSize;
   private final int maxDamage;
   private final boolean isImmuneToFire;
   private final Item containerItem;
   @Nullable
   private String translationKey;
   @Nullable
   private final Food food;

   public Item(Item.Properties properties) {
      this.group = properties.group;
      this.rarity = properties.rarity;
      this.containerItem = properties.containerItem;
      this.maxDamage = properties.maxDamage;
      this.maxStackSize = properties.maxStackSize;
      this.food = properties.food;
      this.isImmuneToFire = properties.immuneToFire;
      this.canRepair = properties.canRepair;
      this.toolClasses.putAll(properties.toolClasses);
      Object tmp = properties.ister == null ? null : net.minecraftforge.fml.DistExecutor.callWhenOn(Dist.CLIENT, properties.ister);
      this.ister = tmp == null ? null : () -> (net.minecraft.client.renderer.tileentity.ItemStackTileEntityRenderer) tmp;
   }
}

interface P{
    void Show(Object obj);
    int i = 20;
}
interface O{
    long O = 66666L;
}
interface C extends P, O{
    void Show(Object obj);
    int i = 20000;
}
public class Test implements C{
    public static void main(String[] args) {
        Test t = new Test();
        t.Show("obj");
    }

    @Override
    public void Show(Object obj) {
        // 實作 void Show(Object obj); 即可
        // 不必管是 P 介面還是 C 介面的 Show()
        System.out.println(obj);
    }
}

interface P{
    void Show();
    int i = 20;
}
interface O{
    long O = 66666L;
}
interface C extends P, O{
    void Show();
    int i = 20000;
}
public class Test implements C{
    public static void main(String[] args) {
        Test t = new Test();
        t.Show();
    }
    @Override
    public void Show() {
        System.out.println("C.i " + C.i);
        System.out.println("P.i " + P.i);
        System.out.println("O.O " + O);
    }
}

interface P{
    void Show();
    int i = 20;
}
class O implements P{
    @Override
    public void Show() {
        System.out.println("666");
    }
    public void Show(String text) {
        System.out.println(text);
    }
}
class A implements P{
    @Override
    public void Show() {
        System.out.println("9487");
    }
    public void Show(String text, int i) {
        System.out.println(text + i);
    }
}
public class Test{
    public static void main(String[] args) {
        Show(new O());
        Show(new A());
    }
    public static void Show(P p) {
        p.Show();
        // p.Show("666"); 不可以!
    }
}