Kotin学习手记——类，android手机开发

return field

}

set(value) {

println(“setAge: $value”)

field = value

}

var name: String = name

get() {

return field // backing field

}

set(value) {

field = value

}

}

kotlin中，get和set方法可以显示写出来，但是一般默认不需要显示写出来，所以可以直接这样简写：

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

var age: Int = age

var name: String = name

}

这样也会默认生成get和set方法，除非你需要自定义get和set方法中的逻辑，那时就需要显示写出来了。

• 定义成员变量必须提供初始值：

var a : Int = 0

var b : String = “”

val c : Long = 0L

这与java也不同，java中定义变量不指定值有默认值，如int是0

• 如果定义了初始值，变量默认具备get和set方法，可以直接引用变量读取值和赋值

val simpleClass = SimpleClass(9, “Hello”)

println(simpleClass.a)

simpleClass.a = 122

println(simpleClass.a)

• 定义变量时如果不提供默认值，则必须定义get和set方法, 快捷键可以提示

var sss: Int

get() {

return 100

}

set(value) {}

//常量属性

val z : Long

get() {

return simpleProperty * 2L

}

• 接口定义：

interface SimpleInf {

//与java不同，接口里面可以定义待实现的常量属性，由子类实现

val simpleProperty: Int // property

fun simpleMethod()

}

与java不同的是，接口里面由子类实现的常量属性，java的接口类中变量值只能是初始化固定的。

• 实现接口：

class SimpleClass(var x: Int, val y: String) : SimpleInf {

//覆写接口中的属性，如果是val则只有get方法 没有set方法，因为val是只读的

override val simpleProperty: Int

get() {

return 2

}

//覆写方法必须加override关键字

override fun simpleMethod() {

}

}

与C++有点类似，实现接口直接在构造函数后面加冒号后写接口类名，覆写接口中的属性和方法都必须加override关键字。java也是需要的，但是java中不加顶多是警告，还是能运行的，但是kotlin不加直接编译报错。

• 抽象类定义：

abstract class AbsClass {

abstract fun absMethod()

//抽象类中的非抽象方法必须添加open才能被子类复写，否则子类不能覆写

open fun overridable(){}

fun nonOverridable(){}

}

与java相同的是，kotlin抽象类中也可以有已实现的方法和纯抽象方法，但是，与java不同的是，如果子类要覆写抽象类里的已实现方法，必须在该方法前面加open关键字。也就是说未加open关键字的方法不能被覆写。

• 实现抽象类：

open class SimpleClass(var x: Int, val y: String) : AbsClass() {

//覆写方法必须加override关键字

override fun absMethod() {}

//如果想子类不能覆写某个override方法，添加final属性

final override fun overridable(){

}

}

与接口一样，继承抽象类也是加冒号，不过后面的抽象类要写构造函数。同样，覆写抽象类中的方法全部都要加override关键字。另外，如果想要某个被覆写的方法不能再被子类覆写，加上final即可，与java一样。

• 普通类继承：

open class SimpleClass(var x: Int, val y: String) {

open fun zzz(string: String){

}

//final方法不能被覆写

final override fun overridable(){

}

}

//继承类

class SimpleC
lass2(x: Int, y: String): SimpleClass(x, y){

override fun zzz(string: String){

}

}

如果类要被子类继承，则要被继承的类名和方法名前面都要加open关键字，否则不能被继承和覆写。

• 属性引用：

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

var age: Int = age

var name: String = name

}

fun main() {

val ageRef = Person::age

val person = Person(18, “Bennyhuo”)

val nameRef = person::name //绑定接受者的属性引用，调用set的时候可以不用传接受者

ageRef.set(person, 20)

nameRef.set(“Andyhuo”)

}

扩展方法和扩展属性：

class PoorGuy{

var pocket: Double = 0.0

}

//定义类的扩展方法

fun PoorGuy.noMoney() {

println(“noMoney”)

}

//定义类的扩展属性 property = backing field + getter + setter

var PoorGuy.moneyLeft: Double

get() {

return this.pocket

}

set(value) {

pocket = value

}

就是在类定义大括号之外，再后续给类定义方法和属性，有点像java静态方法的调用形式，但这样定义的是成员方法和属性，并不是java中那样的静态方法。

fun main() {

val poorGuy = PoorGuy()

poorGuy.noMoney()

println(poorGuy.moneyLeft)

poorGuy.moneyLeft = 10000.0

println(poorGuy.moneyLeft)

}

类和扩展方法不一定在同一个kt文件中，但必须在方法的外层定义，即不能在某个函数方法中定义，必须是顶层的，如不能在main方法中定义。

fun Person.eat(s : String) {

println(“eat$s”)

}

var Person.howOld: Int

get() {

return this.age

}

set(value) {

age = value

}

fun main() {

val eat = Person::eat

val person = Person(10, “张三”)

person.eat(“aaa”)

eat(person, “222”)

println(person.howOld)

}

上面文件中只要导入Person这个类就可以给它定义扩展方法。

• 给系统类添加扩展方法：

//给String类定义扩展方法 给String前后加count个空格

fun String.padding(count: Int, char: Char = ’ '): String {

//生成重复count次的空格连续串

val padding = (1 … count).joinToString(""){ char.toString() }

return “$padding${this}${padding}”

}

//给String类定义扩展方法 判断字符串是否是邮箱

fun String.isEmail(): Boolean {

return matches(Regex("(?:[a-z0-9!# %&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!# %&’+/=?^_`{|}~-]+)|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])")@(?😦?:a-z0-9?\.)+a-z0-9?|\[(?😦?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-][a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])"))

}

//给String类定义扩展方法 字符串重复count次

fun String.times(count: Int): String {

return (1 … count).joinToString("") { this }

}

5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])")@(?😦?:a-z0-9?\.)+a-z0-9?|\[(?😦?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-][a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])"))

}

//给String类定义扩展方法 字符串重复count次

fun String.times(count: Int): String {

return (1 … count).joinToString("") { this }

}