Kotlin-クイックガイド

Kotlinは、Java、JavaScriptなどの新しいオープンソースプログラミング言語です。これは、機能と技術の部分を同じ場所に組み合わせた、静的に型指定された高レベルの言語です。現在、KotlinはJavaとJavaScriptを対象としています。JVM上で実行されます。

Kotlinは、Java、Scala、Groovy、Gosuなどの他のプログラミング言語の影響を受けます。Kotlinの構文はJAVAとまったく同じではない場合がありますが、内部的には、Kotlinは既存のJavaクラスライブラリに依存して、プログラマーにすばらしい結果をもたらします。 。Kotlinは、世界中の開発者に相互運用性、コードの安全性、および明快さを提供します。

長所と短所

以下は、アプリケーション開発にKotlinを使用する利点の一部です。

Easy Language− Kotlinは関数型言語であり、非常に簡単に習得できます。構文はJavaとほとんど同じであるため、覚えるのは非常に簡単です。Kotlinはより表現力があり、コードがより読みやすく、理解しやすくなります。

Concise− KotlinはJVMに基づいており、関数型言語です。したがって、他のプログラミング言語で使用されるボイラープレートコードの多くを削減します。

Runtime and Performance −パフォーマンスの向上と実行時間の短縮。

Interoperability − Kotlinは、それほど複雑ではない方法で相互運用可能なアプリケーションを構築するのに十分成熟しています。

Brand New− Kotlinは、開発者に新たなスタートを切るまったく新しい言語です。これはJavaの代わりではありませんが、JVM上で開発されています。これは、Android開発の最初の公用語として受け入れられています。Kotlinは、次のように定義できます-Kotlin = JAVA +追加の更新された新機能。

Kotlinの欠点のいくつかを以下に示します。

Namespace declaration− Kotlinを使用すると、開発者はトップレベルで関数を宣言できます。ただし、アプリケーションの多くの場所で同じ関数が宣言されている場合は常に、どの関数が呼び出されているかを理解するのは困難です。

No Static Declaration − Kotlinには、Javaのような通常の静的処理修飾子がないため、従来のJava開発者に問題が発生する可能性があります。

ただし、ローカルシステムでKotlinをオフラインで使用する場合は、次の手順を実行してローカルワークスペースを構成する必要があります。

Step 1 − Java8のインストール。

したがって、KotlinはJVMで実行されます。ローカルのKotlin開発にはJDK8を使用する必要があります。JDK 8以降のバージョンをダウンロードしてインストールするには、オラクルの公式Webサイトを参照してください。正しく機能するように、JAVAの環境​​変数を設定する必要がある場合があります。Windowsオペレーティングシステムへのインストールを確認するには、コマンドプロンプトで「java–version」を押すと、システムにインストールされているJavaバージョンが出力として表示されます。

Step 2 −IDEのインストール。

インターネット上で利用可能なIDEは多数あります。あなたはあなたの選択のどれでも使うことができます。次の表に、さまざまなIDEのダウンロードリンクを示します。

IDE名	インストールリンク
NetBeans	https://netbeans.org/downloads/
Eclipse	https://www.eclipse.org/downloads/
Intellij	https://www.jetbrains.com/idea/download/#section = windows

最新のソフトウェアバージョンを使用して、そこから最大限の機能を引き出すことを常にお勧めします。

Step 3 −Eclipseの構成。

Eclipseを開き、「EclipseMarketPlace」に移動します。次の画面が表示されます。

検索ボックスでKotlinを検索し、ローカルシステムにインストールします。インターネットの速度によっては時間がかかる場合があります。Eclipseが正常にインストールされたら、Eclipseを再起動する必要がある場合があります。

Step 4 −Kotlinプロジェクト。

Eclipseが正常に再起動され、Kotlinがインストールされると、Kotlinプロジェクトをその場で作成できるようになります。に移動File → New → Others リストから「Kotlinプロジェクト」を選択します。

プロジェクトのセットアップが完了したら、「SRC」フォルダーの下にKotlinファイルを作成できます。「Src」フォルダを左クリックして「新規」をクリックします。Kotlinファイルのオプションが表示されます。それ以外の場合は、「その他」から検索する必要があります。新しいファイルが作成されると、プロジェクトディレクトリは次のようになります。

これで開発環境の準備が整いました。先に進み、「Hello.kt」ファイルに次のコードを追加します。

fun main(args: Array<String>) {
   println("Hello, World!")
}

Kotlinアプリケーションとして実行し、次のスクリーンショットに示すようにコンソールで出力を確認します。理解と可用性を高めるために、コーディンググラウンドツールを使用します。

Hello, World!

Kotlinはプログラミング言語であり、メモリを割り当ててエンドユーザーに高品質の出力を生成する独自のアーキテクチャを備えています。以下は、JavaやJavaScriptなどの他の種類の言語をターゲットにしている場合に、Kotlinコンパイラが異なる動作をするさまざまなシナリオです。

Kotlinコンパイラはバイトコードを作成し、そのバイトコードはJVMで実行できます。これは、Javaによって生成されたバイトコードとまったく同じです。 .classファイル。2バイトコード化されたファイルがJVMで実行されるときはいつでも、それらは互いに通信できます。これは、相互運用可能な機能がKotlin forJavaで確立される方法です。

KotlinがJavaScriptをターゲットにするときはいつでも、Kotlinコンパイラは .ktファイルをES5.1に挿入し、JavaScriptと互換性のあるコードを生成します。Kotlinコンパイラは、LLVMを介してプラットフォームベースの互換性のあるコードを作成できます。

この章では、Kotlinプログラミング言語で使用できる基本的なデータ型について学習します。

数字

Kotlinでの数値の表現はJavaと非常に似ていますが、Kotlinでは異なるデータ型の内部変換は許可されていません。次の表に、さまざまな数値のさまざまな可変長を示します。

タイプ	サイズ
ダブル	64
浮く	32
長いです	64
Int	32
ショート	16
バイト	8

次の例では、Kotlinがさまざまなデータ型でどのように機能するかを確認します。コーディンググラウンドに次のコードセットを入力してください。

fun main(args: Array<String>) {
   val a: Int = 10000
   val d: Double = 100.00
   val f: Float = 100.00f
   val l: Long = 1000000004
   val s: Short = 10
   val b: Byte = 1
   
   println("Your Int Value is "+a);
   println("Your Double  Value is "+d);
   println("Your Float Value is "+f);
   println("Your Long Value is "+l);
   println("Your Short Value is "+s);
   println("Your Byte Value is "+b);
}

上記のコードをコーディンググラウンドで実行すると、Webコンソールに次の出力が生成されます。

Your Int Value is 10000
Your Double  Value is 100.0
Your Float Value is 100.0
Your Long Value is 1000000004
Your Short Value is 10
Your Byte Value is 1

キャラクター

Kotlinはキャラクターを使用して表現します char。文字は次のように一重引用符で宣言する必要があります‘c’。コーディンググラウンドに次のコードを入力して、Kotlinが文字変数をどのように解釈するかを確認してください。文字変数は、数値変数のように宣言することはできません。Kotlin変数は2つの方法で宣言できます-1つは“var” と別の使用 “val”。

fun main(args: Array<String>) {
   val letter: Char    // defining a variable 
   letter = 'A'        // Assigning a value to it 
   println("$letter")
}

上記のコードは、ブラウザの出力ウィンドウに次の出力を生成します。

A

ブール値

ブール値は、他のプログラミング言語と同様に非常に単純です。ブール値には、trueまたはfalseの2つの値しかありません。次の例では、Kotlinがブール値をどのように解釈するかを確認します。

fun main(args: Array<String>) {
   val letter: Boolean   // defining a variable 
   letter = true         // Assinging a value to it 
   println("Your character value is "+"$letter")
}

上記のコードは、ブラウザに次の出力を生成します。

Your character value is true

文字列

文字列は文字配列です。Javaのように、それらは本質的に不変です。Kotlinには2種類の文字列があります。1つはraw String もう1つは escaped String。次の例では、これらの文字列を利用します。

fun main(args: Array<String>) {
   var rawString :String  = "I am Raw String!"
   val escapedString : String  = "I am escaped String!\n"
   
   println("Hello!"+escapedString)
   println("Hey!!"+rawString)   
}

上記のエスケープ文字列の例では、最初のprintステートメントの後に追加の行スペースを提供できます。以下はブラウザでの出力です。

Hello!I am escaped String!

Hey!!I am Raw String!

配列

配列は同種のデータのコレクションです。Javaと同様に、Kotlinはさまざまなデータ型の配列をサポートしています。次の例では、さまざまな配列を使用します。

fun main(args: Array<String>) {
   val numbers: IntArray = intArrayOf(1, 2, 3, 4, 5)
   println("Hey!! I am array Example"+numbers[2])
}

上記のコードは、次の出力を生成します。配列のインデックス付けは、他のプログラミング言語と同様です。ここでは、値が「3」の2番目のインデックスを検索しています。

Hey!! I am array Example3

コレクション

収集はデータ構造の非常に重要な部分であり、エンジニアがソフトウェア開発を容易にします。Kotlinには2種類のコレクションがあります-1つはimmutable collection （つまり、編集できないリスト、マップ、セット）ともう1つは mutable collection（このタイプのコレクションは編集可能です）。Kotlinシステムはコレクションの特定の違いを表していないため、アプリケーションで使用されるコレクションのタイプを覚えておくことが非常に重要です。

fun main(args: Array<String>) { 
   val numbers: MutableList<Int> = mutableListOf(1, 2, 3) //mutable List 
   val readOnlyView: List<Int> = numbers                  // immutable list 
   println("my mutable list--"+numbers)        // prints "[1, 2, 3]" 
   numbers.add(4) 
   println("my mutable list after addition --"+numbers)        // prints "[1, 2, 3, 4]" 
   println(readOnlyView)     
   readOnlyView.clear()    // ⇒ does not compile  
// gives error  
}

上記のコードは、ブラウザに次の出力を生成します。コレクションの可変リストをクリアしようとすると、エラーが発生します。

main.kt:9:18: error: unresolved reference: clear
   readOnlyView.clear()    // -> does not compile  
                 ^

コレクションでは、Kotlinは次のようないくつかの便利な方法を提供します first(), last(), filter()、など。これらのメソッドはすべて、自己記述的で実装が簡単です。さらに、Kotlinは、コレクションを実装する際にJavaなどの同じ構造に従います。MapやSetなど、任意のコレクションを自由に実装できます。

次の例では、さまざまな組み込みメソッドを使用してMapとSetを実装しています。

fun main(args: Array<String>) {
   val items = listOf(1, 2, 3, 4)
   println("First Element of our list----"+items.first())
   println("Last Element of our list----"+items.last())
   println("Even Numbers of our List----"+items.
      filter { it % 2 = = 0 })   // returns [2, 4]
   
   val readWriteMap = hashMapOf("foo" to 1, "bar" to 2)
   println(readWriteMap["foo"])  // prints "1"
   
   val strings = hashSetOf("a", "b", "c", "c")
   println("My Set Values are"+strings)
}

上記のコードは、ブラウザに次の出力を生成します。

First Element of our list----1
Last Element of our list----4
Even Numbers of our List----[2, 4]
1
My Set Values are[a, b, c]

範囲

RangesはKotlinのもう1つのユニークな特徴です。Haskellのように、それはあなたが範囲を反復するのを助ける演算子を提供します。内部的には、rangeTo() その演算子形式は (..)。

次の例では、Kotlinがこの範囲演算子をどのように解釈するかを確認します。

fun main(args: Array<String>) {
   val i:Int  = 2
   for (j in 1..4) 
   print(j) // prints "1234"
   
   if (i in 1..10) { // equivalent of 1 < = i && i < = 10
      println("we found your number --"+i)
   }
}

上記のコードは、ブラウザに次の出力を生成します。

1234we found your number --2

前の章では、Kotlinシステムで使用できるさまざまなタイプのデータ型について学習しました。この章では、Kotlinで使用できるさまざまなタイプの制御フローメカニズムについて説明します。

もし-そうでなければ

Kotlinは関数型言語であるため、Kotlinのすべての関数型言語と同様です。 “if”は式であり、キーワードではありません。表現“if”必要に応じて値を返します。他のプログラミング言語と同様に、“if-else”ブロックは、初期の条件付きチェック演算子として使用されます。次の例では、2つの変数を比較し、それに応じて必要な出力を提供します。

fun main(args: Array<String>) {
   val a:Int = 5
   val b:Int = 2
   var max: Int
   
   if (a > b) {
      max = a
   } else {
      max = b
   }
   print("Maximum of a or b is " +max)
 
   // As expression 
   // val max = if (a > b) a else b
}

上記のコードは、ブラウザで次の出力を生成します。この例には、使用方法を示す別のコード行も含まれています“If” 式としてのステートメント。

Maximum of a or b is 5

いつの使用

他のプログラミング言語に精通している場合は、switchステートメントという用語を聞いたことがあるかもしれません。これは基本的に、特定の変数に複数の条件を適用できる場合の条件演算子です。 “when”演算子は、変数値を分岐条件と照合します。分岐条件を満たす場合は、そのスコープ内でステートメントを実行します。次の例では、Kotlinの「いつ」について詳しく学習します。

fun main(args: Array<String>) {
   val x:Int = 5
   when (x) {
      1 -> print("x = = 1")
      2 -> print("x = = 2")
      
      else -> { // Note the block
         print("x is neither 1 nor 2")
      }
   }
}

上記のコードは、ブラウザに次の出力を生成します。

x is neither 1 nor 2

上記の例では、Kotlinコンパイラはの値と一致します x与えられた枝で。どのブランチとも一致しない場合は、else部分を実行します。実際には、whenは複数のifブロックと同等です。Kotlinは、開発者に別の柔軟性を提供します。開発者は、チェック内に「、」を指定することで、同じ行に複数のチェックを提供できます。上記の例を次のように変更してみましょう。

fun main(args: Array<String>) {
   val x:Int = 5
   when (x) {
      1,2 -> print(" Value of X either 1,2")
      
      else -> { // Note the block
         print("x is neither 1 nor 2")
      }
   }
}

同じことをブラウザで実行すると、ブラウザに次の出力が表示されます。

x is neither 1 nor 2

Forループ

ループは、あらゆる種類のデータ構造を反復処理する柔軟性を提供する発明です。他のプログラミング言語と同様に、Kotlinもさまざまな種類のループ手法を提供していますが、その中には“For”最も成功したものです。Forループの実装と使用は、概念的にはJavaのforループに似ています。次の例は、実際の例で同じものを使用する方法を示しています。

fun main(args: Array<String>) {
   val items = listOf(1, 2, 3, 4)
   for (i in items) println("values of the array"+i)
}

上記のコードでは、「items」という名前の1つのリストを宣言し、forループを使用して、その定義済みリストを反復処理し、その値をブラウザーに出力しています。以下は出力です。

values of the array1
values of the array2
values of the array3
values of the array4

以下は、コードの別の例です。ここでは、ライブラリ関数を使用して、開発作業をこれまでになく簡単にしています。

fun main(args: Array<String>) {
   val items = listOf(1, 22, 83, 4)
   
   for ((index, value) in items.withIndex()) {
      println("the element at $index is $value")
   }
}

上記のコードをコーディンググラウンドでコンパイルして実行すると、ブラウザに次の出力が表示されます。

the element at 0 is 1
the element at 1 is 22
the element at 2 is 83
the element at 3 is 4

whileループとDo-Whileループ

WhileおよびDo-Whileは、他のプログラミング言語とまったく同じように機能します。これら2つのループの唯一の違いは、Do-whileループの場合、条件はループの最後でテストされることです。次の例は、の使用法を示していますWhile loop。

fun main(args: Array<String>) {
   var x:Int = 0
   println("Example of While Loop--")
   
   while(x< = 10) {
      println(x)
      x++
   } 
}

上記のコードは、ブラウザに次の出力を生成します。

Example of While Loop--
0
1
2
3
4
5
6
7
8
9
10

Kotlinには、Do-Whileループと呼ばれる別のループもあります。このループでは、ループ本体が1回実行された後、条件がチェックされます。次の例は、の使用法を示していますDo-while loop。

fun main(args: Array<String>) {
   var x:Int = 0
   do {
      x = x + 10
      println("I am inside Do block---"+x)
   } while(x <= 50)
}

上記のコードは、ブラウザに次の出力を生成します。上記のコードでは、KotlinコンパイラがDOブロックを実行してから、whileブロックの条件チェックインを行います。

I am inside Do block---10
I am inside Do block---20
I am inside Do block---30
I am inside Do block---40
I am inside Do block---50
I am inside Do block---60

リターン、ブレイク、コンティニューの使用

プログラミング言語に精通している場合は、アプリケーションに適切な制御フローを実装するのに役立つさまざまなキーワードのアイデアが必要です。以下は、ループまたはその他のタイプの制御フローを制御するために使用できるさまざまなキーワードです。

Return− returnは、呼び出された関数から呼び出し元の関数に値を返すキーワードです。次の例では、Kotlinコーディンググラウンドを使用してこのシナリオを実装します。

fun main(args: Array<String>) {
   var x:Int = 10
   println("The value of X is--"+doubleMe(x))
}
fun doubleMe(x:Int):Int {
   return 2*x;
}

上記のコードでは、別の関数を呼び出し、入力に2を掛けて、結果の値をメイン関数である呼び出された関数に返しています。Kotlinは、次の章で説明する別の方法で関数を定義します。今のところ、上記のコードがブラウザで次の出力を生成することを理解するだけで十分です。

The value of X is--20

Continue & Break−継続と中断は、論理的な問題の最も重要な部分です。「break」キーワードは、ある条件が失敗した場合にコントローラーフローを終了し、「continue」はその逆を行います。この操作はすべて、すぐに確認できる状態で行われます。Kotlinは他のプログラミング言語よりも賢く、開発者は可視性として複数のラベルを適用できます。次のコードは、Kotlinでこのラベルを実装する方法を示しています。

fun main(args: Array<String>) {
   println("Example of Break and Continue")
   myLabel@ for(x in 1..10) { // appling the custom label
      if(x = = 5) {
         println("I am inside if block with value"+x+"\n-- hence it will close the operation")
         break@myLabel //specifing the label
      } else {
         println("I am inside else block with value"+x)
         continue@myLabel
      }
   }
}

上記のコードは、ブラウザに次の出力を生成します。

Example of Break and Continue
I am inside else block with value1
I am inside else block with value2
I am inside else block with value3
I am inside else block with value4
I am inside if block with value5
-- hence it will close the operation

ご覧のとおり、コントローラーは、の値が x は5です。 x 5に達すると、ifブロックの実行が開始され、breakステートメントに達すると、制御フロー全体がプログラムの実行を終了します。

この章では、Kotlinを使用したオブジェクト指向プログラミング（OOP）の基本を学習します。クラスとそのオブジェクト、およびそのオブジェクトの操作方法について学習します。OOPの定義により、クラスはランタイムエンティティの青写真であり、オブジェクトはその動作と状態の両方を含む状態です。Kotlinでは、クラス宣言は、Javaと同様に、中括弧で囲まれたクラスヘッダーとクラス本体で構成されます。

Class myClass { // class Header 

   // class Body
}

Javaと同様に、Kotlinでもクラスの複数のオブジェクトを作成でき、そのクラスメンバーと関数を自由に含めることができます。第10章–可視性制御で学習するさまざまなキーワードを使用して、クラスメンバー変数の可視性を制御できます。次の例では、1つのクラスとそのオブジェクトを作成し、それを介してそのクラスのさまざまなデータメンバーにアクセスします。

class myClass {
   // property (data member)
   private var name: String = "Tutorials.point"
   
   // member function
   fun printMe() {
      print("You are at the best Learning website Named-"+name)
   }
}
fun main(args: Array<String>) {
   val obj = myClass() // create obj object of myClass class
   obj.printMe()
}

上記のコードは、ブラウザで次の出力を生成します。ここでは、独自のオブジェクトを使用してmyClassのprintMe（）を呼び出しています。

You are at the best Learning website Named- Tutorials.point

ネストされたクラス

定義上、クラスが別のクラス内に作成されている場合、そのクラスはネストされたクラスと呼ばれます。Kotlinでは、ネストされたクラスはデフォルトで静的であるため、そのクラスのオブジェクトを作成せずにアクセスできます。次の例では、Kotlinがネストされたクラスをどのように解釈するかを確認します。

fun main(args: Array<String>) {
   val demo = Outer.Nested().foo() // calling nested class method
   print(demo)
}
class Outer {
   class Nested {
      fun foo() = "Welcome to The TutorialsPoint.com"
   }
}

上記のコードは、ブラウザに次の出力を生成します。

Welcome to The TutorialsPoint.com

インナークラス

ネストされたクラスが「内部」としてマークされている場合、それは内部クラスとして呼び出されます。内部クラスには、外部クラスのデータメンバーからアクセスできます。次の例では、外部クラスのデータメンバーにアクセスします。

fun main(args: Array<String>) {
   val demo = Outer().Nested().foo() // calling nested class method
   print(demo)
}
class Outer {
   private val welcomeMessage: String = "Welcome to the TutorialsPoint.com"
   inner class Nested {
      fun foo() = welcomeMessage
   }
}

上記のコードは、ブラウザーで次の出力を生成します。ここでは、コンパイル時にKotlinコンパイラーによって提供されるデフォルトのコンストラクターを使用してネストされたクラスを呼び出しています。

Welcome to the TutorialsPoint.com

匿名のインナークラス

匿名の内部クラスは、プログラマーの生活を非常に簡単にする非常に優れた概念です。インターフェイスを実装するときはいつでも、匿名の内部ブロックの概念が浮かび上がります。ランタイムオブジェクト参照を使用してインターフェイスのオブジェクトを作成するという概念は、匿名クラスとして知られています。次の例では、インターフェイスを作成し、AnonymousInnerクラスメカニズムを使用してそのインターフェイスのオブジェクトを作成します。

fun main(args: Array<String>) {
   var programmer :Human = object:Human // creating an instance of the interface {
      override fun think() { // overriding the think method
         print("I am an example of Anonymous Inner Class ")
      }
   }
   programmer.think()
}
interface Human {
   fun think()
}

上記のコードは、ブラウザに次の出力を生成します。

I am an example of Anonymous Inner Class

タイプエイリアス

タイプエイリアスはKotlinコンパイラのプロパティです。これは、既存のタイプの新しい名前を作成する柔軟性を提供します。新しいタイプは作成しません。タイプ名が長すぎる場合は、簡単に短い名前を導入して、将来の使用に使用できます。型エイリアスは、複雑な型に非常に役立ちます。最新バージョンでは、Kotlinは型エイリアスのサポートを取り消しましたが、古いバージョンのKotlinを使用している場合は、次のように使用している可能性があります。

typealias NodeSet = Set<Network.Node>
typealias FileTable<K> = MutableMap<K, MutableList<File>>

この章では、Kotlinのコンストラクターについて学習します。Kotlinには2種類のコンストラクターがあります-1つはprimary constructor もう1つは secondary constructor。1つのKotlinクラスには、1つのプライマリコンストラクターと1つ以上のセカンダリコンストラクターを含めることができます。Javaコンストラクターはメンバー変数を初期化しますが、Kotlinでは、プライマリコンストラクターがクラスを初期化しますが、セカンダリコンストラクターは、同じものを初期化するときに追加のロジックを含めるのに役立ちます。次の例に示すように、プライマリコンストラクタはクラスヘッダーレベルで宣言できます。

class Person(val firstName: String, var age: Int) {
   // class body
}

上記の例では、括弧内にプライマリコンストラクターを宣言しています。2つのフィールドのうち、名は「val」として宣言されているため読み取り専用ですが、フィールドの経過時間は編集できます。次の例では、プライマリコンストラクターを使用します。

fun main(args: Array<String>) {
   val person1 = Person("TutorialsPoint.com", 15)
   println("First Name = ${person1.firstName}") println("Age = ${person1.age}")
}
class Person(val firstName: String, var age: Int) {
}

上記のコードは、2つの変数を自動的に初期化し、ブラウザーに次の出力を提供します。

First Name = TutorialsPoint.com
Age = 15

前述のように、Kotlinではクラスの2次コンストラクターを1つ以上作成できます。この2次コンストラクターは、「constructor」キーワードを使用して作成されます。Kotlinで複数のコンストラクターを作成する場合、またはプライマリコンストラクターにさらにロジックを含める場合は、プライマリコンストラクターが他のクラスによって呼び出される可能性があるため、これを行うことができない場合に必要です。次の例を見てください。ここでは、2次コンストラクターを作成し、上記の例を使用して同じものを実装しています。

fun main(args: Array<String>) {
   val HUman = HUman("TutorialsPoint.com", 25)
   print("${HUman.message}"+"${HUman.firstName}"+
      "Welcome to the example of Secondary  constructor, Your Age is-${HUman.age}")
}
class HUman(val firstName: String, var age: Int) {
   val message:String  = "Hey!!!"
	constructor(name : String , age :Int ,message :String):this(name,age) {
   }
}

Note −セカンダリコンストラクターはいくつでも作成できますが、これらのコンストラクターはすべて、プライマリコンストラクターを直接または間接的に呼び出す必要があります。

上記のコードは、ブラウザに次の出力を生成します。

Hey!!! TutorialsPoint.comWelcome to the example of Secondary  constructor, Your Age is- 25

この章では、継承について学習します。定義上、継承とは、母クラスのいくつかのプロパティを子クラスに蓄積することを意味することは誰もが知っています。Kotlinでは、基本クラスの名前は「Any」です。これは、Kotlinで宣言されている「any」デフォルトクラスのスーパークラスです。他のすべてのOOPSと同様に、Kotlinもこの機能を1つのキーワードとして提供します。“:”。

Kotlinのすべてはデフォルトでfinalであるため、継承を許可するには、クラス宣言の前にキーワード「open」を使用する必要があります。次の継承の例を見てください。

import java.util.Arrays

open class ABC {
   fun think () {
      print("Hey!! i am thiking ")
   }
}
class BCD: ABC(){ // inheritence happend using default constructor 
}

fun main(args: Array<String>) {
   var  a = BCD()
   a.think()
}

上記のコードは、ブラウザに次の出力を生成します。

Hey!! i am thiking

ここで、子クラスのthink（）メソッドをオーバーライドする場合はどうでしょうか。次に、2つのクラスを作成し、その関数の1つを子クラスにオーバーライドする次の例を検討する必要があります。

import java.util.Arrays

open class ABC {
   open fun think () {
      print("Hey!! i am thinking ")
   }
}
class BCD: ABC() { // inheritance happens using default constructor 
   override fun think() {
      print("I Am from Child")
   }
}
fun main(args: Array<String>) {
   var  a = BCD()
   a.think()
}

上記のコードは、子クラスの継承メソッドを呼び出し、ブラウザーに次の出力を生成します。Javaと同様に、Kotlinも多重継承を許可していません。

I Am from Child

この章では、Kotlinのインターフェースについて学習します。Kotlinでは、インターフェースはJava 8とまったく同じように機能します。つまり、メソッドの実装と抽象メソッドの宣言を含めることができます。インターフェースは、定義された機能を使用するためにクラスによって実装できます。第6章の「匿名内部クラス」のセクションで、インターフェイスを使用した例をすでに紹介しました。この章では、それについてさらに学びます。次のコードに示すように、キーワード「interface」を使用して、Kotlinでインターフェースを定義します。

interface ExampleInterface {
   var myVar: String     // abstract property
   fun absMethod()       // abstract method
   fun sayHello() = "Hello there" // method with default implementation
}

上記の例では、「ExampleInterface」という名前の1つのインターフェイスを作成し、その中にいくつかの抽象的なプロパティとメソッドをまとめています。実装されたメソッドである「sayHello（）」という名前の関数を見てください。

次の例では、上記のインターフェイスをクラスに実装します。

interface ExampleInterface  {
   var myVar: Int            // abstract property
   fun absMethod():String    // abstract method
   
   fun hello() {
      println("Hello there, Welcome to TutorialsPoint.Com!")
   }
}
class InterfaceImp : ExampleInterface {
   override var myVar: Int = 25
   override fun absMethod() = "Happy Learning "
}
fun main(args: Array<String>) {
   val obj = InterfaceImp()
   println("My Variable Value is = ${obj.myVar}")
   print("Calling hello(): ")
   obj.hello()
   
   print("Message from the Website-- ")
   println(obj.absMethod())
}

上記のコードは、ブラウザに次の出力を生成します。

My Variable Value is = 25
Calling hello(): Hello there, Welcome to TutorialsPoint.Com!
Message from the Website-- Happy Learning

前述のように、Kotlinは多重継承をサポートしていませんが、一度に3つ以上のインターフェースを実装することで同じことが実現できます。

次の例では、2つのインターフェイスを作成し、後で両方のインターフェイスをクラスに実装します。

interface A {
   fun printMe() {
      println(" method of interface A")
   }
}
interface B  {
   fun printMeToo() {
      println("I am another Method from interface B")
   }
}

// implements two interfaces A and B
class multipleInterfaceExample: A, B

fun main(args: Array<String>) {
   val obj = multipleInterfaceExample()
   obj.printMe()
   obj.printMeToo()
}

上記の例では、2つのサンプルインターフェイスA、Bを作成し、「multipleInterfaceExample」という名前のクラスで、前に宣言した2つのインターフェイスを実装しました。上記のコードは、ブラウザに次の出力を生成します。

method of interface A
I am another Method from interface B

この章では、Kotlin言語で使用できるさまざまな修飾子について学習します。 Access modifierアプリケーションで使用される変数、メソッド、およびクラスの使用を制限するために使用されます。他のOOPプログラミング言語と同様に、この修飾子は、クラスヘッダーやメソッド宣言などの複数の場所に適用できます。Kotlinで使用できるアクセス修飾子は4つあります。

民間

クラス、メソッド、およびパッケージは、プライベート修飾子を使用して宣言できます。何かがプライベートとして宣言されると、その直接のスコープ内でアクセスできるようになります。たとえば、プライベートパッケージはその特定のファイル内でアクセスできます。プライベートクラスまたはインターフェイスには、そのデータメンバーなどからのみアクセスできます。

private class privateExample {
   private val i = 1
   private val doSomething() {
   }
}

上記の例では、クラス “privateExample” 変数iは両方とも、同じKotlinファイルでのみアクセスできます。これらのファイルはすべて、宣言ブロックでプライベートとして宣言されているためです。

保護されています

Protectedは、Kotlinのもう1つのアクセス修飾子です。これは、パッケージを保護できないため、現在トップレベルの宣言には使用できません。保護されたクラスまたはインターフェイスは、そのサブクラスにのみ表示されます。

class A() {
   protected val i = 1
}
class B : A() {
   fun getValue() : Int {
      return i
   }
}

上記の例では、変数 “i” は保護されていると宣言されているため、そのサブクラスにのみ表示されます。

内部

Internalは、Kotlinで導入された新しく追加された修飾子です。何かが内部としてマークされている場合、その特定のフィールドは内部フィールドにあります。内部パッケージは、それが実装されているモジュール内でのみ表示されます。内部クラスインターフェイスは、同じパッケージまたはモジュール内に存在する他のクラスによってのみ表示されます。次の例では、内部メソッドを実装する方法を示します。

class internalExample {
   internal val i = 1
   internal fun doSomething() {
   }
}

上記の例では、「doSomething」という名前のメソッドと変数が内部として記述されているため、これら2つのフィールドには、宣言されたパッケージ内でのみアクセスできます。

公衆

パブリックモディファイヤは、プロジェクトワークスペースのどこからでもアクセスできます。アクセス修飾子が指定されていない場合、デフォルトではパブリックスコープになります。これまでのすべての例では、修飾子については言及していません。したがって、それらはすべてパブリックスコープにあります。以下は、パブリック変数またはメソッドを宣言する方法についてさらに理解するための例です。

class publicExample {
   val i = 1
   fun doSomething() {
   }
}

上記の例では、修飾子について言及していないため、これらのメソッドと変数はすべてデフォルトでパブリックになっています。

この章では、「Extension」という名前のKotlinのもう1つの新機能について学習します。拡張機能を使用すると、メソッドの機能を継承または変更しなくても、一部のメソッド機能を追加または削除できます。拡張機能は統計的に解決されます。実際には既存のクラスを変更しませんが、ドット操作で呼び出すことができる呼び出し可能な関数を作成します。

機能拡張

関数拡張では、Kotlinを使用してメインクラスの外部でメソッドを定義できます。次の例では、拡張機能が機能レベルでどのように実装されているかを確認します。

class Alien {
   var skills : String = "null"
	
   fun printMySkills() {
      print(skills)
   }		
}
fun main(args: Array<String>) {
   var  a1 = Alien()
   a1.skills = "JAVA"
   //a1.printMySkills()
	
   var  a2 = Alien()
   a2.skills = "SQL"
   //a2.printMySkills()
	
   var  a3 = Alien()
   a3.skills = a1.addMySkills(a2)
   a3.printMySkills()
}
fun Alien.addMySkills(a:Alien):String{
   var a4 = Alien()
   a4.skills = this.skills + " " +a.skills
   return a4.skills
}

上記の例では、「addMySkills（）」という名前の「Alien」クラス内にメソッドはありませんが、クラス外の別の場所に同じメソッドを実装しています。これは拡張の魔法です。

上記のコードは、ブラウザで次の出力を生成します。

JAVA SQL

オブジェクト拡張

Kotlinは、Javaの静的機能を実装するための別のメカニズムを提供します。これは、キーワード「コンパニオンオブジェクト」を使用して実現できます。このメカニズムを使用すると、ファクトリメソッド内にクラスのオブジェクトを作成でき、後でクラス名の参照を使用してそのメソッドを呼び出すことができます。次の例では、「コンパニオンオブジェクト」を作成します。

fun main(args: Array<String>) {
   println("Heyyy!!!"+A.show())
}
class A {
   companion object {
      fun show():String {
         return("You are learning Kotlin from TutorialsPoint.com")
      }
   }
}

上記のコードは、ブラウザに次の出力を生成します。

Heyyy!!! You are learning Kotlin from TutorialsPoint.com

上記の例はJavaでは静的に見えますが、リアルタイムでは、同じクラスのメンバー変数としてオブジェクトを作成しています。これが、拡張プロパティにも含まれ、オブジェクト拡張と呼ばれることもある理由です。基本的に、同じクラスのオブジェクトを拡張して、いくつかのメンバー関数を使用します。

この章では、Kotlinプログラミング言語のデータクラスについて詳しく学習します。クラスは、「データ」としてマークされている場合はいつでも、データクラスとしてマークできます。このタイプのクラスは、基本データを分離するために使用できます。これ以外の機能はありません。

すべてのデータクラスには1つのプライマリコンストラクタが必要であり、すべてのプライマリコンストラクタには少なくとも1つのパラメータが必要です。クラスがデータとしてマークされている場合は常に、「toString（）」、「hashCode（）」など、そのデータクラスの組み込み関数の一部を使用できます。どのデータクラスにも、abstract、open、internalなどの修飾子を含めることはできません。データクラスは他のクラスにも拡張できます。次の例では、1つのデータクラスを作成します。

fun main(args: Array<String>) {
   val book: Book = Book("Kotlin", "TutorialPoint.com", 5)
   println("Name of the Book is--"+book.name) // "Kotlin"
   println("Puclisher Name--"+book.publisher) // "TutorialPoint.com"
   println("Review of the book is--"+book.reviewScore) // 5
   book.reviewScore = 7
   println("Printing all the info all together--"+book.toString()) 
   //using inbuilt function of the data class 
   
   println("Example of the hashCode function--"+book.hashCode())
}

data class Book(val name: String, val publisher: String, var reviewScore: Int)

上記のコードは、ブラウザで次の出力を生成します。ここでは、一部のデータを保持する1つのデータクラスを作成し、main関数からそのすべてのデータメンバーにアクセスしました。

Name of the Book is--"Kotlin"
Puclisher Name--"TutorialPoint.com"
Review of the book is--5
Printing all the info all together--(name-Kotlin, publisher-TutorialPoint.com, reviewScore-7)
Example of the hashCode function---1753517245

この章では、「封印された」クラスと呼ばれる別のクラスタイプについて学習します。このタイプのクラスは、制限されたクラス階層を表すために使用されます。封印されているため、開発者は事前定義されたタイプのデータ型を維持できます。封印されたクラスを作成するには、そのクラスの修飾子としてキーワード「sealed」を使用する必要があります。封印されたクラスは独自のサブクラスを持つことができますが、それらのサブクラスはすべて、封印されたクラスと同じKotlinファイル内で宣言する必要があります。次の例では、封印されたクラスの使用方法を示します。

sealed class MyExample {
   class OP1 : MyExample() // MyExmaple class can be of two types only
   class OP2 : MyExample()
}
fun main(args: Array<String>) {
   val obj: MyExample = MyExample.OP2() 
   
   val output = when (obj) { // defining the object of the class depending on the inuputs 
      is MyExample.OP1 -> "Option One has been chosen"
      is MyExample.OP2 -> "option Two has been chosen"
   }
   
   println(output)
}

上記の例では、「MyExample」という名前の封印されたクラスが1つあり、2つのタイプのみが可能です。1つは「OP1」で、もう1つは「OP2」です。メインクラスでは、クラスにオブジェクトを作成し、実行時にそのタイプを割り当てています。これで、この「MyExample」クラスが封印されたので、実行時に「when」句を適用して、最終出力を実装できます。

封印されたクラスでは、コードを複雑にするために不要な「else」ステートメントを使用する必要はありません。上記のコードは、ブラウザに次の出力を生成します。

option Two has been chosen

Javaと同様に、Kotlinはジェネリックスと呼ばれる高階の変数型付けを提供します。この章では、Kotlinがジェネリックを実装する方法と、開発者としてジェネリックライブラリ内で提供される機能を使用する方法を学習します。実装に関しては、ジェネリックはJavaに非常に似ていますが、Kotlin開発者は2つの新しいキーワードを導入しました“out” そして “in” Kotlinコードを開発者にとって読みやすく簡単にするため。

Kotlinでは、クラスとタイプはまったく異なる概念です。例のように、ListはKotlinのクラスですが、List <String>はKotlinの型です。次の例は、ジェネリックがKotlinに実装される方法を示しています。

fun main(args: Array<String>) {
   val integer: Int = 1
   val number: Number = integer
   print(number)
}

上記のコードでは、1つの「整数」を宣言し、後でその変数を数値変数に割り当てました。これが可能なのは、「Int」がNumberクラスのサブクラスであるため、型変換が実行時に自動的に行われ、「1」として出力が生成されるためです。

Kotlinのジェネリックについてもっと学びましょう。アプリケーションで使用するデータ型がわからない場合は、ジェネリックデータ型を選択することをお勧めします。一般的に、Kotlinではジェネリックは次のように定義されます。<T>ここで、「T」はテンプレートを表し、Kotlinコンパイラーによって動的に決定できます。次の例では、Kotlinプログラミング言語でジェネリックデータ型を使用する方法を示します。

fun main(args: Array<String>) {
   var objet = genericsExample<String>("JAVA")
   var objet1 = genericsExample<Int>(10)
}
class genericsExample<T>(input:T) {
   init {
      println("I am getting called with the value "+input)
   }
}

上記のコードでは、ジェネリック戻り値の型を持つ1つのクラスを作成しています。これは、次のように表されます。 <T>。このクラスのオブジェクトを作成しながら、値型を証明することによって実行時にその値を動的に定義したmainメソッドを見てください。これは、ジェネリックがKotlinコンパイラによって解釈される方法です。コーディンググラウンドでこのコードを実行すると、ブラウザに次の出力が表示されます。

I am getting called with the value JAVA
I am getting called with the value 10

ジェネリック型をそのスーパー型のいずれかに割り当てる場合は「out」キーワードを使用する必要があり、ジェネリック型をそのサブタイプのいずれかに割り当てる場合は「in」を使用する必要があります。キーワード。次の例では、「out」キーワードを使用します。同様に、「in」キーワードを使用してみることができます。

fun main(args: Array<String>) {
   var objet1 = genericsExample<Int>(10)
   var object2 = genericsExample<Double>(10.00)
   println(objet1)
   println(object2)
}
class genericsExample<out T>(input:T) {
   init {
      println("I am getting called with the value "+input)
   }
}

上記のコードは、ブラウザで次の出力を生成します。

I am getting called with the value 10
I am getting called with the value 10.0
genericsExample@28d93b30
genericsExample@1b6d3586

Kotlinはサポートしています “delegation” 新しいキーワードを導入してパターンをデザインする “by”。Kotlinは、このキーワードまたは委任方法論を使用して、派生クラスが特定のオブジェクトを介してインターフェイスの実装されたすべてのパブリックメソッドにアクセスできるようにします。次の例は、Kotlinでこれがどのように発生するかを示しています。

interface Base {
   fun printMe() //abstract method
}
class BaseImpl(val x: Int) : Base {
   override fun printMe() { println(x) }   //implementation of the method
}
class Derived(b: Base) : Base by b  // delegating the public method on the object b

fun main(args: Array<String>) {
   val b = BaseImpl(10)
   Derived(b).printMe() // prints 10 :: accessing the printMe() method 
}

この例では、「printme（）」という名前の抽象メソッドを持つ1つのインターフェイス「Base」があります。BaseImplクラスでは、この「printme（）」を実装し、後で別のクラスから「by」キーワードを使用してこの実装を使用しています。

上記のコードは、ブラウザに次の出力を生成します。

10

プロパティの委任

前のセクションでは、「by」キーワードを使用した委任デザインパターンについて学習しました。このセクションでは、Kotlinライブラリに記載されているいくつかの標準的な方法を使用したプロパティの委任について学習します。

委任とは、責任を別のクラスまたはメソッドに渡すことを意味します。プロパティがすでにいくつかの場所で宣言されている場合は、同じコードを再利用してそれらを初期化する必要があります。次の例では、Kotlinが提供するいくつかの標準委任方法と、いくつかの標準ライブラリ関数を使用して、例で委任を実装します。

Lazy（）の使用

Lazyは、プロパティを入力として受け取り、その代わりに次のインスタンスを提供するラムダ関数です。 Lazy<T>、ここで、<T>は基本的に使用しているプロパティのタイプです。それがどのように機能するかを理解するために、以下を見てみましょう。

val myVar: String by lazy {
   "Hello"
}
fun main(args: Array<String>) {
   println(myVar +" My dear friend")
}

上記のコードでは、変数「myVar」をLazy関数に渡します。この関数は、そのオブジェクトに値を割り当て、それをmain関数に返します。以下はブラウザでの出力です。

Hello My dear friend

Delegetion.Observable（）

Observable（）は、オブジェクトを初期化するために2つの引数を取り、呼び出された関数に同じものを返します。次の例では、委任を実装するためにObservable（）メソッドを使用する方法を示します。

import kotlin.properties.Delegates
class User {
   var name: String by Delegates.observable("Welcome to Tutorialspoint.com") {
      prop, old, new ->
      println("$old -> $new")
   }
}
fun main(args: Array<String>) {
   val user = User()
   user.name = "first"
   user.name = "second"
}

上記のコードは、ブラウザに次の出力を生成します。

first -> second

一般に、構文は「by」キーワードが委任された後の式です。ザ・get() そして set() 変数のメソッド p に委任されます getValue() そして setValue() Delegateクラスで定義されたメソッド。

class Example {
   var p: String by Delegate()
}

上記のコードの場合、変数に値を割り当てるために生成する必要があるデリゲートクラスは次のとおりです。 p。

class Delegate {
   operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
      return "$thisRef, thank you for delegating '${property.name}' to me!"
   }
   operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
      println("$value has been assigned to '${property.name} in $thisRef.'")
   }
}

読み取り中はgetValue（）メソッドが呼び出され、設定中は変数setValue（）メソッドが呼び出されます。

Kotlinは静的に型付けされた言語であるため、関数はその中で大きな役割を果たします。例全体で関数を使用しているため、関数についてはかなりよく知っています。関数はキーワード「fun」で宣言されています。他のOOPと同様に、戻り値の型とオプション引数リストも必要です。

次の例では、MyFunctionという関数を定義し、メイン関数からこの関数を呼び出して引数を渡します。

fun main(args: Array<String>) {
   println(MyFunction("tutorialsPoint.com"))
}
fun MyFunction(x: String): String {
   var c:String  = "Hey!! Welcome To ---"
   return (c+x)
}

上記のコードは、ブラウザに次の出力を生成します。

Hey!! Welcome To ---tutorialsPoint.com

関数は次のように宣言する必要があります-

fun <nameOfFunction>(<argument>:<argumentType>):<ReturnType>

以下は、Kotlinで使用できるさまざまなタイプの関数の一部です。

ラムダ関数

Lambdaは、関数を宣言して定義しながら、ボイラープレートコードを大幅に削減する高レベルの関数です。Kotlinを使用すると、独自のラムダを定義できます。Kotlinでは、ラムダを宣言し、そのラムダを関数に渡すことができます。

次の例を見てください。

fun main(args: Array<String>) {
   val mylambda :(String)->Unit  = {s:String->print(s)}
   val v:String = "TutorialsPoint.com"
   mylambda(v)
}

上記のコードでは、「mylambda」と呼ばれる独自のラムダを作成し、このラムダに1つの変数を渡しました。これは、String型で、値「TutorialsPoint.com」を含みます。

上記のコードは、ブラウザに次の出力を生成します。

TutorialsPoint.com

インライン関数

上記の例は、Kotlinアプリケーションで使用できるラムダ式の基本を示しています。これで、ラムダを別の関数に渡して、呼び出し元の関数をインライン関数にする出力を取得できます。

次の例を見てください。

fun main(args: Array<String>) {
   val mylambda:(String)->Unit  = {s:String->print(s)}
   val v:String = "TutorialsPoint.com"
   myFun(v,mylambda) //passing lambda as a parameter of another function 
}
fun myFun(a :String, action: (String)->Unit) { //passing lambda 
   print("Heyyy!!!")
   action(a)// call to lambda function
}

上記のコードは、ブラウザに次の出力を生成します。インライン関数を使用して、ラムダをパラメーターとして渡しました。その他の関数は、「inline」キーワードを使用してインライン関数にすることができます。

Heyyy!!!TutorialsPoint.com

Kotlinには、他のプログラミング言語の多くの機能が含まれています。複数の変数を一度に宣言できます。この手法は、Destructuring宣言と呼ばれます。

以下は、破壊宣言の基本的な構文です。

val (name, age) = person

上記の構文では、オブジェクトを作成し、それらすべてを1つのステートメントで一緒に定義しました。後で、次のように使用できます。

println(name)
println(age)

それでは、実際のアプリケーションで同じものをどのように使用できるかを見てみましょう。次の例を考えてみましょう。ここでは、いくつかの属性を持つ1つのStudentクラスを作成し、後でそれらを使用してオブジェクト値を出力します。

fun main(args: Array<String>) {
   val s = Student("TutorialsPoint.com","Kotlin")
   val (name,subject) = s
   println("You are learning "+subject+" from "+name)
}
data class Student( val a :String,val b: String ){
   var name:String = a
   var subject:String = b
}

上記のコードは、ブラウザに次の出力を生成します。

You are learning Kotlin from TutorialsPoint.com

例外処理はプログラミング言語の非常に重要な部分です。この手法は、アプリケーションが実行時に間違った出力を生成するのを制限します。この章では、Kotlinでランタイム例外を処理する方法を学習します。Kotlinの例外は、Javaの例外と非常によく似ています。すべての例外は、「Throwable」クラスの子孫です。次の例は、Kotlinで例外処理手法を使用する方法を示しています。

fun main(args: Array<String>) {
   try {
      val myVar:Int = 12;
      val v:String = "Tutorialspoint.com";
      v.toInt();
   } catch(e:Exception) {
      e.printStackTrace();
   } finally {
      println("Exception Handeling in Kotlin");
   }
}

上記のコードでは、文字列を宣言し、後でその文字列を整数に関連付けました。これは実際には実行時の例外です。したがって、ブラウザに次の出力が表示されます。

val myVar:Int = 12;
Exception Handeling in Kotlin

Note − Javaと同様に、Kotlinもcatchブロックを実行した後にfinallyブロックを実行します。