Javaの文法

**Javaの文法**（Javaのぶんぽう）の記事では、プログラミング言語Javaの**構文**（シンタックス、）について解説する。また、それ以外についても解説している。

__TOC__
## キーワード一覧

Javaの言語仕様は68種類（Java 25現在）に抑えたキーワードによって比較的コンパクトにまとめられている。Javaの構文はC++言語によく似たものであり、それよりも比較的平易化されている。従って以下のキーワードを眺めるだけでもJavaプログラミングの大まかなスタイルを掴むことができる。

## データ型
Javaのデータ型には大別して、プリミティブ型と参照型がある。

### プリミティブ型
もしくはとも。
プリミティブ型はオブジェクトではなく、スーパークラスを持たない。

; 注:
* オーバフローは例外等にはならず、2の補数として自然な形でラップアラウンド (wrap around) する。例えば、 () に1を加えると、結果は () になる。


```java
float f = 2147483647f;
double d = 9223372036854775807;
```
float型は数字を符号付き32Bitの最大値(2,147,483,647)まで代入できるが、double型は符号付き64Bitの最大値(9,223,372,036,854,775,807)まで代入できる。

また、float型は代入する数字の末尾に「F」または「f」をつけなければdouble型とみなされ、コンパイルエラーになってしまう。
; 注
* 浮動小数点数は決して例外をスローしない
* 0でない値を0（ゼロ）で割った値はInf（無限大）と等値である
* 無限大でない値をInfで割った値は0（ゼロ）と等値である。

; 注:
* J2SE 1.4.2までのcharは基本多言語面 (BMP) の範囲内のコードポイントを符号無し16ビットで表現する。
* J2SE 5.0からは、補助文字をサポートするため、charは符号無し16ビットで表現可能でありBMPの範囲内に限ればコードポイントと同値となるUTF-16符号化形式のコード単位を表現するように変更され、21ビットが必要となるコードポイントの表現にはintを使用するように変更された(JSR#204)。つまりchar型は互換性の問題からあくまで符号無し16ビットのままとされており、UTF-16符号化形式を採用したことから補助文字を扱う場合はコードポイント一つにコード単位を格納したchar値のペアが対応する。これらを適切に取り扱う便宜として、クラスやプリミティブラッパークラスであるクラスなどの各種メソッドが利用できる。

; 注:
* C/C++や類似の言語と異なり、Javaではfalseの代わりに0（ゼロ）またはnullと書くことはできない
* 同様に、0でない値を書いてtrueの代わりとすることはできない
* ブール型をブール型でない基本型へキャストすることとその逆はできない

### 参照型
すべての参照型はオブジェクト型を表すクラスから派生する。オブジェクトは参照型のインスタンスである。クラス`class`は既定でから派生する参照型である。列挙型`enum`は抽象クラスから暗黙的に派生する参照型である。

リフレクション機能のための「クラスを表現するクラス（メタクラス）」としてが存在するが、クラス自体はオブジェクトではない。

#### 文字列
* オブジェクトは不変（変更不能）である
* Stringオブジェクトは生成時に初期化されなければならない
* コンパイラは文字列リテラル（ダブルクォーテーションで囲まれた文字列）を見つけると、Stringオブジェクトを生成する
* 演算子 `+` と `+=` は文字列を連結するためにオーバーロードされる


```java
String str1 = "alpha"; 
String str2 = new String("alpha");
```


* とオブジェクトは可変（変更可能）なので、オブジェクト生成オーバヘッド無しで柔軟に文字列を生成・変更できる。StringBufferとStringBuilderの違いは、StringBufferがマルチスレッドに対応している（＝スレッド・セーフである）のに対し、StringBuilderは対応していないことである。
* StringとStringBufferは互いに独立であり、一方から派生したものではない


```java
StringBuffer str1 = new StringBuffer("alpha");
str1.append("-meta");
str1.setCharAt(str1.indexOf("m"), 'b');
System.out.println(str1);     // str1.toString() を呼び出す。
                              // 印字結果は"alpha-beta"となる
```


#### プリミティブラッパークラス
プリミティブラッパークラス
* 
* 
* 
* 
* 
* 
* 
* 
; 機能:
* ある型の値を他の型へ変換する静的メソッドを提供する
* 基本型を参照型としてラッピングする目的（ボックス化）で使用できる（コレクションに格納するなど）

; その他:

* ブール型以外の基本型の初期値は0。ブール型の初期値はfalse。ラッパークラス（およびObjectクラスに属する全クラス）の初期値はnull。

#### 配列
* 配列自体はオブジェクト型のサブクラスつまり参照型である。
* プリミティブ型の配列、オブジェクト型の配列、さらにそれらの配列の配列（ジャグ配列）、などの配列を扱える。
* プリミティブ型の配列では、全ての要素はその型の値でなければならない。
* オブジェクトの配列では、階層関係にある必要がある（例えば、インタフェースの配列では、あるオブジェクトがその要素になるには、そのインタフェースを実装したクラスのインスタンスでなければならない）。
* 配列オブジェクトは配列要素の数を表す読み取り専用の属性「`length`」を持つ。
* すべての配列は動的に領域確保される。配列を生成する際の要素数として、定数だけでなく変数を使用することができる。
* 「配列の配列」ではない、（C#にあるような「本物の」）多次元配列（矩形配列）は無い。


```java
// 配列を宣言 - 配列名は「myArray」、要素の型は "SomeClass" への参照
SomeClass[] myArray = null;

// 配列を生成
myArray = new SomeClass[10];
```



```java
// または宣言と生成を同時に行う
SomeClass[] myArray = new SomeClass[10];
```



```java
// 配列の要素を割り当てる (ただし、基本型の配列なら必要ない)
for (int i = 0; i < myArray.length; i++)
    myArray[i] = new SomeClass();
```


## リテラル
リテラルの例を示す。

## 国際化サポート
Javaは1バイト整数の型（byte）と文字の型（char）とを区別する。なお、charは、名前に反して必ずしも文字を表現していない場合があり得る。すなわち、実際にはUCS-2（UTF-16）による、いわゆるダブルバイトである。J2SE 5.0以降ではサロゲートAPIによって、サロゲートペアに対応した。

JavaプログラムのソースコードおよびソースファイルはUTF-8でエンコードするのが基本である。Unicodeに対応したエンコードであれば、Javaプログラムのソースコードに直接Unicode文字を記述することもできる。なお、`-encoding`コンパイルオプションを指定することで、対応する任意のエンコードを使用することもできる。ロケール依存のコードページ（日本語版Microsoft Windowsで使われているCP932等）を利用することもできる。

文字列リテラルやコメントの他、クラス名や変数名も国際化に対応している。例えば、次のソースコードはJavaのコードとして正しく解釈されコンパイルされ実行できる。ここではクラス名、変数名、および文字列リテラルとして日本語の文字を使っている。


```java
public class こんにちは世界 {
    private String 文字列 = "こんにちは世界";
}
```


## 演算子
### 算術演算子
算術演算子

### 代入演算子
代入演算子

### 関係演算子
関係演算子

関係演算子(==と!=)を参照型に対して用いた場合、そこで比較されるのは参照先のオブジェクトが同じかどうかであり、オブジェクトの中身の値が一致するか否かではない。オブジェクトの中身を比較したい場合はメソッドを使用する。instanceof演算子は、オブジェクトが指定クラスのインスタンスであるか否かを判定するために用いる。

### 三項演算子
三項演算子は二つの記号`?`と`:`を組み合わせて記述する。条件演算子とも呼ぶ。構文は以下である。

 条件 ? 式1 : 式2

条件が`true`であるとき、式1の値をとる。そうでない場合は式2の値をとる。

例:

```java
String answer = (p < 0.05) ? "reject": "keep";
```

 

```java
// これは以下のコードと等価である:
String answer;
if (p < 0.05) {
  answer = "reject";
} else {
  answer = "keep";
}
```


### 論理演算子
論理演算子
* 短絡評価論理演算 (結果が判定するまでオペランドを左から右へと評価する)
* 必要最小限の式しか評価しない
* 部分的な評価 (完全な評価ではない)

### ビット演算子
ビット演算子

### 文字列演算子

## 制御構造
### if... else
if文
 if (*expr*) {
     *statements*;
 } else if (*expr*) {
     *statements*;
 } else {
     *statements*;
 }
* *expr*は真偽値を与えなければならない。

### switch文
switch文
 switch (expr) {
   case VALUE1:
     statement11 ; … ; statement1L ;
     break ;
   case VALUE2:
     statement21 ; … ; statement2M ;
     break ;
   default:
     statementd1 ; … ; statementdN ;
 }

* `<var>expr</var>` 値の型は`byte`/`short`/`int`/`char`あるいはそれらのプリミティブラッパークラスでなければならない。
** J2SE 5.0以降では列挙型 (Enumのサブクラス) を、Java SE 7以降ではString型を使用することもできる。caseラベルの値にnullは使用できない。
* 各々のcaseラベルの値はユニークなリテラル、あるいはコンパイル時に値が定まる定数式 (constant expression) でなければならず、変数を書くことはできない。
* 上記は古いJavaのswitch文で現在のJavaは機能が拡張されている。

### forループ
for文
 for (*initial-expr*; *cond-expr*; *incr-expr*) {
     *statements*;
 }

#### for-each ループ
J2SE 5.0では、for-each文と呼ばれる新機能が追加された。これは集合の中の全要素を順番に参照するような処理を大いに簡素化する。このような場合、従来は次の例に示すような反復子 (iterator) を書かねばならなかった:

```java
// J2SE 5.0以前にはジェネリクスもないため、実際にはさらに煩雑となる。
public int sumLength(Set<String> stringSet) {
    int sum = 0;
    Iterator<String> itr = stringSet.iterator();
    while (itr.hasNext()) {
        sum += itr.next().length();
    }
    return sum;
}
```


for-each文はこのメソッドを大いに簡素化する:


```java
public int sumLength(Set<String> stringSet) {
    int sum = 0;
    for (String s : stringSet) {
        sum += s.length();
    }
    return sum;
}
```

この例の動作としては、`stringSet`に含まれる全てのについて、長さを取得して`sum`に加算する。

### whileループ
while文

 while (*expr*) {
     *statements*;
 }

### do ... while
do-while文
 do {
     *statements*;
 } while (*expr*);

### 分岐命令

#### 例

```java
int sum = 0;
for (int i = 1; i < 10; i++) {
    if (i == 3) {
        continue;  // このループの残りをスキップしforに戻る。
    }
    sum += i;

    if (sum > 15) {
        break;  // ループを脱出する。
    }
}
```


### ラベル
* 末尾にコロンがついた識別子からなる。
* 分岐命令が参照する文またはブロックを識別するために使われる。
* 仮にラベルを外したとすると、分岐命令は最も内側のループについて機能する。

例:
 *LABEL1*: *statement*;
 *LABEL2*: { *statements*; }

### goto
Javaのキーワードには「goto」という綴りも含まれているが、goto文は無い（他にもうひとつ、constも同様に、キーワードとして予約されているが、予約されているだけで使われていない）。

## オブジェクト
### クラス
Javaではクラスあるいはインタフェースの内部で別のクラスを宣言することができる。これは「ネストされたクラス」(nested class) と呼ばれる。ネストされていないクラスは「トップレベルクラス」(top-level class) と呼ばれる。ネストされたクラスが`static`修飾されていない場合、「内部クラス」(inner class) となる。内部クラスは外側のクラスのインスタンスを暗黙的にキャプチャすることで、静的メンバ、非静的メンバいずれにもアクセスすることができる。ネストされたクラスが`static`修飾されている場合、「静的クラス」(static class) となり、静的メンバのみにアクセスできる。メソッドの内部にクラスを定義することもでき、これは「ローカルクラス」(local class) と呼ばれる。ローカルクラスでは、外側のローカル変数には読み取りアクセスのみできる。また、型の名前を持たないローカルクラスとして「匿名クラス」(anonymous class) を定義し、同時にインスタンス生成をすることもできる。

クラスあるいはインタフェースの内部で別のインタフェースを宣言することもできる。これは「ネストされたインタフェース」と呼ばれる。

クラスを宣言する際は以下の修飾子を付けることができる:
* **abstract** – インスタンス化できない。インタフェースと`abstract` (抽象) クラスだけが`abstract` (抽象) メソッドを持つことができる。抽象クラスを継承する具象 (非`abstract`) サブクラスは、引き継がれた全ての抽象メソッドを、`abstract`でないメソッドでオーバーライドしなければならない。修飾子**final**と併用することはできない。
* **final** – サブクラスを作らせない。 finalクラスのすべてのメソッドは無条件に**final**になる。 修飾子**abstract**と併用することはできない。
* **strictfp** – このクラスとそこに含まれる全てのネストクラスにおいて、全ての浮動小数点演算は厳密な浮動小数点演算動作を使用する。厳密な浮動小数点演算動作は、演算結果がプラットフォームに関わりなく同一となることを保証する。ただしJava 17以降は常にstrictfpを付けたときの挙動と同じになった。

Javaのクラス定義ブロックはセミコロン`;`で終わらせる必要はない点に注意。この点はC++の文法と異なる。

#### 継承

```java
// 子クラスは親クラスを継承する
class ChildClass extends ParentClass { ... }
```


* 任意のクラスのデフォルトの親クラスは`Object`クラスである。
* クラスは単一の親クラスだけを継承できる。実装多重継承はできない。

#### スコープ
* '''this''' – 現在のサブクラス (デフォルト) への参照 (例：`this.someMethod()`)。
* **super** – 親クラスへの参照 (例：`super.someMethod()`)。サブクラスがオーバライドした親クラスのメソッドや、サブクラスが継承しつつも隠蔽した親クラスのフィールドにアクセスするために使うことができる。

### インタフェース
インタフェースとは、実装の詳細がいっさいない抽象型である。その目的は複数のクラスを多態性によって統一的に扱うことである。共通のインタフェースを実装する複数のクラスは、そのインタフェース型のコンテキストにしたがって互いに交換可能とすることができる（リスコフの置換原則）。インタフェースはまた、抽象化 – クラスの実装方法を隠蔽すること – という考え方を強制するのにも役立つ。

インタフェースは抽象メソッドと定数フィールド (static finalフィールド) だけを含むことができる。インタフェースメソッドはデフォルトで**public**かつ**abstract**であり（実装を持たない）、インタフェースフィールドはデフォルトで **public static final** である。インスタンスフィールドやクラスフィールドすなわち状態を持つことができない点が抽象クラスと異なる。

Javaは完全な直交の多重継承はサポートしておらず、インタフェースによる「型の多重継承」のみをサポートする。C++における多重継承（実装の多重継承）には、複数の親クラスや型から複数回継承したフィールドやメソッドを識別するための複雑なルールが伴う。インタフェースを実装から分離することにより、インタフェースはより単純かつ明快に多重継承が持つ利点の多くを提供する。もっとも、実装の多重継承を避ける代価としてコードは若干冗長になる。というのは、インタフェースはクラスのシグネチャを定義するのみで実装を持てないため、インタフェースを継承する全てのクラスは定義されたメソッドをいちいち実装しなければならないからである。純粋な多重継承であれば実装自体も継承されるのでこのようなことはない。

なお、Java 8ではインタフェースのデフォルトメソッドにより実装の多重継承を限定的にサポートするようになった。また、インタフェースが静的メソッドを持つこともできるようになった。

Javaのインタフェースは Objective-C規約のコンセプトによく似た振る舞いをする。

#### インタフェースの実装
クラスは、一つのクラスを継承できるのに加えて、**implements**キーワードを用いて一つ以上のインタフェースを実装することができる。

```java
interface MyInterface {
    void foo();
}

interface Interface2 {
    void bar();
}

class MyClass implements MyInterface {
    void foo() {...}
    ...
}

class ChildClass extends ParentClass implements MyInterface, Interface2 {
    void foo() {...}
    void bar();
    ...
}
```


以下の例では、`Deleteable`インタフェースを実装する非`abstract`クラスは、引数無しで戻り型が`void`である`delete`という名前の非抽象メソッドを定義しなければならない。そのメソッドの実装と機能は各々のクラスによって決定される。


```java
public interface Deleteable {
    void delete();
}
```


このコンセプトにはさまざまな使い道がある。例えば:


```java
public class Fred implements Deleteable {
    // このメソッドはDeleteableインタフェースを満足する
    public void delete() {
        // ここにコードを実装
    }
    public void someOtherMethod() {
    }
}

public void deleteAll(Deleteable[] list) {
    for (int i = 0; i < list.length; i++) {
        list[i].delete();
    }
}
```


上の配列に含まれる全てのオブジェクトは`delete()`メソッドを持つことが保証されるので、`deleteAll()`メソッドは`Fred`オブジェクトと他の如何なる`Deleteable`オブジェクトをも区別する必要がない。

#### インタフェースの継承
インタフェースは`extends`キーワードを用いて一つ以上のインタフェースを継承することができる。


```java
interface ChildInterface extends ParentInterface, AnotherInterface {
    ...
}
```


結果として生じるインタフェースを実装するクラスは、元のインタフェースに含まれたメソッドをも併せて定義しなければならない。


```java
public interface MyInterface {
    foo();
}

public interface Interface2 extends MyInterface {
    bar();
}

public class MyClass implements Interface2 {
    void foo() {...}
    void bar() {...}
    ...
}
```


### アクセス修飾子
アクセス修飾子は、そのクラスやクラスメンバにアクセス可能なクラスを決定する。

#### トップレベルクラスアクセス
デフォルトでは、Javaのクラスは、それら自身のJavaパッケージからのみアクセスできる。これは、クラスのパッケージが、裏に隠れて機能を実行するようなAPIを提供することを可能とする。外にアクセスを公開されたクラスの動作を、隠されたクラスが支える形になる。

* デフォルト (修飾子を省略した場合) – 定義されたパッケージ内からのみアクセス可能。
* **public** – 定義されたパッケージの外のクラスからもアクセス可能。

#### クラスメンバアクセス
*クラスメンバ*とはフィールド、メソッド、コンストラクタ、クラス内で定義されたネストされたクラスのことである。アクセス制限が厳しいものから並べると、クラスメンバのアクセス修飾子は次の通り。
# **private** – そのクラスからのみアクセス可能 (内部クラスからのアクセスを含む)。`private`宣言されたメンバはサブクラスによって引き継ぐことができない。
# package-private (修飾子を省略した場合) – 同じパッケージ内の他クラスからもアクセス可能。
# **protected** – 上に加え、パッケージ外の継承クラスからアクセス可能。
# **public** – 任意のクラスからアクセス可能。

メソッドをオーバライドする際、そのメソッドのアクセス権を「より厳しく」することはできない。さもなくば親クラスのインタフェース契約を壊してしまうからである。したがってオーバライドされる場合、publicメソッドは**public**として宣言されねばならず、protectedメソッドをデフォルトアクセス権（修飾子省略）とすることはできない。しかしながら、メソッドをオーバライドしてアクセス権を「より緩める」ことは許される。したがってオーバライドする際、デフォルト (パッケージ) アクセス権のメソッドは**protected**または**public**として宣言することができ、protectedメソッドは**public**として宣言することができる。

### フィールド
アクセス修飾子に加えて、データフィールドは以下の修飾子によって宣言される:
* **final** – このフィールドの中身は変更できない。ただ一度のみ値を設定（初期化）できる。イニシャライザ (初期化子) がないfinalフィールドを「ブランクfinal」フィールドと呼ぶ。`static`なブランクfinalフィールドは最終的にスタティックイニシャライザによって初期化されなければならない。`static`でないブランクfinalフィールドはコンストラクタの実行中に必ず初期化されなければならない。**volatile**にはなれない。
* **static** – クラスのインスタンスではなくクラスに属する。
* **transient** – オブジェクトの中でも永続的 (persistent) にできないフィールドである。このフィールドの中身を待避または復元してはならないことをコンパイラに知らせる。
* **volatile** – そのフィールドが他スレッドによって非同期にアクセスされる可能性があることをコンパイラに知らせる。**final**にはなれない。

#### 定数
**static**と**final**両方を宣言されたフィールドは事実上、定数である。`static`はそのフィールドがそのクラスにおいてただ一つのみ存在することを示し、`final`はそのフィールドがただ一度のみ値を設定（初期化）可能であることを意味する。

### 初期化子
「イニシャライザ」（初期化子）はフィールドのイニシャライザと同時に実行されるコードのブロックである。

#### 静的初期化子
「スタティックイニシャライザ」（静的初期化子）はstaticフィールドのイニシャライザと同時に実行されるコードのブロックである。静的フィールド初期化子と静的初期化子は宣言された順番に実行される。静的初期化はクラスがロードされた後で実行される。


```java
static int count = 20;
static int[] squares;
static {  // スタティックイニシャライザ
    squares = new int[count];
    for (int i = 0; i < count; i++)
        squares[i] = i * i;
}
static int x = squares[5];  // x には値25が代入される。
```


#### インスタンス初期化子
「インスタンスイニシャライザ」（インスタンス初期化子）はインスタンスの (非`static`な) フィールドの初期化子と同時に実行されるコードのブロックである。インスタンスフィールド初期化子とインスタンス初期化子は宣言された順番に実行される。

インスタンス初期化子とインスタンスフィールド初期化子はコンストラクタが呼び出された際に実行される。正確な実行順序としては、親クラスのコンストラクタが実行された後、かつ、自身のコンストラクタが実行される前、となる。

### メソッド
アクセス修飾子に加えて、メソッドには以下の修飾子を付けて宣言できる：
* **abstract** – 当該クラスでは定義されないメソッドであり、代わりに当該クラスの全ての具象 (非`abstract`) サブクラスによって定義されなければならない。**static**、**final**、**native**のいずれとも併用できない。
* **final** – サブクラスによって再定義できないメソッド。そのメソッドがインスタンス (非`static`) メソッドでありかつ十分小さいならば、コンパイラはそのメソッドをインライン関数のように各所に展開する場合がある（訳注：性能改善目的と思われる）。**abstract**と併用はできない。
* **native** – このメソッドはネイティブなマシン依存コードにリンクする。メソッド本体無しで宣言される。**abstract**と併用はできない。Java Native Interfaceにて使用される。
* **static** – クラスのインタンスではなく、クラスに属する。**abstract**と併用はできない。
* **strictfp** – メソッドとそこに含まれる内部クラス全てにおける浮動小数点演算が、厳密な浮動小数点演算動作を使用する。厳密な浮動小数点演算動作は、演算結果がプラットフォームに関わりなく同一となることを保証する。ただしJava 17以降は常にstrictfpを付けたときの挙動と同じになった。
* **synchronized** – メソッド本体を実行する前に、関連オブジェクトを排他する。関連オブジェクトが他スレッドにて排他済である場合、他スレッドが排他を解除し自スレッドが排他を獲得するまで実行を待たされる。ここで言う関連オブジェクトとは、そのメソッドが**static**ならばオブジェクトを指し、非`static`ならばオブジェクトインスタンスを指す。**abstract**メソッドを**synchronized**として宣言することは可能だが意味はない。何故なら排他とは宣言ではなく実装に伴う機能であり、抽象メソッドは実装を持たないからである。
**private**メソッドは自ずからfinalであり、**abstract**にはできない点に注意。

#### 可変引数
J2SE 5.0において、引数の個数が可変であるようなメソッドについての文法上の便宜 (varargs) が追加された。これによって引数の個数が可変であるメソッドをタイプセーフに使用することが容易になる。最後のパラメタの後に「...」と書くと、Javaは全ての引数を配列に格納する：


```java
public void drawPolygon(Point... points) { /* ... */ }
```


このメソッドを呼ぶ際、プログラマは個々のpointsを単にカンマで区切って書けばよく、オブジェクトの配列をわざわざ用意する必要はない。このメソッドの内部でpointsを参照する際はpoints[0]、points[1]、などのように書ける。pointsが渡されていない場合、配列のlengthは0となる。可変個の引数と別に固定的に必要なパラメタがある場合は、それらのパラメタは可変引数に先立って指定すればよい。


```java
// ポリゴンは少なくとも3つの点を必要とする。
public void drawPolygon(Point p1, Point p2, Point p3, Point... otherPoints) { /* ... */ }
```


### コンストラクタ
コンストラクタはオブジェクトが割り当てられた後すぐに呼び出され、オブジェクトの初期処理を行う。コンストラクタは典型的には**new**キーワードを使用して呼び出されるが、リフレクションを使用して呼ぶこともできる。リフレクション機能はjava.lang.reflectパッケージより提供される。

コンストラクタを宣言する際に使える修飾子はアクセス修飾子のみである。

* 可能ならば、オブジェクトはひとたびコンストラクタを呼ばれた以後は直ちに有効かつ有意味なオブジェクトとなるべきである。分割された複数の初期化用メソッドを使わなければ初期処理が完了しないというような設計は好ましくない。
* 慣習として、引数としてそのオブジェクト自身の型を受け取ってデータメンバを複写するようなコンストラクタを「コピーコンストラクタ」と呼ぶ。
* コンストラクタが明示的に定義されていない場合、コンパイラは暗黙のうちに内容が空で引数を取らないデフォルトのコンストラクタを生成する。
* コンストラクタはオーバーロードできる。
* コンストラクタ内の最初の文は親クラスのコンストラクタ：`super(...);`または同じクラス内の別のコンストラクタ：`this(...);`を呼び出せる。
* もし、`super(...)` または `this(...)`に対する明示的な呼び出しがないならば、コンストラクタ本体が実行される前に、親クラスのデフォルトコンストラクタ`super();`が呼ばれる。

### <code>Object</code>クラスのメソッド
クラスのメソッドは継承されるので、全てのクラスにて使用できる。

#### <code>clone</code>メソッド
メソッドは現在のオブジェクトのコピーである新しいオブジェクトを返す。クラスは、それがクローンできることを明示するためにマーカーインタフェースを実装しなければならない。

#### <code>equals</code>メソッド
メソッドはそのオブジェクトともう一つのオブジェクトを比較し、二つのオブジェクトが同一かどうかを`boolean`型の値で返す。意味的には、このメソッドはオブジェクトの内容を比較するのに対し、関係演算子"`==`"はオブジェクトの参照を比較する。`equals`メソッドはパッケージにあるデータ構造クラスの多くで使われる。これらのデータ構造クラスのいくつかは`Object.hashCode`メソッドにも依存している - `equals`と`hashCode`との間の契約の詳細について、hashCodeメソッドを参照のこと。

#### <code>finalize</code>メソッド

メソッドはリソースの管理のために導入されていたが、Java 9で非推奨となり、Java 18で削除予定になったので、利用してはならない。リソースの管理には以下の方法などを使用する。
# try-with-resources文やtry-finallyを使用し、スコープを抜けたらリソースを開放する。
# でリソースの参照回数を数え、0になったらリソースを開放する、参照カウント方式。
# にコールバックメソッドを登録し、ガベージコレクションされる際にリソースを開放する。コールバックメソッドが呼ばれるまで時間がかかることがあり、なかなかリソースが解放されない場合があることに注意が必要である。

以下、Java 8以前の場合。

メソッドはガベージコレクタがオブジェクトのメモリを解放する前に必ず一度だけ呼び出される。オブジェクトが消滅する前に実行しなければならない何らかの後処理がある場合、各クラスは`finalize`をオーバーライドすることができる。とはいえほとんどのオブジェクトは`finalize`をわざわざオーバーライドする必要はない。

`finalize`メソッドがいつ呼ばれるかは保証されない。複数のオブジェクトの`finalize`がどのような順番で呼ばれるかも不定である。もしJVMがガベージコレクションを実行せずに終了するならば、OSがオブジェクトを解放する可能性があり、その場合`finalize`メソッドは呼ばれない。

`finalize`メソッドは、他のクラスから呼ばれるのを防ぐために、常に`protected`として宣言されるべきである。


```java
protected void finalize() throws Throwable { ... }
```


#### <code>getClass</code>メソッド
メソッドはオブジェクトをインスタンス化するために使われたクラスのオブジェクトを返す。このクラスオブジェクトはJavaにおけるリフレクションの基本となる。その他のリフレクション機能は`[[Java Platform, Standard Edition#java.lang.reflect|java.lang.reflect]]`パッケージにて提供される。

#### <code>hashCode</code>メソッド
メソッドは連想配列にオブジェクトを保存するための「ハッシュ値」として (`int`型の) 整数を返す。インタフェースを実装するクラスは連想配列を提供し`hashCode`メソッドに依存する。`hashCode`の良い実装は安定 (不変) かつ均等に分布するハッシュ値を返す (異なるオブジェクトのハッシュ値は互いに異なる値となる傾向を持ち、かつハッシュ値は整数値の範囲内で均等に分布する)。

連想配列は`equals`と`hashCode`の両メソッドに依存するため、これら二つのメソッドの間では、オブジェクトが`Map`に挿入される場合に関する或る重要な契約が維持されねばならない：

; 二つのオブジェクト a と b に関して
:*`a.equals(b) == b.equals(a)`でなければならない。
:* もし`a.equals(b)`が`true`ならば、`a.hashCode() == b.hashCode()`でなければならない。

この契約を維持するために、`equals`メソッドをオーバーライドしたクラスは同時に`hashCode`メソッドもオーバーライドし、逆もまた同様として、`hashCode`と`equals`が常に同じ性質（または同じ性質の一部）に基づくようにしなければならない。

マップがオブジェクトとの間に有する更なる契約は、ひとたびオブジェクトがマップに挿入されたなら、`hashCode` と `equals`両メソッドの結果は以後変わらないということである。したがって、一般にハッシュ関数はオブジェクトの不変(変更不能)な属性に基くように設計するのが良い。

#### <code>toString</code>メソッド
メソッドはオブジェクトの文字列表現をで返すものである。`'''''toString'''''`メソッドは、オブジェクトが文字列連結演算子(`+`と`+=`)のオペランドとして使われたとき、コンパイラによって暗黙のうちに呼び出される。

#### waitとnotifyスレッドシグナルメソッド
全てのオブジェクトは、そのオブジェクトに関連するスレッドについての二つの待ちリストを持つ。一つの待ちリストは**synchronized**キーワードに伴いオブジェクトをミューテックス排他するために使われる。もしミューテックスが他スレッドによって排他されているならば、自スレッドは排他を待っているスレッドのリストに追加される。もう一つの待ちリストはスレッド間でシグナルを送るためのもので、これは**wait**、**notify**、**notifyAll**の各メソッドを通して使用される。

wait/notifyを用いるとスレッド間での能率的な連携が可能となる。あるスレッドが別スレッドでの処理が終わるのを待ち合わせる必要があるとき、または何らかのイベントが発生するまで待たねばならないとき、スレッドはその実行を一時停止してイベントが発生した際に通知を受け取ることができる。これはポーリングとは対照的である。ポーリングにおいては、スレッドは一定時間スリープしてはフラグや他の状態表示をチェックする処理を繰り返す。ポーリングはスレッドがチェックを繰り返さねばならないという点でより計算コストが掛かる上に、実際にチェックしてみるまでイベント発生を検知できないという意味で鈍感でもある。

##### <code>wait</code>メソッド
`wait`メソッドには三つのオーバーロード版があり、タイムアウト値の指定方法がそれぞれ異なる：、、の三つである。一つ目のメソッドはタイムアウト値が0であり、これはタイムアウトが発生しないことを意味する。二つ目のメソッドはミリ秒単位のタイムアウト値を取る。三つ目のメソッドはナノ秒単位のタイムアウト値を取り、これは`1000000 * timeout + nanos`として計算される。

`wait`を呼んだスレッドは待機状態となり、そのオブジェクトの待ちリストに追加される。そのスレッドは以下の三つのイベントのいずれか一つが起きるまで、オブジェクトの待ちリスト上に留まる：

# 別のスレッドがそのオブジェクトの`notify`または`notifyAll`メソッドを呼ぶ (詳細はnotifyメソッド参照）
# 別のスレッドがそのスレッドのメソッドを呼ぶ
# `wait`にて指定した0でないタイムアウト値が満了する

`wait`メソッドは、そのオブジェクトについての同期(synchronized)ブロックまたは同期(synchronized)メソッドの内部からのみ呼ばねばならない。これは`wait`と`notify`との間で競合を起こさないためである。スレッドが待ちリストに入るとき、そのスレッドはそのオブジェクトのミューテックス排他を解除する。そのスレッドが待ちリストから削除され実行可能スレッドとなった際に、そのスレッドは走行を再開するのに先立ってそのオブジェクトのミューテックスを改めて排他しなければならない。

##### <code>notify</code>と<code>notifyAll</code>メソッド
 と  メソッドはオブジェクトの待ちリストから一つ以上のスレッドを削除し、それらを実行可能スレッドとする。`notify`は待ちリストから1スレッドのみ削除し、`notifyAll`は待ちリストから全てのスレッドを削除する。`notify`がどのスレッドをリストから削除するかは規定されておらず、JVMの実装に依存する。

`notify`と`notifyAll`メソッドは、そのオブジェクトについての同期(synchronized)ブロックまたは同期(synchronized)メソッドの内部からのみ呼ばねばならない。これは`wait`と`notify`との間で競合を起こさないためである。

## アノテーション
Javaの**アノテーション**はクラスやインタフェース、メソッドやフィールド、パッケージなどに対してメタデータとして付加情報を記入する機能で、J2SE 5.0 で追加された。

アノテーションはインタフェースを実装することで自作することもできる。

Javaのアノテーションは三つに分けることができる。
* マーカー・アノテーション &ndash; データが無く名前だけを持つアノテーション。
* 単一値アノテーション &ndash; データを一つだけ持つアノテーション。見かけはメソッド呼び出しに似ている。
* フル・アノテーション &ndash; 複数のデータを持つアノテーション。

### Java標準APIの主なアノテーション
*  &ndash; 対象となるクラスやメソッドが非推奨であることを情報として付加する。
*  &ndash; そのメソッドがスーパークラスのメソッドをオーバーライドしていることを示す。
*  &ndash; 引数で指定した特定の警告メッセージをJavaコンパイラに与えず無視する。
*  &ndash; 定義したいアノテーションがどこに適用されるべきかを指し示すメタアノテーション。
*  &ndash; アノテーションの配置方法を設定するメタアノテーション。

### JUnit4 から利用可能になったアノテーション
;`@Test`:そのメソッドがテストメソッドであることを示す。このメソッドにテストを記述する。従来のJUnitでメソッド名が`test`で始まるメソッドと同じ。
;`@Before`:このアノテーションが付加されたメソッドは、`@Test` アノテーションが付いたメソッドを実行するたびに事前に実行されることを意味する。
;`@After`:このアノテーションが付加されたメソッドは、`@Test` アノテーションが付いたメソッドを実行するたびに、必ず後から実行されることを意味する。
;`@BeforeClass`:このアノテーションが付加されたメソッドは、そのテストクラスを呼び出す前に実行される。
;`@AfterClass`:このアノテーションが付加されたメソッドは、そのテストクラスを呼び出した後に実行される。

### アノテーションを使用する
#### マーカーアノテーション
クラスやメソッドにマーカーアノテーションを付加するには以下のようクラスやメソッドの接頭辞に最低一つ以上のスペースまたは改行コードを入れて修飾子のように記述する。
この例は、クラスに非推奨、メソッドに、スーパークラスからのメソッドをオーバーライドしていることを意味するマーカーアノテーションを付加している例である。

```java
@Deprecated class DeprecatedClass {
    @Override public boolean equals(Object obj) {
        return this == obj;
    }
}
```


#### 単一値アノテーション
単一値アノテーションを付加するには以下のようにする。
この例は、インタフェースを実装したクラスのフィールドにstatic finalなserialVersionUIDが宣言されていないという警告を無視するアノテーションを付加していることを意味する。

```java
@SuppressWarnings(value = {"serial"})
class NoSerialVersionIDClass implements java.io.Serializable { }
```


これは、以下のような書き方もできる。これは単一値アノテーション@SuppressWarningsがvalue()メソッドを一つしか持たないことがわかっているため*value = *を省略できることを意味する。

```java
@SuppressWarnings("serial")
class NoSerialVersionIDClass implements java.io.Serializable { }
```


このアノテーションは、戻り値の型がString[]になっているため同じvalue値であっても以下のように複数指定することができる。以下のように指定することで、シリアルバージョンIDが設定されていない警告と、コレクションで総称型による型チェックを行われていないことによって生ずる警告を無視することができる。 "unchecked"はメソッドに対してのみ設定することもできる。

```java
@SuppressWarnings("serial", "unchecked")
class NoSerialVersionIDClass implements java.io.Serializable {
    public void setupList() {
        List list = new ArrayList();
        list.add("abcdef");
    }
}
```

このアノテーションは正確に記述すると以下のようにString[]配列の初期化宣言のようになる。

```java
@SuppressWarnings(value = {"serial", "unchecked"})
```


#### フルアノテーション
フルアノテーションは、複数のデータ型を持つアノテーションである。ここでは自作したアノテーション `@MyAnnotation` があるとき、以下のように、変数名 = 値の形をカンマで区切って記述する。各値の記法は、各アノテーションで定義されているメソッドの戻り値の型で決まる。たとえばこの場合valueという変数名はStringを戻り型にとる `value()` というメソッドと、`int` を戻り型にとる `version()` というメソッドを持つ。フルアノテーションの場合は、`default` によりデフォルト値が設定されているアノテーション以外は、`value =` や `version =` を省略することはできない。

```java
@MyAnnotation(value = "abc", version = 2)
class AnnotatedClass { }
```


### アノテーションを定義する
アノテーションを定義するには、interfaceキーワードの接頭辞に@をつけて定義する。
#### マーカーアノテーション
マーカーアノテーションは以下のように定義する。メソッドやフィールドが一切ないマーカーインタフェースのアノテーション版ともいえる。やがこれらのアノテーションに相当する。

```java
public @interface MarkerAnnotation { }
```


#### 単一値アノテーション
単一値アノテーションは以下のように定義する。このアノテーションには少なくともメソッドがひとつだけ定義されている。単一値アノテーションのメソッド名にはvalueという名前をつけるのが儀礼である。

```java
@interface Single {
    String value();
}
```


#### フルアノテーション
フルアノテーションは以下のように定義する。以下のように二つ以上のメソッドを定義する。

```java
@interface FullAnnotation {
    String value();
    int id();
}
```


### メタアノテーション
メタアノテーションとは、定義しているアノテーションのみにつけられるアノテーションのことである。メタアノテーションの例としてはや、、があり、これらはクラスやメソッドなどには使うことができず、アノテーションのみに使うことができる。アノテーションを定義するために使われるアノテーションということから、メタアノテーションと呼ばれる。

### メタアノテーションを使用する
メタアノテーションを使ってアノテーションを定義するには、以下のように記述する。


```java
@Retention(RetentionPolicy.SOURCE)
@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD})
public @interface NewAnnotation {
}
```


このとき、は、新たにアノテーション `NewAnnotation` を作るとき、このアノテーション情報はソースコードのみにしか保存されないことを意味する。はこのアノテーションをどの型に使うことができるかを指定している。この場合、`ANNOTATION_TYPE` と `METHOD` を指定しているのでこのアノテーションはアノテーション型とメソッドにしか使うことができない。つまり、この `NewAnnotation` もまた、メソッドだけでなくアノテーションにも保存できるため、メタアノテーションとしても使えることを示している。

### @Retention
メタアノテーションには以下の列挙型を設定することができる。

### @Target
メタアノテーションには以下の列挙型を設定することができる。これは配列を使って

```java
@Target({ElementType.METHOD, ElementType.FIELD, ElementType.TYPE})
```

と複数指定することができる。ただし、同じ値を `{` &hellip; `}` 内で複数使用するとエラーとなる。これによって型を指定することで、そのアノテーションが、どの型に対して使うことができるのかを指定できる。

## 入出力
: *関連項目: [[Java Platform, Standard Edition#java.io]] と [[Java Platform, Standard Edition#java.nio]]*

J2SE 1.3までのJavaはストリーム・ベースのブロッキングI/Oのみをサポートしていた。これは1ストリームにつき1スレッドを必要とした。何故ならストリームの入力または出力を行おうとすると、それが完了するまでそのスレッドは完全に待ちに入ってしまい、他の処理がいっさい行えなくなったからである。これは、Javaを用いたネットワークサービスを構築する上で、スケーラビリティと性能双方の面で大きな問題となっていた。J2SE 1.4以降では非ブロッキングI/OフレームワークとしてNIO (New I/O) が導入され、このスケーラビリティ問題は修正された (ただし、サンによるNIO APIの実装にはまだ多くの問題点がある)。

非ブロッキングIOフレームワークは、以前のブロッキングIOフレームワークより遥かに複雑ではあるが、一つのスレッドで任意の数の"チャネル"を扱うことができる。このフレームワークはReactorパターンをベースとしている。

## 実行コード
### アプリケーション
* (ウェブブラウザではなく) スタンドアロン仮想マシンで実行されるJavaコード
* `main`メソッドは以下のように定義されなければならない:


```java
public class MyClass {
    public static void main(String[] args) {...}
    ...
}
```


### アプレット

* ウェブブラウザで明示された表示領域上で実行されるJavaコード。
* `init`と`destroy`は一度だけ呼ばれるが、`start`と`stop`はユーザがウェブページを訪問するたびに何回も呼ばれる。


```java
// MyApplet.java

import java.applet.*;

public class MyApplet extends Applet {
    init() {...}     // ブラウザが最初にアプレットを読み込むときに呼ばれる。
    destroy() {...}  // ユーザがブラウザを終了するときに呼ばれる。
    start(){...}     // アプレットを実行し始めるときに呼ばれる。
    stop() {...}     // ユーザがウェブページを去るとき、再読込するとき、
                     // ブラウザを終了するときに呼ばれる。
}
```


 

```html
<applet code="MyApplet" width="200" height="200">
</applet>
```


#### appletタグの埋め込み
* HTMLのappletタグをアプレットのソースコードに埋め込むことができる。
* appletタグを書くと、そのアプレットは.htmlファイル無しでも、簡易アプレットビューアによって直接実行可能となる。
* 典型的には、appletタグはimport文の直後に書かれる。
* appletタグは`/* */`コメントによって囲まれていなければならない。


```java
// MyApplet.java
...
/*
<applet code="MyApplet" width="200" height="200">
</applet> 
*/
...
```


### Jakarta Servlet

* Webサーバ上で実行されるJavaコードであり、その出力 (一般的にHTMLやXML) は典型的にはウェブブラウザに対して送信される。

### Jakarta Pages (JSP)

* ウェブページにJavaコードを埋め込む形態。
* JSPタグはウェブサーバで処理され、出力結果 (一般的にHTMLやXML) はクライアントに送信される。
* JSPコードは実行される前にJava Servletにコンパイルされる。
* JSPはJava Servletの拡張である。
* JSPタグの使用法はPHPやASPのタグの使用方法と類似する。

#### JSPタグ

## その他
### ケースセンシティビティ (大文字小文字区別)
Javaはケースセンシティブ (大文字小文字を区別する) である。

### コメント
コメントの文法はC++と同じである。

```java
// 一行コメント

/* 複数行
   コメント */
```


なお、ドキュメンテーションコメントとしてJavadoc方式をサポートする。

```java
/**
 * この行はクラス、インタフェース、メソッド、フィールド宣言の直前に記述する。
 * このコメントはクラスのドキュメントを自動生成する
 * ユーティリティで使用することができる。
 */
```


## 関連項目

* Java
* キーワード (Java)
* Java Platform, Standard Edition

## 参考文献
* James Gosling, Bill Joy, Guy Steele, and Gilad Bracha, *The Java language specification*, third edition. Addison-Wesley, 2005. ISBN 0-321-24678-0.
* Patrick Naughton, Herbert Schildt. *Java 2: The Complete Reference*, third edition. The McGraw-Hill Companies, 1999. ISBN 0-07-211976-4
* Vermeulen, Ambler, Bumgardner, Metz, Misfeldt, Shur, Thompson. *The Elements of Java Style*. Cambridge University Press, 2000. ISBN 0-521-77768-2

## 脚注

### 注釈

### 出典

## 外部リンク
### オラクル
* Java
* Javaソフトウェア
* Java Language and Virtual Machine Specifications - Authoritative description of the Java language
* 
* The Java Tutorials
* New features in Java SE 7