About Kotlin(2)

继续昨天的部分。介绍Kotlin中的类。

Kotlin中的类

抽象类和接口

抽象类

跟Java一样，使用abstract关键字

open class Base{
  open fun f(){}
}
abstract class Derived:Base(){
  override abstract fun f()
}

接口

//内部可以直接写实现
interface MyInterface{
  fun bar()
  fun foo(){    //默认实现
    println("foo")
  }
}

//接口中可以写属性。不允许初始化。实现类必须初始化
interface MyInterface2{
  var name:String //抽象
}
class MyImpl:MyInterface2{
  override var name:String="override name" //重载属性
}

密封类

使用sealed修饰符修饰。其实是一组类的集合。可以用来表示受限的类的继承结构。
其也可以有子类，所有子类也必须在相同的文件中声明。
密封类从某种意义上说，它们是枚举类的扩展:枚举类型的值集也受到限制，但每个枚举常量仅作为单个实例存在，而密封类的子类可以包含多个实例并包含状态。这样又具备了枚举不具备的灵活性。

sealed class BaseClass {

    class Test1 : BaseClass() {
        override fun test() {
            println("Test1实例")
        }

    }
    class Test2 : BaseClass() {
        override fun test() {
            println("Test2实例")
        }
    }
    object Test3 : BaseClass() {
        override fun test() {
            println("Test3实例")
        }
    }
    open fun test() {
        println("BaseClass实例")
    }
}

fun test(instance: BaseClass)=when(instance){
    is BaseClass.Test1-> instance.test()
    is BaseClass.Test2-> instance.test()
    is BaseClass.Test3->instance.test()
}

fun main(str: Array<String>) {
    test( BaseClass.Test1() )
    test( BaseClass.Test2() )
    test( BaseClass.Test3 )
}

内部类

inner标记

使用inner标记才能够访问外部类的变量

class Outer{
  private val bar:Int = 1
  inner class Inner{
    fun foo()=bar
  }
}
//调用的方式.和java类的内部类调用的方式相同
val demo = Outer().Inner().foo()

嵌套类

不用inner标记,直接写在类的内部的类，在kotlin中称为所谓的嵌套类

class Outer{
   private val bar: Int = 1
   class Nested{
     fun foo()=2
   }
}
//嵌套类的调用有点像静态内部类。
val demo = Outer.Nested().foo()

枚举类

枚举类最基本的用法是实现类型安全的枚举

enum class Direction{
  NORTH,SOUTH,WEST,EAST
}
//和Java一样，每个枚举类都是枚举的实例，可以被初始化
enum class Color(val rgb:Int){
  RED(0xFF0000),
  GREEN(0x00FF00),
  BLUE(0x0000FF)
}

匿名类

enum class ProtocolState{
  WAITING{
    override fun signal()=WAITING
  },
  TALKING{
    override fun signal()=TALKING
  };//这里需要用分号分割
  abstract fun signal():ProtocolState
}

Object类（及匿名类）

在Kotlin中使用对象表达式和对象声明进行表示

对象表达式(匿名类)

匿名类其实就是在Java中的匿名内部类。
java中调用方法时，提供的匿名内部类

fun countClicks(window:JComponent){
  var clickCount = 0
  val enterCount=0
  
  //通常的情况，使用Object开头就可以
window.addMouseListener(object:MouseAdapter()){
  override fun mouseClicked(e:MouseEvent){
    //与Java不同的是，甚至可以直接访问变量。(未被final修饰)！
    clickCount++
    enterCount++
  }
  ...
}
}

//多个超类的情况
open class A(x:Int){
  public open val y:Int=x
}
interface B{...}
val ab :A=object:A(1),B{
  override val y = 15
}

//如果只是需要一个对象，什么都不需要的话。也可以直接写
fun foo(){
  val adHoc = object{
    var x:Int = 0
    var y:Int =0
  }
  println(adHoc.x+adHoc.y)
}

这里有一点值得特别注意的的是：
匿名对象可以用作只在本地和私有作用域中声明的类型。只能做为私有函数的返回值。

class C{
  //私有函数，所以其返回雷士的对象是匿名对象
    private fun foo()=object{
        val x :String="x"
    }
  //默认都是public final的方法.使用对象声明返回的类型是Any
    fun publicFoo()=object{
        val x:String="x"
    }
  
    fun bar(){
        val x1= foo().x //可以直接访问
        val x2= publicFoo().x //错误！未能解析的引用"x"
    }
}

对象声明

单例

是指使用object关键字声明的一种类。这种类是单例，并且所有的成员都是静态方法。

object DataProviderManager{
  fun registerDataProvider(provider:DataProvider){}
}

伴生对象

类内部的对象声明可以使用companion关键字标记

class MyClass{
//就是静态内部类咯？但是每个类的伴生对象只能有一个！？
  companion object Factory{
    fun create():MyClass=MyClass()
  }
}

//调用方式类似于Java中的静态方法
val instance = MyClass.create()

//如果按照下列写法，调用时，可以使用名称 Companion
class MyClass{
  companion object{}
}

val x = MyClass.Companion

这里需要注意的是：

在 JVM 平台，只有使用 @JvmStatic 注解，才能将伴生对象的成员生成为真正的静态方法和字段。否则，都只是实例变量

//即使伴生对象的成员看起来像其他语言的静态成员，在运行时他们仍然是真实对象的实例成员，而且，例如还可以实现接口：
interface Factory<T> {
    fun create(): T
}
class MyClass {
    companion object : Factory<MyClass> {
      //注意需要写Override
        override fun create(): MyClass = MyClass()
    }
}
//当然，在 JVM 平台，如果使用 @JvmStatic 注解，你可以将伴生对象的成员生成为真正的静态方法和字段。
//@JvmStatic　注解也可以应用于对象或伴生对象的属性， 使其 getter 和 setter 方法在该对象或包含该伴生对象的类中是静态成员。更多详细的内容之后再看
class MyClassJVM {
     companion object : Factory<MyClassJVM> {
       @JvmStatic override fun create(): MyClassJVM = MyClassJVM()
    }
}

到这里，就大概把Kotin中的类汇总完了。接下来，也还是会按照参考文章的这个思路。记录Kotlin中的属性。方法。修饰符。