Kotlin学习笔记-类和接口

一. class

• 声明

class Person {
}

• 修饰符
  1. classModifier

abstract //抽象类标示
final //标示类不可继承，默认属性
enum //标示类为枚举
open //类可继承，类默认是final的
annotation //注解类

2. accessModifier

private //仅在同一个文件中可见
protected //同一个文件中或子类可见
public //所有调用的地方都可见
internal //同一个模块中可见

• 属性

class Person {
    var name: String = "tom"
        set(value) {
            field = value
        }
        get() = field.toUpperCase()
    var age: Int = 0
}

• 构造方法
  Kotlin 中类可以有一个主构造方法以及多个二级构造方法。主构造方法是类头的一部分

1. 主构造方法

class Person constructor (name: String) {
       init {
       }
}

和上面的区别在于 上面的name只是作为参数传递，而下面的方式中name直接成为类的成员属性

class Person constructor(val name: String) {
       init {
       }
} 

主构造方法的初始化代码可以放到init代码块中，如果没有注解或修饰符则 constructor 可以省略

2. 二级构造方法

class Person {
        constructor(name: String) {
        }
}

3. 如果类有主构造方法, 那么每个二级构造方法都必须委托给主构造方法, 要么直接委托, 要么通过其他二级构造方法间接委托. 委托到同一个类的另一个构造方法时, 使用 this 关键字实现

 class Person(val name: String) {
        constructor(name: String, age: Int) : this(name) {
       }
}

4. 实例化
   Kotlin中没有new关键字

val p = Person("tom")

• 抽象类

abstract class Parent {
    abstract fun foo()
}
class Children : Parent() {
    override fun foo() {
    }
}

• 内部类

class Outer {
    private val bar: Int = 1
    inner class Inner {
        fun foo() {
            println(bar)
        }
    }
}
内部类使用inner修饰，持有外部类的引用，可以访问外部类的属性和方法

• 嵌套类

class Outer {
    val bar: Int = 1
    class Nested {
    }
}

嵌套类和内部类的区别在于嵌套类没有外部类的引用

• 封闭类
  封闭类是枚举类(enum class)的一种扩展: 枚举类的值也是有限的, 但每一个枚举值常数都只存在唯一的一个实例, 封闭类则不同, 它允许的子类类型是有限的, 但子类可以有多个实例, 每个实例都可以包含它自己的状态数据

sealed class Expr {
    class Const(val number: Double) : Expr() 
    class Sum(val e1: Expr, val e2: Expr) : Expr() 
    object NotANumber : Expr()
}

• 数据类
  只保存数据的类，使用data 修饰，类似java中的javabean

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

• 单例

object Singleton {
    fun foo() {
    }
}
fun main(args: Array<String>) {
    Singleton.foo()
}

二.interface

• 定义

interface MyInterface {
    fun foo()
    //默认实现
    fun bar() {
        println("hi")
    }
}

• 实现

class MyClass :MyInterface{
    override fun foo() {
    }
    override fun bar() {
        super.bar()
    }
}

• 接口的属性

interface MyInterface {
    var name: String
}
//实现方式一
class MyClass(override var name: String) : MyInterface {
}
//实现方式二
class MyClass : MyInterface {
    override var name: String
        get() = name
        set(value) {}
}

• 重写
  实现多个接口时，可能会遇到同一方法继承多个实现的问题

interface A {
    fun foo() {
        println("A foo")
    }
    fun bar() {
        println("A bar")
    }
}
interface B {
    fun foo() {
        println("B foo")
    }
    fun bar() {
        println("B bar")
    }
}
class C : A, B {
    override fun foo() {
        super<A>.foo()   //必须指定调用哪个接口的方法
    }
    override fun bar() {
        super<B>.bar()
    }
}