HelloKotlin

Kotlin VS Java

createTime : 2017.08.29

updateTime : 2017.09.14

author:ベテラン機長

version : 1.5.0

審査者:pighead、社会我道哥

0.What is Kotlin ?

KotlinはJVMベースの新しいプログラミング言語で、JetBrainsによって開発された.

KotlinはJavaバイトコードにコンパイルしたり、JavaScriptにコンパイルしたりすることができ、JVMのないデバイスで実行しやすい.

JetBrainsは、現在人気のあるJava IDE IntelliJのプロバイダとして、Apacheライセンスの下でKotlinプログラミング言語をオープンソースしています.

KotlinはAndroidの公式サポート開発言語として正式になった.

1.基礎文法
(1.1)パッケージおよびクラスのインポート、コメント
a.パッケージの定義:

package xx.xxx.xxxx

b.パッケージのインポート:

import xx.xxx.xxxx

c.コード注記:
c1 .行コメント:

//         

c2. 段落コメント:

/*        
            . */

(1.2)変数の定義
a.読取り専用変数:

val i:Int = 10
val i = 1   //           `Int`   

//         null   ,                   null
fun mutily(x: Int?, y: Int?): Int? {
    if (x == null) {
        println("Wrong number format in x")
        return null
    }

    if (y == null) {
        println("Wrong number format in y")
        return null
    }
    return x * y
}

b.書き込み可能変数:

var i = 1

(1.3)関数の定義

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

//               ,            
fun sum(a: Int, b: Int) = a + b
    
//               ？？？
fun printSum(a: Int, b: Int): Unit {
    print(a + b)
}
    
    
//notice      Unit    ,     
fun printSum(a: Int, b: Int) {
    print(a + b)
}

(1.4)文字列テンプレート

fun main(args: Array) {
    if (args.size == 0) return

    print("First argument: ${args[0]}")
}

ケース参照:BaseDemo.kt
(1.5)ロジック制御if and when and for
ケース参照:ControlDemo.kt
(1.6)復帰及びジャンプ
ケース参照:BreakDemo.kt
2.クラスと継承
(2.1)クラスの定義
a.Kotlinのクラスはclassキーワードで定義する

package com.laojizhang.kotlin.clazz

//            :   ,    (        ,     ,   .),               .               ;          ,           .
//                        ,            ,         .            public
class EmptyClass

open class Person(val name: String = "")

class Person1 constructor(name: String)
//              ？？？

//  ：    Java   ，              ，         ？？
//  ：      
open class Person2(val name: String) {
    //         ,                    ,       ,                .                ,    this      :
    constructor(name: String, age: Int) : this(name)

    open val city: String = "beijing"

    open fun eat() {
        println("  Person2    eat")
    }

    fun sleep() {}
}

//  ：                         ？？？
//  ：            public     ,             ,          :
class Person3 private constructor()

class ClassDemo {
    //       
    init {
        println("        ，               ")
    }
}

fun main(args: Array) {
    //     
    val person = Person("laojizhang")
    println("name = " + person.name)

//    val person1 = Person1("laojizhang")
//    println(person1.name)

    val female = Male("laojizhang", 18, true)
    female.eat()

    println("Companion = " + MyClass.Companion)
    println(MyClass.create())

    val user = User("   ", 18, 1, "         ")
    val (a, b, c, d) = user
    val (name, address) = user
    println("name = $a address = $d")
    println("name = $name address = $address")

}

//     
// note:    open   (annotation)   Java   final     :                    .      , Kotlin         final  
class Male(val name1: String, val age: Int, val sex: Boolean) : Person2(name1, age) {

    //     
    override val city: String
        get() = "  "

    //     
    override fun eat() {
//        super.eat()
        println("  Male    eat")
    }

    fun drink() {
        println("  Male    drink")
    }
}


//  Kotlin  ,            ,       :                           ,               ,           (                  ).                     ,      super    ,            ,   , super:
//     A   B     ,      a()   b()          ,          , C                .      f()          ,    C               ,     C            f(),           ,         .
open class A {
    open fun f() {
        print("A")
    }

    fun a() {
        print("a")
    }
}

interface B {
    fun f() {
        print("B")
    } //          'open'  

    fun b() {
        print("b")
    }
}

class C() : A(), B {
    //       f()       :
    override fun f() {
        super.f()/A.f()を び す
//        super.f()/ び しB.f()
}
}
//Companion Object（    ）
//JavaまたはC#と なり、Kotlinのクラスには  メソッドはありません。 くの  、    の わりにパッケージレベル  (package-level function)を  することを  する.
class MyClass private constructor() {
companion object {
fun create(): MyClass {
return MyClass()
}
}
}
//   
abstract class absClass {
abstract fun method1()
abstract fun method2()
}
interface MyInterface {
val property: Int
fun bar()
fun foo() {
//メソッドはオプション
}
}
class ChildClass(override val property: Int) : MyInterface {
override fun bar() {
TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
}
override fun foo() {
super.foo()
}
}
//   と  の  は じであるべきで、  しないことを ったことがなくて、  があって  で  するようにしましょう
sealed class Expr {
class Const(val number: Double) : Expr()
class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()
}
private class MyPrivateClass {
private val name: String = "privateClass"
}
//データクラスand    
data class User(val name: String, val age: Int, val sex: Int, val address: String)

(2.2)アクセス修飾子
クラス、オブジェクト、インタフェース、コンストラクタ、関数、属性、および属性の設定方法は、いずれも可視度修飾子を用いることができる.(属性の取値方法は常に属性自体の可視度と一致するため、その可視度を制御する必要はない.Kotlinには4種類の可視度修飾子が存在する:private,protected,internal(内部)およびpublic.修飾子が明確に指定されていない場合は、デフォルトの可視度publicを使用します.
モジュールの概念
internal修飾子は、このメンバーが同じモジュール内でしかアクセスできないことを示す.より正確には、モジュール(module)は、Kotlinソースファイルのセットを一緒にコンパイルすることを意味します.
IntelliJ IDEAモジュール
Mavenエンジニアリング、またはGradleエンジニアリング.
Antタスクの呼び出しによってコンパイルされたファイルのセット.
a.パッケージのアクセス修飾子
視認性修飾子を指定しない場合は、デフォルトではpublicが使用されます.これは、宣言したものがどこでもアクセスできることを意味します.
宣言されたものをprivateとマークすると、同じソースファイル内でのみアクセスできます.
internalとマークされている場合、同じモジュール内の任意の場所にアクセスできます.
トップレベル宣言ではprotected修飾子は無効です.
b.クラスとインタフェースのアクセス修飾子
privateは、このクラス(およびそのすべてのメンバー)内でのみアクセスできることを示します.
protected-privateと同様に、サブクラスにもアクセスできます.
internal-このモジュール内で、このクラスにアクセスできる場所は、このクラスのinternalメンバーにもアクセスできます.
public-このクラスにアクセスできる場所は、このクラスのpublicメンバーにもアクセスできます.
(2.3)拡張
C#やGosuと同様に、Kotlinはクラスに新しい機能を拡張する能力を提供し、このクラスから継承する必要はなく、Decoratorモードなどの設計モードを使用する必要もない.この機能は特殊な声明によって実現され、Kotlinでは拡張(extension)と呼ばれている.Kotlinは拡張関数(extension function)と拡張属性(extension property)をサポートする.
a.拡張関数
拡張関数を宣言するには、関数名の前に接頭辞を追加し、この関数の受信者タイプ(receiver type)を表す必要があります.つまり、拡張したいオブジェクトタイプを示す必要があります.次の例では、MutableListタイプにswap関数を追加します.
b.すべてのオブジェクトにprintStringメソッドを追加する
オブジェクト変数の値がnullである場合でも呼び出すことができ、拡張関数の実装体内ではthis==nullで受信者がnullであるか否かをチェックすることができる.KotlinではtoString()関数を呼び出すことができ、オブジェクトがnullであるかどうかを検査する必要はありません.この原理によって実現されます.オブジェクトがnullであるかどうかの検査は拡張関数の内部で発生するので、呼び出し者は検査する必要はありません.
c.拡張属性

val  List.lastIndex: Int
    get() = size - 1

d.伴生類に拡張関数を追加する
e.BクラスでAクラスの拡張関数を定義する
ケース参照:ExtensionDemo.kt
3.異常
Kotlin異常とJava異常はほぼ一致するKotlin中のすべての異常クラスはThrowableの子孫クラスである.各例外には、エラーメッセージ、呼び出しスタック、およびオプションのエラー原因があります.
a.try式

// try        ,     try              ,     catch              . finally            try        .
val a: Int? = try { parseInt(input) } catch (e: NumberFormatException) { null }

b.Checked Exception(制御異常)
Kotlinには制御異常は存在しない(checked exception)

       JDK   StringBuilder          :

Appendable append(CharSequence csq) throws IOException

            ?   ,                   (  ,    StringBuilder,    log,    ,   ),         IOException   . 
   ?              IO    (   Writer       Appendable   ).                   :

try {
    log.append(message)
}
catch (IOException e) {
    //               
}

高次関数
Kotlinは、関数を変数に割り当て、他の関数のパラメータとして変数を渡すことをサポートします.パラメータとして他の関数を受け入れる関数を高次関数と呼ぶ
関数呼び出し
Kotlin関数は、名前に接頭辞を付けることができます:参照するか、コードブロックに匿名関数を直接宣言するか、lambda式構文を使用します.
資料の出所
Kotlinチュートリアルのケースアドレス