【Java】メソッド

# メソッドの呼び出しと定義
:sunny:  複数の文をまとめ、それをひとつに処理として名前をつけたもの。

```例.java
public class Main {
  public static void main(String[] args) {
    System.out.println("先生：みなさ〜ん、おはようございま〜す♪");
    student();
    System.out.println("先生：今日も１日お勉強がんばりましょう♪");
  }
    
  public static void student() {
    System.out.println("生徒：おはようございます");
  }
}
```

public static〜始まる
public static void main(String[] args) {　〜　}
と
public static void student() {　〜　}
の 2 件あります。
これがいわゆるメソッドです。
順を追って説明しますね:smile:

３ 行目
System.out.println("先生：みなさ〜ん、おはようございま〜す♪");
が出力される。

4 行目
student();
これがメソッドです:smile:
もうちょい詳しく言うとメソッドの呼び出しです。
student がメソッド名となります。
（）は後ほど説明しますのでスルーしてください:smile:
メソッド名（）　とすることでメソッドを呼び出すことができ、同じメソッド名を呼び出すことができます。
今回で言えば 7 行目の
public static void student() {
を呼び出します:smile:

8 行目
System.out.println("生徒：おはようございます");
が出力される。
今までであれば処理はここで終了ですが、メソッドの場合は main メソッドまで戻ります。
つまり次の処理は 5 行目になります。

5 行目
System.out.println("先生：今日も１日お勉強がんばりましょう♪");
が出力される。

```コンソール.
先生：みなさ〜ん、おはようございま〜す♪
生徒：おはようございます
先生：今日も１日お勉強がんばりましょう♪
```

イメージとしては
1 行目から 3 行目まで処理をすすめます。
↓
4 行目で魔人メソッドを呼び出すための魔法を唱えます。
↓
すると呼び出された魔人メソッドは頼まれた命令を淡々とこなしてくれます（7 行目〜 9 行目）
![lamp_majin.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/532773/a81c0309-7f0e-4fe8-e759-e5766bf228e5.png)
↓
用事を終えた魔人メソッドはとっとと帰ります。
↓
魔人メソッドが途中までやってくれたので続き（５行目）から処理を再開して終わらせました。


・・・みたいなイメージ？:sweat_smile: 
メソッド名を叫んだら何やら召喚されて処理すすめて用件終わったらとっとと帰る・・・みたいな:sweat_smile: 
そんなイメージを私は持ってしまいました:sweat_smile: 

ここで少し整理しますね:smile:
~~魔人の呼び出し方法~~メソッドの呼び出し方法は下記となります。

```.
メソッド名（）
```

~~魔人の作成方法~~**メソッドの作成方法をメソッドの定義**といい定義方法は下記となります。

```.
public static void メソッド名() {
　命令文
}
```

当然ですが**定義したメソッド名と呼び出すメソッド名は一致していないと呼び出せません。**
ちなみにメソッドを定義だけして呼び出さないとどうなるでしょうか？:thinking: 

```例.java
public class Main {
  public static void main(String[] args) {
    System.out.println("先生：みなさ〜ん、おはようございま〜す♪");
    System.out.println("先生：今日も１日お勉強がんばりましょう♪");
  }
    
  public static void student() {
    System.out.println("生徒：おはようございます");
  }
}
```

```コンソール.
先生：みなさ〜ん、おはようございま〜す♪
先生：今日も１日お勉強がんばりましょう♪
```

生徒が返事してくれなくなりました:cry:
つまり呼び出さないかぎりは定義しても意味はないのです。
魔人メソッドも呼ばれないからこの状態というわけです。
↓
![lamp.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/532773/a94894ce-231e-400c-d685-9fff0e783bdc.png)


ここでメソッドで処理をわけるメリットをお伝えします:smile:

:sunny:  メソッドを使用することでプログラムが見やすくなり、全体を把握しやすくなる。
:sunny:  不具合がでたときに修正がしやすくなる。
:sunny:  メソッドは繰り返し使用することができるので、同じ処理を何度も書く必要がなくなり、コードを書く手間も省ける。

今回はメソッドを呼び出しても処理が 1 行しかないためメリットは感じられませんでしたが、コードの量が多くなればなるほど、その恩恵に預かることができるのではないのでしょうか。

# public static void main(String[] args) {　}
:sunny: Java のファイルを実行すると**必ず自動的に main メソッドが実行される。**
:sunny: main メソッドが各メソッドに指示を出し、支持された各メソッドが個々の処理を実行する

いままでなぞだったこやつ。
↓
public static void main(String[] args) {　}

なにを意味するか全然わからず、お経のように記憶してました:sweat_smile: 
どうやらこのお経のような文言を記入することでプログラムを実行するらしい。
つまり書かないと何一つプログラムが実行されないということ:sweat_smile: 

この main メソッドがリーダーとなって他のメソッドにあれやこれやと指示を出しているようです。

いままでなんやろう？と思ってたけど、だいぶ重要だったのね:sweat_smile:  

```例.java
public class Main {
    public static void student() {
        System.out.println("生徒：おはようございます");
    }
    
	public static void main(String[] args) {
        System.out.println("先生：みなさ〜ん、おはようございま〜す♪");
        student();
        System.out.println("先生：今日も１日お勉強がんばりましょう♪");
    }
}
```

main メソッドを一番に処理するならば上記のように main メソッドを一番下にしても main メソッドから読み込まれる・・・ということですよね？？:thinking: 

```コンソール.
先生：みなさ〜ん、おはようございま〜す♪
生徒：おはようございます
先生：今日も１日お勉強がんばりましょう♪
```

ちゃんと読み込まれました！:raised_hands:

# main メソッド以外からメソッドを呼び出す
```例.java
public class Main {
    public static void main(String[] args) {
        methodA();
    }
    
    public static void methodA() {
        System.out.println("メソッドA:メソッドＢさ〜ん");
        System.out.println("メソッドA:こちらメソッドＡです");
        System.out.println("メソッドA:この処理おねがいしまーす");
        methodB();
    }
    
    public static void methodB() {
        System.out.println("メソッドB:はーい、メソッドＢでーす");
        System.out.println("メソッドB:承知しましたー");
        System.out.println("メソッドB:処理まわしまーす");
    }
}
```

```コンソール.
メソッドA:メソッドＢさ〜ん
メソッドA:こちらメソッドＡです
メソッドA:この処理おねがいしまーす
メソッドB:はーい、メソッドＢでーす
メソッドB:承知しましたー
メソッドB:処理まわしまーす
```

最初の基点は main メソッドですが
他のメソッド → 他のメソッド に処理をまわすことができました:smile:

魔人メソッドＡが自分で魔人メソッドＢを呼び出して処理お願いできました:smile:

#引数(ひきすう)
:sunny: メソッドに与える追加情報のようなもの
:sunny: メソッドを呼び出すときに、一緒に引数を渡すと、メソッドの中でその値を利用することができる。

さきほどメソッドの定義と呼び出しのときに (　) があったと思います。
引数はこの (　) を使います:smile:

使い方は見てもらったほうが早いと思いますのでコード記入します。

```例.java
public class Main {
    public static void main(String[] args) {
        like("いるか");
    }
    
    public static void like(String animal) {
        System.out.println("私の好きな動物は" + animal + "です");
    }
}
```

うまく説明ができればいいのですが、どうにもうまく説明できそうにないので、魔人メソッドに登場してもらいます:sweat_smile: 

3 行目の like という魔法で魔人メソッドにご登場いただきます。
そのとき (　) の中に魔人メソッドに渡すものを書きます。
今回は いるか なので いるか を渡します。

いるかを受け取った魔人メソッドは 5 行目を確認します。
5 行目には

like(String animal)

と書かれていました。
魔人メソッドは (　) の中身を見て、String と書かれていることを発見します。
ここでこの いるか が文字だという認識をします。
そしてコードに animal という記載があれば、いるかをぶちこむのだな。と理解します。

6 行目に animal を見つけました:raised_hands:
そぉ〜れ、ぶちこめ〜:fist:

```コンソール.
私の好きな動物はいるかです
```

となります:smile:

メソッドやら引数やら変数やらごっちゃになりそうでややこしいなぁと思います。
文字だけで考えると私は理解が薄いので、擬人化したり、ちょっとストーリーをつけて面白く考えたりすると印象に残りやすいので、理解が深まりやすいです:smile:

1.like("いるか");　← 魔人を呼んで持ち物だけもたせる。
2.like(String animal) ← 魔人が持ち物を確認してデータ型(String)を確認して、animal(変数) にぶちこみ待ち
3.私の好きな動物は" + animal + "です ← キターーー！ぶちこめー！

みたいな:sweat_smile: 

ちなみにさっき

public static void student() {
と
student();

で、引数が何もかかれていなかったと思います。
もし**何も引き渡す情報がなかったとしても (　) は必要なので
必ず記入してください。**

引数のときの呼び出しと定義の方法を記載します:smile:

```引数呼び出し.
メソッド名（引数）
```

```メソッドの定義（引数）.
public static void メソッド名(型 変数) {
　命令文
}
```

# 複数の引数を渡す
:sunny: ,(カンマ)で区切るだけ

```例.java
public class Main {
    public static void main(String[] args) {
        myself("みき", 5);
    }
    
    public static void myself(String name, int birth) {
        System.out.println("私の名前は" + name + " " + birth + "月生まれです");
    }
}
```

3 行目の myself メソッドに引数として みき と 5 という情報をもたせます。
5 行目で みき は文字（String）で name に代入するということを確認。
そして 5 は整数(int)で birth に代入するということを確認。
6 行目に name と birth があったので、それぞれ代入。

```コンソール.
私の名前はみき 5月生まれです
```

情報を複数もたせたいときは　　,　　で区切るだけなので、とても簡単:smile:
でも注意事項もひとつ:point_up:

myself("みき", 5);
public static void myself(int birth, String name)

はＮＧです:no_good:
みき（文字）, 5(整数)　の順番で渡しているのに
受け取り側が　int(整数), String(文字) の順番だと合致しないのでコンパイルエラーになってしまうのです。

ちなみに**メソッドに渡す引数は実引数と呼び**("みき", 5 のこと)
**受け取り側を仮引数といいます**(String name, int birth のこと)

# 戻り値
:sunny: 呼び出されたメソッドから呼び出しもとのメソッドへ値を返す。

```例.java
public class Main {
    public static void main(String[] args) {
        int answer = number(10, 20);
        System.out.println("答えは" + answer);
    }
    
    public static int number(int x, int y) {
        int sum = x + y;
        return sum;
    }
}
```

3 行目
int answer = number(10, 20);
まずメソッド number を呼び出します。
メソッド number に 10 と 20 を引き渡します。

6 行目
public static int number(int x, int y)
の 3 つめの int 。
いつもだったら void になっていたかと思います。
これ、戻り値が関係しています:smile:
ここの説明はちょっと置いといて、さきに進みますね:smile:

7 行目
int sum = x + y;
6 行目で number(int x, int y) で 10 と 20 を引き渡されています。
つまり
x = 10
y = 20
になるので 10 + 20 の答え 30 が変数 sum に代入されます。

8 行目
return sum;
return 30 ・・・ つまり 30 を main メソッドの number(10, 20); へ返します。

3 行目
int answer = number(10, 20);
number(10, 20); に 30 が代入されて戻ってきました。
つまり
int answer = 30
answer に 30 が代入されます。

4 行目
答えは30 と表示される。

```コンソール.
答えは30
```

さきほどの 6 行目の説明をしますね
public static int の int 。
これは戻り値の型を表しています。
この戻り値というのは 8 行目の return sum の sum のことです。
sum には 30 が代入されています。
つまり整数です。
整数のデータ型は int 。
だから public static int となるのです:smile:

ついでにいままで散々使用してきた void 。
この **void というのは戻り値なし**を表します。
戻り値なしの場合は ・・・ void
戻り値ありの場合は ・・・ 戻り値の型
ということになります:smile:

```メソッドの呼び出し、戻り値受け取り（戻り値）.
型 変数名 = メソッド名（引数リスト）;
```

```メソッドの定義（戻り値）.
public static 戻り値の型 メソッド名(引数リスト) {
　命令文
return 戻り値
}
```

return をつかうときに注意点がひとつあります。
return は値を戻すだけでなく**メソッドの終了も行います。**
return のあとにコードを書いても実行されません。
コンパイルエラーとなります。

# 戻り値をそのまま使用
さきほどは 変数 を使用して戻り値を返していました。
しかしそのまま使用することも可能です:smile:

```例.java
public class Main {
    public static void main(String[] args) {
        System.out.println("答えは" + sum(10, 20));
    }
    
    public static int sum(int x, int y) {
        int answer = x + y;
        return answer;
    }
}
```

```コンソール.
答えは30
```

# オーバーロード
:sunny: 同じ名前のメソッドを定義する。

基本的にはメソッドに同じ名前をつけることはできないのですが、型や引数の個数が違えば複数定義できてしまいます:smile:

```例.java
public class Main {
    public static void main(String[] args) {
        fruit("りんご");
        fruit("りんご", "みかん");
    }
    
    public static void fruit(String name) {
        System.out.println("これは" + name + "です");
    }
    
    public static void fruit(String name1, String name2) {
        System.out.println("これは" + name1 + "と" + name2 + "です");
    }
}
```

```コンソール.
これはりんごです
これはりんごとみかんです
```

ちゃんと認識されました:smile:
同じメソッド名の fruits ですが
引数の個数が違うためパソコンくん（JVM）が、名前一緒だけど引数の数が違うから別物なんだなと認識してくれるわけです:smile:

# 引数に配列を使う
```例.java
public class Main {
	public static void main(String[] args) {
		String[] fruits = {"りんご", "みかん", "いちご"};
		food(fruits);
	}

	public static void food (String[] fruits) {
		for (String element : fruits) {
			System.out.println(element);
		}
	}
}
```

3 行目で配列 fruits をつくります。
4 行目で food メソッドを呼び出します。
7 行目の for 文により配列をまわして配列の中身をすべて出力する。

```コンソール.
りんご
みかん
いちご
```

となります:smile:
注意事項としては
public static void food (String[] fruits)
の String のあとに **[] を忘れないようにする**ことかな:smile: