Java Silver対策


#第一章 Javaの基本
###**クラス宣言に含めるもの**
    - フィールド
    - メソッド
    - コンストラクタ
    
###**パッケージ**
異なるパッケージに属するクラスを利用するには、完全修飾クラス名でクラスを記述するか、import文を宣言しなければいけない
####**パッケージの目的**
    - 名前空間を提供し、名前の衝突を避ける
        - パッケージ名は慣習的にドメイン名を逆にしたもの
    - アクセス修飾子と組み合わせてアクセス制御機能を提供する
    - クラスの分類を可能にする
####**パッケージのルール**
    - パッケージに属さないクラスは存在しない
    - パッケージは必ずソースコードの先頭行に記述する（コメントはOK）
    - 明示的にパッケージ宣言したクラスから、無名パッケージに属するクラスにアクセスしようとするとコンパイルエラーになる

###**インポート**
####**インポートの目的**
    - パッケージ名を省略してクラス名だけで記述できるようにする

####**インポートのルール**
    - java.langパッケージは、インポート宣言を省略できる
    - 同じパッケージに属するクラスのインポート宣言も省略可能
    
####**staticインポートのルール**
    - import staticに続けて、省略表記したいフィールドやメソッドの完全修飾クラス名を記述。（()は不要）
    - staticインポートを宣言すれば、あたかも同じクラス内に定義れているフィールドやメソッドのように記述可能
    - インポートしたクラスに、インポートされたメソッドやフィールドと同名のものがあった場合、そのインポートは無視される
    - 同名のフィールドやメソッドを複数インポートした場合は、コンパイルエラーが発生する

###**エントリーポイント**
    - 処理を始めるためのメソッドのこと
    - public static void main(String[] args){}
    - public static void main(String... args){}

        - publicであること
        - インスタンスを生成しなくても実行できること(staticであること)
        - 戻り値は戻せない(void)であること
        - メソッド名はmainであること
        - 引数はString配列型を一つ受け取ること

###**javaコマンド**
```java
public class Main{
 public static void main(String[] args){
  System.out.println(args[0] + " " + args[1]); 
 }
}
```
```command
> javac Main.java
> java Main java one two
→java one

※javacコマンドの引数はファイル名を指定する。=拡張子を含む
※javaコマンドの引数にはクラス名を指定する。=拡張子を含まない
```

#第二章 Javaのデータ型の操作
###**プリミティブ型**
|データ型 |
|-------| 
|boolean ※trueかfalseのどちらか| 
|  char | 
| byte ※-128～127| 
|  short ※-32,768～32,767 | 
| int　※小数点以下切り捨て | 
|  long | 
|  float | 
|  double | 

※nullは変数が何も参照していないことを表すリテラル。一方、空文字は、文字数0のStringオブジェクトを表す。

###**暗黙の型変換**

```java
public class Main {
 public static void main(String[] args){
  Sample s = new Sample();
  int data = 1;
  s.method(data);
 }
}

class Sample {
 public void method(long a){
  System.out.println("A"); //こちらが表示される
 }
 /*
 public void method(short a){
  System.out.println("B");
 }
 */
}

//代入OK例
//byte → short
//char → int → long → float → double
```

###**整数リテラル**
    - リテラルの先頭と末尾には記述できない
    - 記号の前後には記述できない
    - 利用できる記号は、小数点を表すドット[.]、long型やfloat型リテラルを表す[L]や[F]、2進数を表す[0b]、16進数を表す[0x]
    
###**文字リテラルと文字列リテラル**

    - char型の変数には、ダブルクォーテーション""でかこった文字列リテラルは代入不可。代入可能なのは、シングルクォーテーションで囲った文字リテラル、もしくは数値のみ。

###**識別子**
    -　変数やメソッド、クラスなどの名前のこと
        -　予約語は使えない
        -　使える記号は、アンダースコアと通貨記号のみ
        -　数字から始めてはいけない


###**オーバーロード**
```
- シグニチャ
    - メソッド名と引数のリストのセットのこと
    - オーバーロードという仕組みがあるため、同名のメソッドが複数存在する可能性がある。そのため、メソッド名に加えて引数のリスト（数や種類、順番）を同時に使ってメソッドを見分ける
```


this

```
オーバーロードされたコンストラクタから、ほかのコンストラクタを呼び出すにはthisを使う
※thisは必ず最初に記述しなければいけない
```

#第三章 演算子と判定構造の使用
###**2進数から10進数表記への計算**
```
0b010010010
- 右から1,2,4,8と順に書いて、ビットが1のところを合計する
```

###**範囲の狭いデータ型**
```
byte = -128〜127
short = -32768〜32767
```

###**関係演算子や論理演算子**
```
>,>=,<,<=の四つの演算子は、数値の大小を比較するもので、数値以外（boolean）は比較不可

&と&&、|と||の違い
もし必ず両オペランドとも評価したいのであれば、&演算子や|演算子を使う。
```

###**同一性と同値性**
```
同一性 = 同じインスタンスであること。 ==演算子で判定。
※コンスタントプール = 同じ文字列リテラルの場合はtrueが返される。new演算子を使った場合は、false

同値性 = インスタンスは異なるけれど、同じ値であること。　equalsメソッドで判定。
※nullが渡された時には、常にfalseを戻す

```

###**if文**
```java
if(条件式){
}
//{}は省略可能だが、可読性を落とす可能性が高いので非推奨
//省略した場合は、次の一文だけがif文の条件に合致した時の処理として実行される
```

###**switch文**
```
条件式が戻せる値には制限あり。以下は不可
- long型
- doubleやfloatといった浮動小数点数
- boolean

case値として使用できる値は、次の条件を満たすとき
- 条件式が戻す値と同じ型か互換性がある型であること
- 定数であるか、コンパイル時に値を決めることができること
- nullでないこと

※defaulthはどのcaseにもあてはまらなかったときに実行する処理を記述する。どこに記述してもOK
※breakがない場合、見つかるまで以降のcase内の文を実行し続ける。（=フォールスルー）
```

###**三項演算子**
```java
a = (b>=90) ? 0.5 : (b>80) ? 0.2 : 0;
↓
a = (b>=90) ? 0.5 //一つ目の条件がtrueのとき
  : (b> 80) ? 0.2 //二つ目の条件がtrueのとき
  : 0;　　　　　　  //どちらもfalseだったとき

```

#第四章 配列の作成と使用
###**配列**
```
配列の特徴
- 同じ型、もしくは互換性のある型の値しか扱えない
- 扱える要素数はインスタンス生成時に決める。あとで要素数を変えることはできない

配列インスタンスの生成、配列型変数への代入
int[] array = new int[3];
```

###**配列型変数の宣言**
```java
//宣言方法①
int[] array;
int[][] array;

//宣言方法②
int array[];
int array[][];

//宣言方法③
int[] array[];
int[][] array[];

※宣言時に、要素数の指定はできない
例）int[2] array;
※一次元目の要素は指定せずに、二次元目の要素数を指定できない
例）int[][] array = new int[][2];
```

###**配列インスタンスの生成方法**
```java
//コンパイルエラー（要素数を指定していない）
int[] array = new int[];

//コンパイルエラー（要素数に浮動小数点数を記述）
int[] array = new int[2.3];

初期化演算子を使用して要素の値を初期化
int[] array = {10, 20};
int[] array = []{10, 20};

//コンパイルエラー（初期化演算子+大カッコの中に要素数を指定）
int[] array = [2]{10, 20};

//コンパイルエラー（変数宣言と配列のインスタンス生成のタイミングを分ける）
int e[];
e = {2,3};

配列の要素のデフォルト値
- 整数型：0
- 浮動小数点数：0.0
- 真偽型：false
- 文字型：¥u0000
- オブジェクト型：null
```

```
arraycopyメソッド
arraycopy（コピー元配列, コピー元の開始の添え字,　コピー先配列, コピー先の開始の添え字, コピーする要素数）
※同じインスタンスを参照することになる
```
#第五章 ループ構造の使用
###**do-while文**
```java
do{
//繰り返し処理
} while (条件式);
※条件式の後ろにセミコロンを忘れない
※中括弧を省略した場合、doとwhileの間には一文のみを記述できる。二文以上を記述した場合は、コンパイルエラーが発生する。
```
###**for文**
```java
for (初期化文; 条件文; 更新文) {
//繰り返し処理
}

複数の一時変数を使用したfor文
for (int i = 0, j = 0; 条件文; 更新文) {
//繰り返し処理
}
※変数は同じ型でなければいけない
※for文の初期化文で宣言した変数は、for文のブロック外では使うことができない
※for文の条件文を複数記述する場合は、論理演算子を使用する
```

###**拡張for文**
```
- 順方向にしか処理できない
- 一つずつしか処理できない
```
###**無限ループ**
```java
while (true){
}

※条件式を省略
for(int i = 0; true; i++){
}

※更新文を省略
for(int i = 0; i < 5;){
}

```

###**continue**
```
※実行できない到達不可能なコードがあった場合はコンパイルエラー
```

#第六章 メソッドとカプセル化の操作

###**メソッド**
```java
アクセス修飾子 戻り値型 メソッド名(引数の型 引数名){
 return 戻り値;
}
※メソッド宣言で戻り値型の宣言は必須。戻り値を何も戻さない場合には戻り値型にvoidを指定する
※戻り値がvoidであるメソッドは、値を戻せない
※戻り値型と、実際に戻す値の方は同じ出ないければいけない

可変長引数の場合
アクセス修飾子 戻り値型 メソッド名(引数の型... 引数名){
 return 戻り値;
}
※可変長引数は、最後の引数としてのみ使うことができる
※可変長引数は、型の後ろにつける
```

型

```java
public class Sample {
 【float】 divide (int a, int b) {
  return (float) a / (float) b;
 }
}

public class Main{
 public static void main(String[] args) {
  Sample s = new Sample();
  【float(もしくはdouble)】 result = s.divide(10, 2);
  System.out.println(result);
 }
}
//【】の部分が同じ型、もしくは互換性のある方にする必要がある
```

###**staticなフィールド**
```
- staticなフィールドは、「クラス名.フィールド名」もしくは、インスタンスの作成後であれば、「変数名.フィールド名」のどちらでもアクセス可能

- staticなメソッドは、staticで修飾されたものにしかアクセスできない
- staticではないめそっどからは、staticなフィールドにアクセスできる
```
###**オーバロード**
```
オーバーロード = 引数の数、型、順番が異なる同名のメソッドを定義すること。アクセス修飾子を変えただけではオーバーロードにならない。
```

###**コンストラクタ**
```
コンストラクタ = 生成されたインスタンスが他のインスタンスから使われる前に、事前準備を整える「前処理」をするためのメソッドの一種

コンストラクタのルール
- メソッド名をクラス名と同じにすること
- 戻り値型は記述できない
- newと一緒にしか使えない（インスタンス生成時以外は呼び出しができない）
- 明示的にコンストラクタを定義した場合は、デフォルトコンストラクタが追加されない

デフォルトコンストラクタ＝コンストラクタを省略した場合、引数なしのコンストラクタをコンパイラがコンパイル時に追加。一つでもコンストラクタを定義すれば、デフォルトコンストラクタは追加されない

コンストラクタの呼び出し
例）Sampleクラスのインスタンスを生成
new Sample();

初期化ブロック = オーバーロードされた全てのコンストラクタで共通の前処理を宣言できる
※コンストラクタよりも先に実行される
public class Sample {
 {
  //初期化ブロックで行う共通の前処理
 }
}

コンストラクタのオーバーロード、this();
thisを使ってオーバーロードされた他のコンストラクタを呼び出す。
※thisを使って、コンストラクタ内からオーバーロードされたコンストラクタを呼び出す場合、コンストラクタ呼び出しコードよりも前に処理は何も記述できない。
```

###**アクセス修飾子**
|修飾子 |説明 |
|-------| -------| 
|public|全てのクラスからアクセス可能 | 
|  protected | 同じパッケージに属するか　or 継承しているサブクラスからのみアクセス可能 | 
| なし |同じパッケージに属するクラスからのみアクセス可能  | 
| private | クラス内からのみアクセス可能 | 

```java
package ex18;
public class Parent {
 int num = 10; //同じパッケージに属するクラスからのみアクセス可能
}

//-----------------------------------------

package other;
import ex18.Parent;

public class Child extends Parent {
 public static void main(String[] args){
  System.out.println(num);　//コンパイルエラー
 }
}

```
#第七章 継承の操作
###**継承**
```
継承していても引き継げないもの
- コンストラクタ
- privateなフィールドやメソッド

継承関係にあるサブクラスのインスタンスを生成するには、そのクラスのコンストラクタだけでなく、継承元であるスーパークラスのコンストラクタも実行しなければいけない。スーパークラスのコンストラクタから処理される。

継承関係にある二つのクラスで同名のフィールドが使われているときのルール
- フィールドを参照した場合は、変数の型で宣言された方を使う
- メソッドを呼び出した場合には、メソッド内の指示に従う
```

```java
class Parent {
 String name;
 String getName() {
  return this.name;
 }
}

public class Child extends Parent {
 String name;
}
//-----------------------------------------
public class Main {
 public static void main(String[] args){
  Child child = new Child();
  child.name = "sample";
  System.out.println(child.getName()); //→nullと表示される
 }
}
```
###**インターフェース**
```java
インターフェース = クラスから「型」だけを取り出したもの

public interface Sample {
 void hello();
}
- インスタンス化できない
- protectedやprivateでprivateで修飾することが出来ない
- インターフェイスは多重実現可能
- インターフェイスに宣言する抽象メソッドには、処理内容を一切記述することが出来ない
- 動的に値が変わるフィールド記述不可
```

###**抽象クラス**
```java
抽象クラス = インターフェイスとクラスの両方の性質を持ったクラス。実装を持つ具象メソッドと実装を持たない抽象メソッドの両方を持つことができる。インスタンス化出来ない＝継承して利用されることが前提。

①具象メソッドはその抽象メソッドを継承したサブクラスに引き継ぐ。
②抽象メソッドはそのサブクラスでオーバーライドして実装し直さなければいけない

public abstract class AbstractSample {
 
//具象メソッド（サブクラスが引き継ぐ）
 public void methodA(){
  //any code
 }

 //抽象メソッド（サブクラスで実装する）
 public abstract void methodB();
}
```

###**オーバーライド**
```
オーバーライドのルール
- シグニチャが同じであること
- 戻り値型は同じか、サブクラスであること
- アクセス修飾子は同じか、より緩いものを指定すること
    - オーバライドしたメソッドでは、元の定義よりもアクセス制御を緩くすることはできるが、厳しくは出来ない

```

###**キャスト式**
```
キャスト式 = 
スーパークラス型をサブクラス型に、インターフェース型を実装クラス型に変換する際には、明示的にキャスト式を記述する必要あり。
キャスト式は、コンパイラに対する「互換性の保証」とみなされる。

※キャスト式を記述して明示的に型変換をすると、コンパイルは成功するが、型同士に互換性がない場合は、実行時に例外がスローされる。
```

###**継承×コンストラクタ**
```
- スーパークラスのインスタンスが持つコンストラクタが先に実行されなければいけない
- サブクラスのコンストラクタには、スーパークラスのコンストラクタを呼び出す「supeer();」がコンパイラによって先頭行に追加される
```
#第八章 例外の処理
###**例外**
```
例外処理のメリット
- 作成される特定のプログラムに合わせて新しい例外を作成できる
- エラー処理のコードが通常のプログラム機能から分離されているので、プログラムの構造が改善される
- 例外を処理する場所をプログラマーが選択できるので、プログラムの構造が改善される
```
```java
try {
 //例外が発生する可能性のある処理
} catch (例外クラス型(必ずサブクラスのcatchブロックを先に) 変数){
 //例外が発生した時の処理
} catch (例外クラス型 変数){
 //例外が発生した時の処理
} finally {
 //例外が発生の有無に関わらず実行したい処理
}
※複数のcatchブロックがある場合、どちらの例外が先にキャッチされるかを確認する。到達可能なコードでなければ、コンパイルエラーになる。
※tryブロックとfinallyブロックは一つずつしか記述できない。（=コンパイルエラー）
```

```java
例１）
try {
 //例外が発生する可能性のある処理
} catch (例外クラス型(必ずサブクラスのcatchブロックを先に) 変数){
 return "A";
} finally {
 System.out.println("B");
}
→B,　AをReturn

例２）
try {
 //例外が発生する可能性のある処理
} catch (例外クラス型(必ずサブクラスのcatchブロックを先に) 変数){
 return "A";
} finally {
 return "B";
}
→BをReturn
```

###**throws宣言**
throws宣言があれば、try-catch分がなくてもok
(=私はメソッド内でチェック例が発生しても処理しませんが、私の呼び出し元が処理します、という宣言)

```java
public static void subsub() throws IOException {
//IOExceptionが発生する可能性があるがtry-catch分がなくてもok
 FileWriter fw = new FileWriter("data.txt");
}
```
###**throw (例外を投げる)**
私たち自身が例外的状況になったと、JVMに報告することができる

```java
//throw new 例外クラス名("エラーメッセージ");
public class Person {
 int age;
 public void setAge(int age) {
  if (age < 0 ) {
   throw new IlligalArgumentException
   ("年齢は正の数を指定すべきです。指定値 = " + age);
  }
  this.age = age;
 }
}
//=============
public class Main {
 public static void main (String90 args) {
  Person p = new Person();
  p.setAge(-128);
 }
}
```


###**例外クラスの関係**
```
Throwable
↑
- Error
    - プログラムからは回復不可能なトラブル
        - OutOfMemeroyError
        - NoClassDefFoundError
        - StackOverFlowError

- Exception ← RuntimeException

Exceptionはその例外をメソッド内でキャッチするかもしくはthrows宣言で再スローすることを宣言する
RuntimeExceptionはtry-catchを強制されない。また、throws句で宣言しなくてもOK。
```
###**例外クラス**
```java
- IndexOutOfBoundsException
    - 「List, ArrayList」などに対して、不正なインデックスを使ってアクセスした時に発生する例外
例）
  public static void main(String[] args){
   ArrayList<String> list = new ArrayList<>();
   list.add("A");
   list.add(2,"B"); ←コンパイルエラーは発生しないが、実行するとIndexOutOfBoundsExceptionがスローされる
   list.add("C");
   list.add("D");
　}

 
- ArrayIndexOutOfBoundsException
    - 「配列」に対して、不正なインデックスを使ってアクセスした時に発生する例外
例）
 public class Main {
  public static void main(String[] args){
   System.out.println(args[0].length());
  }
 }
> java Main

- ClassCastException
    - 継承関係や実現関係にないクラスをキャストする
- IllegalArgumentException
    - 不正な引数を渡してメソッドを呼び出した
- IllegalStateException
    - 準備が不十分な状態でメソッドを呼び出した
- NullPointerException
    - nullに対してメソッドを呼び出すようなコードを記述
- NumberFormatException
    - 文字列を数値型に変換しようとしたときに文字列が数値型に適した状態
- SecurityException
    - JVMのセキュリティポリシーに反した処理が実行された時に発生する
- ExceptionInInitializerError
    - static 初期化子または static 変数の初期化子の評価時のエラー
//========================
public class Main{
 private static String name;
 static {
  if(name.length() == 0){//中身がnullの変数に対してlengthメソッドを呼び出しているため、NullPointerExceptionが発生し、ExceptionInInitializerErrorを呼ばれる
   name = "sample";
  }
 }
 public static void main(String[] args){
  System.out.println("hello," + name); 
 }
}
//========================
- StackOverflowError
    - 同じメソッドを呼び続ける再帰呼び出しを行い、スタック領域が足りなくなった場合
- NoClassDefFoundError
    - 実行対象のクラスファイルを発見できない時
- OutOfMemeroyError
    - 領域がいっぱいになり新しいインスタンスを作ることが出来なくなった時

```

#第九章 Java APIの主要なクラスの操作
###**Stringクラス**
```
Stringクラスのインスタンスを生成
- newを使ってインスタンス化する
- ダブルクォーテーションでかこった文字列リテラルを記述
※Stringはimmutableなオブジェクトであるため、文字列を変更するには新しくインスタンスを作らなければいけない

・indexOfメソッド
引数で指定された文字が文字列のどの位置に存在するかを調べる
※文字列が存在しなければ-1が戻される

・substringメソッド
文字列から任意の文字列を抽出する
※指定のインデックスが抽出できない場合、StringIndexOutOfBoundsExceptionがスローされる

・trimメソッド
文字列の前後にある空白を除去する
※スペース以外にもタブや改行も含まれる

・replaceメソッド
文字列を置き換える

・lengthメソッド
文字数を戻す

・charAtメソッド
引数で指定された位置にある文字を抽出

・startWithメソッド
文字列が引数で指定された文字で始まるか調べる

・splitメソッド
文字列を分割する

・concatメソッド
Stringクラスに用意されているメソッド、オブジェクト内部の文字列と引数として渡された文字列を連結した、新しい文字列を戻す

・+演算子
文字列を連結する
※nullは、"null"という文字列に置き換えられ文字列として連結される
```

###**StringBuilderクラス**
```
・StringBuilder
デフォルトで16文字分のバッファを持つ
※保持している文字列+デフォルトの16文字分のバッファ

・appendメソッド
文字列に新しい文字列を追加する

・insertメソッド
文字列を任意の場所に挿入する

・deleteメソッド
引数で指定した範囲にある文字列を削除する
例）delete(1,2) //インデックス1からインデックス2まで

・deleteCharAtメソッド
引数で指定した位置にある文字を削除する

・reverseメソッド
文字列を反転する

・replaceメソッド
第一引数と第二引数で指定した範囲の文字列を、第三引数の文字列に置き換える

・subSequenceメソッド/subStringメソッド
任意の範囲の文字列を抽出
抽出された文字列は、新しいオブジェクトが持っており、元の文字列は変化しない
```
###**パターンの例**
|パターン文字|意味　|
|-------| -------| 
|[abc]  | a,bまたはc 　|
|[^abc] | a,b,c以外の文字 | 
|[a-zA-Z]| a-zまたはA-Z　 | 
|[a-d[m-p]|a-dまたはm-p　 | 
|[a-z&&[def]|d,eまたはf　 | 
|[a-z&&[^bc]|b,cを除くa-z | 


###**数量子**
|パターン文字|意味　     |
|-------| ------------- | 
|?      | 1または0回　　 | 
|*      | 0回以上 　　 　| 
|+      | 1回以上 　　 　| 
|{n}    | n回 　　     　| 
|{n,}   | n回以上 　 　　| 
|{n,m}  | n回以上、m回以下| 


###**定義済み文字クラス**
|パターン文字|意味　|
|-------| -------| 
|.      | 任意の文字　 | 
|¥d     | 数字 　　　　| 
|¥D     | 数字以外 　　| 
|¥s     | 空白文字 　　| 
|¥S     | 非空白文字　 | 
|¥w     | 単語構成文字 | 
|¥W     | 非単語文字 　| 


###**ラムダ式**
関数型インターフェイスを実装したクラスのインスタンスを、簡単に作るための文法。
（＝クラスの宣言とインスタンスの生成を同時に行う文法）


###**ラムダ式 （例）**

```java
import java.util.Comparator;
class ComparatorImpl implements Comparator<String> {
    public int compare(String s1, String s2) {
        return s1.compareTo(s2);
    }
}

import java.util.Comparator;
class ComparatorImplTest {
    public static void main(String[] args) {
        Comparator<String> c = new ComparatorImpl();
        System.out.println(c.compare("ABC", "DEF")); // → -1が表示される
    }
}
//---------------------------------
↓ラムダ式で書くと、以下のみ
import java.util.Comparator;
class ComparatorImplTest {
    public static void main(String[] args) {
        Comparator<String> c = (s1, s2) -> s1.compareTo(s2);
        System.out.println(c.compare("ABC", "DEF"));
    }
}
```

###**関数型インターフェイス**
```
「抽象メソッドを1つだけ持つインターフェイス」のこと
例）
java.lang.Comparable
java.lang.Runnable
java.util.Comparator
java.util.concurrent.Callable
java.util.function.Consumer
java.util.function.Function
java.util.function.Predicate
java.util.function.Supplier
…etc
```
###**ラムダ式のメリット**
```
- 抽象メソッドを実装したクラスを最小のコード量で実装できる
- 抽象メソッドの実装と、メソッドを使うところを一つにできる

※ラムダ式の分かりやすさと＝抽象メソッドの実装が「そのままそこに」書いてあり、何をしているかを調べるために、別のファイルをわざわざ見に行かなくてもよい。
```

```
中カッコあり
- 複数の処理を記述できる
- 戻り値を戻すにはreturnが必要

中カッコなし
- 一つしか処理がない
- 戻り値を戻すにはreturnを省略
```


###**LocalDateクラス**
```
- 不変オブジェクトである（変更を加えると、更新された新しいインスタンスへの参照が戻るだけで、元のインスタンスが変わることはない）
- Calendarは可変オブジェクトであったが、LocalDateは不変オブジェクトとなり、扱ってるオブジェクトの値が変更されたかどうかを気にする必要がなくなった
- Calendarでは月は0から始まっていたが、LocalDateでは1から始まり直感的に扱いやすくなった
- 日付を操作するための便利なメソッドが追加された

・ofメソッド
日付を指定してインスタンスを生成(uuuu-MM-dd)
LocalDate.of(2015, 8, 29);
※LocalDate.of(2015, 0, 1); ←存在しない月をしていているが、構文上は誤りはないためコンパイルエラーは発生しない。実行時にjava.time.DateTimeExceptionがスローされる

・nowメソッド
現在の日付でインスタンスを生成(uuuu-MM-dd)
LocalDate.now();

・parseメソッド
文字列の日付をLocalDateクラスの変換(uuuu-MM-dd)
LocalDate.parse("2015-8-29", DateTimeFormatter.ISO_DATE);

・untilメソッド
日付の差を計算する
```


###**LocalTimeクラス**
```
- 不変オブジェクトである（変更を加えると、更新された新しいインスタンスへの参照が戻るだけで、元のインスタンスが変わることはない）
- 24時間で時間を扱い、午前/午後は区別しない

・untilメソッド
日付の差を計算する
```


###**Durationクラス**
```
・betweenメソッド
二つの日時の差を計算する
```

###**Periodクラス**
```
・betweenメソッド
日付の差を計算する
```


###**DateTimeFormatterクラス**
```
・formatメソッド
内部に保持している日付の情報を文字列に変換する
　・BASIC_ISO_DATE = 20150831
　・ISO_ZONED_DATE_TIME = 2015-08-31T00:00:00+09:00[Asia/Tokyo]
　・ISO_INSTANT = 2015-08-30T15:00:00Z
　・ISO_DATE_TIME = 2015-08-31T00:00:00
```



###**ArrayListクラス**
```
コレクション＝何らかの集合のこと

配列の制約
・同じ型、もしくは互換性のある型しか扱えない
・扱える要素数を最初に決めなくてはいけない
・要素アクセスには添字を使わなければいけない
・要素アクセスの際には、要素数を超えないように配慮しなければいけない


コレクションAPIの特徴
・オブジェクトであればどのような型でもあるかえる
・必要に応じて要素数を自動的に増やす
・追加した順に並ぶ
・nullも値として追加できる
・重複した値も追加できる
・スレッドセーフじゃない（安全な平行処理は出来ない）
例）ループで読み出しをしている最中にremoveメソッドを呼び出すと例外（ConcurrentModificationException）がスローされる
・ジェネリックスを使って、扱える型を制限することができる
　List<String> list = new ArrayList<>();

・addメソッド
引数で渡された値をリストの後ろに追加する。
例）
list.add("A");
list.add(2,"B"); ←コンパイルエラーは発生しないが、実行するとIndexOutOfBoundsExceptionがスローされる
list.add("C");
list.add("D");

・setメソッド
追加ではなく、置き換えをする。元の値を上書きする。

・removeメソッド
リストから要素を削除。リストから要素を削除した場合、後ろの要素が繰り上がる。削除対象の要素が複数ある場合は、equalsメソッドがtrueを戻す最初の対象を削除。先に現れた要素だけを削除

ループで読み出しをしている最中にremoveメソッドを呼び出すと、例外がスローされる
```
#第十章 総仕上げ問題
###**Javaの実行環境**
```
Javaのプログラムを実行するには、JVMを含む実行環境（ランタイム環境）が必要。
```

###**ラベル**
```
```
###**ポリモーフィズム**
実際に動作しているインスタンスを、インスタンスの元となった型とは異なる型で扱える仕組み。

```java
メリット
- 実行時により動的なコード
- より柔軟で再利用可能なコード

instanceof演算子
指定した型でインスタンスを扱えるかどうか調べる


public class A {
 public void hello() {
  System.out.println("hello");
 }
}
public class B extends A {
 public void bye() {
  System.out.println("bye");
 }
}

//インスタンスを扱ってる「型」に、呼び出しているメソッドが定義されているかどうかを確認する
public class Main {
 public static void main(String[] args) {
  A a = new B();
  a.bye();
 }
}
```
###**オブジェクト指向概念**
```
データ抽象
- 関係するデータをまとめる

カプセル化
- そのデータを必要とする処理をまとめてモジュール化する

データ隠蔽
- モジュール内のデータを外部からアクセスできないようにする

抽象化（ポリモーフィズム）
- 関係するモジュール同士をまとめる

情報隠蔽
- モジュールの公開範囲を決める

継承
- 機能や役割を引き継ぐもの

インスタンス化
- クラスから動作するモジュールを生成すること
```
第一章：9/9
第二章：12/12
第三章：19/22 (5,14,18)
第四章：9/11 (5,8)
第五章：16/17 (13)
第六章：15/22 (7,10,11,15,17,18,19)
第七章：10/17 (6,8,10,11,13,14,16)
第八章：15/22 (3,6,7,12,13,14,19)
第九章：26/38（14,23,24,26,27,29,30,31,34,35,36,37）
第十章：37/77