Kotlin入门第五节

继承与重写

kotlin所有的类默认都是被final修饰的，不能被集成想要被集成需要用到open关键字kotlin默认所有的方法也是final修饰的，想要被重写可以使用open修饰

open class Father(var name: String) {
    private fun showName() {
        println("父方法" + this.name)
    }

    open fun myname() {
        println(this.name)
    }
}

class Son(var names: String) : Father(names) {
    override fun myname() {
        println("子方法" + this.names)
    }
}

fun main() {
    var person: Father = Son("老黑")
    println(person.myname())
}

类型判断和类型转换

类型判断

 var person: Father = Son("老黑")
    println(person is Father)
    println(person is Son)
    println(person is File)

类型转换

var person: Father = Son("老黑")
    println(person is Father)
    println(person is Son)
    println(person is File)

    if(person is Father){
        (person as Father).showName()
    }
    if(person is Son){
        (person as Son).showName()
    }

Any

Any类似Java中的Object,只提供标，看不到实现，实现在各个平台处理好了，Kt中的任何类都继承了Any object关键字

object修饰的类，只会有一个示例，类似单例

package com.fyx.s1

import sun.plugin.dom.core.Text


//构造器执行顺序,init相当于java的构造器{}
object Ktbase2{

    init {
        println("构造执行了")
    }

     fun show(){
        println("修饰单例模式")
    }
}

fun main() {
    println(Ktbase2)
    println(Ktbase2)
    println(Ktbase2)
    println(Ktbase2)
    println(Ktbase2.show())
}

对象匿名

使用object写法

open class Person {
    open fun showmyTest(name: String) {
        println("原始函数")
    }
}

fun main() {
    var name: Person = object : Person() {
        override fun showmyTest(name: String) {
            println("匿名构造")
        }
    }
    name.showmyTest("老黑")
}

伴生对象

因为kotlin没有static静态关键字，所以使用 companion object 来表示无论对象构建多少次，伴生对象只存在一次伴生对象只会初始化一次

class Person {
    companion object {
        var configUrl = "http://baidu.com"
    }
}

fun main() {
    println(Person.configUrl)
}

内部类和嵌套类

使用inner修饰内部类可以实现内部类访问外部类，且外部类也可以访问内部类

class Body {
    var name = "身体"
    //外访问内
    var heartname = Heart().heartsname

    inner class Heart() {
        var heartsname = "心脏"

        //内访问外
        fun showName() {
            println("我的信息是$name")
        }
    }

}

默认不使用inner就是嵌套类，只能外部类访问内部类，不可内部类访问外部类

class Body {
    var name = "身体"
    //外访问内
    var heartname = Heart().heartsname

     class Heart() {
        var heartsname = "心脏"

        //内访问外
        fun showName() {
            //报错
            println("我的信息是$name")
        }
    }

}

普通类和数据类

普通类就是使用class修饰的类（会根据构造生成默认的字段和get,set 方法）数据类是使用data class 修饰的类（会根据构造生成默认的字段和get,set 方法，结构操作和重写 copy,tostring,hashcode,equals函数）

区别就在于数据类比普通类所提供的方法多

class ResultData1(var code: Int, var mes: String, var data: String) {

}

data class ResultData2(var code: Int, var mes: String, var data: String) {

}

fun main() {
    //普通类
    println(ResultData1(200,"成功","一条数据"))
    //ResultData1@266474c2

    //数据类
    println(ResultData2(200,"成功","一条数据"))
    //ResultData2(code=200, mes=成功, data=一条数据)


    //比较 因为没有重写equals 所以默认比较的是地址值，所以是false
    println(ResultData1(200,"成功","一条数据")==ResultData1(200,"成功","一条数据"))
    //false

    //比较 因为没有重写equals 所以默认比较的是地址值，所以是false
    println(ResultData2(200,"成功","一条数据")==ResultData2(200,"成功","一条数据"))
    //true
}

结构化声明

结构化声明是一种简单快捷的数据取值，数据类默认是生成了结构化函数

注意：结构化函数必须命名成component1 以此类推

class ResultData1(var code: Int, var mes: String, var data: String) {

    operator fun component1() = code
    operator fun component2() = data
    operator fun component3() = mes
}

data class ResultData2(var code: Int, var mes: String, var data: String) {

}

fun main() {
    var (name, data, sex) = ResultData1(12, "描述", "数据")
    println("$name$data $sex")

    var (names, datas, sexs) = ResultData2(12, "描述", "数据")
    println("$names$datas $sexs")
}

运算符重载

运算符重载plus做运算

class Math(var num1: Int, var num2: Int) {
    operator fun plus(data1: Math): Int {
        return (this.num1 + data1.num1) * (this.num2 + data1.num2)
    }
}

fun main() {
    println(Math(1,2) + Math(1,2))
}

枚举类型

enum class Week {
    星期一,
    星期二,
    星期三
}

data class Info(var name: String, var size: String) {
    fun show() {
        println("${this.name}长度是$size")
    }
}

enum class BodyInfo(private var info: Info) {
    Head(Info("头", "20")),
    Hand(Info("手", "30")),
    Body(Info("身体", "20"));

    fun show() {
        println("${this.info.name} ${this.info.size}")
    }

    fun updateData(info: Info) {
        this.info.size = info.size
        this.info.name = info.name
        println("${this.info.name} ${this.info.size}")
    }
}

fun main() {
    println(Week.星期一)
    println(Week.星期三 is Week)

    //常用枚举
    BodyInfo.Body.show()
    BodyInfo.Hand.updateData(Info("我不是手,我是胳膊","长度20公分"))
}

密封类

根据下面的代码，我们想要打印出成绩优秀的学生名字，那么使用传统的枚举是实现不了的，我们可以使用密封类（sealed）来实现

enum class Week {
    S1,
    S2,
    S3,
    S4
}

class Teacher(private var data: Week) {
    fun show() =
        when (this.data) {
            Week.S1 -> "很差"
            Week.S2 -> "及格"
            Week.S3 -> "良好"
            Week.S4 -> "优秀"
        }
}
fun main() {
    println(Teacher(Week.S1).show())
}

密封类的特点，所有的类都需要集成原密封类

sealed class Week {
    object S1 : Week()
    object S2 : Week()
    object S3 : Week()
    class S4(var stuName: String) : Week()
}

class Teacher(private var data: Week) {
    fun show() =
        when (this.data) {
            is Week.S1 -> "很差"
            is Week.S2 -> "及格"
            is Week.S3 -> "良好"
            is Week.S4 -> "优秀该学生的名字是${(this.data as Week.S4).stuName}"
        }
}

fun main() {
    println(Teacher(Week.S1).show())
    println(Teacher(Week.S4("李雷")).show())
}

这里可能会存在疑问，为什么又成员变量的类需要使用class而不是object,因为其他类都是单例，使用object 来创建的枚举至始至终都是一个对象，而class对象的类可以是多个

接口

interface USB {
    var name: String
    var info: String
    fun show(): String

}

class Mouse(override var name: String = "鼠标", override var info: String = "雷蛇鼠标") : USB {
    override fun show(): String {
        return "${this.name} 和${this.info}"
    }
}

class KeyWorld(override var name: String = "键盘", override var info: String = "雷蛇键盘") : USB {
    override fun show(): String {
        return "${this.name} 和${this.info}"
    }
}

fun main() {
    println(Mouse().show())
    println(KeyWorld().show())
}

抽象类

一些流程相似，但是内部具体实现不同的可以使用抽象类

abstract class Layout {
    fun load() {
        setContentView(getWeight())
        this.initView()
        this.initData()
        this.initXXX()
    }

    private fun setContentView(weight: Int) {
        println("我的宽度是${weight}")
    }

    abstract fun getWeight(): Int

    abstract fun initView()

    abstract fun initData()

    abstract fun initXXX()
}

class AppLayOut : Layout() {
    override fun getWeight(): Int {
        return 100
    }

    override fun initView() {
        println("初始话视图")
    }

    override fun initData() {
        println("初始化数据")
    }

    override fun initXXX() {
        println("初始化XXX")
    }

    fun show() {
        super.load()
    }
}

fun main() {
    AppLayOut().show()
}

泛型

泛型就是将类型以参数的方式进行传递，从而提高代码的扩展性

//万能输出器
class DataOutm(var data: T) {
    fun show() {
        println("万能输出${data.toString()}")
    }
}

data class Person(var name: String, var age: Int) {

}
data class Foot(var name: String, var price: Double) {

}

fun main() {
    var Jack=Person("老王",18)
    var Apple=Foot("苹果",18.0)
    DataOutm(Jack).show()
    DataOutm(Apple).show()
}

vararg 可变参数

类似与Java中的参数…

//vararg 表示可以传入任意类型的参数
class DataOutm(vararg data: T, var flag: Boolean) {

    //out 我们的T只能被读取，不能被修改 T只能读取
    private val objdata: Array = data

    //返回数据的值
    public fun showData(index: Int): T? {
        return objdata[index]
    }
}

fun main() {
    //默认的泛型是
    var data=DataOutm("我是字符串",12,"I",12.01f,54.21,null ,flag = false)
    println(data.showData(0))
    println(data.showData(1))
    println(data.showData(2))
    println(data.showData(3))
    println(data.showData(4))
    println(data.showData(5))
}

Kotlin入门第五节

Java相关栏目本月热门文章