Kotlin学习笔记三 (类相关语法)

Kotlin类的基础知识

//Kotlin 也是用class声明一个类， 冒号后面是这个类的父类
class MyActivity1 : Activity()

//Kotlin Any类是kotlin所有类的父类，就像Java中的Object类一样，可不用显示声明
class MyAny : Any()

//实现接口，继续在后面添加即可，不用使用implement关键字 接口和父类没有先后顺序要求
//下面Activity() 小括号的意思是直接调用父类无参的构造方法，如果MyActivity2没有默认无参的构造函数，小括号也可以省略
class MyActivity2 : Activity(), View.OnClickListener {
    override fun onClick(v: View?) {
    }
}

//Kotlin的类默认是public final修饰的 如果不希望这个是final的可以加上open关键字
//kotlin给类增加构造参数，直接在类名后面直接添加一个构造参数，不需额外去写一个构造函数
//如果想在构造函数用添加一些语句，则需要用到init{}代码块
open class MyActivity3(var str :String) : Activity(){
    //init代码块在 构造参数函数调用时执行
    init {
        str = "MyActivity3"
        println("MyActivity3")
    }
}

//Kotlin的次级构造函数
//如果需要多个构造参数的话，就需要使用次级构造函数，次级构造函数必须直接或间接的基础当前类或者父类的构造函数
//隐藏的主构造函数，是直接在类名后面的
class AButton: Button {
    constructor(context: Context?) : super(context)
    constructor(context: Context?, attrs: AttributeSet?) : super(context, attrs)
    constructor(context: Context?, attrs: AttributeSet?, defStyleAttr: Int) : super(context, attrs, defStyleAttr)
    constructor(context: Context?, attrs: AttributeSet?, defStyleAttr: Int, defStyleRes: Int) : super(context, attrs, defStyleAttr, defStyleRes)
}

访问修饰符 internal是Kotlin特有的

//当前类私有
private 
//当前类及其子类都可以访问
protected
//所有类都可以访问
public 
//同Module可以访问 跨Module不可以访问
internal

伴生对象 companion object

用于解决Kotlin中没有静态方法的问题,还用一种方式是使用@JvmStatic注解

class MyUtils{
    //companion object 用来声明伴生对象，这样就可以用静态方法的方式调用
    companion object  {
        fun isZero(int:Int):Boolean{
            return int == 0
        }
    }
}
//Kotlin中调用方法，就像java中调用静态函数一样
fun main(args: Array<String>) {
    MyUtils.isZero(1)
}

//Java中调用 需要 类名.Companion.函数名
public static void main(String[] args){
    MyUtils.Companion.isZero(0);
}

使用伴生对象来实现一个单列模式

class Single private constructor(){
    companion object {
        fun get():Single{
            return Holder.instance
        }

    }
    private object Holder{
        val instance  = Single()
    }
}

fun main(args: Array<String>) {
    var single = Single.get()
}

Kotlin中代理模式的实现

interface Animal{
    fun bork()
}
class Dog:Animal{
    override fun bork() {
        println("wang")
    }
}
//Kotlin使用 by 关键字来实现代理，下面代码中by关键字后面 将animal保存在Zoo对象的内部，
//编译器让Zoo类自动实现Animal的接口的所有方法，实现的方法animal传参也全部可以调用
class Zoo(animal: Animal):Animal by animal

fun main(args: Array<String>) {
    val dog = Dog()
    Zoo(dog).bork()
}

数据类可以替代java bean

使用 data 关键字来声明是数据类
默认是public final ，编译器自动实现了 getter 、setter 、toString 、 hashCode 、equals 、 copy 这些方法
不需要像java一样在重新定义这些方法

data class Car(var name:String,var wheelCount:Int)
fun main(args: Array<String>) {
    val car = Car("BMW",6)
    var name = car.name
    var wheelCount = car.wheelCount
    println("车名:$name,轮子数量:$wheelCount")
    println(car.toString())
    println(car.hashCode())
}

Kotlin中的枚举类

enum class EnumClass{
    A,B,C,D
}

fun method(enumClass: EnumClass) = when(enumClass){
    EnumClass.A ->{
    }
    EnumClass.B ->{
    }
    EnumClass.C ->{
    }
    EnumClass.D ->{
    }
}

密闭类是Kotlin的一种枚举类，使用sealed关键字

密闭类相对普通的枚举类，它可以有自己的子类，不过子类也必须在密闭类内部创建
相比普通的枚举类，扩展性更强。

//kotlin中使用 object关键字 声明创建的是单例对象 
sealed class SealedEnum{
    object A:SealedEnum()
    object B:SealedEnum()
    object C:SealedEnum()
    object D:SealedEnum()
    class F(var name:String):SealedEnum()
}
fun work(sealedEnum: SealedEnum) = when(sealedEnum){
    SealedEnum.A ->{
    }
    is SealedEnum.F ->{
    }
    else -> {
    }
}