Kotlin学习四：Kotlin中的类和对象_kotin类后面括号

一、类定义

Kotlin 中使用一般使用关键字 class 声明类，后面紧跟类名：

class KotlinClass {  // 类名为 KotlinClass
    // 大括号内是类体构成
}
1
2
3

接口定义

interface IKotlinInterface
1

单例

Kotlin使用object替换class来修饰类，可以实现单例模式，
java单例类：

public class JavaInstanceClass{
      private JavaInstanceClass(){}
      private static JavaInstanceClass INSTANCE;
      public static JavaInstanceClass getInstance(){
          if(INSTANCE==null)
              INSTANCE=new JavaInstanceClass();
          return INSTANCE;
      }
}
1
2
3
4
5
6
7
8
9

Kotlin单例类：

object KotlinInstanceClass{
    // 大括号内是类体构成
}
1
2
3

二、类的修饰符

类属性修饰符

abstract    // 抽象类  
final       // 类不可继承，默认属性
enum        // 枚举类
open        // 类可继承，类默认是final的
annotation  // 注解类
1
2
3
4
5

类权限修饰符

private    // 仅在同一个文件中可见
protected  // 同一个文件中或子类可见
public     // 所有调用的地方都可见
internal   // 同一个模块中可见
1
2
3
4

Kotlin中类默认是final的，如果需要定义可以继承的类，需要加open修饰符

三、构造器

主构造器
直接在类名后面定义，使用constructor关键字，init区相当于构造器的方法体：

class Person constructor(firstName: String) {
    init {
         println("Constructor")("FirstName is $firstName")
    }
}

//或者省略constructor关键字：
class Person (firstName: String) {
    init {
         println("Constructor")("FirstName is $firstName")
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

主构造器中的参数可以在init段代码中使用，也可以在类主体的属性初始化代码中使用，但不能在方法体中使用：

class Person (firstName: String) {
    init {
         println("Constructor")("FirstName is $firstName")
    }
    var fullName: String = "$firstName"
}
1
2
3
4
5
6

主构造器不是必须的。

栗子：
创建一个 Runoob类，并通过构造函数传入网站名：

class Runoob  constructor(name: String) {  // 类名为 Runoob
    // 大括号内是类体构成
    var url: String = "http://www.runoob.com"
    var country: String = "CN"
    var siteName = name

    init {
        println("初始化网站名: ${name}")
    }

    fun printTest() {
        println("我是类的函数")
    }
}

fun main(args: Array<String>) {
    val runoob =  Runoob("菜鸟教程")
    println(runoob.siteName)
    println(runoob.url)
    println(runoob.country)
    runoob.printTest()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

输出结果为：

初始化网站名: 菜鸟教程
菜鸟教程
http://www.runoob.com
CN
我是类的函数
1
2
3
4
5

次构造器

在类体中用constructor关键字定义：

class Person {
    constructor(context: Context) {

    }

    constructor(context: Context,str: String) {

    }
}
1
2
3
4
5
6
7
8
9

如果有主构造器，在类体中定义的次构造器要直接或间接使用this(xxx)调用主构造器：

class Person (str:String) {
    constructor(context: Context):this("xxx"){

    }

    constructor(context: Context,str: String):this(context) {

    }
}
1
2
3
4
5
6
7
8
9

三、抽象类

抽象是面向对象编程的特征之一，类本身，或类中的部分成员，都可以声明为abstract的。抽象成员在类中不存在具体的实现。

注意：无需对抽象类或抽象成员标注open注解。

open class Base {
    open fun f() {}
}

abstract class Derived : Base() {
    override abstract fun f()
}
1
2
3
4
5
6
7

四、嵌套类

这里的嵌套类类似于Java中的静态嵌套类。

我们可以把类嵌套在其他类中，看以下实例：

class Outer {                  // 外部类
    private val bar: Int = 1
    class Nested {             // 嵌套类
        fun foo() = 2
    }
}

fun main(args: Array<String>) {
    val demo = Outer.Nested().foo() // 调用格式：外部类.嵌套类.嵌套类方法/属性
    println(demo)    // == 2
}
1
2
3
4
5
6
7
8
9
10
11

五、内部类

内部类使用 inner 关键字来表示。

内部类会带有一个对外部类的对象的引用，所以内部类可以访问外部类成员属性和成员函数。

class Outer {
    private val bar: Int = 1
    var v = "成员属性"
    /**嵌套内部类**/
    inner class Inner {
        fun foo() = bar  // 访问外部类成员
        fun innerTest() {
            var o = this@Outer //获取外部类的成员变量
            println("内部类可以引用外部类的成员，例如：" + o.v)
        }
    }
}

fun main(args: Array<String>) {
    val demo = Outer().Inner().foo()
    println(demo) //   1
    val demo2 = Outer().Inner().innerTest()   
    println(demo2)   // 内部类可以引用外部类的成员，例如：成员属性
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

为了消除歧义，要访问来自外部作用域的 this，我们使用this@label，其中 @label 是一个 代指 this 来源的标签，如上面的this@Outer

六、匿名内部类

使用对象表达式来创建匿名内部类：

//接口定义
interface TestInterFace {
    fun test()
}
1
2
3
4

class Test {
    var v = "成员属性"

    fun setInterFace(test: TestInterFace) {
        test.test()
    }
}

fun main(args: Array<String>) {
    var test = Test()

    /**
     * 采用对象表达式来创建接口对象，即匿名内部类的实例。
     */
    test.setInterFace(object : TestInterFace {
        override fun test() {
            println("对象表达式创建匿名内部类的实例")
        }
    })
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

七、类的属性

属性定义

使用val声明可变的变量，使用val声明不可变的常量：

class Runoob {
    var name: String = ……
    val url: String = ……
}
1
2
3
4

创建类的实例：

//在Kotlin中：
val runoob = Runoob()

//在Java中：
Runoob runoob = new Runoob()
1
2
3
4
5

使用类变量：

runoob.name           // 使用 . 号来引用
runoob.url
1
2

getter 和 setter

属性声明的完整语法：

var <propertyName>[: <PropertyType>] [= <property_initializer>]
    [<getter>]
    [<setter>]
1
2
3

getter 和 setter 都是可选

如果属性类型可以从初始化语句或者类的成员函数中推断出来，那就可以省去类型，val不允许设置setter函数，因为它是只读的。

var allByDefault: Int? // 错误: 需要一个初始化语句, 默认实现了 getter 和 setter 方法
var initialized = 1    // 类型为 Int, 默认实现了 getter 和 setter
val simple: Int?       // 类型为 Int ，默认实现 getter ，但必须在构造函数中初始化
val inferredType = 1   // 类型为 Int 类型,默认实现 getter
1
2
3
4

栗子：

以下实例定义了一个 Person 类，包含两个可变变量 lastName 和 no，lastName 修改了 getter 方法，no 修改了 setter 方法。

class Person {

    var lastName: String = "zhang"
        get() = field.toUpperCase()   // 将变量赋值后转换为大写
        set

    var no: Int = 100
        get() = field                // 后端变量
        set(value) {
            if (value < 10) {       // 如果传入的值小于 10 返回该值
                field = value
            } else {
                field = -1         // 如果传入的值大于等于 10 返回 -1
            }
        }

    var heiht: Float = 145.4f
        private set
}

// 测试
fun main(args: Array<String>) {
    var person: Person = Person()

    person.lastName = "wang"

    println("lastName:${person.lastName}")

    person.no = 9
    println("no:${person.no}")

    person.no = 20
    println("no:${person.no}")

}
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
32
33
34
35

输出结果为：

lastName:WANG
no:9
no:-1
1
2
3

Kotlin 中类不能有字段。提供了 Backing Fields(后端变量) 机制,备用字段使用field关键字声明,field 关键词只能用于属性的访问器，如以上实例：

var no: Int = 100
        get() = field                // 后端变量
        set(value) {
            if (value < 10) {       // 如果传入的值小于 10 返回该值
                field = value
            } else {
                field = -1         // 如果传入的值大于等于 10 返回 -1
            }
        }
1
2
3
4
5
6
7
8
9

非空属性必须在定义的时候初始化,kotlin提供了一种可以延迟初始化的方案,使用 lateinit 关键字描述属性：

public class MyTest {
    lateinit var subject: TestSubject

    @SetUp fun setup() {
        subject = TestSubject()
    }

    @Test fun test() {
        subject.method()  // dereference directly
    }
}
1
2
3
4
5
6
7
8
9
10
11