Kotlin编程权威指南学习知识点预览

一、变量、常量和类型:

        变量、常量以及 Kotlin 基本数据类型。变量常量在 应用程序中可用来储值和传递数据。类型则用来描述常量或变量中保存的是什么样的数据。    

        1、声明变量:

// 变量定义关键字 —— 变量名 —— 类型定义 —— 赋值运算符 —— 赋值var name : Int = 5

        2 、Kotlin的内置数据类型:

        3、只读变量:

                Kotlin 提供了一种语法来声明只读变量,也就是说,变量一旦赋值就不能更改。

                要声明可修改变量,使用 var 关键字。要声明只读变量,使用 val 关键字。

         4、类型推断:

                Kotlin 有个语言特性叫类型推断,对 于已声明并赋值的变量,它允许你省略类型定义。

var age = 5
val fristName = "Everbrilliant89"

          5、编译时常量: 

               编译时常量只能在函数(指包括 main 在内的所有函数)之外定义。这是因为,编译时常量必须在编译时(程序编译时)赋值,而 main 和其他函数都是在运行时(程序运行时)才调用, 函数内的变量也是在那时赋值。编译时常量要在这些变量赋值前就已存在。

const val MAX_VALUE = 5000

          

二、条件语句:

        1、if/else语句:

        2、range :

                在 in 1..5 中,..是一种操作符,表示某个范围(range)。范围包括从..操作符左侧的值到..操作符右侧值的一系列值。所以,1..5 包括 12345。除了数字,范围也可以是一 系列字符。

        3、when表达式:

                when 表达式是 Kotlin 的另一个控制流工具。类似于 if/else 语句,when 表达式允许你编写条件式,在某个条件满足时,就执行对应的代码。它的语法比较简洁,非常适合有三到四个分支 的情况。

 fun demoFunc() {val faction = when(race) {"dwarf" -> "Keepers of the Mines""gnome" -> "Keepers of the Mines""orc" -> "Free People of the Rolling Hills""human" -> "Free People of the Rolling Hills"else -> "noName"}}

三、函数:

        函数是能完成某项特定任务的可复用代码块,是编程非常重要的一部分。

        1、函数结构的剖析:

                一个函数的两个主要部分:函数头和函数体。

 

        2、函数头:

       

  • 修饰符:private、public、protected
  • 函数声明关键字:fun
  • 函数名:
  • 函数参数:函数参数总是只读的,你不能在函数体内再给它们赋值。
  • 函数返回类型

         3、函数的作用域:

         4、默认值参数: 

                参数列表中可以给参数赋值默认的值。

 private fun castFirebal(numFireballs: Int = 2) {println("A glass of Fireball springs into existence. (x$numFireballs)")}

          5、 单表达式函数:

                 函数都只有一个表达式语句,或者说都只有一条求 值语句。Kotlin 提供了更简单的方式来定义这类函数,对于这类单表达式函 数,返回类型、花括号、返回语句都可以省掉。

   

private fun castFirebal(numFireballs: Int = 2) = println("A glass of Fireball springs into existence. (x$numFireballs)")

             6、具名函数参数:   

        castFirebal(5)//具名函数castFirebal(numFireballs = 6)

             7、Unit函数:

                Kotlin 使用 Unit 返回类型表明这样一件事:函数没有返回值。函数定义 中如果没使用 return 关键字,那暗含的意思就是,Unit 就是这个函数的返回类型。

             8、Nothing类型: 

                Kotlin 还有一种叫作 Nothing 的类型。类似于 UnitNothing 类型的函数也不返回任何东 西。但这是它们唯一相同的地方。在编译器看来,Nothing 就意味着函数不可能成功执行完成, 它要么抛出异常,要么因某个原因再也返不回调用处。

             9、Java中的文件级函数:

                 Java 中,函数和变量都只能定义在类里,但 Kotlin 没有这样 的要求。

            10、函数重载:

                如果一个函数有多种实现,就可以说它被重载了。默认值参并 不是重载的唯一方式。你可以用相同的函数名定义多个实现。

             11、反引号中的函数名:

                定义或调用以空格和其他特殊字符命名的函数,不过,函数名要用一对反引号括起来。首先是支持 Java 互操作。Kotlin 提供了很多便利的工具,支持在 Kotlin 文件中调用现有 Java 代码的方法(Kotlin Java 的互操作详见第 20 章)。Kotlin Java 各自有不同的保留关键字,不 能用作函数名。使用反引号括住函数名就能避免任何潜在冲突。

                在 Kotlin 中,is 是个保留关键字(你会在第 14 章中看到,Kotlin 的标准库有个 is 操作符, 可以用来检查实例类型)。而在 Java 中,is 不是关键字,所以是有效的方法名。有了反引号,就 可以在 Kotlin 中调用 Java is 方法了。

          

四、匿名函数与函数类型:

                定义时不取名字的函数,我们称之为匿名函数。匿名 函数和具名函数既相似又不同。明显的不同之处有两个:匿名函数的定义中没有名字;和其他代码交互的方式有点特别。匿名函数通常整体传递给其他函数,或者从其他函数返回。这种交互主 要靠函数类型函数参数实现。

            1、匿名函数:

                    把一个匿名函数作为参数传递给 count 函数: 

    val numLetters = "guangdongshenzhen".count({letters -> letters == 's'})//匿名函数作为参数传入函数countval numLetters1 = "guangdongshenzhen".count { letters ->letters == 's'}//count函数在源码中的定义public inline fun CharSequence.count(predicate: (Char) -> Boolean): Int {var count = 0for (element in this) if (predicate(element)) ++countreturn count}
  • 函数类型:匿名函数也有类型,我们称其为函数类型(function type)。匿名函数可以当作变量值赋给函数类型变量。然后,就像其他量一 样,匿名函数就可以在代码里传递了      
    //匿名函数赋值给变量//: () -> String 表示变量存储的是哪种类型的函数// () -> String 是你给 greetingFunction 变量指定的函数类型定义val greetingFunction :() -> String = {val currentYear = 2018"Welcome to SimVillage, Mayor! (copyright $currentYear)"}
  • 隐式返回:和具名函数不一样,除了极少数的情况外,匿名函数不需要 return 关键字来返回数据。没有 return 关键字,为了返回数据,匿名函数会隐式或自动返回函数体最后一行语句的结果。
  • 函数参数:需要带参数时,参数的类型放在匿名函数的类型定义中,参数名则放在函数定义中。
    val greetingFunction :(String) -> String = { youName ->"你好,我的名字叫: $youName)"}
  • it关键字:定义只有一个参数的匿名函数时,可以使用 it 关键字来表示参数名。当你有一个只有一个参数的匿名函数时,it和命名参数都有效。 
    val greetingFunction :(String) -> String = { "你好我的名字叫: $it)"}
  •  多个参数:it 关键字语法只适用于一个参数的情况。匿名函数支持多个参数。如果有多个参数,需要使用命名参数。   
     val greetingFunction :(String,Int) -> String = {myName,age ->"你好我的名字叫: $myName" + ",今年:$age 岁了"}

        2.类型推断:

        定义一个变量 时,如果已把匿名函数作为变量值赋给它,就不需要显式指明变量类型了。类型推断也支持带参数的匿名函数,但为了帮助编译器更准确地推断变量类型,匿名函数的 参数名和参数类型必须有。    

    val greetingFunction = {myName:String,age:Int ->"你好我的名字叫: $myName" + ",今年:$age 岁了"}

       3、定义参数是函数的函数:

         函数支持包括函数在内的任何类型的参数。一个函数类型的参数定义起来和其他类型的参数 一样:在函数名后的一对圆括号内列出,再加上类型。

    val greetingFunction = {myName:String,age:Int ->"你好我的名字叫: $myName" + ",今年:$age 岁了"}fun runSimulation(name :String ,greegreetingFunction :(String,Int) -> String) {var age = 18println(greetingFunction(name, age))}

        4、函数内联:

                Kotlin 有一种优化机制叫内联,可以解决 lambda 引起的内存开销问题。有了内联,JVM 就不需要使用 lambda 对象实例了,因而避免了变量内存分配。为了使用内联方法优化 lambda,以 inline 关键字标记使用 lambda 的函数即可。

    inline fun runSimulation(name :String ,greegreetingFunction :(String,Int) -> String) {var age = 18println(greetingFunction(name, age))}

         5、函数引用:

           函数引用可以把一个具名函数(使用 fun 关键字定义的函数)转换成一个值参。要获得函数引用,使用::操作符,后跟要引用的函数名。     

    protected fun demoFunc() {runSimulation("WY",::costPrinter)}private fun runSimulation(name: String, costPrinter: KFunction1<Int, Unit>) {}fun costPrinter(num :Int) {val cost = 400println("construction cost: ${cost * num}")}

        6、函数类型作为返回类型:

        和其他数据类型一样,函数类型也是有效的返回类型,也就是说,你可以定义一个能返回函 数的函数。

       

五、null安全与异常:

        null 是个特殊值,用来表明 var val 变量的值不存在。包括 Java 在内的许多编程语言中, null 常常会导致应用崩溃,因为让不存在的东西做事情是不可能的。如果一个 var val 变量能 接受 null 值,Kotlin 需要你做个特别声明。这有助于避免 null 相关的应用崩溃。

        1、可空性:

         对于 null 值问题,Kotlin 反其道而行之。除非另有规定,变量不可为 null 值。

        2、Kotlin的null类型:

    protected fun demoFunc() {var beverage = readLine()beverage = null // 如返回值不是String?而是String则赋值为null则报错}//String?表示可空String的类型private fun readLine(): String? {return "nihao"}

        3、null安全:

         Kotlin 区分可空类型和非可空类型,所以,你要一个可空类型变量做事,而它又可能不存在,对于这种潜在危险,编译器时刻警惕着。为了应对这种风险,Kotlin 不允许你在可空类型值上调用函数,除非你主动接手安全管理。

  • 安全调用操作符(?.):不确定会不会返回null,此时可选择使用安全调用操作符;
    var beverage = readLine()?.capitalize()
  • 使用带let的安全调用:主要作用是在指定的作用域内定义一个或多个变量。
      var beverage = readLine()?.let { if (it.isNotBlank()) {it.capitalize()} else {"isBlank"}}
  • 使用!!.操作符:!!.操作符也能用来在可空类型上调用函数。但我要给你个警告:相比安全调用操作符,!!.操作符太激进,一般应该避免使用。视觉上看,代码中的!!.操作符也给人语气很重的感觉,因为它真的很危险。如果你用了!!.,就是在向编译器宣布:“万一我使唤干活的东不存在,我要求你立刻抛出空指针异常!!”(顺便提一下,!!.的官方名字是非空断言操作符但开发人员更喜欢叫它“感叹号操作符”。)
    var beverage = readLine()!!.length
  • 使用if判断null值情况;
  • 使用空合并操作符号:另一种检查 null 值的方式是使用 Kotlin 空合并操作符?:
        var beverage = readLine()val beverageServed:String = beverage ?: "Buttered Ale"

        4、异常:

  • 抛出异常:Kotlin 允许你主动示意有异常发生。这种行为又叫抛出一个异常,由throw 操作符触发。
  • 自定义异常:
  • 异常处理:try/catch 语句,Kotlin 可以让你决定如何来处理异常。

         5、先决条件函数:

  

六、字符串:

        1、字符串截取:

  • substring:   
  • split:  

        2、字符串操作:

  • replace函数:

        3、字符串比较:

        引用相等比较很少用于比较字符串。一般来说,相比关心两个字符串是不是同一实例,我们
更关心它们是不是相等字符,以及顺序是否一致(或者说两个不同的类实例是否结构相同)。
        就比较字符串来说,== 操作符的行为方式和 Kotlin 不 一样,Java 用== 做引用比较。要在 Java 中做结构相等比较,要用 equals 函数。

        4、遍历字符:

  •   forEach函数

七、数:

        1、数字类型:

        

         2、整数(Int):

         3、小数数字(Float或Double):

         4、字符串转数值类型:

  • toFloat:
  • toDouble:
  • toDoubleOrNull:安全转换函数
  • toIntOrNull:
  • toLong:
  • toBigDecimal

       5、Double类型格式化:

    "%.2f".format("2.6666666")

        6、位运算:

八、标准库函数:

        1、apply标准函数:

        apply 函数可看作一个配置函数:你可以传入一个接收者,然后调用一系列函数来配置它以便使用。如果提供 lambda apply 函数执行,它会返回配置好的接收者。

    val menuFile = File("1.txt")menuFile.setReadable(true)menuFile.setWritable(true)menuFile.setExecutable(true)val menuFile2 = File("2.txt").apply { setReadable(true)setWritable(true)setExecutable(true)}

        2、let函数:

        let 函数能使某个变量作用于其 lambda 表 达式里,让 it 关键字能引用它。

        3、run函数:

        run 和 apply 差不多。但与 apply 不同,run 函数不返回接收者。

        val menuFile3 = File("3.txt")menuFile3.run { readText().contains("ss")}

         4、with函数:

        with函数是run的变体。它们的功能行为是一样的,但 with 的调用方式不同。调用 with 时需要值参作为其第一个参数传入。 

        val nameTooLong = with("Polarcubis, Supreme Master of NyetHack") { length >= 20 }

         5、also函数:

            also 函数和 let 函数功能相似。和 let 一样,also 也是把接收者作为值参传给 lambda。但 有一点不同;also 返回接收者对象,而 let 返回 lambda 结果。

        6、takeIf函数:

        takeIf 函数需要判断 lambda 中提供的条件表达式(叫 predicate),给出 true false 结果。如果判断结果是 true,从 takeIf 函数返回接收者对象;如果是 false,则返回 null

        val menuFile4 = File("4.txt").takeIf { it.canRead() && it.canWrite() } ?.readText()

九、List与set:

        1、List:

  •  获取列表元素:用元素的索引(index)和[]操作符可以获取列表中的任意元素。列表中的元素基于零索引(zero-indexed存放。
    private fun printList() {val patronList = listOf<String>("wangwu","lisan")var name =patronList[0];val contains = patronList.contains("zhangsan")}
  • 更改列表内容:列表可变性是由列表的类型决定的,指的是列表元素是否可修改。支持内容修改的列表叫可变列表(mutable list)。要创建可变列表,可以使用 mutableListOf 函数。
    private fun printMutableList() {val mutableList = mutableListOf("wangwu","lisan")mutableList.add("张三")mutableList.remove("lisan")}

        2、遍历:

        在 for 循环里,in 指定将要被遍历的对象。也可以forEach和forEachIndexed,,或Iterable去遍历。

      private fun forList() {val mutableList = mutableListOf("wangwu","lisan")for (forList in mutableList) {}mutableList.forEach { name ->print("名字是 $name")}mutableList.forEachIndexed { index, name ->print("序列号为:$index ===名字是 $name")}}

        3、解构:

        通过使用_符号过滤不想要的元素,你还可以有选择地从 List 集合里解构元素。

        4、set:

       Set 集合里的所有元素都具有唯一性;Set 集合不支持基于索引的存取值函数,因为它里面的元素顺序不固定。

  • 创建Set集合:
    private fun showSet() {val nameSet = setOf<String>("wangwu","lisan")nameSet.contains("zhangsan")//索引值读取 Set 集合的元素虽然可行,但因为 elementAt 函数内部实现机制的问题,//相比按索引读取 List 集合的元素,读取速度要慢上一个数量级nameSet.elementAt(2)   }
  •  向Set集合中添加元素:

      5、while循环:

        当某个条件满足时,就执行循环体里的代码。

      6、break表达式:

      7、数组类型:

    val playerAges:IntArray = intArrayOf(25,23,5,9,48)

      

十、Map:

        与 List Set 类型不同的是,Map 里的元素是由你定义的键值对组成的,获取元素的方式 是基于键,而不是基于索引。在 Map 里,键具有唯一性,它对应一个具体的值。值则可以重复, 没有唯一性要求。从这个角度看,Map Set 有了另一个共同点:就像 Set 里的元素一样,Map里的键都是唯一的。

        1、创建map

        Map 集合里,键必须是同一类型,值也必须是同一类型,而键和值可以是不同类型。

        to 函数将它左边和右边的值转化成一个对(Pair)——一种表示两个元素一组(键和值)的特 殊类型。

    private fun showMap() {val patronGold = mapOf(Pair("wangwu",15),Pair("lisi",18),Pair("wangmuzi",16))val patronGold1 = mapOf("wangwu" to 15,"lisi" to 18)}

        2、读取Map集合的值:

    private fun printMap() {val patronGold = mapOf("wangwu" to 15,"lisi" to 18)val gold = patronGold["wangwu"]val lisiGold = patronGold.getValue("lisi")}

        3、向Map集合添加项:

     private fun putMutableMap() {val mutableMap = mutableMapOf("wangwu" to 15,"lisi" to 18)mutableMap.put("wangyi",88)}

        4、修改Map集合值:

    private fun modifyMutableMap() {val mutableMap = mutableMapOf("wangwu" to 15,"lisi" to 18)mutableMap["wangwu"] = 66}

              

十一、定义类:

        在面向对象编程的世界里,类是核心,是一类独特“事 物”的代码形式的定义。具体来讲,类定义的是事物包含哪一类数据,能做什么样的工作。

        1、定义类:

        类可以定义在一个独立的文件中,也可以和函数或变量定义在一起。类定义在单独一个文件 里,可以给应用程序未来的规模升级预留扩展空间。

        2、构造实例:

        构造函数的工作就是构造,说得再具体一点,就是构造一个实例以备后用。调用构造函数和调用一般函数在语法上很像:使用一对圆括号接收值参。

        3、类函数:

       定义类行为就是在类结构体里添加函数定义。定义在类里的函数叫类函数

        4、可见性与封装:

        

        5、类属性:

        类数据定义,又叫作类属性,用来描述类的特有状态和特征。

  • 属性getter与setter;
  • 属性可见性;
  • 计算属性。

        

十二、初始化:

        调用一个类的构造函数,创建了该类的一个实例。这个过程叫实例化。给对象分配内存就是实例化对象,给对象赋值就是初始化对象。

        1、构造函数:

var name: String = ""
var heealthPoints: Int = 0
var isBlessed: Boolean = false
var isImmortal: Boolean = false
class Player (_name: String,_healthPoints: Int,_isBlessed: Boolean,_isImmortal: Boolean){var name = _nameget() = field.capitalize()private set(value) {field = value.trim()}var healthPoints = _healthPointsval isBlessed = _isBlessedprivate val isImmortal = _isImmortal
}//调用
val player = Player("Madrigal", 89, true, false)

        2、次构造函数:

        有主就有次,对应主构造函数的是次构造函数。如果你为某个类指定了主构造函数,那么该 类的所有实例都要用它构造。如果你指定了一个次构造函数,那只是多了一种构造类实例的方式 (主构造函数的要求仍要满足)。 

class Player (_name: String){var name = _namevar age :Int = 0//这里 this 关键字指的是构造函数所在的类实例。constructor(_name :String ,_age :Int) :this(_name) {name = _nameage = _age}
}

        3、默认参数:

class Player (_name: String,_age :Int =18){var name = _namevar age :Int = 0lateinit var adrr :String//age为默认参数可实现constructor(_name :String ,_age :Int, _adrr :String) :this(_name,_age) {name = _nameage = _ageadrr = _adrr}//age为默认参数也不可实现constructor(_name :String , _adrr :String) :this(_name) {name = _nameadrr = _adrr}
}

         4、初始化块:

        初始化块代码会在构造类实例时执行,类似于Java中的static初始化块。用关键字init定义一个初始化块。

        5、初始化顺序:

  • 主构造函数里声明的属性;
  • 类级别的属性赋值;
  • init 初始化块里的属性赋值和函数调用;
  • 次构造函数里的属性赋值和函数调用;

        6、延迟初始化:

  • 延迟初始化:对于任何 var 属性声明,你都可以加上 lateinit 关键字。这样, Kotlin 编译器会允许你延后初始化属性。
  • 惰性初始化:可以暂时不初始化某个变量,直到首次使用它。使用代理要用到 by 关键字。Kotlin 标准库里有一些预先配置好的代理可用,lazy 就是其中一个。惰性初始化会用到 lambda 表达式,你可以在表达式里定义属性初始化需要执行的代码。

十三、继承:

        1、创建子类

        子类继承哪个类,就会共享哪个类的全部属性。让子类继承的类通常叫作父类或超类

        事实上,类默认都是封闭的,也就是说不允许其他类来继承自己。要让某个类开放继承,必须使用 open 关键字修饰它。

/该类可被继承必须加上open
open class Player (_name: String,_age :Int =18){var name = _namevar age :Int = 0lateinit var adrr :String//age为默认参数可实现constructor(_name :String ,_age :Int, _adrr :String) :this(_name,_age) {name = _nameage = _ageadrr = _adrr}//age为默认参数也不可实现constructor(_name :String , _adrr :String) :this(_name) {name = _nameadrr = _adrr}//可重新函数必须加上openopen fun showName() {}//要想某个函数不被子类覆盖,就使用 final 关键字修饰它final fun showPassdWord() {}}class MyPlayer(_name: String, _age: Int) : Player(_name) {override fun showName() {}
}

         2、类型检查:

        Kotlin 的 is 运算符是个不错的工具,可以用来检查某个对象的类型。

        3、Kotlin类层次:

        每一个类都会继承一个共同的叫作 Any 的超类。

        

package kotlinpublic open class Any {public open operator fun equals(other: Any?): Booleanpublic open fun hashCode(): Intpublic open fun toString(): String
}

十四、对象:

        1、object:

        如果只想用一个实例来管理整个应用运行时间内的一致性状态的话,可以考虑定义一个单例
singleton )。使用 object 关键字,你可以定义一个只能产生一个实例的类——单例。单例类一
旦实例化,在整个应用的运行周期内,只会存在一个实例。即使你再次实例化它,你得到的还是
最初产生的实例。

        使用 object 关键字有三种方式:对象声明object declaration)、对象表达式object expression和伴生对象companion object)。

  • 对象声明:
object open class MyPlayer(_name: String, _age: Int) : Player(_name) {init {}override fun showName() {}
}
  • 对象表达式:这个匿名类依然遵循 object 关键字的一个规则,即一旦实例化,该匿名类只能有唯一一个实例存在。
  val signalPlayer = object : MyPlayer("",5) {override fun showName() {super.showName()}}

伴生对象:将某个对象的初始化和一个类实例捆绑在一起,可以考虑使用伴生对象。使用 companion 修饰符,你可以在一个类定义里声明一个伴生对象。一个类里只能有一个伴生对象。第一种,包含伴生对象的类初始化时,伴生对象就会被初始

化。由于这种相伴关系,伴生对象就适合用来存放和类定义有上下文关系的单例数据。第二种,只要直接访问伴生对象的某个属性或函数,就会触发伴生对象的初始化。
open class MyPlayer(_name: String, _age: Int) : Player(_name) {//类似于Java中的static方法companion object {private const val MAPS_FILEPATH = "nyethack.maps"fun load() = File(MAPS_FILEPATH).readBytes()}
}
//直接调用MyPlayer.load()

        2、嵌套类:

        可以使用 class 关键字定义一个嵌套在另一个类里的命名类。

        3、数据类:

  • 数据类必须有至少带一个参数的主构造函数;
  • 数据类主构造函数的参数必须是 val var

    数据类不能使用 abstractopensealed inner 修饰符。

    4、枚举类:

    enum class Direction { NORTH, EAST, SOUTH, WEST 
    }

    5、运算符重载:

    data class Coordinate(val x: Int, val y: Int) { val isInBounds = x >= 0 && y >= 0 operator fun plus(other: Coordinate) = Coordinate(x + other.x, y + other.y) 
    }

十五、接口与抽象类:

       接口可以用来定义一组未实现的公共属性和行为。具体如何实现,开发者不用管,实现接口 的类会负责处理。类之间想要共享属性或函数,但又无法建立继承关系时,就非常适合使用这种 只定义而不实现的接口特性。也就是说,通过使用接口,无须继承或被继承,一组类就可以拥有 共同的属性和函数。

        1、定义接口:

interface Fightable { var healthPoints: Int val diceCount: Int val diceSides: Int val damageRoll: Int fun attack(opponent: Fightable): Int 
}

        2、实现接口:

open class MyPlayer(_name: String, _age: Int,override var healthPoints: Int,override val diceCount: Int,override val diceSides: Int,override val damageRoll: Int
)  : Fightable{override fun attack(opponent: Fightable): Int {TODO("Not yet implemented")}}

         3、默认实现:

        不是每个属性和函数都需要在接口实现类里提供不同的具体实现。所以,接口里提供默认实
现可以减少重复代码。

         4、抽象类:

        在类定义之前加上 abstract 关键字。除了具体的函数实现,抽象类也可以包含抽象函数——只有定义,没有函数实现。

abstract class MyPlayer(_name: String, _age: Int,override var healthPoints: Int,override val diceCount: Int,override val diceSides: Int,override val damageRoll: Int
)  : Fightable{}

       不管超类是哪种类型的类(一般类、抽象类或接口),子类默认都会共享其超类的所有属性 和函数。如果一个类实现了一个接口,那么它的子类也必须满足这个接口的所有实现需求。

      首先,接口里不能定义构造函数。其次,一个类只能继承一个抽象类,但可以实现多个接口。  

open class MyPlayer(_name: String, _age: Int,override var healthPoints: Int,override val diceCount: Int,override val diceSides: Int,override val damageRoll: Int
) : Player(_name), Fightable {override fun attack(opponent: Fightable): Int {TODO("Not yet implemented")}}

 

十六、泛型:

        泛型系统允许函数和其他类型接受 你或编译器当前无法预知的类型,大大提高了代码的复用率。

        1、泛型类:   

class LootBox<T>(item: T) { private var loot: T = item 
}

        2、泛型函数:

class LootBox<T>(item: T) { var open = false private var loot: T = item //定义的名为 fetch 的泛型函数会返回 T,这是 LootBox 类指定的泛型参数,
//也是代表 item类型的占位符。fun fetch(): T? { return loot.takeIf { open } } 
}

         3、多泛型参数: 

class LootBox<T>(item: T) { var open = false private var loot: T = item fun fetch(): T? { return loot.takeIf { open } } 
//R这个泛型参数将用作 fetch 函数的返回类型
//定义时,这个 R 泛型参数要放在尖括号里,置于函数名之前:fun <R> fetch。
//fetch 返回的是一个 R?,即一个可空的 R 类型。
//由于函数类型声明(T) -> R,lootModFunction 函数能接受 T 类型的值参,返回一
//个 R 类型的结果值fun <R> fetch(lootModFunction: (T) -> R): R? { return lootModFunction(loot).takeIf { open } } 
}

         4、vararg关键字与get函数:

        这个 vararg 关键字,初始化 泛型类时,就能把它的 item 变量看作元素数组, 而非单个元素了。

        5、in与out:

        泛型参数可以扮演两种角色:生产者producer)或消费者consumer)。生产者 角色就意味着泛型参数可读而不可写;消费者角色则相反,可写而不可读。

        out 关键字表明,泛型参数将扮演可读而不可写的生产者角色。

        6、reified关键字:

        reified关键字能帮你检查泛型参数类型。Kotlin 提供了 reified 关键字,它允许你在运行时保留类型信息。

        

十七、扩展:

        扩展可以在不直接修改类定义的情况下增加类功能。扩展可以用于自定义类。

       1、定义扩展函数:

         定义扩展函数和定义一般函数差不多,但有一点大不一样:除了函数定义,你还需要指定接
受功能扩展的 接收者类型 receiver type )。
        
//this 的内容加上传入值参决定
//的一个或多个感叹号(默认值是 1)。this 关键字指接收者实例
fun String.addEnthusiasm(amount: Int = 1) = this + "!".repeat(amount)

        2、超类上定义在扩展函数:

//在 Any 类上定义一个叫 easyPrint 的扩展函数。因为是定义在 Any 超类上的
//,所以 easyPrint支持在任何类上调用。
fun Any.easyPrint() = println(this)

        3、泛型扩展函数:

        

//let 函数被定义成了泛型扩展函数,所以能支持任何类型。它接受一个 lambda 表达式,这个
//lambda 表达式以接收者 T 作为值参,返回的是 R——lambda 表达式返回的任何新类型。
public inline fun <T, R> T.let(block: (T) -> R): R { return block(this) 
}

        4、扩展属性:

        

十八、函数式编程基础:

十九、Konlin与Java互操作:

        

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/745115.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

cesium wall 扩散墙(动态立体墙效果 Primitive 方法)

cesium wall 扩散墙(动态立体墙效果)以下为源码直接复制可用 1、实现思路 1、此效果运用cesium 中 Primitive 方法,通过传入中心点、半径、顶点数、颜色来进行加载。 2、运用 Math 方法 对传进来的中心点、半径、定点数,来计算个顶点经纬度。 3、通过Primitive 方法中upda…

643.子数组最大平均数

题目&#xff1a;给你一个由 n 个元素组成的整数数组 nums 和一个整数k。 找出平均数最大且长度为 k 的连续子数组&#xff0c;并输出该最大平均数。 任何误差小于10^-5 的答案都将被视为正确答案。 解题思路&#xff1a;规定了子数组的长度为k&#xff0c;因此可以通过寻找子…

洛谷——P1352 没有上司的舞会

题目描述 某大学有 n 个职员&#xff0c;编号为1…n。 他们之间有从属关系&#xff0c;也就是说他们的关系就像一棵以校长为根的树&#xff0c;父结点就是子结点的直接上司。 现在有个周年庆宴会&#xff0c;宴会每邀请来一个职员都会增加一定的快乐指数 ri​&#xff0c;但…

【MySQL】深入解析索引实现原理

文章目录 1、索引介绍2、索引分类2.1、数据结构HashB Tree 2.2、存储方式聚簇索引非聚簇索引 2.3、功能特性主键索引唯一索引普通索引 2.4、字段数量单列索引多列索引 3、最佳实践3.1、索引覆盖3.2、回表操作3.3、最左匹配原则3.4、索引下推 1、索引介绍 对于MySQL数据库来说…

笔试题:小红的循环小数 数论 欧拉 快速幂 小费马定理

小红的循环小数 众所周知&#xff0c;所有的无限循环小数都可以写成分数的形式 小红想让你判断循环节长度为k的无限循环小数的分母是否可能是p。你能帮帮她吗&#xff1f; 共有q次询问。 输入描述 第一行输入一个正整数 q q q&#xff0c;代表询问次数。 接下来的 q q q行&…

Tensorflow笔记(二):常用函数2、激活函数、优化器等、神经网络模型实现(商品销量预测)

import tensorflow as tf import numpy as np from tqdm import tqdm# ----------------------------- tensor常用函数2 ----------------------------------- a tf.constant([1, 2, 3, 1, 2]) b tf.constant([0, 1, 3, 4, 5]) c tf.where(tf.greater(a, b), a, b) # 若a&g…

计算机毕业设计-springboot+vue前后端分离电竞社交平台管理系统部分成果分享

4.5系统结构设计 本系统使用的角色主要有系统管理员、顾客、接单员&#xff0c;本系统为后台管理系统&#xff0c;游客用户可以经过账号注册&#xff0c;管理员审核通过后&#xff0c;用账号密码登录系统&#xff0c;查看后台首页&#xff0c;模块管理&#xff08;顾客信息&am…

mysql重构

力扣题目链接 列转行 SELECT product_id, store1 store, store1 price FROM products WHERE store1 IS NOT NULL UNION SELECT product_id, store2 store, store2 price FROM products WHERE store2 IS NOT NULL UNION SELECT product_id, store3 store, store3 price FROM p…

全栈的自我修养 ———— js中的复制api

通常用于可以禁止用户复制或者在复制的内容后面添加版权信息等 一、代码二、展示1、访问粘贴板的内容2、替换复制内容3、在复制内容的后面添加版权信息4、监听粘贴事件 一、代码 <body><div class"demo">不可以被复制</div><div class"de…

如何从任何文档生成指令数据集以进行LLM微调

使用轻量级库经济地生成高质量的合成数据集 大型语言模型 &#xff08;LLMs&#xff09; 是功能强大的通用工具&#xff0c;但它们通常缺乏特定于领域的知识&#xff0c;这些知识通常存储在企业存储库中。 使用您自己的数据微调自定义LLM可以弥合这一差距&#xff0c;而数据准…

【Shiro反序列化漏洞】Shiro-550反序列化漏洞复现

&#x1f36c; 博主介绍&#x1f468;‍&#x1f393; 博主介绍&#xff1a;大家好&#xff0c;我是 hacker-routing &#xff0c;很高兴认识大家~ ✨主攻领域&#xff1a;【渗透领域】【应急响应】 【Java、PHP】 【VulnHub靶场复现】【面试分析】 &#x1f389;点赞➕评论➕收…

了解下索引的几棵树?

二叉树 二叉搜索树最好的情况性能是O(logn)&#xff0c;最坏情况是O(n) 红黑树 它的时间复杂度是O(logn)&#xff0c;但是在数据量特别大的时候&#xff0c;树会特别高&#xff0c;就会遍历很多层级&#xff0c;对性能影响较大 BTree B树是一种多叉路衡查找树&#xff0c;相对于…

解决NVM安装Node失败:淘宝NPM镜像HTTPS证书到期及源切换指南

博主猫头虎的技术世界 &#x1f31f; 欢迎来到猫头虎的博客 — 探索技术的无限可能&#xff01; 专栏链接&#xff1a; &#x1f517; 精选专栏&#xff1a; 《面试题大全》 — 面试准备的宝典&#xff01;《IDEA开发秘籍》 — 提升你的IDEA技能&#xff01;《100天精通鸿蒙》 …

如果利用AOP/Aspect来修改方法的入参

问题描述&#xff1a; 最近项目代码过三方测试&#xff08;国企项目&#xff09;&#xff0c;在一系列代码扫描审计检查下&#xff0c;代码发现一部分修改&#xff0c;例如请求参数发生了编码/加密&#xff0c;导致后台需要对请求的参数进行解码/解密&#xff0c;后端那么接口&…

访问者模式(Visitor Pattern)

访问者模式 说明 访问者模式&#xff08;Visitor Pattern&#xff09;属于行为型模式&#xff0c;表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。 该模式是将数据结构与数据操作分离的设计模式&#xff0c;是…

Flutter 多语言、主题切换之GetX库

多语言、主题切换之GetX库 前言正文一、配置项目二、模拟UI三、语言配置① 常量键② 语言配置文件③ 配置 四、持久化五、切换语言① my_home.dart② home.dart③ mine_controller.dart④ language_setting_controller.dart⑤ language_setting.dart⑥ mine.dart 六、切换主题①…

基于SpringBoot的“家政服务管理平台”的设计与实现(源码+数据库+文档+PPT)

基于SpringBoot的“家政服务管理平台”的设计与实现&#xff08;源码数据库文档PPT) 开发语言&#xff1a;Java 数据库&#xff1a;MySQL 技术&#xff1a;SpringBoot 工具&#xff1a;IDEA/Ecilpse、Navicat、Maven 系统展示 系统首页界面图 用户注册界面图 服务信息界面…

WorldGPT、Pix2Pix-OnTheFly、StyleDyRF、ManiGaussian、Face SR

本文首发于公众号&#xff1a;机器感知 WorldGPT、Pix2Pix-OnTheFly、StyleDyRF、ManiGaussian、Face SR HandGCAT: Occlusion-Robust 3D Hand Mesh Reconstruction from Monocular Images We propose a robust and accurate method for reconstructing 3D hand mesh from m…

ConnectionResetError: [WinError 10054] 远程主机强迫关闭了一个现有的连接。

发生的错误信息&#xff1a; File "C:\Users\malongqiang\.conda\envs\ObjectDetection\lib\ssl.py", line 1309, in do_handshakeself._sslobj.do_handshake() ConnectionResetError: [WinError 10054] 远程主机强迫关闭了一个现有的连接。 分析原因&#xff1a; …

接口的回调

接口是引用型变量 接口回调技术&#xff1a;把实现该接口的类的实例引用赋给接口变 量&#xff08;存放对象的引用&#xff09;→接口变量可调用被类重写的接口方法。 ★注意★&#xff1a;接口com无法调用类中非接口方法