コトリン-概要

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

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

長所と短所

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

*Easy Language* -Kotlinは関数型言語であり、非常に簡単に学習できます。 構文はJavaに非常によく似ているため、覚えやすいです。 Kotlinはより表現力があり、コードをより読みやすく、理解しやすくします。

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

ランタイムとパフォーマンス-パフォーマンスの向上とランタイムの短縮。

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

*Brand New* -Kotlinは、開発者に新たなスタートを与えるブランドの新しい言語です。 JVMを介して開発されていますが、Javaに置き換わるものではありません。 アンドロイド開発の最初の公式言語として受け入れられています。 Kotlinは次のように定義できます-Kotlin = JAVA +追加の更新された新機能。

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

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

静的宣言なし-Kotlinには、従来のJava開発者に何らかの問題を引き起こす可能性のあるJavaのような通常の静的処理修飾子がありません。

Kotlin-環境設定

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

ステップ1 *-Java 8のインストール。

したがって、KotlinはJVMで実行されます。ローカルのKotlin開発にはJDK 8を使用することが本当に必要です。 JDK 8以上のバージョンをダウンロードしてインストールするには、http：//www.oracle.com/technetwork/java/javase/downloads/indexl [oracle]の公式Webサイトを参照してください。 JAVAの環境変数は、適切に機能するように設定する必要があります。 Windowsオペレーティングシステムでのインストールを確認するには、コマンドプロンプトで「java –version」を押すと、出力としてシステムにインストールされているjavaバージョンが表示されます。

ステップ2 *-IDEのインストール。

インターネット経由で多くのIDEを利用できます。任意の選択肢を使用できます。次の表に、さまざまなIDEのダウンロードリンクがあります。

IDE Name	Installation Link
NetBeans	https://netbeans.org/downloads/
Eclipse	https://www.eclipse.org/downloads/
Intellij	https://www.jetbrains.com/idea/download/#section = windows

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

ステップ3 *-Eclipseの構成。

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

Eclipse Market Place

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

ステップ4 *-Kotlinプロジェクト。

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

Kotlinプロジェクト

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

こんにちは

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

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

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

Hello, World!

Kotlin-アーキテクチャ

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

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

アーキテクチャ

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

Kotlin-基本タイプ

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

番号

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

Type	Size
Double	64
Float	32
Long	64
Int	32
Short	16
Byte	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変数は、“ var” *を使用する方法と“ val” *を使用する方法の2つの方法で宣言できます。

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

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

ブール値

ブール値は、他のプログラミング言語のように非常に簡単です。ブール値には、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つは*不変コレクション*（これはリスト、マップ、および編集不可のセットを意味します）ともう1つは*ミュータブルコレクション*（このタイプのコレクションは編集可能）です。 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]

範囲

範囲もコトリンのユニークな特徴です。 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で利用可能なさまざまなタイプの制御フローメカニズムについて説明します。

If-その他

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

Whenの使用

他のプログラミング言語に精通している場合は、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

ループ用

ループは、あらゆる種類のデータ構造を反復処理する柔軟性を提供するような発明です。他のプログラミング言語と同様に、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ループ*の使用法を示しています。

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ループ*の使用法を示しています。

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、Break、Continueの使用

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

*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

継続と中断-継続と中断は論理的な問題の最も重要な部分です。「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-クラスとオブジェクト

この章では、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 finddevguides.com"
   }
}

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

Welcome to The finddevguides.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 finddevguides.com"
   inner class Nested {
      fun foo() = welcomeMessage
   }
}

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

Welcome to the finddevguides.com

匿名の内部クラス

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

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のコンストラクターについて学習します。 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("finddevguides.com", 15)
   println("First Name = ${person1.firstName}")
   println("Age = ${person1.age}")
}
class Person(val firstName: String, var age: Int) {
}

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

First Name = finddevguides.com
Age = 15

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

fun main(args: Array<String>) {
   val HUman = HUman("finddevguides.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) {
   }
}

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

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

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

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

Calling hello(): Hello there, Welcome to finddevguides.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-可視性コントロール

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

非公開

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

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

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

保護されています

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

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

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

内部

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

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

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

パブリック

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

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

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

Kotlin-拡張機能

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

機能拡張

関数の拡張では、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 finddevguides.com")
      }
   }
}

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

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

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

Kotlin-データクラス

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

すべてのデータクラスには1つのプライマリコンストラクターが必要であり、すべてのプライマリコンストラクターには少なくとも1つのパラメーターが必要です。クラスがデータとしてマークされるたびに、「toString（）」、「hashCode（）」など、そのデータクラスの組み込み関数の一部を使用できます。データクラスには、abstract and 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つのデータクラスを作成し、メイン関数からそのすべてのデータメンバーにアクセスしたブラウザーで、次の出力を生成します。

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」クラスと呼ばれる別のクラスタイプについて学習します。このタイプのクラスは、制限されたクラス階層を表すために使用されます。 Sealedを使用すると、開発者は事前定義された型のデータ型を維持できます。シールドクラスを作成するには、そのクラスの修飾子としてキーワード「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はGenericsと呼ばれるより高次の変数型付けを提供します。この章では、KotlinがGenericsを実装する方法、および開発者としてGenericsライブラリ内で提供される機能を使用する方法を学習します。実装に関しては、ジェネリックはJavaにかなり似ていますが、Kotlin開発者はKotlinコードをより読みやすく、開発者が簡単にするために、2つの新しいキーワード*“ out” および“ in” *を導入しました。

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)
   }
}

上記のコード部分では、 <T> として表される汎用戻り型を持つ1つのクラスを作成しています。 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は、新しいキーワード*“ 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」キーワードを使用してこの実装を使用しています。

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

プロパティの委任

前のセクションでは、「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関数に渡します。これにより、値がオブジェクトに割り当てられ、メイン関数に同じ値が返されます。以下はブラウザの出力です。

Hello My dear friend

Delegetion.Observable（）

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

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

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

first -> second

一般に、構文は「by」キーワードが委任された後の式です。変数 p の* get（）および set（）メソッドは、Delegateクラスで定義された getValue（）および setValue（）*メソッドに委任されます。

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-関数

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

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

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

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

Hey!! Welcome To ---finddevguides.com

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

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

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

ラムダ関数

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

次の例を見てください。

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

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

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

finddevguides.com

インライン関数

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

次の例を見てください。

fun main(args: Array<String>) {
   val mylambda:(String)->Unit  = {s:String->print(s)}
   val v:String = "finddevguides.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!!!finddevguides.com

Kotlin-破壊宣言

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

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

val (name, age) = person

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

println(name)
println(age)

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

fun main(args: Array<String>) {
   val s = Student("finddevguides.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 finddevguides.com

Kotlin-例外処理

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

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

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

val myVar:Int = 12;
Exception Handeling in Kotlin

注-Javaと同様に、Kotlinはcatchブロックの実行後にfinallyブロックも実行します。

Kotlin-quick-guide

コトリン-概要

長所と短所

Kotlin-環境設定

Kotlin-アーキテクチャ

Kotlin-基本タイプ

番号

キャラクター

ブール値

文字列

配列

コレクション

範囲

Kotlin-制御フロー

If-その他

Whenの使用

ループ用

WhileループとDo-Whileループ

Return、Break、Continueの使用

Kotlin-クラスとオブジェクト

ネストされたクラス

内部クラス

匿名の内部クラス

タイプエイリアス

Kotlin-コンストラクター

コトリン-継承

Kotlin-インターフェース

Kotlin-可視性コントロール

非公開

保護されています

内部

パブリック

Kotlin-拡張機能

機能拡張

オブジェクト拡張

Kotlin-データクラス

コトリン-シールドクラス

コトリン-ジェネリック

コトリン-委任

プロパティの委任

Lazy（）を使用する

Delegetion.Observable（）

Kotlin-関数

ラムダ関数

インライン関数

Kotlin-破壊宣言

Kotlin-例外処理