Kotlin入门（二）

本文链接： https://blog.csdn.net/xiangshiweiyu_hd/article/details/90613054

1、面向对象

创建一个 bean 类

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

fun main() {
    var person = Person("韩小呆", 20)
    print("人的姓名：${person.name} 人的年龄：${person.age} ")
}

在这里 “class Person(var name: String, var age: Int)” 表示 Person 是含有两个参数构造方法的类，在初始化该对象时候，需将参数传递进去

2、定义一个外部类

带参数构造方法的外部类

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

不含参构造方法外部类

class Person {
     var name: String = ""
     var age: Int = 0
}

声明方法则正常声明即可

2、封装

private       //仅自己 可以访问使用
protected    //自己、子类、同包 可以访问
默认         // 自己、同包 可以访问
public      //任何情况下都 可以访问

3、继承

父类定义方式：

open class Person {
    var age: Int = 0
    open fun like() {
        println("异性朋友")
    }
}

这里的 “open” 修饰类时，表示允许被继承，修饰方法时表示允许被子类重写。
“open”关键字与“private”关键字不可以同时进行修饰

子类定义方式：

class Man : Person() {
    override fun like() {
        print("美女")
    }
}

这里的 “class Man : Person()” 创建方式表示该类继承自 Person 类
“override ” 关键字表示重写父类的 “like( )”方法

这里就和 Java 语言不同了父类声明的时候需要加 “open” 关键字，而子类进行重写的时候必须加 “override” 关键字

4、抽象类

定义抽象父类

abstract class Person( var name: String) {
    abstract fun like()
}

继承抽象类的子类

class Man(name: String) : Person(name) {
    override fun like() {
        print("$name like 美女")
    }
}

测试类

fun main() {
    var man = Man("小呆")
    man.like()
}

5、接口

定义接口

interface Usb {
    fun work()
}

定义抽象类

abstract class Device {
    abstract fun doSomething()
}

实现接口和继承抽象类

class Computer : Device(), Usb {
    override fun doSomething() {
        println("play game")
    }

    override fun work() {
        println("插入鼠标")
    }
}

测试类

fun main() {
    var computer = Computer()
    computer.doSomething()
    computer.work()
}

这里没有什么特别的和 Java 的相关代码相同的

6、代理模式

定义公共接口

interface WashBow {
    fun washing()
}

子类 1 实现接口

class Son :WashBow{
    override fun washing() {
      println("儿子洗碗")
    }
}

子类 2 实现接口并且将自己设置为代理类

class Father : WashBow by Son() {
    override fun washing() {
        println("爸爸看着儿子")
        Son().washing()
    }
}

测试类

fun main() {
    var father = Father()
    father.washing()
}

这里的 by 关键字表示子类 2 需要实现的抽象方法由子类 1 进行实现
这个代码存在问题代码内包含两个子类1 对象

7、单例模式

公共接口

 interface WashBow {
    fun washing()
}

单例的子类 1

object Son : WashBow {
    override fun washing() {
        println("儿子洗碗")
    }
}

子类 2

class Father : WashBow by Son {
    override fun washing() {
        println("爸爸看着儿子")
        Son.washing()
    }
}

测试类

fun main() {
    var father = Father()
    father.washing()
}

这里的 Object 声明类直接该类转换为单例类

8、密封类

通过 sealed 关键字进行修饰 class 导致其只能被内部继承，而外部类若要初始化该类，则必须通过内部子类进行初始化
闭包的代码

sealed class Father {

    fun seyHello(){
        println("你好！！！")
    }

    class SonOne : Father()
    class SonTwo : Father()
}

测试类代码

fun main() {
    var father: Father = Father.SonOne()
    var fatherTwo: Father = Father.SonTwo()

    father.seyHello()
    fatherTwo.seyHello()
}