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()
对象的成员变量访问方式
对象引用.对象成员
stu.name
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*/
}
注:
延迟加载的变量在第一次初始化时会输出代码块中的所有内容，之后再次调用时，都只会
输出最后一行代码的内容。
扫一扫
395
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
