Kotlin学习笔记(二)-面向对象编程

面对对象编程 （OOP）

Object Oriented Programming

互联网系统发展概括

面向过程(Procedure)-> 面向对象（Object）-> 面向组件（Component）-> 面向服务（Service）-> SaaS/PasS/IasS -> 互联网系统

在OOP中，封装减少了操作粒度，数据结构上的封装使数据减少，自然减少了问题求解的复杂度；对代码的封装使代码得以复用，减少代码体积，同样使问题简化。

程序 = 算法+数据结构 = 基于对象操作的算法+以对象为最小单位的数据结构

类和类成员（构造）

Kotlin的类声明，默认是final和public的

分为主构造函数(primary contrcutor)和次构造函数(secondary contructor)

// 主构造函数，如果有注解或者可见性修饰符，contructor是必需的，否则可以省略
data class Student constructor(var name: String, var age: Int) {

    var addr:String = "" // 类的属性必须初始化，除非是抽象的。

    init {
        // 初始化代码块；主构造的参数可以在初始化块中使用。它们也可以在类体内声明的属性初始化器中使用
    }
     constructor(name: String, age: Int, gender: String) : this(name, age) {
    }
}

抽象类

含有抽象函数的类，成为抽象类。

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

    abstract var addr: String //抽象属性不能初始化;必须使用abstract修饰或者lateinit修饰。 
    abstract fun doAbstract() // 抽象函数必须使用abstract修饰；默认open修饰；没有具体实现。

    open fun doSleep() {
        // 抽象类中可以用具体实现的函数，但是默认final（不能被重写），除非加上open修饰
        // do something
    }
}

接口

类似于Java，接口没有构造函数，一个类可以实现（使用：）多个接口，使用逗号隔开。

// 和Java不同（所有方法都是抽象的），Kotlin接口中可以包含抽象方法和方法实现
interface IProject {
    // 接口中声明的属可以是抽象的，或者是提供访问器的实现。 
    val name: String
    val owner: String
        get() = "Kotlin" // 访问器

    fun save()

    fun print() {
        // do something
    }
}

覆盖冲突： 当一个类从它的直接父类继承同一个函数的多个实现，那么必须要重写这个函数并且提供自己的实现。

interface IService {
    fun print() {
        // do something
    }
}


class ProjectImpl(override val name: String) : IProject, IService {
    override fun print() {
        super.print()// 调用父类的方式
        super.print()
    }

    override fun save() {
    }
}

抽象类和接口的差异

1. 概念上的区别

接口主要是对动作的抽象；抽象类是对根源（事物本质）的抽象。

1. 语法层面的区别

接口不能保存状态，可以有属性但是必须是抽象的。抽象类单继承，接口多实现。

1. 设计层面区别

抽象是对事物的抽象(is a)，即对类抽象。接口是对行为的抽象（has a）。

继承

用open修饰的类，可以被子类继承

class Child : Base(){
    override fun showBase() {
        super.showBase()
    }
}

open class Base {
   // Kotlin提倡所有的操作都是明确的，因此需要被重写的函数也要设成open类型。
   // 接口和抽象函数定义的默认都是open的。
  // 如果不希望被重写，可以在前面加final。
   open  fun showBase() {}
}

枚举

//枚举基本形式,每一个枚举常量都是一个对象
enum class Color {
    RED, GREEN, BLUE,
}

// 初始化枚举值
enum class ColorDecorate(val rgb: Int) {
    RED(0XFF0000), GREEN(0X00FF00), BLUE(0X0000FF);
}

// 枚举常量也可以声明自己的匿名类
enum class ColorInner() {
    RED {
        override fun show(): ColorInner {
            return RED
        }
    };

    abstract fun show(): ColorInner
}

fun main(args: Array) {
    println(Color.BLUE.name)//BLUE,枚举对象的值
    println(Color.BLUE.ordinal)//2，枚举对象的下标位置
    println(ColorDecorate.BLUE.rgb)//255
    val enumValues = enumValues()
    enumValues.forEach { println(it) }
}

单例模式与伴生对象

通过单例模式保证系统中一个类只有一个对象实例。

1. object对象-Kotlin单例

object AdminUser {
    val username: String = "admin"
}
fun main(args: Array) {
    val username = AdminUser.username
    println(username) // admin
//  val  admin = AdminUser() // 提示错误，无法编译
}

2. 嵌套object对象

class DataProcessor {
    object FileUtils {
        fun getFileContent(): String = "content"
    }
}
fun main(args: Array<String>) {
    val fileContent = DataProcessor.FileUtils.getFileContent()
    println(fileContent)//content

    val dataProcessor = DataProcessor()
//    dataProcessor.FileUtils.getFileContent() // 编译失败，object对象不能使用实例访问
}

3. 匿名object

class AnonymousObjectType {
    // 私有函数，返回的是匿名object类型
    private fun privateFoo() = object {
        val x = "x"
    }

    // 公有函数，返回的类型是Any
    fun publicFoo() = object {
        val x = "x"// 无法访问到
    }

    fun test() {
        val x1 = privateFoo().x   // Works
//        val x2:String = publicFoo().x  // ERROR:Unresolved reference 'x'
    }
}

4. 伴生对象

companion object 修饰，一个类只有一个伴生对象；我们可以像Java静态的方法或属性一样使用一个类中的伴生对象的函数和属性。

class ClassA {
     // 一个类的伴生对象默认引用名是Companion；所以下边也可以这么写
     // companion object {
     companion object Factory{
        fun getName(): String {
            return "cllassA"
        }
    }
}

fun main(args: Array) {
    ClassA.Companion.getName()
    ClassA.getName()

    /**
     * 一个类的伴生对象默认引用名是Companion；
     *（1）在Kotlin之间调用可以省略
     *（2）在Java中引用Kotlin伴生对象，需要加Companion或者使用注解声明@JvmStatic
     */
}

@JvmField注解:生成与该属性相同的静态字段。
@JvmStatic注解:在单例对象和伴生对象中生成对应的静态方法。

伴生对象的初始化是在相应的类被加载解析时，与Java静态初始化器的语义相匹配，但是在运行时仍然是真实的实例成员，而且还可以实现接口。

interface ICompanion {
    fun fCompanion()
}

class ClassA {
    companion object Factory: ICompanion {
        override fun fCompanion() {
        }

        fun getName(): String {
            return "cllassA"
        }
    }
}

5. 数据类

使用关键字data标识，重写类的equals/hashCode/toString。
- 主构造函数至少需要一个参数。
- 主构造函数的所有参数都需要标记为val或者var。
- 数据类不能是抽象、开发、密封或者内部的，只能是final的。

//如果我们想创建一个无参的构造方法，我们需要对所有属性指定默认值，否则在创建时候必须初始化具体属性的值。
data class Cook(val name: String = "username", val age: Int = 0) {
}

fun main(args: Array) {
    val cook1 = Cook()
    val cook2 = Cook("liuhe")
    val cook3 = Cook("liuhe", 23)
    println(cook1)//Cook(name=username, age=0)
    println(cook2)//Cook(name=liuhe, age=0)
    println(cook3)//Cook(name=liuhe, age=23)
}

标准数据类Pair和Triple

6. 嵌套类与内部类

嵌套类与内部类

类可以标记为 inner 以便能够访问外部类的成员。内部类会带有一个对外部类的对象的引用。

class NestedClasses {
    class Outer {
        private val zero = 0
        val one = 1

        // 嵌套类（类中的类），没有持有外部类的引用，无法访问外部类中的变量。
        class Nested {
            fun accessOuter() = {
                // println(zero) // error, cannot access outer class
                // println(one) // error, cannot access outer class
            }
        }

        // 内部类，使用inner标识以便访问外部类的成员
        inner class Inner {
            fun accessOuter() = {
                println(one)
                println(zero)
            }
        }
    }
}

fun main(args: Array<String>) {
    println(NestedClasses.Outer.Nested().accessOuter())
    println(NestedClasses.Outer().Inner().accessOuter())
//    println(NestedClasses.Outer.Inner().accessOuter()) // error ,cannot access
}

匿名内部类

window.addMouseListener(object: MouseAdapter() {
    override fun mouseClicked(e: MouseEvent) {
        // ……
    }
})

委托

代理模式（Proxy Pattern）也称为委托模式。Kotlin在语言层面上原生支持委托模式。就是两个对象参与同一个请求，接受请求的对象将请求委托（Delegation）给另一个对象来处理。

委托属性

class DelegationPropertiesDemo {
    var content: String by Content()

    override fun toString(): String {
        return "DelegationPropertiesDemo Class"
    }
}

// content 使用by 关键字后，getValue和setValue是必须要实现的。
class Content {
    operator fun getValue(delegationPropertiesDemo: DelegationPropertiesDemo, property: KProperty<*>): String {
        return "$delegationPropertiesDemo property '${property.name}' = 'balala...'"
    }

    operator fun setValue(delegationPropertiesDemo: DelegationPropertiesDemo, property: KProperty<*>, s: String) {
    }
}

fun main(args: Array<String>) {
    val delegationPropertiesDemo = DelegationPropertiesDemo()
    println(delegationPropertiesDemo.content) // DelegationPropertiesDemo Class property 'content' = 'balala...'
}

懒加载属性委托（lazy）

它接受一个lambda并返回一个Lazy()的lanmbda表达式并记录下结果，后续调用get()只返回之前记录的结果。