Kotlin 面向对象

一、 类

Kotlin没有new关键字

默认修饰符是public

二、属性

 1.

fun main() {
    var a=A()
    println(a.name)
    println("===========")
    a.name="liu"
}

class A{
    //只读
    val age  get() = 10
    //
    var name ="tom"
    get() {
      println("调用name get属性")
        return field
    }
    set(value){
        println("调用name set属性")
        field=value
    }
}

 

 2.延迟初始化

可以在使用时，再分配内存空间

（1）

private lateinit var name: String

（2）

val name: Int by lazy { 1 }

三、构造方法

1.默认构造参数减少构造函数重载

fun main() {
    val stu1 = Student()
    val stu2 = Student(age = 20)
    val stu3 = Student(name = "lili")
    val stu4 = Student(age = 16, name = "lili")
}
//默认赋值
class Student(val age:Int=18,var name:String="tom"){

}

2.var val

如果类构造函数前没有使用var val，则它不会自动赋值给属性

没有带var val 的参数名，只能在init中使用

3.init语句块

创建对象时会自动执行init， init可以有多个

fun main() {
    val stu1 = Student()
}
class Student(val age:Int=18,var name:String="tom"){
    init {
        println(age)
    }
    init {
        println(name)
    }
}

4.次要构造方法

在类上定义的构造方法是主要构造，在类里定义的叫次要构造。

次要构造必须加上  constructor

fun main() {
    val stu1 = Student(18,"")
}
class Student  (){
    constructor(age:Int,name: String) :this (){

    }
}

次要构造必须调用主要构造

fun main() {
    val stu1 = Student(18,"Tom","852")
}
class Student  (age:Int){
    init {
        println(age)
    }
    constructor(age:Int,name: String) :this (age){
        println(name)
    }
    constructor(age:Int,name: String,code:String) :this (age,name){
        println(code)
    }
}

四、继承

 1.类默认下不能被继承

想要继承需要父类使用open关键字

fun main() {
    val stu1 = Student1(18)
}
open class Student  (age:Int){
    init {
        println(age+1)
    }
}
class Student1(age:Int):Student(age){

}

 2.super

如果子类没有主构造，则次构造使用super继承父类

fun main() {
    val stu1 = Student1(18)
}
open class Student  (age:Int){
    init {
        println(age+1)
    }
}
class Student1:Student{
    constructor(age:Int):super(age){
    }
}

如果继承了多个类和接口，并且他们又相同得方法名 

interface  A {
    fun test(){
        print("A")
    }
}

class B{
    fun test(){
        print("B")
    }
}

class C:A{
  override  fun test(){
        super<A>.test()
    }
}

3.重写父类方法

父类方法需要加open，并且子类加override 

open class Student  () {
    open fun test() {
        println("父类")
    }
}
class Student1:Student() {
    override fun test() {
        println("父类")
    }
}

4.final

五、接口

1.接口方法内可以实现

fun main() {
    B().test()
}
interface  A {
    fun test(){
        print("OK")
    }
}
class B:A{

}

2.

六、抽象类

七、伴生对象

Kotlin中不存在静态得概念，可以使用 companion object {} 

fun main() {
    println(A.a)
    A.test()
}

class A{
    companion object {
        val a=10
        fun test(){
            print("fun")
        }
    }
}

一个类中只允许定义一个伴生对象

编译器给 companion object 默认加上一个名字companion

编译后

八、扩展

fun main() {
    A().test2()
}
class A{
    fun test1(){
        println("test1")
    }
}
fun A.test2(){
    println("test2")
}

九、多态

十、数据类

 主构造至少要有一个参数

所有得主构造参数都必须要有 var或者val

数据类不能是抽象的，open的、sealed的、inner的

fun main() {
    var a=A(18,"tianjin")
    print(a)
}

data class A(var age:Int,val address:String)

十一、密封类

限制只能传入子类

 

十二、嵌套类、内部类