int ほげ = 1; // OK
int hoge = 1; // OK
int _hoge = 1; // OK
int $hoge = 1; // OK
int 1hoge = 1; // NG
int #hoge = 1; // NG
int boolean = 1; // NG
int hoge+fuga = 1; // NG

public class Main {

}

// 文
System.out.println("hogehoge");

int hoge = 0;
{
    int fuga = 0;

    System.out.println("fuga : " + fuga);
    // hoge はスコープの中なのでアクセス可能
    System.out.println("hoge : " + hoge);
}

// fuga はスコープの外なのでコンパイルエラー
// System.out.println("fuga : " + fuga);

public class Hoge {
    private int hoge;

    public Hoge(int hoge) {

    }
}

public class Hoge {
    private int mHoge;

    public Hoge(int hoge) {

    }
}

public class Hoge {
    // public で static な void の main メソッド
    // 引数の文字列型配列は、コマンドライン引数を受け取るためのもの
    public static void main(String[] args) {

    }
}

// 1 は int 型だが、Integer 型は int 型のラッパークラスのため、オートボクシングにより自動的に参照型のクラスへの変換が行われる
Integer integer = 1;

if (条件式) {
    文;
} else if (条件式)
    文;
} else {
    文;
}

switch (判定対象) {
case 条件値リテラル:
    文;
    break;
case 条件値リテラル:
    文
    break;
default:
    文;
    break;
}

for (初期化式; 条件式; 変化式) {
    文;
}

for (型 変数名 : 配列ないしリスト構造オブジェクト) {
    文;
}

while (条件式) {
    文;
}

do {
    文;
} while (条件式);

while (条件式) {
    if (条件式) {
        // (中止) if の条件式に合致した場合、直ちに繰り返し処理を終了する
        break;
    }

    if (条件式) {
        // (中断) if の条件式に合致した場合、この文以後の繰り返し処理は実行せず、次の繰り返し処理を開始する。
        continue;
    }
}

public class MyClass {

}

class MyClass2 {

}

public class MyClass {
    // クラスの中のクラス宣言。インナークラスと呼ぶ。
    public class NestedClass {

    }

    // static なインナークラス。特別にネストクラスとも呼ぶ。
    public static class InnerClass {

    }
}

public interface MyInterface {
    public void hoge();
}

public enum MyEnum {
  // MyEnum 型の定数 HOGE と FUGA
  HOGE,
  FUGA;
}

public class MyClass {
    // void は値を返さないメソッド
    public void myMethod() {

    }

    // (オーバーロード) 同じ名前、同じ返り値の型、異なる引数でメソッドを定義することが出来る
    public void myMethod(int hoge) {
        // 値を返さないメソッドでも、return 文は宣言可能。その時点でメソッドの処理を終える
        return;
    }

    // 可変長引数は、型名の後ろに三点リーダーをつける。可変長引数の実態は配列。
    // int 型の値を返すメソッド
    public int doHoge(Object... objects) {
        // メソッドの宣言に合ったものを返す
        return 0;
    }
}

// 抽象メソッドの定義
public enum MyEnum {
    HOGE() {
        @Override
        public void doHoge() {
            // something to do
        }
    };

    public abstract void doHoge();
}

// インタフェースの実装
public enum MyEnum implements MyInterface {
    FUGA() {
        @Override
        public void fuga() {
            // do something wonderful
        }
    };

    @Override
    public void hoge() {
        // do something
    }
}

interface MyInterface {
    public void hoge();
    public void fuga();
}

public class MyClass {
    // 引数のないコンストラクタを、デフォルトコンストラクタと呼ぶ
    public MyClass() {

    }

    public MyClass(int hoge) {

    }
}

public enum Hoge {
    // ここに enum 型定数を定義した時に、コンストラクタの呼び出しがある
    HOGE(1);

    private final int someValue;

    // よそのクラスから直接インスタンス化出来ないようにするため、private で宣言する
    // それ以外で宣言するとコンパイルエラー
    // また、親クラスのコンストラクタを呼ぶことも許されない
    private Hoge(int someValue) {
        this.someValue = someValue;
    }
}

public class HogeClass {
    public static final HashMap<String, String> SOME = new HashMap<String, String>();

    // クラスのロード時に実行される処理のまとまり
    static {
        SOME.put("hoge", "fuga");
    }
}

// このソースコードが属するパッケージ名の宣言。
// パッケージ名の宣言はソースファイルの一番最初にしなければならないが、コメントは許容される。
package jp.mixi.sample;

public class MyClass {

}

package jp.mixi.sample2;

// パッケージ名とクラス名を全て記述するものを、完全修飾名（FQDN）と呼ぶ
import jp.mixi.sample.MyClass;
// ワイルドカードで指定する方法。java.utilパッケージ以下の、任意のクラスにアクセス可能
import java.util.*;

public class MyClass2 {

}

public class ChildClass extends ParentClass {

}

public class ConcreteClass implements MyInterface, AnotherInterface {

}

// MyClass 型のオブジェクトの生成
MyClass myClassObject = new MyClass();

// コンパイルエラー
AbstractClass hoge = new AbstractClass();
MyInterface obj = new MyInterface();

MyInterface obj = new MyInterface() {
    @Override
    public void hoge() {
        // 実装をここで行なってしまう
    }
};

final int hoge = 0;
MyInterface obj = new MyInterface() {
    @Override
    public void hoge() {
        System.out.println("hoge: " + hoge);
    }
}

public class HogeClass {
    private int hoge;

    public HogeClass(int hoge) {
        // this.hoge は HogeClass 型オブジェクトの hoge 変数 を意味する
        this.hoge = hoge;
    }
}

public class HogeClass {
    private int hoge;

    public HogeClass(int hoge) {
        // ここでは、this.hoge は HogeClass 型オブジェクトの hoge を指す
        this.hoge = hoge;
    }

    public class NestedClass {
        private int hoge;
        public void doSomething() {
            // ここでは、this.hoge は NestedClass 型オブジェクトの hoge を指す
            int fuga = this.hoge + 1;
            // インナークラスは、その外側のクラスのメンバであることから、
            // インナークラスから、その属するクラスのオブジェクトへの参照を HogeClass.this で得ることができる
            int piyo = HogeClass.this.hoge + 1;
        }
    }

    public static class InnerClass {
        public void doSomething() {
            // ネストクラスからは、その外側クラスの参照を HogeClass.this では得ることが出来ない
            // コンパイルエラー
            int moga = HogeClass.this.hoge + 1;
        }
    }
}

Class<HogeClass> clazz = HogeClass.class;

// @Deprecated アノテーションによって、このクラスの使用が推奨されないことを示す
// もし他のクラスがこのクラスを使用している場合、コンパイラが警告を発する
@Deprecated
public class MyClass extends Hoge {
    // @Override アノテーションによって、このメソッドが、親クラスのメソッドをオーバライドしていることを示す
    // これにより、オーバライドしているようで実はオーバライドになっていない、という不幸なバグをコンパイル時に検知できる
    @Override
    public void hoge() {
        // @SuppressWarnings によって、コンパイラに対して警告表示の抑制を指示する
        // アノテーションに引数を渡すことも可能
        @SuppressWarnings("rawtypes")
        List list = new ArrayList();
    }
}

// メソッドに付与するアノテーション MyAnnotation の宣言
@Target(ElementType.METHOD)
public @interface MyAnnotation {
}

// リフレクションによる実行時の読み込みが出来るアノテーションの宣言
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
}

public @interface MyAnnotation {
    String value();
}

// 型変数を <> で囲って宣言する。
public class MyClass<Value> {
    // 型変数に宣言した変数名は、型名として扱う。
    private Value v;
}

public class MyClass2 {
    // 返り値の型の宣言の前に、型変数の宣言をする
    public <T> void hoge(T hoge) {

    }

    // 型変数に宣言した変数名は、型名として扱う。このため、引数の型指定や返り値の型指定に型変数名を使う
    public <T> T fuga (T hoge) {

    }
}

// 型変数を複数宣言することも可能
public class MyClass3<E, V> {

}

public class Hoge {
    public void hoge() {
        // MyClass の型変数 Value に、String 型をバインドする。
        MyClass<String> myclass = new MyClass<String>();

        // 型変数の宣言をしたクラスに、何のクラスもバインドしないでいるとコンパイラが警告を出す
        MyClass myclass2 = new MyClass();
    }
}

public class Hoge {
    public void hoge() {
        MyClass2 myclass = new MyClass2();
        // メソッドに型変数を宣言した場合の呼び出し。メソッド名の前にバインドする型を指定する。
        myclass.<String>fuga("fuga");
    }
}

// 型変数を宣言しているクラスのサブクラスを定義する際にも、型のバインドを行う
public class MyChildClass extends MyClass3<String, String> {

}

// 型変数へのバインドの際、バインドする型が String 型ないしそのサブクラスであることを要求する
public class MyClass<Value extends String> {

}

// 型変数へのバインドの際、バインドする型が String 型ないしそのサブクラスであり、かつ Cloneable インタフェースを実装していることを要求する
// インタフェースの実装の要求も extends キーワードを使用する
// インタフェースの実装の要求の宣言は、クラスの継承の要求の宣言の後に行われなければならない
public class MyClass2<Value extends String & Cloneable> {

}

public class Hoge {
    public void hoge() {
        // 何らかの型にバインドすることを宣言するために、ワイルドカードを使用する
        MyClass<?> myclass = new MyClass<String>();

        // 何らかの String 型ないしそのサブクラスの型にバインドする
        MyClass<? extends String> myclass2 = new MyClass<String>();

        // 何らかの String 型ないしそのスーパークラスの型にバインドする
        MyClass<? super String> myclass3 = new MyClass<String>();
    }
}

public class MyThread extends Thread {
    @Override
    public void run() {
        // 並列で走らせたい処理
    }
}

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 並列で走らせたい処理
    }
}

public class MySample {
    // メインスレッドのエントリポイントの main メソッド
    // main メソッドの宣言は必ずこのようにする
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        // 新しいスレッドの準備をし、実行可能状態にする
        new Thread(runnable).start();
    }
}

public class MySample {
    public static void main(String[] args) {
        Runnable runnable1 = new MyRunnable1();
        Runnable runnable2 = new MyRunnable2();
        // スレッドの開始は順に実行されるが、runnable1 と runnable2 のそれぞれの処理の間に順序の保証はない
        new Thread(runnable1).start();
        new Thread(runnable2).start();
    }

    public static class MyRunnable1 implements Runnable {
        public void run() {
            // このスレッドの中の処理順序は上から順に実行
            for (int i = 0; i < 10000; i++) {
                System.out.println("i: " + i);
            }
        }
    }

    public static class MyRunnable2 implements Runnable {
        public void run() {
            // このスレッドの中の処理順序は上から順に実行
            for (int i = 0; i < 10000; i++) {
                System.out.println("i: " + i);
            }
        }
    }
}

public class MyClass {
    private Object lockObject = new Object();
    private int something;

    // このメソッドの実行権限は、MyClass インスタンスのロックを取得したスレッドに与えられる
    public synchronized void hoge() {
        something++;
    }

    public void fuga() {
        // このブロックの実行権限は、MyClass インスタンスのロックを取得したスレッドに与えられる
        // このブロックがメソッド全体をカバーする場合は、動作上は synchronized をメソッドに付与した場合とおなじになる
        synchronized (this) {
            something++;
        }
    }

    public void piyo() {
        // このブロックの実行権限は、lockObject インスタンスのロックを取得したスレッドに与えられる
        synchronized (lockObject) {
            something++;
        }
    }

    public void poo() {
        // synchronized で排他制御していないので、不整合が起こる可能性がある
        something++;
    }

    // static なメソッドは、その属するクラスのクラスオブジェクトに対してロックを掛ける
    public static synchronized void foo() {

    }
}

public class MyClass {
    public void hogehoge() throws IOException {
        // IO をつかって何かする
        // ...

        // 良くないことが起こった時
        throw new IOException("something went wrong!"); // 例外クラスのインスタンスを作って、throw する
    }
}

public class MyClass {
    public void hogehoge(int index) {
        if (index >= 5) {
            // 予期しないことをさせられる場合
            throw new IllegalArgumentException("index should be less than 5."); // 例外クラスのインスタンスを作って、throw する
        }
    }
}

public class MyClass {
    public void hogehoge() {
        try {
            // 検査例外を投げるメソッド呼び出しを含む何らかの処理
            // ...
        } catch (FileNotFoundException e) {
            // FileNotFoundException に対する例外処理
        } catch (IOException e) {
            // IOException に対する例外処理
        }
    }
}

public class MyClass {
    public void hogehoge() {
        try {
            // 検査例外を投げるメソッド呼び出しを含む何らかの処理
            // ...

        // ダメな例
        // FileNotFoundException は IOException のサブクラスなので、
        // FileNotFoundException がスローされても、例外の判定で IOException とみなされ、
        // FileNotFoundException をキャッチしているところの例外処理に到達しなくなる
        } catch (IOException e) {
            // IOException に対する例外処理
        } catch (FileNotFoundException e) {
            // FileNotFoundException に対する例外処理
        }
    }
}

public class MyClass {
    public void hogehoge() {
        try {
            // 何らかの、IOを使った処理
        } catch (IOException e) {
            // 例外処理
        } finally {
            // IO リソースのクローズ処理
        }
    }
}

public class MyClass {
    public void hogehoge() {
        try {
            // 何らかの処理
        } finally {
            // 必ず処理しておくべき内容
        }
    }
}

String hoge = "hoge";

// 新しい String クラスの hoge オブジェクト
String hoge = "hoge";

// hoge 変数の参照するオブジェクトが、新しく生成した "hogeabc" を表す String クラスのオブジェクトになる
hoge += "abc";

public class Sample {
    public static void main(String[] args) {
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new InputStreamReader(new FileInputStream("hogehoge.txt")));
            StringBuffer buffer = new StringBuffer();
            String line = null;
            while ((line = reader.readLine()) != null) {
                buffer.append(line);
            }
        } catch (FileNotFoundException e) {
        } catch (IOException e) {
        } finally {
            if (reader != null) {
                try {
                    // 複数の IO ストリームオブジェクトがネストしている場合は、一番外側を close すると内側すべても同時に close される
                    reader.close();
                } catch (IOException e) {
                }
            }
        }
    }
}

package jp.mixi.sample;

class Hoge {
}

public class Main {
    public static void main(String[] args) {
        // 予約語としての class によって、そのクラスの Class 型のインスタンスを得る
        System.out.println(Hoge.class.getSimpleName());
        // すべてのクラスの基底クラスである Object クラスが持つ、Class 型オブジェクトを得るメソッドによってそのインスタンスを得る
        System.out.println(new Hoge().getClass().getSimpleName());

        // Class#forName() で、FQDN によるクラス名を指定して、Class 型のインスタンスを得る
        Class<?> clazz = Class.forName("jp.mixi.sample.Hoge");
    }
}

package jp.mixi.sample;

class Hoge {
}

public class Main {
    public static void main(String[] args) {
        Class<?> clazz = Class.forName("jp.mixi.sample.Hoge");

        // クラスの宣言に付与されたアノテーションをすべて取得する
        Annotation[] annotations = clazz.getAnnotations();

        // クラスの宣言にある public なコンストラクタの定義をすべて取得する
        Constructor<?>[] constructors = clazz.getConstructors();

        // private なコンストラクタも含めてすべてのコンストラクタの定義を取得する
        Constructor<?>[] allConstructors = clazz.getDeclaredConstructors();

        // アクセス可能なすべてのフィールドの定義を取得する
        Field[] fields = clazz.getFields();

        // 定義されたすべてのフィールドを取得する
        Field[] allFields = clazz.getDeclaredFields();

        // public なメンバメソッドを取得する
        Method[] methods = clazz.getMethods();

        // すべてのメソッドを取得する
        Method[] allMethods = clazz.getDeclaredMethods();
    }
}