【JavalSilver】基礎知識

# 基礎知識
						
 ### char型					
* 初期値は空文字。				
* シングルクォーテーションで括った文字。				
* シングルクォーテーションで括った「\u」から始まるUnicode番号。
(\u0000～\uFFFF)			
* 0～65535までの数値。				
* すべて型から見て縮小変換。(キャストが必要)				

### その他の型
* float、doubleは浮動小数点数。				
* long l = 40L 、float f = 1,15F。				
						
* byte(-128～127) → short(-32768～32767) → int → long → float → double
   
### var型					
* ローカル変数の宣言しか使えない。				
* メソッドの引数、コンストラクタの引数、メソッドの戻り型、フィールドに使用できない。				
* finalを使用する際はvarの左側に宣言				
* var v1 = 5_23; → 出力結果：523				
※アンダースコアが含まれていても、通常の数値として扱われる				
※アンダースコアは先頭、末尾には定義できない。				
※連続させてもOK  (例)523__3, 5_23__3				
* var v1; ×　→　var v1 = 100; ○				
* var型にnullを代入できない				
* var型は複数まとめて宣言できない。(例)var v1 = 10, v2 = 20;

```java:例題
public class Sample {
    String name;
}
```
```java
inmport java.util.ArrayList;

public class Test {
    var sample = new ArrayList<Sample>(); // コンパイルエラー
    public var test() { // コンパイルエラー
        var sample = new Sample();
        var samples = new ArrayList<>();
        samples.add("A");
        samples.add("B");
        for(var s : samples) {
            System.out.println(s);
        }
    }
}
```

```:実行結果
コンパイルエラー
```
						
### static変数(クラス変数)					
* staticで宣言する変数のこと。				
* クラス変数、クラスメソッドにアクセスするには、「クラス名.フィールド」と書く。				
* static変数はクラスのロード時に初期化。				
* staticイニシャライザは、クラスファイルがロードされたタイミングで1度だけ実行されるブロック。クラスをインスタンス化する前や、main()メソッドを呼び出す前に実行したい処理で使用。				
												
### インスタンス変数(メンバ変数)					
* クラスの直下、メソッドの外に宣言する変数。				
* 同名のローカル変数があるときは、「this.フィールド」、または、「インスタンスを格納している変数名.フィールド」でアクセス。				
※thisとはそのクラスのオブジェクト自身のことをさす。				
* 明示的な初期化を行っていない場合は、コンパイラ(コンストラクタ)によって初期化される。				
						
### ローカル変数					
* メソッド内で宣言する変数のこと。				
* 初期化されていないローカル変数を使用するとコンパイルエラー。
* アクセス修飾子をローカル変数に使えない。				
* ローカル変数はその変数を宣言したメソッド内だけが有効範囲となる。
* 変数名だけを記述すると、コンパイラはローカル変数だと解釈する。
* インスタンス変数やクラス変数は、同じクラス内に同名のものを複数定義することとはできない。
```java:例題
public class Sample {
    static int num = 23;
    public static void main(String[] args) {
        // int num = Sample.num;を記述するとコンパイルエラーはなくなる。
        int num = num; // ローカル変数num初期化されていないため
        System.out.println(num);
    }	
}
```

```:実行結果
コンパイルエラー
```

* 初期化されていないローカル変数を参照しようとするとコンパイルエラー。
elseではxに対して初期が行われていないため
```java:例題
public class Main {
    public static void main(String[] args) {
        int x;
        int y = 3;
        if(y > 2){
            x = ++y;
            y = x + 5;
        } else {
            y++;
        }
        System.out.println(x + "," + y);    
    }
}
```
```:実行結果
コンパイルエラー
```

* 初期化されていないローカル変数を参照しようとするとコンパイルエラー。
```java:例題
public class Main {
    public static void main(String[] args) {
        String str;
        test(str);
    }
    private static void test() {
        System.out.println(str);
    }
}
```
```:実行結果
コンパイルエラー
```

### 抽象クラス
```java:実装例
abstract class workingPeople {			
    public void vacation {		
        System.out.println("A");	
    }		
    abstract void work();
    public static void sample() {
        System.out.println("B");	
    }
}			
```

* 抽象クラスのオブジェクトを生成することができない。				
* 抽象メソッドがあるクラスは必ず抽象クラスとして宣言しないといけない。	
* 抽象クラスには、具象メソッドと抽象メソッドの定義可能。				
* 抽象メソッドを定義するときはabstractで修飾しないといけない。
* privateメソッドは定義可能。
* 抽象クラスを継承する際に抽象メソッドが定義されている場合、必ずサブクラス内でオーバーライドする必要がある。		
						
### 抽象メソッド					
* 実装(処理)を持たないため{}も定義せず、;(セミコロン)で定義完了とする。

```java:実装例
public abstract int method();
```
						
### 具象メソッド					
* abstractで修飾していない実装(処理)を持つメソッド。				
```java:実装例 			
private int method() { return num;}		
private void method() { }		
```

### オーバーロード					
* 同じクラス内に同じ名前で引数の順番、引数の型や数が異なるメソッドを複数定義すること。			
* アクセス修飾子が異なるだけで、オーバーロードとして見なされない。
						
### オーバーライド					
* メソッド名、引数の型、数が同じ。				
* 戻り値の型が同じか、サブクラス型。				
* アクセス修飾子がスーパークラスメソッドと同じか、より公開範囲が広い修飾子。		
* final修飾子が指定されたメソッドは、サブクラスでのオーバーライドが禁止。	
* staticメソッドはオーバーライドできない。

```java:実装例
public abstract class A {			
    abstract void sample();		
}

public class B extends A {
    @Override 
    // Aクラスのメソッドが引数なしに対して、Bクラスのメソッドは引数ありのためオーバーライドができていない
    void sample(int i) {
        System.out.println(10);
    }
    public static void main(String[] args) {	
        A a = new B();
        a.sample();
    }	
}
```

```:実行結果
コンパイルエラー
```
						
### 関数型インタフェース					
* オーバーライドすべきメソッドが1つだけのインタフェース。				
→抽象メソッドが1つだけ定義されているインタフェース。			
						
### ラッパークラス					
* 基本データ型の値をオブジェクトとして扱うためのクラス。				
						
### 静的インポート					
* static変数やstaticメソッドのクラス名を指定せずに使用するためのインポート機能。
			
 ```java:実装例
package pack1.pack2;		
    public class Access1 {		
    public static int num = 55;	
}
```

 ```java
import static pack1.pack2.Access1.*;			
public class Access2 {			
    // Access1クラス自体のインポートを行ってないため、コンパイルエラー
    int num1 = Access1.num;
    int num2 = num; // コンパイル成功
    int num3 = pack1.pack2.Access1.num; // コンパイル成功		
}
```
						
### インタフェース
```java:実装例
public interface Sample {			
    public void methodA();		
    void methodB();		
}
```

* インタフェースに定義した変数には「public static final」修飾子が必ず指定される。(公開するためのものなので、publicなメンバを定義する)
* インタフェースに宣言できる変数はstaticな変数のみ。
* インタフェースでは定数とメソッドのみが定義できる。				
* インスタンス化できない				
* 抽象メソッドを定義できる				
* 抽象メソッドはアクセス修飾子を付与していないと暗黙で「public abstract」修飾子を付与		
* インタフェースに定義する抽象メソッドは、protected、privateで修飾できない。	
* 具象メソッドはdefaultメソッドとstaticメソッド以外の実装はできない。
* defaultというキーワードを記述することによって「具象メソッド」も定義可能。
* インタフェースのメソッドは抽象メソッドと同様に、インタフェースを実装したクラスでメソッドを実装する必要がある。

```java
public interface Employee {			
    void setName(String name);		
    default String getName() {		
        return "No Name";	
    }		
}			
```

* privateな具象メソッドを定義できる				
* 具象メソッド(default、static)はアクセス修飾子を指定しない場合は暗黙でpublic付与。
* インタフェースを実装したクラスは、宣言されているメソッドを実装しなければならない。			
※引数が同じメソッドを同時に実装はできない。			
* インタフェースを実装したクラスが抽象クラスの場合、インタフェースのメソッドをオーバーライドしなくてもよい。
* defaultメソッドをオーバーライドしたメソッドから、元のdefaultメソッドを呼び出すには次の構文。
インタフェース名.super.メソッド名();			
						
* java.lang.Objectクラスに提供されているequals()、hashcode()、toStirng()メソッドの3つはdefaultメソッドとしてオーバーライドすると、コンパイルエラーになる。
* 中カッコ「{}」だけを記述して処理を記述しないものを「処理なし」で解釈される。

```java
public interface Sample {			
    public void hello() {} // ←コンパイルエラー		
}			
```

* オーバーライドする際に、より厳しいアクセス修飾子で修飾しているため。
```java:例題
public interface Function {			
    void process();		
}			
```
```java
class Sample implements Function {			
    protected void process() {
        System.out.println("A");
    }		
}			
```
```:実行結果
コンパイルエラー
```

* sampleメソッドをDクラスで実装していないため
```java:例題						
interface A {			
    public void sample();	
}			
```
```java
interface B extends A {			
    public void test();
}
```
```java
abstract class C implements B {			
    public void test() {
        System.out.println("A");
    }
}
```
```java
class D extends C {			
    public void test() {		
        System.out.println("B");
    }		
}			
```	
```java
public class Main {			
    public static void main(String[] args) {		
        C c = new D();
        c.test(); 	
    }		
}
```

```:実行結果
Dクラスでコンパイルエラー
```





* 利用中のOS用のJDKをインストールすると、Java開発環境がセットアップされる。		
* 頻繁に実行されるコードを監視して、実行を最適化する。				
* 実行時に、クラスは必要に応じてロードされる。				
* コマンドライン引数を渡さなかった場合は、配列argsは「要素数0の配列」を保持している。			

```java:実装例 「java Sample」で実行	
public class Sample {		
    public static void main(String[] args) {	
        System.out.println(args.length);
    }	
}
```

```:実行結果
0
```	
														
* 1つのソースファイル内に複数のクラスを定義する場合、main()メソッドを持つクラスはソースファイルの先頭に定義する必要がある。			

```java:実装例
class Sample {		
    public static void main(String[] args) {	
        System.out.println(Foo.func());
        System.out.println("Sample");
    }	
}

class Foo {		
    public static int func() {	
        return 10;
    }	
}
```

```:実行結果
10Sample
```	

* AクラスはBクラスに依存しているため、Aクラスを実行すればいい。

```java:実装例
pacage b;

public class B {}
```

```java
pacage a;
import b.B;

public class A {		
    public static void main(String[] args) {	
        B b = new B();
    }	
}
```
```
javac a/A.java
java a/A

上記で実行
```