🔰超入門　Kotlinの基本的な知識

今回はKotlinの基本的な超入門の内容をまとめていきます。

#プログラムの3つの基本構造
Kotlinの解説の前に、プログラムの基本構造について話します。
``1,順次進行``とは、プログラムが書かれている上から順に処理をしていくというプログラムの構造です。
``2,条件分岐``とは、特定の条件のときはAという処理、そうじゃないときはBという処理をするプログラム構造です。
``3,繰り返し``とは、決まった回数や条件を満たすまで同じ処理を繰り返すプログラム構造です。
繰り返しは、反復処理といったりもします。

#Kotlinの特徴
Kotlinは、`モダンな言語`、`コンパイラ言語`、`オブジェクト指向言語`といった特徴があります。
モダンな言語とは、現代的なプログラミング言語の構文を取り入れていて、読みやすくて書きやすいプログラミング言語のことをいいます。
コンパイラ言語とは、機械語に一括して変換してから実行するプログラミング言語のことで、処理が高速という特徴があります。
オブジェクト指向言語とは、オブジェクト指向開発という「データと処理」を1セットとしてプログラムを組み立てていく開発手法に適した言語のことです。

#関数について
まず初めに関数について説明していきます。
関数の便利なところは、
``同じコードを何度も書かなくて済む``
``同じものを他の場面で使える``
``一度定義すれば、他の人も使える``

関数には、``自分で作る関数　``と、``Kotlinが用意してくれる関数``の２種類がある。
２番目の``Kotlinが用意してくれる関数``は、あらかじめ定義をしてくれています。
自分の場合は、これからAndroidのアプリ開発を行なっていく予定なので、公式のドキュメントに使い方が書いてあります。
プログラムの始点のことを``エントリポイント``と言います。
kotlinでは、main関数から処理が始まります。

``自分で作る関数　``
自分で作る関数には下記のような決まった構文があります。
引数名を記入するメリットとしては、``処理の中で使える``、``関数に引数を入れることで、処理のできる幅が広がる``、``[オーバーライド]した際にコンパイラが判断できる``ことなどが挙げられます。
※``オーバーライド``とは、一言で言うと、メソッドの上書きのことです。
構文

```
fun 関数名(引数名: 引数型)　{
  実行する処理
  return で戻り値を返す
}
```
以下のサンプルコードでは、3つの数字の受け取るメソッドを作り、3つの数字の平均を表示させている。
returnを使うことで、計算した結果をさらに計算したり、文字列とくっつけたりすることが可能となります。

```Sample.kt
fun main() {
    val result = avg(10, 3, 5)
    println(result)
}

fun avg(i1 : Int, i2: Int,i3: Int) :Int{
    return (i1 + i2 + i3) / 3
}
```



#Kotlinのソースコードの基本記述
Kotlinでは、関数からプログラムがスタートします。
関数を作ることを**関数を定義する**といいます。
プログラミングでの関数は、処理のことです。

kotlinでは、`main関数`からプログラムが始まります。
文字を表示する関数``println()``メソッドを使用して、文字列や、数字を表示する。
文字列の場合は、「""」で囲む。数字の場合は必要なし。
実行すると、
「Good morning」
「こんにちは」
「1」
が表示されるようにする。

```Sample.kt
fun main() {
    println("Good morning")

    println("こんにちは")

    println(1)
}
```

#変数について
変数は例えるなら箱のことです。
変数があることで、文字や数字などのデータを変数に入れておくことができます。
変数にデータを入れることを``「代入」``といい、取り出すことを``「参照」``といいます。

###変数には名前をつけることができ、変数名といいます。
変数名に使える文字には、ルールがあります。
∟変数名には、アルファベット、数字、アンダースコア( _ )が使えます。
∟``予約語``は変数名にすることができません。
``予約語``とは、「return」「class」「for 」「while」など、プログラミング言語ですでに役割が決まっている単語のことをいいます。

変数を作ることを「変数を宣言する」といいます。
初めて変数にデータを入れることを「変数の初期化」といいます。

###val と val の違い
Kotlin には変数を定義するためのキーワードとして、val と var が用意されています。

val: 再代入できない参照を保持するための変数 (immutable reference)です。Java の final 変数に相当します。value の略。
var: 再代入可能な変数 (mutable reference)です。variable の略。

```Sample.kt
fun main() {
    val NUM:Int = 1
    val Num:Int = 2
    val num:String = "3です"

    println(NUM)
    println(Num)
    println(num)
}
```

#データ型
データ型とは、変数に入れるデータの種類のことです。
今回は、データ型の数値型、文字列型、ブール型、データ型の型推論について説明します。
**Kotlinでは、変数にデータを入れるときに、データ型を指定する必要があります。**
∟このような言語のことを、静的型付け言語といい、Kotlin、Java、Go、C言語などがあります。
→逆に、動的型付け言語は、データ型を指定する必要がなく、自動的にデータ型を判断してくれる言語です。
∟Ruby、Python、JavaScript、PHPなどがあります。

###数値型
数値型には、整数型と、少数型がある。
整数型のデータ型は、桁数が小さい順にByte,Short,Int,Longがあり、
少数型のデータ型は、小数点以下の桁数が小さい順にFloat,Doubleがあります。

###文字列型
文字列型のデータ型は、``Char``,``String``があります。

``Char``は、シングルクォーテーションで、文字1つの場合、
``String``は、ダブルクォーテーションで文字2つ以上の場合に使い分けをします。

###ブール型
ブール型は、Boolean型（ブーリアン型）ともいいます。
ブール型は、trueまたfalseの2つのうち、どちらか1つを持つ型です。

```Sample.kt
fun main() {
    var a: Int = 10
    var b: Int = 5
    var bool:Boolean;

    bool = (a > b);

    println(bool);
}
```
→「true」が表示される。

###型推論
Kotlinの場合、``変数を初期化するときは、変数に入れるデータの種類を指定する必要がありません。``
変数に代入しようとしているデータから、自動的に判断してくれるからです。
これを型推論と言います。

型推論付き静的型付け言語は、コンパイルをしてデータ型が決まった後は、異なるデータ型の値を代入することができません。
なぜなら、型推論付き静的型付け言語は、コンパイルしたタイミングで型を決めるからです。

変数の型を調べるのには、``javaClass.kotlin``を使用する。

```Sample.kt
fun main() {
    val var01 = 1;
    val var02 = 12345
    val var03 = 1234567890;
    val var04 = 123456789000;

    println(var01.javaClass.kotlin)
    println(var02.javaClass.kotlin)
    println(var03.javaClass.kotlin)
    println(var04.javaClass.kotlin)
}
```

####実行結果

int (Kotlin reflection is not available)
int (Kotlin reflection is not available)
int (Kotlin reflection is not available)
long (Kotlin reflection is not available)

∟int型で扱えるものはintに。扱えないものはlongに。
Kotlinが型を自動で推論し、変数を初期化してくれる。

#配列
配列とは、複数のデータを格納することができるデータ型です。
``要素``:配列の1つ1つの箱のこと
``要素数``:箱の数のこと
　``インデックス``:配列のそれぞれの要素に割り振られた情報のこと。一番左から０、１、２...
###配列の宣言
配列の書き方は、いくつかありますが、今回は``arrayListOf``関数を使用します。
下記のサンプルコードのデータを変更する場合には、``変数名[インデックス番号] = "変更したい名前"``とする。
また、Java同様に多次元配列を作ることも可能です。

```Sample.kt
fun main() {
    val name = arrayListOf("sato","suzuki","tanaka")

    println(name[0])
}
```

#条件分岐
条件分岐とは、条件に合致する場合は「処理A」、そうじゃないときは「処理B」ということができます。

###if文
構文
``if(条件式){条件がtrueだった時の処理}``
波括弧は省略することができます。
違う条件を設定する場合は、``elseif()``
条件を満たさない場合を設定　する場合は、``else``

サンプルコードでは、5以上10未満だったら「合格」、それ以外は「不合格」と表示させます。

```Sample.kt
fun main() {
    val integer = 7

    if(integer >= 5 && integer < 10) {
        println("合格")
    } else {
        println("不合格")
    }
}
```

#繰り返し
繰り返しとは、決まった回数や条件を満たしてれば、同じ処理を実行するプログラム構造です。

###for文
for文は、条件を満たしていれば、同じ処理をぐるぐる繰り返します。
そして、条件を満たさなくなったタイミングで、繰り返しがおわります。

　for文の構文
```
for (変数 in 開始する値..終了させる値){
　繰り返し中に実行する処理;
}
```

**for(変数　in 配列変数名)**
とすることで、配列の要素をひとつずつ変数に格納されていく。
Javaで言うところの、拡張for文みたいな扱いだと思います。


###break文
break文は、ある条件にあてはまったとき、繰り返し処理を終了させることができます。

###continue文
contine文は、繰り返し処理で、ある条件にあてはまったときにその処理をスキップしたい場合に使います。

###サンプル
今回は、for文で1から10まで1ずつ増やしていく繰り返しを記述します。
そして、if文を使い、3になったらスキップ、7になったらfor文がおわる記述をしましょう。
また、その動きがわかるように、カウンタ変数を表示させる。

```Sample.kt
fun main() {
    for (i in 1..10) {
        if (i == 3) {
            continue
        } else if (i == 7) {
            break
        } else {
            println(i)
        }
    }
```

→「1,2,4,5,6」が表示される。

#クラスとは　
クラスとは、「データ」と「処理」をまとめたものになります。
Kotlinでは、「データ」のことを``プロパティ``といい、「処理」のことを``メソッド``といいます。

``プロパティ``は、クラス内で定義された``変数``のことです。
プロパティは、変数と同じように、数値や文字列を代入したり、参照したりすることができます。
``プロパティと変数の違いは、クラスの外にあるかクラスの中にあるかの違いです。``
``プロパティ``は文字列を代入したり、参照したりすることができる。

``メソッド``も``関数``と同じで、いろいろな「処理」をまとめて1つにしたものです。
簡単にいうと、``メソッド``は、クラス内に定義された関数です。

####クラスの定義
クラスを作ることをクラスを定義するという。
クラス名の最初の文字は、大文字にするのが慣習になっている。

サンプルでは、
クラス名をTestとして、国語と数学の合計を計算するメソッドを定義します。

```
class Test {
  fun total(japanese: Int, math: Int) {
    println(japanese + math)
  }
}

```

###クラスを使う
クラスを使用するには、定義しただけでは使うことができません。
クラスから作られたインスタンを変数に代入してから使います。
インスタンスになって初めて使うことができます。

###インスタンス
インスタンスとは、実態という意味です。クラスという型から、実際に使える「モノ」を作ることをいいます。
サンプルでは、nameというプロパティをTestクラス内で定義をし、
main関数で、a1という変数にTestクラスのインスタンスを代入している。
そして、インスタンス化したTestクラスに定義されているtotalメソッドを呼び出して、引数に点数を入れる。
そして、Testクラスのプロパティnameを呼び出して「tanaka」を代入する。
最後にprintlnで表示させる。

```
class Test {
  var name =""
  fun total(japanese: Int, math: Int) {
    println(japanese + math)
  }
}


fun main() {
  //インスタンス化
  var a1 = Test()
  a1.total(90,60)
  a1.name = "tanaka"
 println(a1.name) 
}
```

上記のように、プロパティは、インスタンスごとに存在する。
インスタンスを定義する度に異なるプロパティを定義しなければならない。
しかし、そのプロパティをインスタンスごとに1つずつ定義していたら、口数がかかってしまいます。
それを解消するために``コンストラクタ``がある。

###コンストラクタ
KotlinにおいてJavaと違うのは、コンストラクタを区別していることです。

Kotlinには``プライマリコンストラクタ``と``セカンダリコンストラクタ``があります。
``コンストラクタとはオブジェクト生成時に自動的に呼ばれる処理です。``
その性質からクラスのメンバの初期化処理等によく使用されます。クラスに1つ以上のコンストラクタが必ず存在します。
今回は、``プライマリコンストラクタ``について見ていきます。

**コンストラクタの定義**

```
class クラス名 constructor(引数) {

}
```

「constructor」は、基本的には省略可能です。
以下のサンプルでは、manクラスを宣言しています。

```
class man(val fullname: String, val age: Int)
```

このクラスには、このクラスには波括弧なしで、丸括弧に宣言があるだけとなっています。
このような丸括弧で囲まれたコードブロックは、プライマリコンストラクタ と呼ばれます。

``プライマリコンストラクタ``は2つの役割を持ちます。
**1,コンストラクタの引数を指定する**
**2,引数で初期化されるプロパティを定義する**

コンストラクラタにより以下のようにインスタンスを生成できます

```
val man = Man("Yamada Taro",23)
```

参考
https://www.youtube.com/watch?v=UswtcJlDZ3I
https://www.kenschool.jp/blog/?p=5634