円とドル換算プログラムを通して静的メソッドを理解する

#対象読者
- 最近オブジェクト指向プログラミングに手をつけ始めた人（つまり初心者向け）
- 静的メソッドとはなんぞや？と思っている人

#はじめに
表題の通り円とドル換算プログラムを通して静的メソッドを理解して行きます．

そこで今回用いる言語はC#を使っていきます．

（JavaとかC++，Pythonとかじゃなくてごめんなさい．．）

C#を通して静的メソッドが理解できる記事にできたらなと思います．

#円とドル換算プログラムを書いていこう！
円とドルを換算する時はだいたい1ドル100円くらいでしょと思うので

適当に100円に換算するプログラムを書いていってもいいが，

流石にそれは汎用性がないので現時点での1ドルがいくらなのかを用いて

計算するプログラムを書いていく

**1ドル　→　107.77円（2019年7月18日現在）** 

これを用いて書いていく

##メソッドとか何も考えずにプログラム
とりあえずメソッドとかそんなめんどくさいことを考えずに

シンプルに円とドルを換算表を作成する方法を書いていく

```
1ドルは107.77円です．
2ドルは215.54円です．
3ドルは323.31円です．
4ドルは431.08円です．
5ドルは538.85円です．
6ドルは646.62円です．
7ドルは754.39円です．
8ドルは862.16円です．
9ドルは969.93円です．
10ドルは1077.7円です
```

の結果を出力する際に考えられるプログラミングとしては

至極シンプルにコードを書いていくとこんな感じになる．


```c#:Program.cs
using System;

namespace YenDollarConvert
{
    class MainClass
    {
        public static void Main(string[] args){
            for (int dol = 1; dol <= 10; dol++){
                double yen = dol * 107.77;
                Console.WriteLine("{0}ドルは{1}円です．", dol, yen);
            }
        }
    }
}
```

このプログラムでドルを円に換算するという点に関しての目的は達成できた．

ただ，これ以上改良する必要のないプログラムならこれで十分である．

しかし，今は小さなプログラムではあるが，今後大きなプログラムに発展させていくと

考えるとこんなプログラムを残されたらたまったもんじゃない．

##換算計算をメソッドとして独立させる
ここでドルを円に換算させるプログラムがMainのメソッドに入ってしまっています．

そこでこの問題を解決させる方法の1つとして

**ドル→円換算している部分をメソッドとして独立させる**

ということです．

独立させたプログラムがこちら

```c#:Program.cs
using System;

namespace YenDollarConvert
{
    class MainClass
    {
       public static void Main(string[] args){
            for (int dol = 1; dol <= 10; dol++){
                double yen = YenToDollar(dol);
                Console.WriteLine("{0}ドルは{1}円です．", dol, yen);
            }
        }

        static double YenToDollar(int dollar){
            return dollar * 107.77;
        }
    }
}
```

とりあえずドル→円換算部分をメソッドにしました．

するとでてきました．**static**が．．．

こいつが今回の主役の静的メソッドです．

###そもそも静的とは？
静的というのはインスタンスを生成せずに，プロパティを参照したり，

メソッドを呼び出したりすることができます．

つまり，インスタンスを生成せずに利用できる物を静的と呼んでいます．

例にするとこんな感じです．

```c#:Program.cs
       public static void Main(string[] args){
            //インスタンスを生成せずにDateTimeクラスのTodayプロパティを呼び出し
            DateTime today = DateTime.Today; 
            //インスタンスを生成せずにConsoleクラスのWriteLine()メソッドを呼び出し．
            Console.WriteLine("今日は{0}月{1}日です．", today.Month, today.Day);
        }
```

こんな感じで利用するときは new する必要がなく，そのまま使うことができます．

話を戻すと， YenToDollar()は静的メソッドとして置いています．

なぜここを静的にしているのかというと，

仮にここを静的メソッドにせずにインスタンス生成が必要なメソッドだとしましょう．

するとインスタンス化したメソッドを呼び出すにはどのインスタンスなのかを指定する必要があります．

ただ，今回の場合ドル→円換算プログラムはわざわざインスタンスを生成して呼び出す必要もないですし，

わざわざインスタンスを生成してからメソッドを呼び出すのも面倒ですよね．

なので，今回YenToDollarは静的メソッドにしています．

（厳密に話すとMainメソッドが静的なのでMainメソッドから直接インスタンスメソッドを呼び出すことができないという説明が必要なのですが，今回は省略します．．）

##円→ドルの機能を追加する

このままだとドル→円といった単方向の換算しかできないので円→ドルの換算の

メソッドも追加していきましょう．

```c#:Program.cs
       public static void Main(string[] args){
            for (int dol = 1; dol <= 10; dol++){
                double yen = DollarToYen(dol);
                Console.WriteLine("{0}ドルは{1}円です．", dol, yen);
            }
            Console.WriteLine();
            for (int yen = 100; yen <= 1000; yen += 100){
                double dollar = YenToDollar(yen);
                Console.WriteLine("{0}円は{1:0.0000}ドルです", yen, dollar);
            }
        }

        static double DollarToYen(int dollar){
            return dollar * 107.77;
        }

        static double YenToDollar(int yen){
            return yen / 107.77;
        }
```

ここで円→ドル換算する時に繰り返し処理で100ずつ足していますが，

1円ずつ足してもほとんど換算している感じがないので100ずつ足しています．

出力結果はこんな感じになります．

```
1ドルは107.77円です．
2ドルは215.54円です．
3ドルは323.31円です．
4ドルは431.08円です．
5ドルは538.85円です．
6ドルは646.62円です．
7ドルは754.39円です．
8ドルは862.16円です．
9ドルは969.93円です．
10ドルは1077.7円です．

100円は0.9279ドルです
200円は1.8558ドルです
300円は2.7837ドルです
400円は3.7116ドルです
500円は4.6395ドルです
600円は5.5674ドルです
700円は6.4953ドルです
800円は7.4232ドルです
900円は8.3511ドルです
1000円は9.2790ドルです
```

#クラスとして機能に分離させる
今のままでも機能としては十分に働いてはいるのですが，

円とドルの換算プログラムが別のプログラムで必要になった時に今のままでは汎用性が低いです．

例えば今のままだと使えそうなメソッドだけを切り取って貼ってといった作業が必要です．

それではどうするかというと，ここでクラスを使います．

クラスを用いて独立させることで換算させる計算はどのプログラムでも汎用させることが可能

ということになってきます．

それでは換算するプログラムをクラスにまとめていきましょう．

```c#:YenConverter.cs
      public class YenConverter
    {
        public double DollarToYen(int dollar){
            return dollar * 107.77;
        }

        public double YenToDollar(int yen){
            return yen / 107.77;
        }
    }
```

これでとりあえず換算クラスは完成です．

ここでこのYenConverterクラスを用いることで機能をまとめることができました．

Mainプログラムでの使い方はこんな感じになる．

```c#:Program.cs
       public static void Main(string[] args)
        {
            YenConverter converter = new YenConverter();

            for (int dol = 1; dol <= 10; dol++){
                double yen = converter.DollarToYen(dol);
                Console.WriteLine("{0}ドルは{1}円です．", dol, yen);
            }
            Console.WriteLine();

            for (int yen = 100; yen <= 1000; yen += 100){
                double dollar = converter.YenToDollar(yen);
                Console.WriteLine("{0}円は{1:0.0000}ドルです", yen, dollar);
            }
        }
```

こんな感じでインスタンスを生成してYenConverterに入っているメソッドを呼び出すと言った

流れでプログラムしていきます．

ただ，このYenConverterのクラスはインスタンスされたプロパティやインスタンスされた

フィールドを利用していないので，これらのメソッドは静的にすることができます．

なのでYenConverterのメソッドを静的にすると，

```c#:YenConverter.cs
      public class YenConverter
    {
        public double DollarToYen(int dollar){
            return dollar * 107.77;
        }

        public double YenToDollar(int yen){
            return yen / 107.77;
        }
    }
```

```c#:Program.cs
       public static void Main(string[] args)
        {
            for (int dol = 1; dol <= 10; dol++){
                double yen = YenConverter.DollarToYen(dol);
                Console.WriteLine("{0}ドルは{1}円です．", dol, yen);
            }
            Console.WriteLine();

            for (int yen = 100; yen <= 1000; yen += 100){
                double dollar = YenConverter.YenToDollar(yen);
                Console.WriteLine("{0}円は{1:0.0000}ドルです", yen, dollar);
            }
        }
```

こんな感じで改変することができます．

静的メソッドにすることによって new でインスタンス化する必要もなくなり，

よりプログラムがスッキリしました．

YenConverter.csには見てわかるように静的メソッドしかありません．

ここから，YenConverterのクラスは静的クラスにすることができます．

###静的クラスとは？
静的クラスとは今までの説明で薄々勘付くとは思いますが，

インスタンスを生成しなくても使えるクラスです．

例を出すとConsoleも静的クラスです．

（Console.WriteLine()もインスタンス化しなくても出せる！）

よって変更した後のYenConverter.csはこうなります．

```c#:YenConverter.cs
      public static class YenConverter{

        public static double DollarToYen(int dollar)
        {
            return dollar * 107.77;
        }

        public static double YenToDollar(int yen)
        {
            return yen / 107.77;
        }
    }
```

#おわりに
円→ドル換算を例に静的メソッドを説明していきました．

この使い方をマスターするだけで，ドルだけじゃなくてポンドや色んな換算もクラスで処理することができます．

一応色々な通貨の換算できるクラスだけ載せておきます．

最後までみてくださりありがとうございました！

```c#:YenConverter.cs
      public static class YenConverter
    {
        private const double perDollar = 107.77; //ドル
        private const double perPound = 134.71; //英国ポンド
        private const double perYuan = 15.68; //中国通貨元
        private const double perEuro = 121.02; //ユーロ

        //ドル→円
        public static double DollarToYen(int dollar)
        {
            return dollar * perDollar;
        }

        //円→ドル
        public static double YenToDollar(int yen)
        {
            return yen / perDollar;
        }

        //ポンド→円
        public static double PoundToYen(int pound){
            return pound * perPound;
        }

        //円→ポンド
        public static double YenToPound(int yen){
            return yen / perPound;
        }

        //元→円
        public static double YuanToYen(int yuan)
        {
            return yuan * perPound;
        }

        //円→元
        public static double YenToYuan(int yen)
        {
            return yen / perPound;
        }

        //ユーロ→円
        public static double EuroToYen(int euro)
        {
            return euro * perPound;
        }

        //円→ユーロ
        public static double YenToEuro(int yen)
        {
            return yen / perPound;
        }

    }
```