Kotlin基础 （四）

31_kotlin面向对象概念入门

    理解协同开发
 

32_kotlin面向对象实战

  社会分工
    对洗衣机生产商(程序员A)
      电机工作原理
      排水工作原理
      马达工作原理
      电压转换方式
      保险
      …
    对使用者(程序员B)
      买个洗衣机
      设置模式，开始洗
      …
 
实战代码：

创建一个 Class文件： WashMachine
示例代码：

/*
 *  程序员 A 创建的洗衣机
 *  属性：var module:String ——>什么牌子的
 *  var size:Int ——>可以洗多少升
 */

class WashMachine (var module:String,var size:Int){

    // 打开洗衣机的门
    fun openDoor(){
        println("洗衣机的门已经打开了...")
    }
    // 关闭洗衣机的门
    fun closeDoor(){
        println("洗衣机的门已经关闭了...")
    }
    // 开始洗衣服的方法
    fun start(){
        println("放水...")
        println("水放满了...")
        println("电机开始转...")
        println("洗好了...")
    }
}

创建一个 File 文件
示例代码：

/*
 *  程序员 B 写的代码
 *  程序员 B 的需求：洗衣服
 */

fun main(args: Array<String>) {
    // 怎么弄出一个洗衣机(买一个洗衣机)
    var washMachine = WashMachine("小天鹅",12)
    // 洗衣服前应该打开洗衣机的门
    washMachine.openDoor()
    washMachine.closeDoor()
    washMachine.start()
}

 

33_kotlin面向对象实战-洗衣机升级

 
创建一个 Class文件
示例代码：

/*
 *  程序员 A 创建的洗衣机
 *  属性：var module:String ——>什么牌子的
 *  var size:Int ——>可以洗多少升
 */

class WashMachine(var module: String, var size: Int) {

    var isDoorOPen = true
    var currentmode = 0

    // 打开洗衣机的门
    fun openDoor() {
        println("洗衣机的门已经打开了...")
        isDoorOPen = true
    }

    // 关闭洗衣机的门
    fun closeDoor() {
        println("洗衣机的门已经关闭了...")
        isDoorOPen = false
    }

    fun selectMode(mode: Int) {
        currentmode = mode
        when (mode) {
            0 -> println("初始模式，请您选择模式")
            1 -> println("轻柔")
            2 -> println("狂柔")
            else -> println("不要乱拧，拧环了不保险啊！")
        }
    }

    // 开始洗衣服的方法
    fun start() {
        if (isDoorOPen) {
            println("哔哔...门还没关呢，不能运行")
        } else {
            when (currentmode) {
                0 -> {
                    println("选择模式错误，不能开始洗衣服")
                }
                1 -> {
                    println("放水")
                    println("轻柔开始，发动机转速 慢")
                    println("洗完啦！")
                }
                2 -> {
                    println("放水")
                    println("狂柔开始，发动机转速 快")
                    println("洗完啦！")
                }
                else -> {
                    println("选择模式错误，不能开始洗衣服")
                }
            }
        }
    }
}

创建一个 File 文件
示例代码：

/*
 *  程序员 B 写的代码
 *  程序员 B 的需求：洗衣服
 */

fun main(args: Array<String>) {
    // 怎么弄出一个洗衣机(买一个洗衣机)
    var washMachine = WashMachine("小天鹅",12)
    // 洗衣服前应该打开洗衣机的门
    washMachine.openDoor()
    println("把衣服放进去了！")
    washMachine.closeDoor()
    washMachine.selectMode(1)
    washMachine.start()
}

 

34_kotlin面向对象实战-封装

封装

  隐藏内部实现的细节
  隐藏内部实现的细节就是封装
  封装就是隐藏内部实现的细节
 
创建一个 Class文件
示例代码：

/*
 *  程序员 A 创建的洗衣机
 *  属性：var module:String ——>什么牌子的
 *  var size:Int ——>可以洗多少升
 */

class WashMachine(var module: String, var size: Int) {

    var isDoorOPen = true
    var currentmode = 0

    // 打开洗衣机的门
    fun openDoor() {
        println("洗衣机的门已经打开了...")
        isDoorOPen = true
    }

    // 关闭洗衣机的门
    fun closeDoor() {
        println("洗衣机的门已经关闭了...")
        isDoorOPen = false
    }

    fun selectMode(mode: Int) {
        currentmode = mode
        when (mode) {
            0 -> println("初始模式，请您选择模式")
            1 -> println("轻柔")
            2 -> println("狂柔")
            else -> println("不要乱拧，拧环了不保险啊！")
        }
    }

    // 开始洗衣服的方法
    fun start() {
        if (isDoorOPen) {
            println("哔哔...门还没关呢，不能运行")
        } else {
            when (currentmode) {
                0 -> {
                    println("选择模式错误，不能开始洗衣服")
                }
                1 -> {
                    println("放水")
                    println("轻柔开始，发动机转速 慢")
                    setMotorSpeed(100)
                    println("洗完啦！")
                }
                2 -> {
                    println("放水")
                    println("狂柔开始，发动机转速 快")
                    setMotorSpeed(1000)
                    println("洗完啦！")
                }
                else -> {
                    println("选择模式错误，不能开始洗衣服")
                }
            }
        }
    }

    // 封装两个逻辑 发动机转速 慢 和  发动机转速 快
    // 设置发动机转速的方法
    private fun setMotorSpeed(speed: Int) {
        println("当前发动机转速为 ${speed} 圈/秒")
    }
}

创建一个 File 文件
示例代码：

/*
 *  程序员 B 写的代码
 *  程序员 B 的需求：洗衣服
 */

fun main(args: Array<String>) {
    // 怎么弄出一个洗衣机(买一个洗衣机)
    var washMachine = WashMachine("小天鹅",12)
    // 洗衣服前应该打开洗衣机的门
    washMachine.openDoor()
    println("把衣服放进去了！")
    washMachine.closeDoor()
    washMachine.selectMode(2)
    washMachine.start()

    // 当 WashMachine 这个类的 setMotorSpeed() 方法没有给设置 private 时 程序员 B 可以操作 转速(这样是不恰当的，所以 setMotorSpeed()要设置为私有的方法)
    // setMotorSpeed()方法是洗衣机内部的一个东西，不应该被别人看到，这一点就叫封装
    // （生活中的封装例如：禁止撕毁，撕毁不进行保险）
    //washMachine.setMotorSpeed(10000)
}

 

35_kotlin面向对象-继承(open和override)

继承

    继承是指一个对象直接使用另一个对象的属性和方法。
 
创建一个 Class 类 ：Father
示例代码：

/*
 *  父亲
 *
 */
// 写完 open 后才可以 进行 子类的继承
open class Father {
    var chactor:String = "性格内向"
    open fun action(){
        println("很有绅士风度！")
    }
}

创建一个 Class 类 ：Son
示例代码：

/*
 *  孩子
 *
 */
// 继承 父亲的属性和方法 (: Father)
// 在 kotlin 里不是随便就可以继承的，需要父类打开了允许继承才可以进行继承
// 需要到父类去写一个关键字 ：open
class Son : Father(){
    // override：重写父类的方法
    //在 kotlin 里不可以直接重写父类的方法，需要父类打开了允许才可以进行重写方法
    override  fun action(){
        println("儿子很乖，在公共场合很有礼貌")
    }
}

创建一个 File ：Test1
示例代码：

fun main(args: Array<String>) {
    // 初始化 Son 类
    var son1 = Son();
    println("儿子的性格${son1.chactor}")
    son1.action()
}

 

36_kotlin抽象类和继承

抽象类

    抽象类：如果子类的某个共有行为拥有不同的实现方式，父类中用于描述该行为的方法可以不定义方法体，但此时需要在方法首部中加上 abstract 修饰符，将该方法定义为抽象方法。
 
创建一个 Class 类 ：Human
示例代码：

/*
 * 抽象类
 * 抽象的人类
 */
abstract class Human(var name:String) {
    // 既然方法是抽象的那么类也应该是抽象的
    // 因为 eat 方法在子类中会进行不同的操作所以进行了抽象化
    abstract fun eat()
}

创建一个 Class 类 ：Man
示例代码：

class Man(name:String):Human(name) {
    override fun eat(){
        println("${name}可爱的！")
    }
}

创建一个 Class 类 ：Woman
示例代码：

class Woman(name:String):Human(name) {
    override fun eat(){
        println("${name}漂亮的！")
    }
}

创建一个 File ：Test2
示例代码：

fun main(args: Array<String>) {
    var person1 = Man("华晨宇")
    person1.eat()

    var person2 = Woman("邓紫棋")
    person2.eat()
}

 

37_kotlin面向对象-多态

多态

    同种功能，不同表现形态.
 
创建一个 Class 类 ：Human
示例代码：

/*
 * 抽象类
 * 抽象的人类
 */
abstract class Human(var name:String) {
    // 既然方法是抽象的那么类也应该是抽象的
    // 因为 eat 方法在子类中会进行不同的操作所以进行了抽象化
    abstract fun eat()

    // 说话
    abstract fun speak()
}

创建一个 Class 类 ：Man
示例代码：

class Man(name:String):Human(name) {
    override fun eat(){
        println("${name}可爱的！")
    }

    override fun speak() {
        println("${name}高音很高！")
    }
}

创建一个 Class 类 ：Woman
示例代码：

class Woman(name:String):Human(name) {
    override fun eat(){
        println("${name}漂亮的！")
    }
    override fun speak() {
        println("${name}唱歌很好听！")
    }
}

创建一个 File ：Test3
示例代码：

fun main(args: Array<String>) {
    var person1 = Man("华晨宇")
    var person2 = Woman("邓紫棋")
    var person3 = Man("贝克汉姆")
    var person4 = Woman("蒙娜丽莎")

    // 请这些人到一个集合里面(房间)
    var houseList = listOf<Human>(person1,person2,person3,person4)
    // 进行遍历
    for (h in houseList){
        h.speak()
    }
}

 

38_kotlin面向对象-抽象类和接口

什么是接口？

    接口泛指实体把自己提供给外界的一种抽象化物（可以为另一实体），用以由内部操作分离出外部沟通方法，使其能被内部修改而不影响外界其他实体与其交互的方式。
 

接口的声明和实现

      使用 Interface 关键字
 
抽象类与接口十分的类似
 

抽象类和接口的区别是什么呢？

      抽象类是事物的本质
      接口是事物的能力
 
 
创建一个 Interface 接口 ：IMan
示例代码：

/*
 *  抽象类 和 接口
 *  定义 一个 接口
 *  用途：人的接口
 */
interface IMan{
    fun hair()
}

创建一个 抽象类 ：Human
示例代码：

abstract class Human {
    abstract fun eat()
}

创建一个 Class类：Man
示例代码：

/*
 *    如果是抽象类的话 : (:号)后面要代一个 ()
 *    如果接口的话直接写名字就可以了
 *
 *    抽象类是事物的本质
 *    接口是事物的能力
 */
class Man : Human(),IMan{
    // 重写 IMan 接口的方法
    override fun hair(){
        println("头发是黑色的")
    }

    override fun eat() {
        println("细嚼慢咽的吃饭!")
    }

}

创建一个 Class类：NuanNan
示例代码：

// NuanNan 类不具备 IMan这样的一个接口所以不进行实现
class NuanNan : Human() {
    override fun eat() {
        println("慢吞吞的吃！")
    }

}

创建一个 File类：Test
示例代码：

fun main(args: Array<String>) {
    var man1 = Man()
    man1.hair()

    var man2 = NuanNan()
    man2.eat()

    // 因为 man2 也就是 NuanNan 类没有实现 IMan 接口所以会报错
    //var house = listOf<IMan>(man1,man2)

    var house = listOf<Human>(man1,man2)
    for (p in house){
        if (p is Man){
            p.eat()
        }
    }
}

 

39_kotlin面向对象-委托和代理

委托和代理

    委托是把事情托付给别人或别的机构办理.
 
    代理是指以他人的名义，在授权范围内进行对被代理人直接发生法律效力的法律行为。代理的产生，可以是受他人委托.
 

Kotlin接口代理

    采用 by 关键字

 
创建一个 Interface接口：IWashBowl
示例代码：

/*
 *   洗碗的接口
 */
interface IWashBowl {
    fun washing()
}

创建一个 Class类：BigHeadSon
示例代码：

/*
 *   大头儿子
 */
class BigHeadSon : IWashBowl{
    override  fun washing(){
        println("我是大头儿子，我在洗碗，一次赚1块钱.")
    }
}

创建一个 Class类：SmallHeadFather
示例代码：

/*
 *   小头爸爸
 */

// 在这里实现代理的接口，小头爸爸让大头儿子去洗碗，从中赚取9块钱
// 通过实现代理接口后，washing()这个方法不用再 SmallHeadFather 里去实现了，而是让 BigHeadSon 中去实现了
class SmallHeadFather : IWashBowl by BigHeadSon(){
    
}

创建一个 File：Test
示例代码：

fun main(args: Array<String>) {
    // 因为在 SmallHeadFather 这个类中 实现了代理的接口所以是大头儿子去洗碗
    var father = SmallHeadFather()
    father.washing()
}

执行结果：
    我是大头儿子，我在洗碗，一次赚1块钱.
 
修改 SmallHeadFather 类里的代码
示例代码：

/*
 *   小头爸爸
 */

// 在这里实现代理的接口，小头爸爸让大头儿子去洗碗，从中赚取9块钱
// 通过实现代理接口后，washing()这个方法不用再 SmallHeadFather 里去实现了，而是让 BigHeadSon 中去实现了
class SmallHeadFather : IWashBowl by BigHeadSon(){
    override fun washing() {
        // 实现代理接口后可以再代理前实现一些东西
        println("我是小头爸爸，我赚了10块钱")
        BigHeadSon().washing()
        // 实现代理接口后可以再代理后实现一些东西
        println("我看着儿子把碗洗完了！")
    }
}

执行结果：
    我是小头爸爸，我赚了10块钱
    我是大头儿子，我在洗碗，一次赚1块钱.
    我看着儿子把碗洗完了！
 

40_kotlin面向对象-单例模式

fun main(args: Array<String>) {
    // 如果定义同一个类的两个对象出来，那么它们是不相等的（这时会报错）
    var a = BigHeadSon()
    var b = BigHeadSon()
    println(a == b)
}

上面的代码会报错因为，是两个不同的对象
 
如果在BigHeadSon 类 中(把 class 修改为 object)
 
    那么by BigHeadSon ：代表的是不需要重新创建 BigHeadSon 这个类的对象了，并且大头儿子在内存当中有且仅有一个
 
上一节的代码中有一些些错误(如下代码中)
    错误为：by BigHeadSon())中有 BigHeadSon()

// 代码(by BigHeadSon())中有 BigHeadSon()：只要调用了构造方法 BigHeadSon() 那么在计算机内存里就是创建了一个对象(大头儿子)了
class SmallHeadFather : IWashBowl by BigHeadSon(){
    override fun washing() {
        // 实现代理接口后可以再代理前实现一些东西
        println("我是小头爸爸，我赚了10块钱")
// 只要调用了构造方法 BigHeadSon() 那么在计算机内存里就是创建了一个对象(大头儿子)了
// 所以这里又再一次创建了一个对象出来了(大头儿子被创建了两次)

        BigHeadSon().washing()
        // 实现代理接口后可以再代理后实现一些东西
        println("我看着儿子把碗洗完了！")
    }
}

修改了 BigHeadSon 类：(把 class 修改为 object)
示例代码：

/*
 *   大头儿子
 */

// object：保证大头儿子有且只有一个
object BigHeadSon : IWashBowl{
    override  fun washing(){
        println("我是大头儿子，我在洗碗，一次赚1块钱.")
    }
}

修改了 SmallHeadFather类：(把 BigHeadSon() 修改为 BigHeadSon)
示例代码：

/*
 *   小头爸爸
 */

// 在这里实现代理的接口，小头爸爸让大头儿子去洗碗，从中赚取9块钱
// 通过实现代理接口后，washing()这个方法不用再 SmallHeadFather 里去实现了，而是让 BigHeadSon 中去实现了
// by BigHeadSon ：代表的是不需要重新创建 BigHeadSon 这个类的对象了，并且大头儿子在内存当中有且仅有一个
class SmallHeadFather : IWashBowl by BigHeadSon{
    // 上面的代码(by BigHeadSon())中有 BigHeadSon()：只要调用了构造方法 BigHeadSon() 那么在计算机内存里就是创建了一个对象(大头儿子)了
    override fun washing() {
        // 实现代理接口后可以再代理前实现一些东西
        println("我是小头爸爸，我赚了10块钱")
        // BigHeadSon().washing()：
        // 如果用上面的代码：只要调用了构造方法 BigHeadSon() 那么在计算机内存里就是创建了一个对象(大头儿子)了
        // 如果用上面的代码：只所以这里又再一次创建了一个对象出来了(大头儿子被创建了两次)

        // 如果用下面的代码：大头儿子在内存当中有且仅有一个
        BigHeadSon.washing()
        // 实现代理接口后可以再代理后实现一些东西
        println("我看着儿子把碗洗完了！")
    }
}

File：Test 的代码基本没变(只是添加了测试代码)
示例代码：

fun main(args: Array<String>) {
    // 因为在 SmallHeadFather 这个类中 实现了代理的接口所以是大头儿子去洗碗
    var father = SmallHeadFather()
    father.washing()

    // 如果定义同一个类的两个对象出来，那么它们是不相等的（这时会报错）
//    var a = BigHeadSon()
//    var b = BigHeadSon()
//    println(a == b)
}