Kotlin 进阶之路(三) 面向对象
3.1 面向对象的概念
面向对象是将要解决的问题按照一定的规则划分为多个独立的对象，然后通过调用对象的方法来解决
问题。面向对象的三大特性，封装性、继承性、多态性。
1.封装性
封装性是面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体的实现细节。
例如，用户使用电脑，只需要手指敲键盘即可，无需知道电脑内部是怎么工作的。
2.继承性
继承性主要是指类与类之间的关系，通过继承，可对原有类的方法进行扩展。
例如，学生和工人都属于人类，人类都需要吃饭，学生和工人都可以继承人类，分别扩展各自吃饭
的方法。
3.多态性
多态性是指在程序中允许出现重名，在一个类中定义的属性和方法被其它类继承后，它们可以有
不同的数据类型或表现出不同的行为，这使得同一个属性和方法在不同的类中具有不同语义。
例如，当听到 Cut 这个单词时，理发师的行为是理发，演员的行为是停止表演，不同的对象，
所表现的行为是不一样的。
3.2 类与对象
- 类的定义
类是对象的抽象，用于描述一组对象的共同特征和行为。类中可以定义成员变量(属性)
和成员函数(方法)
class Student{ //成员变量 private val name = "" private val age = 0 //成员函数 private fun sayHi(){ println("你好，我是${name}, 我今年${age}岁") } }
- 对象创建
Kotlin 中对象通过 类名() 的形式来直接创建
var 对象名称 = 类名()
var stu = Student()
对象的成员变量访问方式
对象引用.对象成员
class Student{ //成员变量 var name = "Mike" var age = 16 //成员函数 fun sayHi(){ println("你好，我是${name}, 我今年${age}岁") } } fun main(args: Array<String>) { var student = Student() student.sayHi() println("姓名:${student.name}") student.name = "James" println("姓名:${student.name}") /*你好，我是Mike, 我今年16岁 姓名:Mike 姓名:James*/ }
- 类的封装
类的封装是指在定义一个类时，将类中的属性私有化，使用 private 关键字来修饰，私有
属性只能在所属类中访问，为了让外界能范围私有属性，可以提供 public 修饰的共有方法。
class Student{ var name : String = ""//默认是公有 private var age : Int = 0 fun setAge(age : Int){ if (age > 0) this.age = age else println("输入年龄有误") } 默认是公有 fun sayHi(){ println("你好，我是${name}, 我今年${age}岁") } } fun main(args: Array<String>) { var stu = Student() stu.setAge(24) stu.name = "Kobe" stu.sayHi() /*你好，我是Kobe, 我今年24岁*/ }
3.3 构造函数
构造函数是类的一个特殊成员，将在类实例化对象时被自动调用，可用来为类的属性赋值。
Kotlin 中的构造函数分为两种————主构函数和次构函数。构造函数使用关键字 constructor 定义
- 主构函数
在 Kotlin 中，一个类可以有一个主构造函数和多个次构造函数。主构造函数位于类头跟
在类名之后，如果主构造函数没有任何注解或可见性修饰符， constructor 关键字可
省略。语法格式如下
class 类名 constructor([形参1, 形参2, 形参3]){}
当定义一个类时，如果没有显示指定主构函数， Kotlin 编译器会默认为其生成一个无参
主构函数，这点和 Java 是一样的。无参主构函数的两种写法。
class 类名 constructor(){}
class 类名(){}
一般我们经常用的是有参的构造函数为属性赋值。在主构函数中赋值时，使用 init{} 初始化代码块
class Click constructor(username : String){ var name : String init { name = username println("我是$username") } } fun main(args: Array<String>) { var click = Click("猫哆哩") //我是猫哆哩 }
- this 关键字
Kotlin 中也提供了 this 关键字，用于在函数中访问对象的其它成员。上面的 init{} 可写成
init{
this.name = username
}
- 次构函数
Kotlin 中可以定义多个次构函数，次构函数必须调用主构函数或其它次构函数，调用方式
为 次构函数 : this(参数列表)
注意:
当新定义的次构函数调用主构函数或次构函数时，被调用的构造函数中参数顺序必须和新定义
的次构函数参数顺序一致，并且参数个数必须小于新定义的次构函数的参数个数。
class Workers constructor(name : String){ var name : String init { this.name = name println("我叫${name}") } constructor(name: String, age: Int) : this(name){ println("我叫${name}, 我今年${age}岁") } constructor(name: String, age: Int, sex: String) : this(name, age){ println("我叫${name}, 我今年${age}岁,我是${sex}生") } } fun main(args: Array<String>) { var person = Workers("洛天依", 26, "女") /*我叫洛天依 我叫洛天依, 我今年26岁 我叫洛天依, 我今年26岁,我是女生*/ }
3.4 类的继承
- 类的继承
在 Kotlin 中，类的继承是指在一个现有类的基础上去构建一个新类，构建出来的新类被
称为子类，现有类被称作父类，子类将自动拥有父类所有可继承的属性和方法。
继承使用关键字 : , class A : B{} A 类继承 B 类
Kotlin 中所有的类默认使用 final 修饰，因此，当继承某类时，需要在类前面加 open 关键字
open class Father(){ fun sayHello(){ println("Hello") } } class Son : Father(){} fun main(args: Array<String>) { var son = Son() son.sayHello() //Hello }
总结:
1、在 Kotlin 中，一个类只能继承一个父类，不能继承多个父类
2、多个类可以继承一个父类
3、在 Kotlin 中，多层继承是允许的，即一个类的父类可以再去继承另外的父类
4、在 Kotlin 中，子类和父类是一种相对概念，一个类可以是另一个类的子类，也可能是其它类的父类
- 方法重写
子类对父类的方法或属性进行修改，该过程被称为方法或属性的重写。
注:
重写的方法或属性应和父类的方法名或属性名一样，并且方法前面使用 override 关键字标识
在父类中被重写的属性或方法前必须使用 open 关键字修饰
open class Father(){ open var name = "洛天依" open var age = 26 open fun sayHello(){ println("Hello! 我叫$name, 我今年$age 岁") } } class Son : Father(){ override var name = "阿黛尔" override var age = 48 override fun sayHello() { println("Hello! It's me, 我叫 $name, 我今年$age 岁") } } fun main(args: Array<String>) { var father = Father() father.sayHello() var son = Son() son.sayHello() /*Hello! 我叫洛天依, 我今年26 岁 Hello! It's me, 我叫 阿黛尔, 我今年48 岁*/ }
- super 关键字
super 关键字用于访问父类的成员变量或方法，一般用于在子类中访问父类的成员
super.成员变量
super.成员方法([形参1, 形参2…])
注:
Kotlin 中所有类都继承 Any 类，它是所有类的父类，类比 Java 中的 Object类
如果一个类在声明时没有指定父类，则默认为 Any 类，在程序运行时， Any 类自动映射
为Java 中的 java.lang.Object 类
3.5 抽象类和接口
- 抽象类
抽象类使用关键字 abstract 修饰，抽象方法也需要用 abstract 修饰。需要注意的是，包
含抽象方法的类必须声明为抽象类，但抽象类可以不包含任何抽象方法，只需用 abstract
修饰即可。抽象类是不可以被实例化的，其中的抽象方法没有方法体，不可以被调用。
abstract class Animal{ abstract fun eat() } class Monkey(food : String) : Animal(){ var food = food override fun eat() { println("猴子正在吃$food") } } fun main(args: Array<String>) { var monkey = Monkey("香蕉") monkey.eat() //猴子正在吃香蕉 }
- 接口
如果一个抽象类中的所有方法都是抽象的，则可以将类定义为接口。接口也就是一个特
殊的抽象类，使用关键字 interface 来声明，接口中定义的方法默认包含 abstract 修饰
符，可以省略不写
interface Animal{ fun eat() } interface Monkey : Animal{ fun sleep() } class GoldenMonkey(food: String) : Monkey{ var food = food override fun eat() { println("我是金丝猴，我喜欢吃$food") } override fun sleep() { println("我是金丝猴，我喜欢睡觉") } } fun main(args: Array<String>) { var goldenMonkey = GoldenMonkey("香蕉") goldenMonkey.eat() goldenMonkey.sleep() /*我是金丝猴，我喜欢吃香蕉 我是金丝猴，我喜欢睡觉*/ ｝
总结:
接口中的方法都是抽象的，不能实例化对象
当一个类实现接口时，如果这个类是抽象类，则实现接口中部分方法即可，否则需要实现所有方法
一个类可以实现多个接口，但 : 之间需要用 , 隔开
一个接口可以继承多个接口，但 : 之间需要用 , 隔开
一个类在继承另一个类的同时还可以实现接口，继承的类和实现的接口都放在 : 后面
3.6 常见类
- 嵌套类、内部类
Kotlin 的嵌套类是指可以嵌套在其他类中的类，该类不能访问外部类的成员
Kotlin 的内部类是指使用 inner 修饰的嵌套类，可以访问外部类的成员
class Outer{ var name = "洛天依" var age = 26 class Nested{ fun sayHello(){ //println("Hello! 我叫${name}, 今年${age}岁")//无法访问外部类字段 } } } class Outer{ var name = "洛天依" var age = 26 inner class Inner{ fun sayHello(){ println("Hello! 我叫${name}, 今年${age}岁") } } } fun main(args: Array<String>) { Outer().Inner().sayHello() }
- 枚举类
枚举就是一 一例举，每个枚举常量都是一个对象，枚举常量用逗号分隔，用关键字 enum 修饰
enum class Week1{ 星期一,星期二,星期三,星期四,星期五,星期六,星期日 } enum class Week2(val what:String, val doSomeThine: String){ MONDAY("星期一", "上班") TUESDAY("星期二", "聚会") WEDNEWSDAY("星期三", "上班") THURSDAY("星期四", "上班") FRIDAY("星期五", "上班") SATURDAY("星期六", "加班") SUNDAY("星期日", "休息") }
- 密封类
密封类用于表示受限制的类层次结构，当一个值只能在一个集合中取值，而不能取其他
值时，此时可以用密封类。在某种意义上，密封类是枚举类的扩展，即枚举类型的值集合。每个枚举常量只存在一个实例，而密封类的一个子类可以有包含状态的多个实例。
密封类必须用 sealed 关键字修饰
由于密封类的构造函数是私有的，因此密封类的子类只能定义在密封类的内部或同一文件中
sealed class Stark{ //罗伯 斯塔克 class RobStark : Stark(){} //桑莎 斯塔克 class SansaStark : Stark(){} //艾丽娅 斯塔克 class AryaStark : Stark(){} //嵌套类 class BrandonStark(){} } //密封类 Stark 子类 class JonSnow : Stark(){}
注:
Kotlin 中密封类和枚举类的区别，密封类适用于子类可数的情况，而枚举类适用实例可数的情况
- 数据类
Kotlin 中专门处理数据一些数据或对象的状态的类称为数据类，类似于 Java 中的 Bean
类、entity 类、model 类。数据类的语法格式为，
data class 类名({形参1, 形参2…})
注:
数据类的主构造函数至少有一个参数，如果需要一个无参的构造函数，可将构造函数的参数都设置默认值
数据类中的主构造函数中传递的参数必须用 val 或 var 修饰
在 Kotlin 1.1 版本之前数据类只能实现接口，1.1 版本后可继承其它类
编译器可自动生成一些常用的方法，如 equals()、hashCode()、toString()、
componentN()、copy()等，这些方法也可自定义
- 单例模式
单例模式是指在程序运行期间针对该类只存在一个实例，就好比世界上只有一个太阳一
样。Kotlin 中的单例模式是通过 object 关键字来完成的，通过 object 修饰的类即为单例类。
object Singleton{ var name = "单例模式" fun sayHello(){ println("Hello, 我是一个$name,浑身充满正能量") } } fun main(args: Array<String>) { Singleton.name = "小太阳" Singleton.sayHello() //Hello, 我是一个小太阳,浑身充满正能量 }
注: 单例类不需要创建实例对象，直接通过 类名.成员名 调用类中的属性或函数
- 伴生对象
Kotlin 中没有静态变量，因此使用伴生对象来替代 Java 中的静态变量，伴生对象是在类
加载是初始化，生命周期与该类的生命周期一致。通过关键字 companion 来标识，由于
每个类中有且仅有一个伴生对象，因此可以不指定伴生对象的名称，其它对象也可共享
伴生对象。
companion object 伴生对象名称(也可以不写){
程序代码...
}
有名称： 调用方式为 类名.伴生对象名.成员名 或 类名.成员名
无名称： 调用方式为 类名.Companion.成员名 或 类名.成员名
class Company{ companion object Factory{ fun sayHello(){ println("我是一个伴生对象，与伴生类相伴") } } } fun main(args: Array<String>) { //第一种调用方式 类名.伴生对象名.成员函数名 Company.Factory.sayHello() //第二种调用方式 类名.成员函数名 Company.sayHello() ｝
3.7 委托
委托也叫代理模式，是最常用的一种设计模式。简单说就是 A 的工作交给 B 来做。
在 Kotlin 中，委托是通过 by 关键字实现的，主要分为类委托，和属性委托。
- 类委托
接下来演示定义接口 Wash，已经两个接口的实现类 Child 和 Parent, Parent 类要实现的功能委托给 Child 进行处理。
interface Wash{ fun washDishes() } class Child : Wash{ override fun washDishes() { println("委托大头儿子洗碗，耶!") } } //第一种委托方式 class Parent : Wash by Child(){} //第二种委托方式 class Parent(washer : Wash) : Wash by washer fun main(args: Array<String>) { //第一种 var parent = Parent() parent.washDishes() //第二种 var child = Child() Parent(child).washDishes() //委托大头儿子洗碗，耶! ｝
- 属性委托
Kotlin 中的属性委托是指一个类的某个属性值不是在类中直接进行定义，而是将其委托给一个代
理类，从而实现对该类的属性进行统一管理。语法格式如下:
val/var <属性名> : <类型> by <表达式>
by 后面的表达式是指委托类，属性对应的 get() 和 set() 会被委托给 getValue() 和
setValue() 方法，因此属性的委托不必实现任何接口。
class Parent{ var money : Int = 0 operator fun getValue(child: Child, property : KProperty<*>) : Int{ println("getValue()方法被调用，修改的属性为: ${property.name}") return money } operator fun setValue(child: Child, property: KProperty<*>, value: Int){ println("getValue()方法被调用，修改的属性为: ${property.name} 属性值: ${value}") money = value } } class Child{ //将压岁钱委托给父母 var money : Int by Parent() } fun main(args: Array<String>) { val child = Child() println("(1) 父母给孩子100元压岁钱") child.money = 100 println("(2) 买玩具花了50") child.money -= 50 println("(3) 自己还剩${child.money}") /*(1) 父母给孩子100元压岁钱 getValue()方法被调用，修改的属性为: money 属性值: 100 (2) 买玩具花了50 getValue()方法被调用，修改的属性为: money getValue()方法被调用，修改的属性为: money 属性值: 50 getValue()方法被调用，修改的属性为: money (3) 自己还剩50*/ }
注:
setValue() 和 getValue() 方法前必须用 operator 关键字修饰
getValue()方法返回类型必须与委托属性相同或是其子类
如果委托属性是 val 类型，被委托方法只需要实现 getValue()， 如果是 var 类型，则需要实现
getValue() 和 setValue()
- 延迟加载
Kotlin 中提供了延迟加载功能，又叫懒加载，当变量被访问时才会被初始化。通过关键字
by lazy 标识，延迟加载要求变量声明为 val 类型。延迟加载也是委托的一种形式。
fun main(args: Array<String>) { val content by lazy { println("Hello") "world"//第一次初始化后，再次调用该变量时，只会输出 ^lazy 的内容 } println(content) println(content) /*Hello world world*/ }
注:
延迟加载的变量在第一次初始化时会输出代码块中的所有内容，之后再次调用时，都只会
输出最后一行代码的内容。
