he is coding

Kotlin中的类

| Comments

继承

  • 继承和实现接口都使用:
1
class A : B()

超类

  • kotlin中万物的超类是Any…对应Java中的Object
  • 默认声明的类都是final的,如果要声明一个可以继承的类,需添加关键字open
  • 方法也是一样的,如果支持override,也需要加open
  • 属性也是支持覆盖的,加open,本质上就是重写该属性的get方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
open class Shape{
    open val name : String = "Shape"

    open fun doSth(){
        //...
    }

}

class Rectangle : Shape(){
    
    override val name: String
        get() = "2222"

    override fun dosth() {
        super.dosth()
    }
}

如果本身是抽象类,那就不需要open

接口

  • 和Java8一样,支持默认实现
  • 可以声明属性,但是必须是抽象的或者使用访问器实现
1
2
3
4
5
6
7
8
9
10
11
12
interface x {
    val count : Int = 1 //编译不通过
    
    val count : Int // pass
    //等价于 
    fun getCount() : Int
    
    val count : Int 
        get()= 666
    //等价于在上面的基础上提供了默认值666    

}
  • override冲突
1
2
3
4
5
6
7
8
9
10
11
12
13
14
interface A{
    fun doSth()
}

interface B{
    fun doSth()
}

class C : A,B{
    override fun doSth(){
        super<A>.doSth() // 指明调用A的方法
    }
}

嵌套类

两种,一种有inner关键字,相当于Java的非静态内部类,可以访问外部类对象,一种没有,相当于Java的静态内部类

1
2
3
4
5
6
7
8
9
10
class A{
    val name = "name"

    inner class B {
        fun x() = name
    }
    
    class C {
    }
}

匿名类

使用object关键字

1
2
3
4
5
6
7
8
9
window.addMouseListener(object : MouseAdapter() {
    override fun mouseClicked(e: MouseEvent) {
        //...
    }

    override fun mouseEntered(e: MouseEvent) {
        //...
    }
})

生成某个超类的子类对象,并且这个子类对象还实现了某某接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
open class A(x: Int) {
    public open val y: Int = x
}

interface B {...}

val ab: A = object : A(1), B {
    override val y = 15
}

println(ab is A) //true
println(ab is B) //true 

//is 等于 Java的 instanceof

或者仅仅是一个匿名对象

1
2
3
4
5
6
7
8
9
10
val nothing = object {
        var x: Int = 0
        var y: Int = 0
        
        fun work(){
            //...
        }   
    }

println(nothing.x)    

单例类

1
2
3
4
5
6
7
object Single {
    
    fun work(){
    }
}

Single.work()//可以直接调用

类似于Java中的饿汉式单例模式

伴生类

  • 使用关键字companion
  • 必须定义在类中
  • 效果等同于Java中的静态变量,静态方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class A {

    companion object {
        val NUM = 100
        
        fun work() {
        }
    }
}

//可以直接当成静态变量访问
print(A.NUM)
A.work()

Comments