Android—Kotiln基础教程（五）

前言

在上一篇中主要讲解了Kotlin关于集合相关的知识点&＃xff0c;在本篇中&＃xff0c;将会对Kotlin的对象进行详解&＃xff01;

1. 对象

1.1 示例一(无构造函数)

class Player {//分析点1var name &＃61; "abc"get() &＃61; field.capitalize()set(value) {field &＃61; value.trim()}var age &＃61; 10 get() &＃61; field.absoluteValueprivate set(value) { field &＃61; value.absoluteValue}val rolledValue//取随机数get() &＃61; (1 until 6).shuffled().first()var words: String? &＃61; null //分析点2fun saySomeThine() { //分析点3words?.also { "Hello ${it.toUpperCase()}" }.run(::println)}
}
fun main{var player &＃61; Player()player.name &＃61; "tom"//player.age&＃61;-10 //因为set被改成私有&＃xff0c;所以这里报错player.words&＃61;"main hello" println(player.name)println(player.age)println(player.rolledValue)player.saySomeThine()
}


定义了一个对象&＃xff0c;里面有对应的成员属性。注意看这里面的分析点&＃xff1a;

• 分析点1&＃xff1a;分别实现了对应的get、set方法&＃xff0c;并且在对应的方法里实现了对应的逻辑。
• 分析点2&＃xff1a;该成员变量并没有任何get、set方法
• 分析点3&＃xff1a;在方法saySomeThine里&＃xff0c;对成员属性使用了.also关键字&＃xff0c;最后再打印

运行效果&＃xff1a;

Tom
10
4
main hello


从这个运行效果可以看到&＃xff1a;对象里的成员&＃xff0c;就算不实现对应的get、set方法&＃xff0c;并且在没有使用private情况下&＃xff0c;在外部依旧可以调用对应的get、set方法。

1.2 示例二(有主构造函数)

// ----------------初始化
class Player1(_name: String,_age: Int,_isNormal: Boolean) {var name &＃61; _nameget() &＃61; field.toLowerCase()private set(value) {field &＃61; value.trim()}private var age &＃61; _agevar isNormal &＃61; _isNormalfun playerInfo() {//println(_name) //会报错println("name: $name; age:$age ;isNormal $isNormal")}
}fun main() {var player &＃61; Player1("Tom", 20, true)player.playerInfo()}


运行效果

name: tom; age:20 ;isNormal true


从这段代码看&＃xff0c;这个Player1应该是一个拥有有参构造方法的对象。而对应的_name、_age、_isNormal&＃xff0c;就是对应构造方法里的构造参数&＃xff0c;有效期也仅在对应的构造方法里。

1.3 示例三(有主次构造函数)

class Player2(_name: String,var age: Int &＃61; 12, //执行顺序 1var isNormal: Boolean) {var name &＃61; _name //执行顺序2get() &＃61; field.capitalize()private set(value) {field &＃61; value.trim()}fun playerInfo() {println("name: $name; age:$age ;isNormal $isNormal")}//次构造函数【】 这里的this()相当于执行了主构造函数 相当于顺序1和2constructor(name: String) : this(name, age &＃61; 100, isNormal &＃61; false ) {this.name &＃61; name.toUpperCase()println("constructor----------")//执行顺序 4}init { // 执行顺序3//初始化代码块 会在构造类实例时执行// 则可以 在这进行 数值的检查 满足条件则抛出异常println("init----------")require(age > 10) { println("age must be positive") }require(name.isNotBlank()) { println("player must have a name") }}
}fun main() {var player2&＃61;Player2("Tom", 20, true)player2.playerInfo()var player3 &＃61; Player2("bob", isNormal &＃61; false)player3.playerInfo()var player4&＃61;Player2("hqk")player4.playerInfo()
}


运行效果&＃xff1a;

init----------
name: Tom; age:15 ;isNormal true
init----------
name: Bob; age:12 ;isNormal false
init----------
constructor----------
name: HQK; age:100 ;isNormal false


这次在代码里面加入了constructor以及init&＃xff0c;constructor的意思就是创建一个次构造函数&＃xff1b;而init相当于java里面的static代码块。里面对应的执行顺序在注释里标注清楚了。

而init代码块里含有require方法&＃xff0c;这里面的意思就是&＃xff1a;当里面的表达式不成立/false时&＃xff0c;将直接报错&＃xff0c;自定义错误信息就在后面闭包里实现。

1.4 示例四(延迟初始化)

class Player3 {lateinit var equipment: Stringfun ready() {equipment &＃61; "sharp knife"}fun battle() {if (::equipment.isInitialized) println(equipment)}
}fun main{var palyer3 &＃61; Player3()palyer3.ready() //必须 调用该方法 才能使用对应的属性变量palyer3.battle()
}


运行效果&＃xff1a;

sharp knife


在之前的学习中&＃xff0c;我们认知到&＃xff0c;当我们定义变量的时候&＃xff0c;要么一开始赋初始值&＃xff0c;要么通过.?表明这个变量为可空。但在对象的使用里&＃xff0c;我既不想一开始赋初始值&＃xff0c;也不想让这个变量为可空的&＃xff0c;那就只有通过lateinit表明这个属性变量需要在后面初始化&＃xff08;使用它之前&＃xff09;&＃xff01;

那万一在使用它之前未初始化该怎么办呢&＃xff1f;岂不是就直接报空指针异常了&＃xff1f;Kotlin也提供了对应的解决方案&＃xff1a;只要无法确认 lateinit 变量是否完成初始化&＃xff0c;可以执行 isInitialized 检查

1.5 示例五(惰性初始化)


class Player4(_name: String) {var name &＃61; _nameval config by lazy { loadConfig() }private fun loadConfig(): Boolean {println("loading...")return false}
}fun main{var play4 &＃61; Player4("Tom");println(play4.config)
}


运行效果

loading...
false


这里我们看到&＃xff0c;当定义成员属性时&＃xff0c;使用了by lazy {}的方式&＃xff0c;让config实现了惰性初始化。当使用play4.config成员属性时&＃xff0c;它才会初始化相应的操作。

1.6 示例六(初始化陷阱)

class Player5() {init {//这样会直接报错blood &＃61; this.blood.times(4)}var blood &＃61; 100
}


当我们将变量放在init闭包后时&＃xff0c;将会发现代码居然报了语法错误。解决方案也很简单&＃xff0c;只需要将init闭包放在最后即可。

class Player6() {var blood &＃61; 100init {//这样就不会报错blood &＃61; this.blood.times(4)}
}fun main{var play6&＃61;Player6()println(play6.blood )
}


运行效果&＃xff1a;

400


1.7 示例七(对象的继承)

class Player7() {val name: Stringprivate fun firstLetter() &＃61; name[0]init {name &＃61; "Jack" //分析点1firstLetter()}//--------------继承----------------open class Product(val name: String) { //分析点2open fun description() &＃61; "Product: $name"open fun load() &＃61; "Nothing..."fun add(num1: Int, num2: Int) &＃61; num1 &＃43; num2 //该方法不可被子类重写}class LuxuryProduct : Product("Java") {//---重载override fun load() &＃61; "Java " &＃43; description()}
}
/*** 类型转换*/
fun sale(p: Player7.Product) {println(p.load())
}fun main() {val play7 &＃61; Player7()println(play7.name)val product &＃61; LuxuryProduct()product.description().run(::println)product.load().run(::println)//类型检测println(product is LuxuryProduct)println(product is Player7.Product)sale(product)sale(product as Player7.Product) //分析点3
}


我们先看这几点分析点&＃xff1a;

• 分析点1&＃xff1a;和上面示例一样&＃xff0c;当init代码块在对应的属性定义下方时&＃xff0c;可在这闭包里初始化对应变量&＃xff0c;即使变量是用val修饰的&＃xff0c;依然能够初始化。
• 分析点2&＃xff1a;当我们想是用继承时&＃xff0c;可以通过open class XXX定义被继承的对象&＃xff0c;里面的方法如果想要被子对象重写的话可使用open修饰对应的方法。子类继承父类语法为&＃xff1a;class 子类 : 父类
• 分析点3&＃xff1a;当我们想进行对象的转换时&＃xff0c;可使用as关键字强转对应的对象。

运行效果

Jack
Product: Java
Java Product: Java
true
true
Java Product: Java
Java Product: Java


结束语

好了&＃xff0c;本篇到这里就结束了&＃xff0c;本想着在这篇吧对象讲完的&＃xff0c;奈何发现内容太丰富了。还有很多很多&＃xff0c;加上时间不允许了&＃xff0c;还要写那个代码撸猫&＃xff0c;所以暂时放到下一篇了。