Kontlin笔记

作者: 编程的猫 | 来源:发表于2020-04-09 17:55 被阅读0次

Kontlin笔记
android跳转手机系统应用信息界面
黑白置换之日
Kotlin 类型
Android-9 Kotlin之greendao
Kontlin之Rx+Retrofit实战(豆瓣列表)
开发笔记目录查看
目录
《大江大河》笔记若干（一）
记笔记分为闪念笔记、文献笔记和永久笔记

var和val

可以理解为var声明变量，val声明常量。var是可读可修改，val只可读不可修改。
init{}类初始化块，相当于java中的静态代码块，在类被加载的时候就会执行。

空值

kotlin 中定义方法时，默认接收的是非 null 参数。
如果定义某个方法可以接收 null参数，则在声明方法参数时在参数后面加上？

fun test(str1:String?){    //String 后面的 ？ 就表示该方法可以接收 null 作为参数
    //DO STH 
}

When表达式,类似于java中的switch:

when(变量){
    分支A -> 表达式
    else -> 表达式
}

带返回值的when表达式:

var result=when(变量){
    分支A -> 表达式（要有返回值，最终将值赋给result）
    else -> 表达式（要有返回值，最终将值赋给result）
}

for循环遍历list

 /**
     * for循环遍历list
     */
    fun forFunction() {
        val list = listOf("狗狗", "猫猫", "猪猪", "鹿鹿")
        for ((a, b) in list.withIndex()) {
            println(message = "TAG:$TAG  索引a:$a    值b:$b")
        }
    }

Map

声明格式：

var map=TreeMap<键类型,值类型>()
map[key]=value

Loop和Range

var nums1=1..100  //表示我们声明了一个闭区间数组，其中包含的数值为 1-100。 .. 表示闭区间
var nums2=1 util 100 //前闭后开区间，取值 1-99. util 表示前闭后开区间

示例：

 /**
     * for循环遍历list
     */
    fun forFunction() {
        val list = listOf("狗狗", "猫猫", "猪猪", "鹿鹿")
        println(message = "TAG$TAG ===========   索引     值")
        for ((a, b) in list.withIndex()) {
            println(message = "TAG:$TAG  索引a:$a    值b:$b")
        }
        //list内容反转
        list.reversed()
        println(message = "TAG$TAG ===========  list  反转     值")
        for (s in list) {
            println(message = "TAG$TAG  value:$s")
        }

        var l = 1..10
        var m = 1 until 10
        println(message = "TAG$TAG ===========    闭区间     值")
        for (i in l) {
            println(message = TAG + i)
        }
        println(message = "TAG$TAG ===========    前闭后开 unit     值")
        for (i in m) {
            println(message = TAG + i)
        }
        /**
         * 设置步长
         */
        println(message = "TAG$TAG ===========    步长     值")
        for (i in l step 2) {
            println(message = TAG + i)
        }
        //数据反转
        println(message = "TAG$TAG ===========   数据 反转     值")
        val reversed = l.reversed()
        for (i in reversed) {
            println(message = TAG + i)
        }
    }

函数和函数表达式

函数的简化

//原函数：
fun sum(a:Int , b:Int):Int{
    return a+b
}

//简化后
fun sum(a:Int , b:Int):Int=a+b

使用var声明函数

 /**
     * 使用var声明函数
     * 函数表达式一
     */
    var i = { x: Int, y: Int -> x + y }

    /**
     * 函数表达式二
     */
    var j: (Int, Int) -> Int = { x, y -> x + y }
  
    //调用
    val i1 = i(2, 3)
    println(message = "TAG$TAG   函数i的调用结果:$i1")
    val j1 = j(4, 3)
    println(message = "TAG$TAG   函数j的调用结果:$j1")

默认参数和具名参数

具有默认参数值的函数声明

val Pi=3.1415926
fun getRoundArea(PI:Float=Pi , radius:Float):Float{    //为变量PI赋予了默认值 Pi,这样，调用该方法时可以不再传递PI。但，如果我们想传入的值和默认值不一致时还是需要传入的
    return PI*radius*radius
}

调用待用默认参数值的函数

var a=getRoundArea(3.14f,5.0f) //因为我们相传入的PI和默认值不一致，所以，需要将3.14f传入

具名参数的调用
所谓具名函数，就是调用函数时候指明参数给哪个变量

var a=getRoundArea(radius=5.0f) //我们需要的PI值与默认值一致，此时不需要再传入PI值。只需要通过 radius=5.0f 声明我们传入了半径值

字符串和数字的转换

var a="13"
a.toInt() //字符串转换为Int
var b=13
b.toString() //Int转换为字符串

根据用户输入的数字动态计算

fun main(array:ArrayList<String>){
    println(“请输入第一个数值”)
    var a=readLine()    //读取键盘输入的字符串内容，并赋值给a 
    println(“请输入第二个数值”)
    var b=readLine()

    var num1=a!!.toInt()  //readLine(）得到的可能是null，所以此处通过 !! 断言输入不为null
    var num2=b!!.toInt() 

    println("${num1}+${num2}=${num1+num2}")
}

异常处理

try{
    //可能会出错的代码块
}catch(e:Excepiton){
    //出错之后的处理逻辑
}

利用递归实现阶乘函数

fun fact(a:Int):Int{
    if(a==1){
        return 1
    }else{
        return a*fact(a-1) //函数内调用函数本身就成为了递归
    }
}

尾递归优化

尾递归的参详http://www.ruanyifeng.com/blog/2015/04/tail-call.html
递归本质上是一种循环操作。纯粹的函数式编程语言没有循环操作命令，所有的循环都用递归实现，这就是为什么尾递归对这些语言极其重要，循环可以用递归代替，而一旦使用递归，就最好使用尾递归。
kotlin中尾递归关键字 tailrec

为什么需要尾递归优化

递归非常耗费内存，因为需要同时保存成千上百个调用记录，很容易发生"栈溢出"错误（stack overflow）。但对于尾递归来说，由于只存在一个调用记录，所以永远不会发生"栈溢出"错误。
示例:

    /**
     * tailrec 是尾递归函数的关键字
     * 尾递归函数是指，在该函数的最后一步操作中依旧是调用函数本身
     * 为了实现尾递归，我们定义了该方法接收两个参数：num 是我们传入的需要计算累加值得的变量，total用来接收最终的返回值
     */
    tailrec fun accumulation(num: Int, total: Int): Int {
        return if (num == 1) {
            total
        } else {
            //此时，该调用的含义是：先计算 total=num+total,然后计算 num=num-1
            accumulation(num - 1, num + total)
        }
    }

面向对象入门——定义一个类并构建对象

//定义一个类，包含两个成员变量 height和width
class Rect(var height:Int,var width:Int)

fun main(args: Array<String>) {
    var rect=Rect(5,10) //构建Rect对象，不需要new
    println("矩形的宽${rect.width}高${rect.height}") //引用Rect类中成员变量
}

静态属性和动态行为/方法——为类定义成员方法

//定义一个类，包含两个成员变量 height和width.并定义一个成员方法
class Rect(var height: Int, var width: Int) {
    fun getArea(a: Int, b: Int): Int = a * b
}

fun main(args: Array<String>) {
    var rect = Rect(5, 10) //构建Rect对象，不需要new
    println("矩形的宽${rect.width}高${rect.height}") //引用Rect类中成员变量
    println("矩形的面积是${rect.getArea(rect.width, rect.height)}") //引用Rect类中成员变量

}

面向对象

案例：

/**
 * 定义成员变量和成员方法
 */
class WashMachine(brand: String, size: Int) {

    var isDoorOpen = false
    var curMode = 0

    fun openDoor() {
        println("Wash     打开洗衣机的门    ")
        isDoorOpen = true
    }

    fun closeDoor() {
        println("Wash    关闭洗衣机的门    ")
        isDoorOpen = false
    }

    /**
     * 设置洗衣机的模式
     */
    fun setMode(mode: Int) {
        curMode = mode
        when (mode) {
            0 -> println("Wash  慢速模式")
            1 -> println("Wash   标准模式")
            2 -> println("Wash   快速模式")
            else -> println("Wash   初始状态")
        }
    }

    fun start() {
        if (isDoorOpen) {
            println("Wash   洗衣机的门还没有关闭，请先关闭洗衣机的门")
        } else {
            when (curMode) {
                0 -> {
                    println("Wash  现在是慢速模式，发动机转速慢")
                    println("Wash   开始洗衣服")
                }
                1 -> {
                    println("Wash   现在是标准模式，发动机正常运行")
                    println("Wash   开始洗衣服")
                }
                2 -> {
                    println("Wash   现在是快速模式，发动机快速运行")
                    println("Wash   开始洗衣服")
                }
                else -> println("Wash   你还没有设置洗衣机的模式")
            }
        }
    }
}

调用:

       val washMachine = WashMachine("小天鹅", 20)
        washMachine.setMode(2)
        washMachine.openDoor()
        washMachine.closeDoor()
        washMachine.start()

面向对象——继承

一个对象直接使用另一个对象的属性或方法 —— 同Java
被继承的父类必须用 open 修饰，表示允许其他类继承该类
父类中的方法如果允许子类重写，也需要用 open 修饰
重写父类方法时需要用 override 修复重写后的方法
继承的格式：class 子类：父类()
父类：

open class Father {    //用 open 修饰，允许被继承
    var character = "性格内向"
    open fun action() {    //用open修饰，允许被重写
        println("喜欢读书")
    }
}

子类:

class Son : Father() {    //继承。 Son 继承自 Father
    override fun action() {    //重写父类方法
        //super.action()
        println("儿子的性格是$character")   
        println("儿子不喜欢看书，但是喜欢唱歌")
    }
}

抽象类及其实现

抽象的关键字 abstract —— 同Java
抽象类和方法不需要用 open 声明可以被继承/实现
抽象类:

abstract class Human (var name: String){      //定义抽象类，使用 abstract 修饰。包含成员变量name
    abstract fun eat()      //定义抽象方法， 使用 abstract 修饰
}

实现:

class Man(name: String) : Human(name) {    //继承自Human抽象类
    override fun eat() {    //必须重写抽象方法
        println("${name}是男人，是家中劳力，所以吃的多")
    }
}

多态

同种功能，不同的表现形式即为多态
抽象类:

//定义抽象类，使用 abstract 修饰。包含成员变量name
abstract class Human(var name: String) {      
    //定义抽象方法， 使用 abstract 修饰
    abstract fun eat()      
   //定义抽象方法
    abstract fun pee() 
}

子类Man:

class Man(name: String) : Human(name) {
    override fun pee() {
        println("${name}是男人，是站着尿尿的")
    }

    override fun eat() {
        println("${name}是男人，是家中劳力，所以吃的多")
    }
}

子类Woman:

class Woman(name: String) : Human(name) {
    override fun eat() {
        println("${name}是女人,饭量比较小")
    }

    override fun pee() {
        println("${name}是女人，是蹲着尿尿的")
    }
}

调用示例：

fun main(args: Array<String>) {
    var man=Man("张三")
    var woman=Woman("小花")

    var list= listOf<Human>(man,woman)    //定义集合
    for (human in list){    //遍历集合
        human.pee()
    }
}

接口及其实现

接口--数据有进有出的交互方式、
接口关键字：interface —— 同Java
接口是事物的能力（代表某种事物的特性），抽象类是事物的本质（代表的是一类事物的共性）
子类实现接口时，接口名后面不需要（）
定义接口IMan

interface IMan {    //定义一个男人的接口
    fun xiaodidi()
}

Man类实现IMan接口：

class Man(name: String) : Human(name) ,IMan{  //男人属于人，所以继承Human;男人有小弟弟，所以实现 IMan接口
    override fun xiaodidi() {
        println("这是重写IMan接口中的方法——男人有小弟弟")
    }

    override fun pee() {
        println("${name}是男人，是站着尿尿的")
    }

    override fun eat() {
        println("${name}是男人，是家中劳力，所以吃的多")
    }
}

太监不能实现IMan接口：

class TaiJian(name: String) : Human(name) {  //太监属于人，但是太监没有小弟弟，所以不能实现 IMan接口
    override fun eat() {
        println("太监也能吃饭")
    }

    override fun pee() {
        println("太监也会尿尿")
    }
}

代理和委托

委托，把自己不干的事情交给别人做
代理，做别人委托的事情
kotlin中接口代理关键字：by

场景说明

围裙妈妈只负责做饭，不负责洗碗
小头爸爸洗一次碗可以赚到10元
大头儿子洗一次碗可以赚到1元
小头爸爸承揽了洗碗的活，最终交给大头儿子做，中间赚了9元差价

代码实现——完全委托

定义洗碗的接口

interface IWashBow {    //定义一个洗碗接口，包含一个洗碗方法
    fun washBow()
}

大头儿子实现接口

class BigHeadSon:IWashBow {    //被实现的接口后面不需要加（）
    override fun washBow() {
        println("我是大头儿子，每次洗碗赚1元钱")
    }
}

小头爸爸实现接口并委托事件给小头儿子

class SmallHeadFather:IWashBow by BigHeadSon(){     //委托关键字 by;被委托方(即代理方)如果不是单例类，则后面需要跟()

}

程序调用及输出结果

fun main(args: Array<String>) {
    var father=SmallHeadFather()
    father.washBow()    //小头爸爸已经将洗碗的操作委托为小头儿子了，所以，此处本质是调用的小头儿子的洗碗操作
}

单例模式

单例关键字：object

我们在定义一个类时，使用object 替换 class 来修饰这个类，就表示，这是一个单例类

单例类作为代理人时，不需要（）

场景说明

小头爸爸为了增进父子感情，想和小头儿子一起洗碗

小头爸爸重写接口方法 —— 未使用单例时的错误写法

class SmallHeadFather:IWashBow by BigHeadSon(){    

    override fun washBow() {
        println("我是小头爸爸，我把洗碗事件委托给了大头儿子")
        BigHeadSon().washBow()  //委托方重写了事件之后，需要手动调用代理方的方法。但是，此处又通过（）构建了一个小头儿子对象，已经不再是我们初始委托的那个大头儿子了。所以，此处是有问题的。
        println("我是小头爸爸，大头儿子洗完碗之后，我赚了9元")
    }
}

使用单例后的正确写法：

大头儿子单例类

object BigHeadSon:IWashBow {    //单例关键字object,声明为单例类之后会立即在内存中创建单例对象，并一直存在
    override fun washBow() {
        println("我是大头儿子，每次洗碗赚1元钱")
    }
}

小头爸爸委托事件给单例的大头儿子

class SmallHeadFather:IWashBow by BigHeadSon{     //被委托方(即代理方)是单例类，不需要通过（）构建对象

    override fun washBow() {
        println("我是小头爸爸，虽然我把洗碗事件委托给了小头儿子，但是我要和他一起洗碗")
        BigHeadSon.washBow()  //委托方重写了事件之后，需要手动调用代理方的方法。由于 BigHeadSon是单例的，所以，这还是我们之前委托的那个儿子
        println("我是小头爸爸，我和小头儿子洗完碗之后，我赚了9元")
    }
}

外部调用

fun main(args: Array<String>) {
    var father=SmallHeadFather()
    father.washBow()    //小头爸爸已经将洗碗的操作委托为小头儿子了，但因为重写了洗完事件，所以，本子是调用的父亲的洗完事件，父亲的洗完事件中有一部分是自己做的，另一部分是儿子做的
}

枚举--enum

示例代码:

enum class Week {   //枚举关键字 enum 
    星期一, 星期二, 星期三, 星期四, 星期五, 星期六, 星期天
}

fun main(args: Array<String>) {
    println(Week.星期一)
    println("${Week.星期一}在Week中的索引是${Week.星期一.ordinal}")
}

结果.png

印章类/密封类 (Sealed Class)

印章类的特点

子类类型有限的类成为印章类/密封类
印章类使用 sealed 作为修饰符
印章类本身没有构造方法

印章类与枚举的区别

都是有限的数据
枚举更注重具体的数据
印章类更注重数据的类型

印章类示例代码

场景说明

假设你家有一头公驴、一头母驴、一头公马。那么，
它们可能会生出一头小驴，
也可能会生出一头小骡子。

代码示例:
声明印章类:

sealed class Son {  //使用 sealed 声明 Son 为印章类/密封类

    class SmallMule() : Son()   //声明小骡子 SmallMule 为 Son的子类。
    class SmallDonkey() : Son() //声明小驴子 SmallDonkey 为 Son的子类

    fun sayHello(son: Son) {
        if (son is SmallMule) {     //判断是不是XX的实例的关键字 is 
            println("小骡子对大家说大家好")
        } else if (son is SmallDonkey) {
            println("小驴子对大家说大家好")
        }
    }
}

调用印章类:

fun main(args: Array<String>) {
    var mule = Son.SmallMule()
    var donkey = Son.SmallDonkey()

    var list = listOf<Son>(mule, donkey)
    for (son in list) {
        son.sayHello(son)
    }
}

运行结果.png

https://www.jianshu.com/p/35f0c16242e4

Kontlin笔记
var和val 可以理解为var声明变量，val声明常量。var是可读可修改，val只可读不可修改。init{}类...
android跳转手机系统应用信息界面
kontlin开发： val intent = Intent()intent.action = Settings....
黑白置换之日
Kontlin日常数值类型 Double 64 Float 32 Long 64 Int 32 Short 16...
Kotlin 类型
类型推断 Kontlin 和 Java 一样，是强类型语言，但 Kotlin 支持类型推断，变量和方法，如果可以推...
Android-9 Kotlin之greendao
起因是这样的，公司的项目之前一直是使用sqlite的，不过重构后，就改用realm了（Kontlin对Realm的...
Kontlin之Rx+Retrofit实战(豆瓣列表)
用到的资源库实体类 activity 网络请求条目布局
开发笔记目录查看
笔记一：笔记二：笔记三：笔记四：笔记五：笔记六：
目录
羊皮笔记01 羊皮笔记02 羊皮笔记03 羊皮笔记04 羊皮笔记05 羊皮笔记06 羊皮笔记07
《大江大河》笔记若干（一）
后续笔记若干…… 后续笔记若干…… 后续笔记若干…… 后续笔记若干…… 后续笔记若干……
记笔记分为闪念笔记、文献笔记和永久笔记
记笔记分为闪念笔记、文献笔记和永久笔记 7/10 1，记闪念笔记 2，记文献笔记 3，记永久笔记 ——申克•阿伦斯...

Kontlin笔记

var和val

空值

for循环遍历list

Map

Loop和Range

函数和函数表达式

使用var声明函数

默认参数和具名参数

字符串和数字的转换

根据用户输入的数字动态计算

异常处理

利用递归实现 阶乘函数

尾递归优化

为什么需要尾递归优化

面向对象入门——定义一个类并构建对象

静态属性和动态行为/方法——为类定义成员方法

面向对象

面向对象——继承

抽象类及其实现

多态

接口及其实现

代理和委托

kotlin中接口代理关键字：by

场景说明

代码实现——完全委托

程序调用及输出结果

单例模式

单例关键字：object

场景说明

小头爸爸重写接口方法 —— 未使用单例时的错误写法

使用单例后的正确写法：

大头儿子单例类

小头爸爸委托事件给单例的大头儿子

外部调用

枚举--enum

印章类/密封类 (Sealed Class)

印章类/密封类 (Sealed Class)

印章类的特点

印章类与枚举的区别

印章类示例代码

场景说明

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

利用递归实现阶乘函数