Kotlin面向对象

学习《第一行代码——Android（第3版）》做些笔记

类声明

示例：

class Car{
    var name = "YY"
    var price = 10
    var paoleduoyuan = 0

    fun run1km(){
        paoleduoyuan=paoleduoyuan+1
    }
}
1
2
3
4
5
6
7
8
9

实例化用例：

fun main(){
    var mycar = Car()
    println(mycar.name)
    mycar.run1km()
}
1
2
3
4
5

类继承

允许类被继承，需要加上open关键字。

抽象类可以不加。

可继承类例子：

open class car{

}
1
2
3

派生类例子：

    class EV:car(){
        code here
    }
1
2
3

构造

上面一节 car()后面的括号，表示使用的是基类的无参数构造函数。

Kotlin涉及到主构造函数、次构造函数的概念。

一般只会用到主构造函数，默认不带参数。也可以显式指定参数。主构造函数没有函数体。直接定义在类名后面。 这个的作用就是给参数传值吗?

class EV(val name:String, val price:Int):car(){
    //code here
    init{
        println("My car is"+name+"I paid "+price+" yuan")
    }
}

val myEV = EV("ET",200)
1
2
3
4
5
6
7
8

init{}用于在构造时实现一些逻辑操作。

根据括号里填写的参数，来’重载’选用构造函数。

使用示例：

class Student(val sno: String, val grade: Int, name: String, age: Int) :
    Person(name, age) {
    ...

1
2
3
4

下面一段我不太理解，引用自郭霖《第一行代码》

注意，我们在Student类的主构造函数中增加name和age这两个字段时，不能再将它们声明成val，因为在主构造函数中声明成val或者var的参数将自动成为该类的字段，这就会导致和父类中同名的name和age字段造成冲突。因此，这里的name和age参数前面我们不用加任何关键字，让它的作用域仅限定在主构造函数当中即可。
现在就可以通过如下代码来创建一个Student类的实例：
val student = Student(“a123”, 5, “Jack”, 19)

注意：任何一个类只能有一个主构造函数，但是可以有多个次构造函数，次构造函数有函数体。

次构造函数必须直接或者间接调用主构造函数。

示例：

class EV(val myname:String,val Battery：Int，carname:String,price:Int):car(carname,price){
    //次构造函数1，带两个参数
    constructor(myname:String,Battery:Int):this(myname,Battery,"TT",200){

    }
    //次构造函数2 无参，使用了上一个构造函数
    constructor():this("my mini",30){

    }
}
1
2
3
4
5
6
7
8
9
10

次构造函数可以互相调用，从而间接调用主构造函数。根据参数数量不同，实现重载。

下面三种实例化就都可以使用了：

val mycar1 =EV()
val mycar2 =EV("MINI EV",30)
val mycar3 =EV("T",90,"TT",200)
1
2
3

不写主构造函数的情况：

前面说了，主构造函数的形式就是类名后面跟的参数表，那么不写那个括号就是没有主构造函数。

class EV:car{
    constructor(myname:String,Battery:Int):super(name,price){

    }
}
1
2
3
4
5

因为没有主构造函数，所以不需要在父类名后面跟用来区分主构造函数调用哪个父类构造函数的括号。

并且需要在次构造函数中实现父类构造函数的调用。使用super对应于上面的this.

接口

接口是用于实现多态编程的重要组成部分。

单继承结构的语言，任何一个类最多只能继承一个父类，但是却可以实现任意多个接口。

所谓多态，就是用基类的指针指向子类，来使用子类实现的新方法（我以前是学C++的）。

interface usecar{
    /* 没有默认实现，子类必须实现的方法 */
    fun run()
    /* 支持默认实现，不要求必须覆盖的方法 */
    fun charge(){
        println("Battery is full")
    }
}

class EV(myname:String,Battery:Int,name:Int,price:Int):car(name,price),usecar{
    override fun run(){
        println("car run")
    }

    override fun charge(){
        println("you cost 10 hours")
        Battery=Battery+100;
    }
}

val myEV=EV("MINIEV",100,"T",20)



fun myusecar(myuse:usecar){
    myuse.run()
    myuse.charge()
}

//使用多态
myusecar(myEV)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

函数可见性

public Kotlin默认 所有类可见

private 私有 当前类可见

protected 保护 当前类和子类可见

internal 同一个模块中的类可见

数据类

Kotlin可以自动实现一些常用的和数据处理相关的方法，只要在声明的时候加上data关键字。

equals()、toString()这样的方法就可以自动实现，不用自己写。

示例：

/**
 * You can edit, run, and share this code.
 * play.kotlinlang.org
 */

data class Cellphone(val brand: String, val price: Double)

fun main() {
    println("Hello, world!!!")
    
    val cellphone1 = Cellphone("Samsung", 1299.99)
    val cellphone2 = Cellphone("Samsung", 1299.99)
    println(cellphone1)
    println("cellphone1 equals cellphone2 " + (cellphone1 == cellphone2))

}

>>>输出结果
Hello, world!!!
Cellphone(brand=Samsung, price=1299.99)
cellphone1 equals cellphone2 true
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

单例类

在全局只有一个实例的类。来源于设计模式中的单例模式。

如果希望全局只有这么一个实例，可以这样做。

类声明的时候把class替换成object

object mycar{
    fun run(){
        println("car run")
    }
}

mycar.run()
1
2
3
4
5
6
7

可以在object里直接写函数，然后通过类似使用静态方法的方式直接通过类名来调用方法。Kotlin会自动创建一个单例类实例并维护保障只有一个实例。