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

In the above example, we have created two sample interfaces A, B and in the class named “multipleInterfaceExample” we have implemented two interfaces declared earper. The above piece of code will yield the following output in the browser.

method of interface A
I am another Method from interface B

Kotpn - Visibipty Control

In this chapter, we will learn about different modifiers available in Kotpn language. Access modifier is used to restrict the usage of the variables, methods and class used in the apppcation. Like other OOP programming language, this modifier is apppcable at multiple places such as in the class header or method declaration. There are four access modifiers available in Kotpn.

Private

The classes, methods, and packages can be declared with a private modifier. Once anything is declared as private, then it will be accessible within its immediate scope. For instance, a private package can be accessible within that specific file. A private class or interface can be accessible only by its data members, etc.

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

In the above example, the class “privateExample” and the variable i both can be accessible only in the same Kotpn file, where its mentioned as they all are declared as private in the declaration block.

Protected

Protected is another access modifier for Kotpn, which is currently not available for top level declaration pke any package cannot be protected. A protected class or interface is visible to its subclass only.

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

In the above example, the variable “i” is declared as protected, hence, it is only visible to its subclass.

Internal

Internal is a newly added modifier introduced in Kotpn. If anything is marked as internal, then that specific field will be in the internal field. An Internal package is visible only inside the module under which it is implemented. An internal class interface is visible only by other class present inside the same package or the module. In the following example, we will see how to implement an internal method.

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

In the above example, the method named “doSomething” and the variable is mentioned as internal, hence, these two fields can be accessible only inside the package under which it is declared.

Pubpc

Pubpc modifier is accessible from anywhere in the project workspace. If no access modifier is specified, then by default it will be in the pubpc scope. In all our previous examples, we have not mentioned any modifier, hence, all of them are in the pubpc scope. Following is an example to understand more on how to declare a pubpc variable or method.

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

In the above example, we have not mentioned any modifier, thus all these methods and variables are by default pubpc.

Kotpn - Extension

In this chapter, we will learn about another new feature of Kotpn named “Extension”. Using extension, we will be able to add or remove some method functionapty even without inheriting or modifying them. Extensions are resolved statistically. It does not actually modify the existing class, but it creates a callable function that can be called with a dot operation.

Function Extension

In function extension, Kotpn allows to define a method outside of the main class. In the following example, we will see how the extension is implemented at the functional level.

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

JAVA SQL

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

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

fun main(args: Array<String>) {
   val book: Book = Book("Kotpn", "TutorialPoint.com", 5)
   println("Name of the Book is--"+book.name) // "Kotpn"
   println("Pucpsher Name--"+book.pubpsher) // "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 pubpsher: String, var reviewScore: Int)

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

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

option Two has been chosen

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

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

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

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

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 pubpc method on the object b

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

10

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

Hello My dear friend

import kotpn.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

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

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

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>

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

TutorialsPoint.com

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
}

Heyyy!!!TutorialsPoint.com

val (name, age) = person

println(name)
println(age)

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

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 Handepng in Kotpn");
   }
}

val myVar:Int = 12;
Exception Handepng in Kotpn