インスタンスの考え方・クラス型変数・コンストラクタ・静的メンバ

#クラス型変数とは

##インスタンス生成時の詳細
**(コード)**

```java
//インスタンス・ダース・ベイダーを生成
StChara dath = new StChara();//①・②

//フィールド値を代入
dath.name = "ダース・ベイダー";//③
dath.focelevel = 100;//③
dath.status = "暗黒卿";//③
```
**(考え方)**
<img width="1006" alt="スクリーンショット 2018-02-25 10.35.26.png" src="https://qiita-image-store.s3.amazonaws.com/0/229025/4df93a40-a4bf-61b2-abf4-703e0339678b.png">



　①　インスタンスのメモリ領域及の確保及びフィールド作成。
　②　①で作成したそのメモリ領域に対するリンクを作成。これで、①で作成したメモリ領域にアクセスが可能になる。
　③　フィールド値を代入。

##クラス変数は参照型

**(コード)**

```java
//dath2クラス変数を作成
StChara dath = new StChara();
dath.name = "ダース・ベイダー";
dath.focelevel = 100;
dath.status = "暗黒卿";
Stchara dath2;//①クラス変数dath2を定義。
dath2 = dath;//②dath２にdathのリンク先を代入。（newで新しくインスタンスを生成して無いため）
```

**(考え方)**
<img width="1002" alt="スクリーンショット 2018-02-25 13.39.22.png" src="https://qiita-image-store.s3.amazonaws.com/0/229025/8c3b4f67-eeb9-960b-4472-3bd1e1732dcb.png">



クラス変数は参照型変数のため、リンク先が代入される。

##クラス型変数をフィールドに用いる
※ここからはスターウォーズじゃありません。
**(コード)**

```java
//Heroクラス
public class Hero {
	String name;
	int hp;
	Sword heroSword;//①sword型のheroSwordフィールドを作成。
	void attack(){
		System.out.println(this.name +"は"+this.heroSword.name+"で攻撃した！");//③
		System.out.println("敵に"+this.heroSword.damage+"ポイントのダメージを与えた！！");//③
	}
}
```

```java
//swordクラス
public class Sword{
	String name;
	int damage;
}
```

```java
//mainクラス
public class Main {
	public static void main(String[] args) {
		Sword sword = new Sword();
		sword.name = "炎の剣";
		sword.damage = 10;

		Hero hero = new Hero();
		hero.name = "ミナト";
		hero.hp = 100;
		hero.heroSword = sword;//②heroインスタンスのheroSord属性に、swordインスタンスを代入する。
		hero.attack();
	}
}
```

**（出力結果）**

```
ミナトは炎の剣で攻撃した！
敵に10ポイントのダメージを与えた！！
```

**(考え方)**
①HeroインスタンスにSword型のクラス変数「heroSword」を宣言する。
②heroSwordにswordインスタンスを代入。
③クラス変数heroSwordにswordインスタンスが代入されているため、「this.herosword.name」が「sword.name」と同様の意味を持ち、swordインスタンスの「name」「damage」が参照出来る。

**(補足)**
「あるクラスが別のフィールドを利用している関係」＝「has-aの関係」という。
上記コードでいうと、「hero has-sword」となる。

##クラス型変数をメソッド引数や戻り値で使用する


```java
//Heroインスタンスを生成
Hero hero1 = new Hero();
hero1.name = "ミナト";
hero1.hp = 100;
```

```java
//Heroインスタンスを生成
Hero hero2 = new Hero();
hero2.name = "アサカ";
hero2.hp = 100;
```


```java
//Wizardインスタンスを生成
Wizard wizard = new Wizard();
wizard.name = "スガワラ";
wizard.hp = 50;
wizard.heal(hero1);
wizard.heal(hero2);
```

```java
public class Wizard {
	String name;
	int hp;
	void heal(Hero heroX) {;//クラス変数を引数に使う事で、インスタンスを代入出来る様になる。インスタンスを代入する事によってインスタンスのフィールド値を参照出来る様になる。
		heroX.hp+=10;
		this.hp+=10;
		System.out.println(heroX.name+"のHPを10回復した！");
		System.out.println(heroX.name+"のHPは"+heroX.hp);
		System.out.println(this.name+"のHPは"+this.hp);//heroを回復させ、Wizard自身も回復する。
	}

}
```
**(出力結果)**

```
ミナトのHPを10回復した！
ミナトのHPは110
スガワラのHPは60
アサカのHPを10回復した！
アサカのHPは110
スガワラのHPは70
```

#コンストラクタとは
##コンストラクタの考え方
**（考え方）**
インスタンスの生成時に、実施する初期処理（値の代入、メソッド）をコンストラクタという。

**（宣言方法）**

```java
クラス名(引数を受け取る変数){  
  this.引数を受け取る変数　＝ 値;
}
```
で宣言する事が出来る。
この際、`void`含む戻り値の指定はNG。

**（コード）**

```java
public class Hero {
	String name;
	int hp;

	Hero(String name) {//コンストラクタ
		this.hp = 100;
		this.name = name;
	}
```

##コンストラクタのオーバーロード
**(考え方)**
引数の型・引数の数を変える事により、複数の同一名コンストラクタを使用できる。
また、オーバーロードの際は他の、コンストラクタを呼び出して使用する事が出来る。

```
this(引数名);
```

**(コード)**

```java

public class main {
	public static void main(String[] args){
	  Cleric a = new Cleric("聖職者",10,10);
	  Cleric b = new Cleric("聖職者",10);
	  Cleric c = new Cleric("聖職者");
	}
}
```

```java

public class Cleric {
	String name;
	int hp = 50;
	final static int HPMAX = 50;
	int mp;
	final static int MPMAX = 10;


	public void selfAid() {
		System.out.println(this.name + "はセルフエイドを唱えた！");
		this.hp = HPMAX;
		this.mp -= 5;
		System.out.println("HPが最大まで回復した。");
	}
//コンストラクタ
	Cleric(String newName,int newHp,int newMp){
	  this.name = newName;
	  this.hp = newHp;
	  this.mp = newMp;
	}

	Cleric(String name,int hp){
		this(name, hp, Cleric.HPMAX);//ここのthisで他の処理を呼び出す、定数フィールドは静的メンバのため、インスタンスの生成前から呼出可能。
	}

	Cleric(String name){
		this(name,Cleric.HPMAX);
	}
}
```

**(出力結果)**

```java
聖職者Aはセルフエイドを唱えた！
HPが最大まで回復した。
聖職者Bはセルフエイドを唱えた！
HPが最大まで回復した。
聖職者Cはセルフエイドを唱えた！
HPが最大まで回復した。
```

#静的メンバ
##静的メンバの考え方
**(考え方)**
同じクラスから複数のインスタンスを生成しても、必ず共通する値やメソッド（初期値等）を、静的メンバとして定義する必要がある。

**(参考)先ほどのダース・ベイダーの図でいうと・・・**
<img width="1001" alt="スクリーンショット 2018-02-25 12.01.51.png" src="https://qiita-image-store.s3.amazonaws.com/0/229025/b7f9fcf2-d23f-b4d4-6486-927e76a0ef9d.png">

##静的フィールド
**(定義方法)**
インスタンスのクラス内 `static データ型 変数名　　//静的フィールドを作成`

```java
//Stcharaクラス
static int firstLevel;
```

メインのクラス内 `インスタンスのクラス名.変数名　= 値  //静的フィールドに値を代入`

```java
//Stcharaクラス
Stchara.firstLevel = 1;
```

**(定義する事で得られる効果)**
・静的フィールドを生成する事で、`クラス名.変数名`でフィールドの値が呼び出せる様になる。（フィールドの値はクラス自身が保持）
・インスタンスを生み出す前からに、クラス変数が利用可能になる。

##静的メソッド

**(定義方法)**

```
static 戻り値 メソッド名{
  処理内容
　}
```
**(定義する事で得られる効果)**
・静的メソッドを生成する事で、`クラス名.メソッド名`でメソッドが呼び出せる様になる。（メソッドはクラス自身が保持）
・インスタンスを生み出す前から、メソッドが利用可能になる。

**(静的メソッドの注意点)**
・使用するフィールドは、必ず静的フィールドを使用する。