Kotlin essay 2019-10-31

怼烎@ 2023-06-12 04:19 49阅读 0赞

# Kotlin essay 2019-10-31 #

## 1.Hello world ##

fun main(){
        println("hello world")
    }

#### Notice ####

If you don’t specify a package in a source file, its content goes to the default package.  
In Kotlin versions earlier than 1.3, the main function must have a parameter of type `Array<String>`.

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

### 2.Functions ###

//function type 1
    fun printMessage(message: String): Unit {                               
        println(message)
    }
    
    //function type 2
    fun printMessageWithPrefix(message: String, prefix: String = "Info") {  
        println("[$prefix] $message")
    }
    
    //function type 3
    fun sum(x: Int, y: Int): Int {                                        
        return x + y
    }
    
    //function type 4
    fun multiply(x: Int, y: Int) = x * y                                
    
    fun main() {
        printMessage("Hello")  
        printMessageWithPrefix("Hello", "Log")
        printMessageWithPrefix("Hello")
        printMessageWithPrefix(prefix = "Log", message = "Hello")       
        println(sum(1, 2))
    }

result:

Hello
    [Log] Hello
    [Info] Hello
    [Log] Hello
    3

#### Notice ####

Default return type is Unit,it can be omitted.

#### Infix Functions ####

fun main() {
    
      infix fun Int.times(str: String) = str.repeat(this)        // 1
      println(2 times "Bye ")                                    // 2
    
      val pair = "Ferrari" to "Katrina"                          // 3
      println(pair)
    
      infix fun String.onto(other: String) = Pair(this, other)   // 4
      val myPair = "McLaren" onto "Lucas"
      println(myPair)
    
      val sophia = Person("Sophia")
      val claudia = Person("Claudia")
      sophia likes claudia                                       // 5
    }
    
    class Person(val name: String) {
      val likedPeople = mutableListOf<Person>()
      infix fun likes(other: Person) { likedPeople.add(other) }  // 6
    }

result:

Bye Bye 
    (Ferrari, Katrina)
    (McLaren, Lucas)

#### Operator Functions ####

fun main() {
        operator fun Int.times(str: String) = str.repeat(this)       // 1
        println(2 * "Bye ")    // 2
    
        operator fun String.get(range: IntRange) = substring(range)  // 3
        val str = "Always forgive your enemies; nothing annoys them so much."
        println(str[0..14])        // 4
    }

result:

Bye Bye 
    Always forgive

#### Functions with vararg Parameters ####

Varargs allow you to pass any number of arguments by separating them with commas.

fun printAll(vararg messages: String) {                            // 1
        for (m in messages) println(m)
    }
    printAll("Hello", "Hallo", "Salut", "Hola", "你好")                 // 2
    
    fun printAllWithPrefix(vararg messages: String, prefix: String) {  // 3
        for (m in messages) println(prefix + m)
    }
    printAllWithPrefix(
        "Hello", "Hallo", "Salut", "Hola", "你好",
        prefix = "Greeting: "                                          // 4
    )
    
    fun log(vararg entries: String) {
        printAll(*entries)                                             // 5
    }

result:

Hello
    Hallo
    Salut
    Hola
    你好
    Greeting: Hello
    Greeting: Hallo
    Greeting: Salut
    Greeting: Hola
    Greeting: 你好

### 3. Variables ###

Kotlin has powerful type inference.  
Kotlin does not enforce immutability.  
Use val over var.

fun main() {
        var a: String = "initial"  // 1
        println(a)
        val b: Int = 1             // 2
        val c = 3                  // 3
        println(b)
        println(c)
    }

result:

initial
    1
    3

#### Notice ####

You’re free to choose when you initialize a variable, however, it must be initialized before the first read.  
e.g.1:

fun main() {
        var e: Int  // 1
        println(e)  // 2
    }

result:

Variable 'e' must be initialized

e.g.2:

fun someCondition() = true 
    
    fun main() {
        val d: Int  // 1
        if (someCondition()) {
            d = 1   // 2
        } else {
            d = 2   // 2
        }
    
        println(d) // 3
    }

result:

## 4. Null Safety ##

In an effort to rid the world of NullPointerException, variable types in Kotlin don’t allow the assignment of null. If you need a variable that can be null, declare it nullable by adding ? at the end of its type.

fun main() {
        var neverNull: String = "This can't be null"            // 1
    
        neverNull = null                                        // 2 error
    
        var nullable: String? = "You can keep a null here"      // 3
    
        nullable = null                                         // 4
    
        var inferredNonNull = "The compiler assumes non-null"   // 5
    
        inferredNonNull = null                                  // 6 error
    
        fun strLength(notNull: String): Int {                   // 7
            return notNull.length
        }
    
        strLength(neverNull)                                    // 8
        strLength(nullable)                                     // 9 error
    }

result:

Null can not be a value of a non-null type String
    Null can not be a value of a non-null type String
    Type mismatch: inferred type is String? but String was expected

## 5. Classes ##

Class name,class header and class body.  
if the class has no body, curly braces can be omitted.

class Customer                                  // 1
    
    class Contact(val id: Int, var email: String)   // 2
    
    fun main() {
        val customer = Customer()                   // 3
        val contact = Contact(1, "mary@gmail.com")  // 4
        println(contact.id)                         // 5
        contact.email = "jane@gmail.com"            // 6
        println(contact.email)            // 7
    }

result:

1
    jane@gmail.com

## 6. Generics ##

### Generic Classes ###

class MutableStack<E>(vararg items: E) {              // 1
    
      private val elements = items.toMutableList()
    
      fun push(element: E) = elements.add(element)        // 2
    
      fun peek(): E = elements.last()                     // 3
    
      fun pop(): E = elements.removeAt(elements.size - 1)
    
      fun isEmpty() = elements.isEmpty()
    
      fun size() = elements.size
    
      override fun toString() = "MutableStack(${elements.joinToString()})"
    }
    
    fun main() {
      val stack = MutableStack(0.62, 3.14, 2.7)
      stack.push(9.87)
      println(stack)
    
      println("peek(): ${stack.peek()}")
      println(stack)
    
      for (i in 1..stack.size()) {
        println("pop(): ${stack.pop()}")
        println(stack)
      }
    }

result:

MutableStack(0.62, 3.14, 2.7, 9.87)
    peek(): 9.87
    MutableStack(0.62, 3.14, 2.7, 9.87)
    pop(): 9.87
    MutableStack(0.62, 3.14, 2.7)
    pop(): 2.7
    MutableStack(0.62, 3.14)
    pop(): 3.14
    MutableStack(0.62)
    pop(): 0.62
    MutableStack()

### Generic Functions ###

class MutableStack<E>(vararg items: E) {              // 1
    
      private val elements = items.toMutableList()
    
      fun push(element: E) = elements.add(element)        // 2
    
      fun peek(): E = elements.last()                     // 3
    
      fun pop(): E = elements.removeAt(elements.size - 1)
    
      fun isEmpty() = elements.isEmpty()
    
      fun size() = elements.size
    
      override fun toString() = "MutableStack(${elements.joinToString()})"
    }
    
    fun <E> mutableStackOf(vararg elements: E) = MutableStack(*elements)
    
    fun main() {
      val stack = mutableStackOf(0.62, 3.14, 2.7)
      println(stack)
    }

result:

MutableStack(0.62, 3.14, 2.7)

## 7. Inheritance ##

open class Dog {                // 1
        open fun sayHello() {       // 2
            println("wow wow!")
        }
    }
    
    class Yorkshire : Dog() {       // 3
        override fun sayHello() {   // 4
            println("wif wif!")
        }
    }
    
    fun main() {
        val dog: Dog = Yorkshire()
        dog.sayHello()
    }

result:

wif wif!

#### Notice ####

Kotlin classes are final by default.  
Kotlin methods are also final by default.

### Inheritance with Parameterized Constructor ###

open class Tiger(val origin: String) {
        fun sayHello() {
            println("A tiger from $origin says: grrhhh!")
        }
    }
    
    class SiberianTiger : Tiger("Siberia")                  // 1
    
    fun main() {
        val tiger: Tiger = SiberianTiger()
        tiger.sayHello()
    }

result：

A tiger from Siberia says: grrhhh!

### Passing Constructor Arguments to Superclass ###

open class Lion(val name: String, val origin: String) {
        fun sayHello() {
            println("$name, the lion from $origin says: graoh!")
        }
    }
    
    class Asiatic(name: String) : Lion(name = name, origin = "India") // 1
    
    fun main() {
        val lion: Lion = Asiatic("Rufo")                              // 2
        lion.sayHello()
    }

result:

Rufo, the lion from India says: graoh!

Asiatic name pass to Lion name.