Kotlin学习——hello kotlin & 函数function & 变量 & 类 + 泛型 + 继承

Love The Way You Lie 2024-02-18 12:51 52阅读 0赞

![在这里插入图片描述][e2ebf88730c6425e970258ce31df3de2.png]

Kotlin 是一门现代但已成熟的编程语言，旨在让开发人员更幸福快乐。 它简洁、安全、可与 Java 及其他语言互操作，并提供了多种方式在多个平台间复用代码，以实现高效编程。

[https://play.kotlinlang.org/byExample/01\_introduction/02\_Functions][https_play.kotlinlang.org_byExample_01_introduction_02_Functions]

#### 目录 ####

*  引出
 *  hello
 *  function函数
 *   *  Infix Functions 中缀函数
     *  Operator Functions 算术函数
     *  变长参数vararg Parameters
 *  变量
 *   *  kt中的null
 *  kt中的类
 *  泛型 Generics
 *   *  泛型函数Generic Functions
 *  继承Inheritance
 *   *  超类Asiatic
 *  总结

## 引出 ##

--------------------

1.kotlin初识；  
2.function函数，变量，null；  
3.泛型，接口，继承，超类；

## hello ##

![在这里插入图片描述][a1c100b1bcd64b20afe7a1237d9ceb4a.png]

package com.tianju.ktLearn
    
    
    fun main() {
                                // 2
        println("Hello, World!")        // 3
    }

## function函数 ##

*  返回值为Unit，表示没有返回值, 类似与java里面的 void
 *  Unit可以省略不写，可以传两个参数，参数带有默认值

![在这里插入图片描述][40f299c036eb4427bbbfa66ac967dedc.png]

package com.tianju.ktLearn
    
    // 返回值为Unit，表示没有返回值, 类似与java里面的 void
    fun printMsg(msg: String): Unit {
        
        println(msg)
    }
    
    // Unit可以省略不写，可以传两个参数，参数带有默认值
    fun printMsgWithPrefix(msg: String, prefix:String = "info") {
        
        println("[wtt--$prefix] $msg")
    }
    
    fun sum(x: Int, y: Int): Int {
        
        return x+y;
    }
    
    fun multiply(x: Int,y: Int) = x*y
    
    fun main() {
        
        printMsg("Pet!")
        // 可以不传参，带有默认参数的
        printMsgWithPrefix("Hello")
        printMsgWithPrefix("Hello","Peter")
        printMsgWithPrefix(prefix = "MMDD", msg = "HTTP")
        val sum = sum(100, 300)
        println(sum)
        println(multiply(3,30))
    }

### Infix Functions 中缀函数 ###

具有单个参数的成员函数和扩展可以转换为中缀函数。

![在这里插入图片描述][78ee768d31604381adc460ce3f7140ae.png]

package com.tianju.ktLearn;
    
    // 具有单个参数的成员函数和扩展可以转换为中缀函数
    fun main(){
        
            infix fun Int.times(str: String) = str.repeat(this)
            println(2 times "Hei!")
    
    
            // to 是标准库中的函数 kotlin.Pair<A, B>
            val  pair = "WHTT" to "PPTS"
            println(pair)
    
            // 自定义一个 onto 函数
            infix fun String.onto(str: String) = Pair(this,str)
            val myPair = "MVC" onto "WWW"
            println(myPair)
    
            val pet = Person("peter",34)
            val Shi = Person("Shirley",30)
            pet likes Shi
            println(pet.people[0])
    }
    
    class Person(val name: String,val year: Int){
        
    
            val people = mutableListOf<Person>()
            infix fun likes(person: Person){
        
                    people.add(person)
            }
    
    }

### Operator Functions 算术函数 ###

Certain functions can be “upgraded” to [operators][], allowing their calls with the corresponding operator symbol.

![在这里插入图片描述][69d2a65d2a5749afa432f9eceac20620.png]

package com.tianju.ktLearn
    
    // 符号times 就是 下面的 乘号 *
    operator fun Int.times(str:String) = str.repeat(this)
    
    fun main() {
        
        println(2 * "Bye")
        val str = "Always forgive your enemies; nothing annoys them so much."
        operator fun String.get(range: IntRange) = substring(range)
        println(str[0..14])
    }

### 变长参数vararg Parameters ###

![在这里插入图片描述][7222ac4ba7494bab86c5ae3d6cf1434d.png]

package com.tianju.ktLearn
    
    fun printAll(vararg msgs: String) {
        
        for (msg in msgs){
        
            println(msg)
        }
    }
    
    fun printWithPre(vararg msgs: String, prefix:String): Unit {
        
        for (msg in msgs) println("[嘻嘻嘻--$prefix]$msg")
    }
    
    fun logs(vararg msgs:String){
        
        printAll(*msgs)
    }
    
    fun main() {
        
        printAll("pet","sh","wt")
        printWithPre("pet","sh","wt", prefix ="Hi")
        logs("sh","wtt","abc")
    
    }

## 变量 ##

Kotlin具有强大的类型推理能力。虽然你可以显式地声明变量的类型，但你通常会让编译器通过推断来完成这项工作。Kotlin不强制执行不变性，但建议这样做。本质上使用val而不是var。

val b: Int = 1             // 2
    val c = 3                  // 3

声明一个不可变变量并对其进行初始化。

声明一个不可变变量并在不指定类型的情况下对其进行初始化。编译器推断类型Int。

### kt中的null ###

*  在kt里面，如果有一个可以为null，需要在类型后面加上 问号 ?
 *  函数只能传入不为null的值
 *  参数类型后面加个 ? 问号后，传入的值可以为null

![在这里插入图片描述][f529846bfcc54e33ab02b152c6825277.png]

![在这里插入图片描述][443a6f9b61204ac697bfa2384ccfbe7f.png]

package com.tianju.ktLearn
    
    
    fun main() {
        
        var neverNull : String = "never Null"
        // neverNull = null
        println(neverNull)
    
        // 在kt里面，如果有一个可以为null，需要在类型后面加上 问号 ?
        var nullable:String? = "can be null"
        nullable = null
        println(nullable)
        fun strLength(notNull:String ): Int {
        
            return notNull.length
        }
    
        // 函数只能传入不为null的值
        strLength(neverNull)
    //    strLength(nullable) // 爆红
    
        val str = descStr(null)
        println(str)
    
        println(descStr("hello are you ok?"))
    }
    
    /**
     * 返回值为String，
     * 参数类型后面加个 ? 问号后，传入的值可以为null
     */
    fun descStr(maybeStr: String?): String {
        
        if (maybeStr !=null && maybeStr.length>0){
        
            return "StrLength is ${maybeStr.length}"
        }
        return "null"
    }

## kt中的类 ##

*  在kt里面没有 new 关键字

![在这里插入图片描述][2313f6662166417b9a40056182608630.png]

## 泛型 Generics ##

![在这里插入图片描述][1ac6e07d9bb04426933b2a31f8b30b45.png]

package com.tianju.ktLearn
    
    /**
     * 可以输入多个参数 vararg
     * <E> 泛型
     */
    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 mut = MutableStack<String>("hello","pet")
        println("is mut empty?---> " + mut.isEmpty())
        print(mut)
        mut.push("wtt")
        println(mut)
        mut.peek()
        println(mut)
        val pop = mut.pop()
        println(pop)
        println(mut)
        println("is mut empty?---> " + mut.isEmpty())
    }

![在这里插入图片描述][fa0b68d01aba439caed7bb599df8a75a.png]

### 泛型函数Generic Functions ###

如果函数的逻辑独立于特定类型，则也可以生成函数。例如，您可以编写一个实用程序函数来创建可变堆栈：

![在这里插入图片描述][1cf7d688125b447aa619a0598173565c.png]

## 继承Inheritance ##

![在这里插入图片描述][3bba4bd7aaad401bb1bfa1a8d2306b6d.png]

![在这里插入图片描述][1eacdf1770324d87833b35263172c241.png]

### 超类Asiatic ###

![在这里插入图片描述][4c72893649b949b3819a6644f859b0a8.png]

![在这里插入图片描述][a3b564696e074488ac9047fd8a8c4625.png]

package com.tianju.ktLearn
    
    /**
     * open 关键字就表示是接口 interface
     */
    open class Dog{
        
        open fun fake(){
        
            println("wow wow !")
        }
    }
    
    class YourDog : Dog(){
        
        override fun fake() {
        
            println("miao wu ,wow")
        }
    }
    
    /**
     * 带参数的接口
     * interface with par
     */
    open class Cat(val name: String){
        
        fun sayHello(){
        
            println("A cat name is [$name] say hello")
        }
    }
    
    class Arya : Cat("Arya")
    
    /**
     * 超类 ：将构造函数参数传递给超类
     */
    open class Lion(val name:String,val age: Int){
        
        fun sayHello(){
        
            println("hi, every one, my name is $name, age is $age")
        }
    }
    
    /**
     * Asiatic声明中的name既不是var也不是val：它是一个构造函数参数
     */
    class Asiatic(name: String) : Lion(name = name, age = 18)
    
    
    fun main() {
        
        val dog = YourDog()
        dog.fake()
    
        val cat : Cat = Arya()
        cat.sayHello()
        println(cat.name)
    
        val lion: Lion = Asiatic("Peter")
        lion.sayHello()
    }

--------------------

## 总结 ##

1.kotlin初识；  
2.function函数，变量，null；  
3.泛型，接口，继承，超类；

[e2ebf88730c6425e970258ce31df3de2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/021a2f8ebc98479283e7f7be9ef0ab0a.png
[https_play.kotlinlang.org_byExample_01_introduction_02_Functions]: https://play.kotlinlang.org/byExample/01_introduction/02_Functions
[a1c100b1bcd64b20afe7a1237d9ceb4a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/ad270ed9bf834259acdb232b6a4394b6.png
[40f299c036eb4427bbbfa66ac967dedc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/440d04f0d248418aa22d3b72b259d686.png
[78ee768d31604381adc460ce3f7140ae.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/687c2d0f96174605a82e4d6ad430ac47.png
[operators]: https://kotlinlang.org/docs/reference/operator-overloading.html
[69d2a65d2a5749afa432f9eceac20620.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/992ca9643bcb4a2eb57cb385d874841f.png
[7222ac4ba7494bab86c5ae3d6cf1434d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/aa4689ceebaf4e4385403b542e6b494c.png
[f529846bfcc54e33ab02b152c6825277.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/8551980877de47fc89ffe5f277d5193a.png
[443a6f9b61204ac697bfa2384ccfbe7f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/f579778d61df47a79c40363a57b3fd5d.png
[2313f6662166417b9a40056182608630.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/49daacaaf543442d86dc790710c9b77e.png
[1ac6e07d9bb04426933b2a31f8b30b45.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/74d88be5502641a18e8bc3425a67a686.png
[fa0b68d01aba439caed7bb599df8a75a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/ad0803335db04a9cbefd516a514b25eb.png
[1cf7d688125b447aa619a0598173565c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/a4fe7bfcf93e481d881a0e0b51483d87.png
[3bba4bd7aaad401bb1bfa1a8d2306b6d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/25cb05eff45e4be8aca05a8e77040019.png
[1eacdf1770324d87833b35263172c241.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/7fd812a3643641f59fea71570df7a49b.png
[4c72893649b949b3819a6644f859b0a8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/a4df08769ae242eaa3b2f5eb05c726d6.png
[a3b564696e074488ac9047fd8a8c4625.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/18/f243007b596f42a798c9cf7d6b3bafbc.png