Kotlinの構文を覚えるためにざっくり記事にまとめてみた

var a = 0;
val b = 0;

a = 10;
b = 10; // エラー

val int: Int = 10
val long: Long = 1000000000L
val short: Short = 100
val byte: Byte = 50
val float: Float = 10.5f
val double: Double = 10.123456789
val char: Char = 'A'
val boolean: Boolean = true
val string: String = "S.A.G.A佐賀!"

var a = 0;
var b: Double
var c // エラー

val a: Float = 10.0 // エラー
val b: Double = 10 // エラー

val a: Float = 10.0f
val b: Double = 10.0

var a = 10
var b = a.toLong()

val msg1 = "S.A.G.A\n佐賀!"
val msg2 = """S.A.G.A
              佐賀!"""

println(msg1)
println(msg2)

val msg1 = "S.A.G.A\n佐賀!"
val msg2 = """S.A.G.A
             |佐賀!""".trimMargin();
val msg3 = """
          S.A.G.A
          佐賀!
""".trimIndent();

// 実行結果は同じ
println(msg1)
println(msg2)
println(msg3)

val address = "佐賀"
val msg = "S.A.G.A${address}!"

println(msg) // S.A.G.A佐賀!

val a = 1_000
val b = 1000

val a = 1000000000L
val b = 1000000000l // エラー

val c = 10.5f
val d = 10.5F

val a = arrayOf(1, 2, "さん", null)

val a: IntArray = intArrayOf(1, 2, 3)
val b: Array<Int> = arrayOf(1, 2, 3)

val list: List<String> = listOf("A", "B", "C") // [A, B, C]
val set: Set<String> = setOf("A", "B", "C", "B", "C") // [A, B, C]
val map: Map<String, Any> = mapOf("name" to "田中", "age" to 32) // {name=田中, age=32}

val list: MutableList<String> = mutableListOf("A", "B", "C")
list[0] = "a"

println(list) // [a, B, C]

val a: String? = "佐賀"
println(a?.length) // 2

val b: String? = null
println(b?.length) // null

val a: String? = null
println(a?.length ?: 0) // 0

val a: String? = "佐賀"
println(a!!.length) // 2

val a = "佐賀"
if (a is String) println(a) // 佐賀

val a = 5
val b: IntRange = 1..10

println(a in b) // true
println(a !in b) // false

fun main() {
  val a = 10
  val msg = if (a > 5) {
    "5よりも大きい"
  } else {
    "5よりも小さい"
  }

  println(msg) // 5よりも大きい
}

fun main() {
  val a = 10
  val msg = if (a > 5) {
    "5よりも大きい"
  }

  println(msg) // エラー
}

fun main() {
  val a = 10
  val msg = if (a > 5) "5よりも大きい" else "5よりも小さい"

  println(msg)
}

fun main() {
  when (1) {
    1 -> println("1です")
    2 -> println("2です")

    else -> println("どちらでもない")
  }
}

fun main() {
  val a = 3

  when {
    a <= 5 -> println("5以下")

    else -> println("5以上")
  }
}

fun main() {
  val array = arrayOf(1, 2, 3)
  for (arr in array) println(arr)

  val map = mapOf("name" to "田中", "age" to 32)
  for ((key, value) in map) println("${key}:${value}")
}

fun main() {
  val array = arrayOf(1, 2, 3)
  for ((index, value) in array.withIndex()) println("${index}:${value}")
}

fun main() {
  for (i in 1..5) println(i) // 1 2 3 4 5
}

fun main() {
  for (i in 1 until 5) println(i) // 1 2 3 4
}

fun main() {
  for (i in 5 downTo 1) println(i) // 5 4 3 2 1
}

fun main() {
  for (i in 1..5 step 2) println(i) // 1 3 5
}

fun main() {
  for (i in 1..10) {
    if (i % 3 === 0) continue
    println(i)
    if (i == 8) break
  } // 1 2 4 5 7 8
}

fun main() {
  outer@ for (i in 1..3) {
    for (j in 1..3) {
      if (i * j > 5) break@outer
      println("${i * j}")
    }
    println(i)
  } // 1 2 3 1 2 4
}

fun main() {
  var a = 1;
  while (a < 2) {
    println(a)
    a++
  }
}

fun main() {
  var a = 1;

  do {
    println(a)
    a++
  } while (a < 2)
}

fun main() {
  fun sum (num1: Int, num2: Int): Int {
    return num1 + num2
  }

  println(sum(2, 5))
}

fun main() {
  fun sum (num1: Int, num2: Int) = num1 + num2

  println(sum(2, 5))
}

fun main() {
  fun sum (num1: Int = 1, num2: Int = 1) = num1 + num2

  println(sum(2, 5)) // 7
  println(sum()) // 2
}

fun sum (num1: Int = 1, num2: Int = 1) = num1 + num2

fun main() {
  println(sum(num2 = 2)) // 3
  println(sum(num2 = 2, 3)) // エラー
}

fun sum (num1: Int = 1, num2: Int) = num1 + num2

fun main() {
  println(sum(2)) // エラー
}

fun sum (num1: Int, num2: Int = 2) = num1 + num2

fun main() {
  println(sum(2)) // 4
}

fun sum (vararg numArr: Int): Int {
  var result = 0
  for (num in numArr) result += num

  return result
}

fun main() {
  val arr = intArrayOf(1, 2, 3, 4)

  println(sum(*arr)) // 10

  // 可変長引数の一部として配列を渡すことも可能
  println(sum(5, *arr, 2)) // 17
}

fun sumAndProduct (vararg numArr: Int): Pair<Int, Int> {
  var result1 = 0
  var result2 = 1
  for (num in numArr) {
    result1 += num
    result2 *= num
  }

  return Pair(result1, result2)
}

fun main() {
  val arr = intArrayOf(1, 2, 3, 4)
  // 分解宣言
  val (sum, product) = sumAndProduct(*arr)

  println(sum) // 10
  println(product) // 24
}

fun <T> invokeOnEach(list: Array<T>, action: (T) -> Unit) {
  for (element in list) action(element)
}

fun main () {
  val names = arrayOf("松田", "田中", "江頭")

  fun greet(name: String) {
    println("Hello, ${name}!")
    // Hello, 松田!
    // Hello, 田中!
    // Hello, 江頭!  
  }

  invokeOnEach(names, ::greet)
}

{ 引数 -> 関数 }

fun <T> invokeOnEach(list: Array<T>, action: (T) -> Unit) {
  for (element in list) action(element)
}

fun main() {
  val names = arrayOf("松田", "田中", "江頭")

  // 高階関数の最後の引数がラムダ式なら、関数の外に出すことができる
  invokeOnEach(names) { name -> println("Hello, ${name}!") }
}

fun <T> invokeOnEach(list: Array<T>, action: (T) -> Unit) {
  for (element in list) action(element)
}

fun main() {
  val names = arrayOf("松田", "田中", "江頭")

  // ラムダ式の引数が単一の場合、その引数を暗黙的な引数itで受け取ることができる
  invokeOnEach(names) { println("Hello, ${it}!") }
}

fun main() {
  val names = arrayOf("松田", "田中", "江頭")
  names.forEach {
    if (it === "田中") return
    println("${it}")
  }
  // 下記は実行されない
  println("終了")
} // 松田

fun main() {
  val names = arrayOf("松田", "田中", "江頭")
  names.forEach loop@ {
    if (it === "田中") return@loop
    println("${it}")
  }

  println("終了")
} // 松田 江頭 終了

fun main() {
  val names = arrayOf("松田", "田中", "江頭")
  names.forEach {
    if (it === "田中") return@forEach
    println("${it}")
  }

  println("終了")
} // 松田 江頭 終了

fun main() {
  class User {
    val name = "田中"
    val age = 30

    fun intro() {
      println("私は${name}です。年齢は${age}歳です。")
    }
  }
  
  val user = User()
  user.intro() // 私は田中です。年齢は30歳です。
}

fun main() {
  class User {
    val name = "田中"
    val age = 30

    internal fun intro() {
      println("私は${name}です。年齢は${age}歳です。")
    }
  }
  
  val user = User()
  user.intro() // 私は田中です。年齢は30歳です。
}

fun main() {
  class User {
    val name = "田中"
    var age = 30
      set(value) {
        if (value < 18) {
          println("パチンコは18歳から")
        } else {
          field = value
        }
      }

    internal fun intro() {
      println("私は${name}です。年齢は${age}歳です。")
    }
  }
  
  val user = User()
  user.age = 17 // パチンコは18歳から
}

fun main() {
  // class クラス名 constructor(引数: 型) {}
  class User constructor(name: String, age: Int) {
    var name: String
    var age: Int

    // 初期化処理
    init {
      // 引数とプロパティ名が同じ場合はthisで参照
      this.name = name
      this.age = age
    }

    fun intro() {
      println("私は${name}です。年齢は${age}歳です。")
    }
  }
  
  val user = User("田中", 30)
  user.intro() // 私は田中です。年齢は30歳です。
}

fun main() {
  class User (internal var name: String, var age: Int) {
    fun intro() {
      println("私は${name}です。年齢は${age}歳です。")
    }
  }
  
  val user = User("田中", 30)
  user.intro() // 私は田中です。年齢は30歳です。
}

fun main() {
  class User (var name: String, var age: Int) {
    // 引数がひとつだけ渡されたとき
    constructor(name: String):this(name, 26)
    // 引数が渡されなかったとき
    constructor()this("松田")

    fun intro() {
      println("私は${name}です。年齢は${age}歳です。")
    }
  }
  
  val user1 = User("田中", 30)
  val user2 = User("田中")
  val user3 = User()
  user1.intro() // 私は田中です。年齢は30歳です。
  user2.intro() // 私は田中です。年齢は26歳です。
  user3.intro() // 私は松田です。年齢は26歳です。
}

fun main() {
  class User (var name: String = "松田", var age: Int = 26) {
    fun intro() {
      println("私は${name}です。年齢は${age}歳です。")
    }
  }
  
  val user1 = User("田中", 30)
  val user2 = User("田中")
  val user3 = User()
  user1.intro() // 私は田中です。年齢は30歳です。
  user2.intro() // 私は田中です。年齢は26歳です。
  user3.intro() // 私は松田です。年齢は26歳です。
}

fun main() {
  // openを付与することで継承可能
  open class UserName (var name: String) {
    // メソッドも同様でopenを付与することでオーバーライド可能
    open fun intro() {
      println("ユーザー名：${name}")
    }
  }

  // UserNameクラスを継承
  class UserProfile(name: String, var age: Int): UserName(name) {
    // オーバーライドするにはoverrideをつける
    override fun intro() {
      println("私は${name}です。年齢は${age}歳です。")
      // 継承元のintro()を実行
      super.intro()
    }
  }
  
  val userName = UserName("田中") 
  val userProfile = UserProfile("田中", 30) 

  userName.intro() // ユーザー名：田中
  userProfile.intro() // 私は田中です。年齢は30歳です。　ユーザー名：田中
}

fun main() {
  // abstractを付与
  abstract class User (var name: String) {
    abstract fun intro()
  }

  class UserName(name: String): User(name) {
    override fun intro() {
      println("ユーザー名：${name}")
    }
  }
  
  val userName = UserName("田中")
  userName.intro() // ユーザー名：田中
}

fun main() {
  abstract class S {
    abstract fun method1()
    abstract fun method2()
    abstract fun method3()
  }

  class A: S() {
    override fun method1() {}
    override fun method2() {}
    override fun method3() {} // 不要
  }
  
  class B: S() {
    override fun method1() {} // 不要
    override fun method2() {}
    override fun method3() {}
  }
}

interface C1 {
  fun method1()
}

interface C2 {
  fun method2()
}

interface C3 {
  fun method3()
}

fun main() {
  class A: C1, C2 {
    override fun method1() {}
    override fun method2() {}
  }
  
  class B: C2, C3 {
    override fun method2() {}
    override fun method3() {}
  }
}

interface MyInterface1 {
  fun method() = println("method1")
}

interface MyInterface2 {
  fun method() = println("method2")
}


fun main() {
  class MyClass: MyInterface1, MyInterface2 {
    override fun method() {
      super<MyInterface1>.method()
      super<MyInterface2>.method()
    }
  }
}

interface MyInterface {
  var str: String
  fun method() = println("${str}")
}

fun main() {
  class MyClass: MyInterface {
    override var str = "ABC"
  }

  val myClass = MyClass()
  myClass.method()
}

fun main() {
  open class Animal {}
  class Dog: Animal() {
    fun sound() = println("ワンッ")
  }
  
  val animal: Animal = Dog() // アップキャスト
  if (animal is Dog) { // ダウンキャスト
    // 以降はDog型として扱われる（スマートキャスト）
    animal.sound()
  }
}

class Outer {
  private class Nest {
    fun print() = println("ネスト")
  }
  
  fun run() {
    val nest = Nest()
    nest.print()
  }
}

fun main() {
  val outer = Outer()
  outer.run() // ネスト
}

class Outer(val name: String = "アウター") {
  inner class Nest(val name: String = "ネスト") {
    fun print() {
      println("${name}")
      // ラベル構文を使用することでOuterクラスのnameへアクセス
      println("${this@Outer.name}")
    }
  }
  
  fun run() {
    val nest = Nest()
    nest.print()
  }
}

fun main() {
  val outer = Outer()
  outer.run() // ネスト　アウター
}

fun main() {
  data class User(var name: String, var age: Int)
}

fun main() {
   data class User(var name: String, var age: Int)
   
   val user1 = User("田中", 30)
   val user2 = User("田中", 30)
   
   // equalsメソッド（同値性のチェック）
   println(user1 == user2) // true
   
   // toStringメソッド（文字列化）
   println(user1) // User(name=田中, age=30)
   
   // comnponentNメソッド（分割代入）
   val (name, age) = user1
   println(name) // 田中
   
   // copyメソッド（複製）
   val user3 = user1.copy("江頭") // 特定のプロパティの値を変更し複製することも可能
   println(user3) // User(name=江頭, age=30) 
}

object { クラス本体 }

// クラスの継承やインターフェイスの実装がある場合
object: 親クラスorインターフェイス { クラス本体 }

btn.setOnClickListener(object: View.OnClickListener {
  override fun onClick(view: View) {
    ボタンがクリックされた時の処理
  }
})

btn.setOnClickListener({ view: View -> ボタンがクリックされた時の処理 })

btn.setOnClickListener { ボタンがクリックされた時の処理 }

object User {
  var name = "田中"
  var age = 29
  
  fun intro() {
    println(" 私は${name}です。年齢は${age}歳です。")
  }
}

fun main() {
  User.age = 30
  User.intro() // 私は田中です。年齢は30歳です。
}

class User {
  object user1 {
    val name = "松田"
  }
  
  companion object {
    val name = "江頭"
  }
}

fun main() {
  val user1 = User.user1.name
  val user2 = User.name
  println(user1)
  println(user2)
}

const val MAX_COUNT = 12

class Sample<T> (var value: T) {
  fun getProp(): T {
    return value
  }
}

fun main() {
  val sample1 = Sample<String>("ABC")
  val sample2 = Sample<Int>(10)
  println(sample1.getProp())
  println(sample2.getProp())
}

open class Parent() {}

class Child(): Parent() {
  val name = "田中"
}

// Parentまたはその派生クラスのみ
class Sample<T: Parent> (var value: T) {
  fun getProp(): T {
    return value
  }
}

fun main() {
  val sample1 = Sample<Child>(Child())
  println(sample1.getProp().name)
  val sample2 = Sample<Int>(10) // エラー
}

fun <T> returnSize(arr: Array<T>): T = arr[arr.size - 1]

fun main() {
  val arr1 = arrayOf(1, 2, 3)
  val arr2 = arrayOf('A', 'B', 'C')

  println(returnArr<Int>(arr1))  // Int型
  println(returnArr(arr2))       // Char型
}

// fun 拡張するクラス名.メソッド名(引数:型): 戻り値の型 { 処理 }

fun String.addName(name: String): String {
  return this + "と${name}"
}

fun main() {
  val name = "江頭"
  println(name.addName("松田")) // 江頭と松田
}