Kotlin文法の基本文法について（1）

https://zhuanlan.zhihu.com/p/36079284 

Kotlinの基本的な文法を紹介するには、まずKotlin全体のプログラミングスタイルを体験します。

1.パッケージステートメント

Kotlinでのパッケージの定義はJavaとは少し異なります。Kotlinでは、ディレクトリとパッケージの構造が一致している必要はありません。Kotlinのソースコードはディスク上のどこにあってもかまいません。

 

• 1.パッケージステートメント

ソースファイルは通常、パッケージ宣言の最初のJavaと同じです。

package com.mikyou.hellokotlin

/**
 * Created by mikyou on 2018/4/1.
 */
fun main(args: Array<String>) {
    println("Hello Kotlin")
}

 

• 2.パッケージのデフォルトのインポート

デフォルトで各Kotlinファイルにインポートされる複数のパッケージがあります。

第二に、関数の定義

 

• 1.関数定義はキーワード「fun」を使用し、関数パラメーターの形式は「parameter：type」、関数の戻り値タイプ「fun（...）：Int」です。

fun sum(a: Int, b: Int, c: Int): Int {
    return a + b + c
}

 

• 2.式は関数本体であり、戻り値の型は省略できます。Kotlinの型推論関数を使用して、関数の戻り値の型を推論できます。

fun sum(a: Int, b: Int, c: Int) = a + b + c

 

• 3.戻り値のない関数（Javaのvoid戻り値と同様）

fun printSum(a: Int, b: Int, c: Int): Unit {
    println(a + b + c)
}

またはユニットタイプを省略します

fun printSum(a: Int, b: Int, c: Int) {
    println("sum = ${a + b + c}")
}

 

• 4.可変長パラメーター関数は、「vararg」キーワードを使用して、Javaと同様にpublic void setData（Object ... objects）を識別できます。

fun vars(vararg args: Int) {
    for (arg in args) {
        print(arg)
    }
}

 

• 5.ラムダ（無名関数）

val sumLambda: (Int, Int, Int) -> Int = { a, b, c -> a + b + c }

テスト

println("sum = ${sumLambda(1, 6, 7)}")

3つ、定数と変数

定数や変数に初期化値を設定することはできませんが、コンパイラは参照前に初期化する必要があります。コンパイラは自動型判定をサポートしています。つまり、宣言時に型を指定できず、コンパイラが判定します。宣言時に初期化されていない場合は、変数の型を指定する必要があります

 

• 1.変数変数の定義：varキーワード

var <変数名>：<変数タイプ> = <初期値>

var sum: Int = 3
sum = 8

//由于编译支持类型推导可以省略Int类型
var sum = 3
sum = 8

 

• 2.不変変数の定義：Javaの最終型と同様に2回割り当てることのできないvalキーワード

val <定数名>：<定数タイプ> = <初期値>

val sum: Int //没有赋值初始化之前必须指定类型
sum = 5

`` `kotlin
fun sum（a：Int、b：Int、c：Int）：Int { return a + b + c }

<h3 id = "4">四、注释</h3>

> Kotlin 支持单行和多行注释，和java中类似。


<h3 id = "5">五、字符串模板</h3>

 * 1、模板中的简单名称


```kotlin
fun main(args: Array<String>) {
    var a = 1
    var s1 = "a is $a"
}

 

• 2.テンプレート内の任意の式

fun main(args: Array<String>) {
    var a = 1
    a = 2
    val s2 = "${s1.replace("is", "was")}, but now is $a"
}

6、条件式を使用する

 

• if式を使用してJavaの三項演算子を置き換えます

fun maxOf(a: Int, b: Int): Int {
    if (a > b) {
        return a
    } else {
        return b
    }
}

fun main(args: Array<String>) {
    println(maxOf(1, 5))
}

Kotlinのif式には戻り値があるため、次の形式に簡略化できます。

fun maxOf(a: Int, b: Int) = if (a > b) a else b

fun main(args: Array<String>) {
    println(maxOf(1, 5))
}

7つのNULLチェックメカニズム

ステートメントのKotlin航空安全設計パラメーターは空である可能性があります。空の判定プロセスで使用する場合 、フィールドプラス!! Javaのように空の例外をスローし、 追加後に別の フィールドを追加しますか？処理の戻り値はnullまたは協力？：短い判断処理

//类型后面加?表示可为空
var age: String? = "23"
//字段后面加"!!"抛出空指针异常
val ages = age!!.toInt()
//字段后面加”？“不做处理返回 null
val ages1 = age?.toInt()
//使用”?:“ 表示age为空返回-1
val ages2 = age?.toInt() ?: -1

 

• 1.参照にnull値がある可能性がある場合、対応する型宣言は、nullになる可能性があることを示すために、型の後に「？」として明確にマークする必要があります。
  strの文字列の内容が整数でない場合は、nullを返します。

fun main(args: Array<String>) {
    if (args.size < 2) {
        println("Two Integers Expected")
        return
    }
    val x = parseInt(args[0])
    val y = parseInt(args[1])

    //println(x + y) 由于标识了可能为null,直接使用x + y在编译器看来是非法，需要去做非空判断
    if (x != null && y != null) {
        println(x + y)
    }
}

fun parseInt(s: String): Int? {//表示当前函数返回值可能为null,就必须在类型后面标识"?"
    return s.toInt()
}

8、型検出と自動型変換

is演算子を使用して、式が特定のタイプのインスタンスであるかどうかを確認できます（Javaのinstanceofキーワードと同様）。

fun getStringLength(obj: Any): Int? {
    if (obj is String) {
        // 做过类型判断以后，obj会被系统自动转换为String类型
        return obj.length
    }

    //在这里还有一种方法，与Java中instanceof不同，使用!is
    // if (obj !is String){
    //   // XXX
    // }

    // 这里的obj仍然是Any类型的引用
    return null
}

または

fun getStringLength(obj: Any): Int? {
  if (obj !is String)
    return null
  // 在这个分支中, `obj` 的类型会被自动转换为 `String`
  return obj.length
}

こんな感じでも

fun getStringLength(obj: Any): Int? {
  // 在 `&&` 运算符的右侧, `obj` 的类型会被自动转换为 `String`
  if (obj is String && obj.length > 0)
    return obj.length
  return null
}

ナイン、インターバル

in演算子を使用して、数値が指定された範囲内にあるかどうかを検出します。範囲式には、「..」rangeTo関数の演算子形式があり、！を組み合わせて使用​​できます。間隔は、比較できるすべての型をサポートできます。ネイティブ整数型の場合、内部で最適化された実装があります。

 

• 1.数値が指定された間隔内にあるかどうかを検出します

val x = 10
val y = 9
if (x in 1..y + 1) {//表示x是否在1~y+1范围内。
    println("fits in range")
}

 

• 2.番号が指定された間隔の外にあるかどうかを検出します

val list = listOf("a", "b", "c")
if (-1 !in 0..list.lastIndex) {
    println("-1 is out of range")
}

if (list.size !in list.indices) {
    println("list size is out of valid list indices range too")
}

 

• 3.間隔の反復

for(x in 1..10){//相当于 x >= 1 && x <= 10
    println(x)
}

または

fun printList(num: Int) {
    for (i in 1..num) {//相当于 i >= 1 && i <= num
        print(i)
    }
}

終了要素を除外するには、until関数を使用します

for (i in 1 until 10) {// i in [1, 10) 排除了 10,相当于 i >= 1 && i < 10
    println(i)
}

 

• 4.シーケンスの反復

for(x in 1..100 step 2){//递增数列迭代，每次间隔步长是2；1，3，5，7...
    println(x)
}

for(x in 9 downTo 0 step 3){//递减数列迭代，每次间隔步长是3；9，6，3，0
    println(x)
}

10.コレクションを使用する

 

• 1.コレクションを繰り返し処理します

fun main(args: Array<String>) {
    val items = list.of("java", "kotlin", "python")
    for (item in items) {
        println(item)
    }
}

 

• 2. in演算子を使用して、セットにインスタンスが含まれているかどうかを判別します

when {
    "java" in items -> println("is good lang")
    "kotlin" in items -> println("is good good lang")
    else -> println("python is best lang")
}

 

• 3.ラムダ式を使用してコレクションをフィルタリングおよびマップします

fun main(args: Array<String>) {
    val langs = listOf("C", "C++", "Java", "Python", "JavaScript")

    langs.filter { it.startsWith("C") }
            .sortedBy { it }
            .map { it.toUpperCase() }
            .forEach { println(it) }
}

11.ループを使用する

Kotlinでループする方法は2つあります。for、while、forループをトラバースするために「in」を使用する方法と、2つのトラバーサル方法があります。

 

• 1.Forループ

val items = listOf("java", "kotlin", "android")
for (item in items) {//for遍历集合
    println("lang $item")
}

for (index in items.indices) {//类似于java中的数组的length-index的遍历
    println("The $index index is ${items[index]}")
}

 

• 2.whileループ

val items = listOf("java", "kotlin", "android")
var index = 0
while (index < items.size) {//while 循环的遍历方式
    println("The $index lang is ${items[index++]}")
}

12、条件を使用する場合、

if in kotlinの使用はjavaに似ていますが、in kotinが値を持つ式であり、javaがステートメントである場合、kotlinのif式を使用して、kotlinのjavaの3項演算子を置き換えることができます。スイッチに似ているとき

fun main(args: Array<String>) {
    println(descript("hello"))
}

fun descript(obj: Any): String = when (obj) {
    1 -> "one"
    "hello" -> "hello word"
    is Long -> "long type"
    !is String -> "is not String"
    else -> {
        "unknown type"
    }
}

13、クラスとインスタンスを作成します

fun main(args: Array<String>) {
    val rectangle = Rectangle(100.0, 200.0)
    val triangle = Triangle(100.0, 100.0, 100.0)
    println("rectangle is ${rectangle.isSquare}, and perimeter is ${rectangle.perimeter}, and area is ${rectangle.calculateArea()}")
    println("triangle  perimeter is ${triangle.perimeter}, and area is ${triangle.calculateArea()}")
}

abstract class Shape(val sides: List<Double>) {
    val perimeter: Double get() = sides.sum()
    abstract fun calculateArea(): Double
}

interface RectangleProperity {
    val isSquare: Boolean
}

class Rectangle(var height: Double, var length: Double)
    : Shape(listOf(height, length, height, length)), RectangleProperity {
    override fun calculateArea(): Double = height * length
    override val isSquare: Boolean get() = height == length
}

class Triangle(var sideA: Double, var sideB: Double, var sideC: Double)
    : Shape(listOf(sideA, sideB, sideC)) {
    override fun calculateArea(): Double = sideA * sideB * sideC
}

この時点で、Kotlinエントリの基本的な文法は終了です。次の記事では、Kotlin関連のコンテンツについて詳しく説明します。