学习kotlin系列之六（面向对象）

1、访问器

kotlin字段是私有的 会生成get和set方法
当有需求只能内部设置名称 外部不能修改名称
方法就是：在该属性下增加private set

1）访问器

fun main(args: Array<String>) {
    val person = Person()
    println(person.age)
    println(person.name)
//    person.name="hehe" //无法设置该属性
//报错 Cannot assign to 'name': the setter is private in 'Person
}

class Person {
    var name = "小明"
        private set
    var age = 20
}

2）自定义访问器

当有需求只能设置小于150的年龄
在该属性下增加 set()方法

fun main(args: Array<String>) {
    val person = Person()
    person.age=190
    println(person.age )
    println(person.name)
}

class Person {
    var name = "张峰"
    var age = 20
        set(value) {
            if (value < 150) {
                //切记使用field
                field = value
            }else{
                println("年龄太大了")
            }
        }
}

2、构造函数

1）构造函数

kotlin构造函数：
构造函数不带var的那种（name：String,age:Int） 只能往里面传参数；
带var那种（var name：String,var age:Int）相当于setter 和getter

fun main(args: Array<String>) {
val person=Person1("呵呵",30)
    println(person.age)

}

class Person1(var name: String,var age: Int) {

}

2）构造函数参数的使用

使用init关键字

class Person11(name: String, age: Int) {
    var name = ""
    var age: Int = 0

    //构造函数中的代码可以放到init中执行
    init {
        this.name = name
        this.age = age
    }
}

3）次构造函数

主构函数和次构函数顺序，先走主构函数 —>次构函数

fun main(args: Array<String>) {
    var person = Person3("大头", 22, "13132421")
}

//次构函数即重载
class Person3(var name: String, var age: Int) {
    init {
        println("走了主构函数")
    }

    var phone = ""

    constructor(name: String, age: Int, phone: String) : this(name, age) {
        println("走了次构函数")
        this.phone = phone
    }
}

3、继承

kotlin的类都是 final的 不能被继承所以父类要是用open关键字

fun main(args: Array<String>) {
val son=Son()
    println(son.age)
    println(son.name)
   son.habit()
}
open class Father{
   open var name="hehe"
    open var age=25
    //动态行为
    open fun habit(){
        print("呵呵喜欢抽烟")
    }

}

//子继承父业
class Son:Father(){
    override var name: String="didi"
    override var age: Int=10
    override fun habit() {
//        super.habit()
        println("我不爱抽烟")
    }
}

4、抽象类

抽象类:反映的是事物的本质
说明：
（1）抽象类里面可以没有抽象方法和抽象属性
（2）并且方法和属性可以具体实现
（3）抽象类可继承抽象类，抽象类只能单继承

fun main(args: Array<String>) {
    val zh = Chinese()
    println(zh.color)
    println(zh.language)
    zh.eat()
    val usa = Chinese()
    println(usa.color)
    println(usa.language)
    usa.eat()
    val af = Chinese()
    println(af.color)
    println(af.language)
    af.eat()
}

//定义人类抽象类
abstract class Human {
    //人类共同属性

    //肤色
    abstract var color: String
    //语言
    abstract var language: String

    //吃饭
    abstract fun eat()

}

open class Chinese : Human() {
    override var color: String = "黄色"
    override var language: String = "中文"

    override fun eat() {
        println("吃饭用筷子")
    }
}

class American : Human() {
    override var color: String = "白色"
    override var language: String = "英语"

    override fun eat() {
        println("吃饭用刀叉")
    }
}

class African : Human() {
    override var color: String = "黑色"
    override var language: String = "葡萄牙语"

    override fun eat() {
        println("吃饭用手")
    }
}

5、接口

1）接口

接口：接口反映的是事物的能力
描述：接口可以进行多实现

fun main(args: Array<String>) {
    val xiaoming = XiaoMing()
    xiaoming.eat()
    println(xiaoming.language)
    xiaoming.ride()

}

//小明
class XiaoMing : Chinese(), RideBike, DriveCar {
    override fun drive() {

        println("小明学会了开车")
    }

    override fun ride() {
        println("小明学会了骑自行车")
    }

}

//能力使用接口表示
interface RideBike {
    fun ride()
}

interface DriveCar {
    fun drive()
}

2）接口细节

接口细节：java中接口里面可以具体实现，kotlin不行；
描述： java中接口方法是不能实现的 kotlin 是可以实现的。

fun main(args: Array<String>) {
    val xiaoming = XiaoMing()
    xiaoming.eat()
    println(xiaoming.language)
    xiaoming.ride()
}
//小明
class XiaoMing : Chinese(), RideBike, DriveCar {
    override val licenseNumber: String="1425646476"
    override fun drive() {

        println("小明学会了开车")
    }

    override fun ride() {
        println("小明学会了骑自行车")
    }

}

//能力使用接口表示
interface RideBike {
    fun ride()
}

interface DriveCar {
    //车牌
//    val licenseNumber="12432132"
    val licenseNumber: String

    fun drive(){}
}

6、多态

描述：通过父类的接收 执行的是子类的方法

fun main(args: Array<String>) {
    val dog:Animal = Dog()
    dog.let {
        println(it.color)
        it.call()
    }
    val cat = Cat()
    cat.let {
        println(it.color)
        it.call()
    }
}

//定义动物类
abstract class Animal {
    var color: String = ""
    //行为
    abstract fun call()
}

//狗
class Dog : Animal() {
    override fun call() {
        println("狗汪汪叫")
    }

}

//猫
class Cat : Animal() {
    override fun call() {
        println("猫喵喵叫")
    }

}

来源：CSDN

作者：Hunter2916

链接：https://blog.csdn.net/Hunter2916/article/details/103458433