kotlin doc 之接口和可见修饰符

接口

kotlin中的接口和java8是非常相似的。它们包含了抽象方法的声明和一般方法的实现。接口与抽象类的区别在于它不能存储状态。接口虽然有属性，但是需要被抽象或者提供访问器的实现。

interface MyInterface{
    fun bar()
    fun foo(){

    }
}

实现接口

一个类或者对象能够实现多个接口

class Child : MyInterface{
    override fun bar(){

    }
}

接口中的属性

你可以在接口中声明属性，接口中的属性要么时抽象的，要么它提供了访问器的实现。接口中的属性声明没有“bcking fields”,因此接口中的访问器不能够引用它们

interface MyInterface{
    val prop : Int // 抽象

    val properWithImp : String
        get() = "foo"

    fun foo(){
        print(prop)
    }
}

class Child : MyInterface{
    override val prop : Int = 29
}

接口继承

一个接口可以继承多个接口，因此为它们的成员增加实现，并且声明了新的方法和属性。自然地，实现这么接口的一个类只需要定义没有完成的实现。

interface Named{
    val name : String
}

interface Person : Named{
    val firstName : String 
    val lastName : String

    override val name : String get() = "$firstName $lastName"
}

data class Employee{

    override val firstName : String,
    override val lastName : String,
    val position : Position
}:Person

重写冲突

当我们声明了很多类型，有可能出现同一个方法的不同实现

interface A{
    fun foo(){
        print("A")
    }

    fun bar()
}

interface B{
    fun foo(){
        print("B")
    }
    fun bar(){
        print("bar")
    }
}

class C : A{
    override fun bar(){
        print("bar")
    }
}

class D : A,B{
    override fun foo(){
        super<A>.foo()
        super<B>.foo()
    }    

    override fun bar(){
        super<B>.bar()
    }
}

通过super<父类名称>调用父亲接口的实现

可见修饰符

类、对象、接口、构造方法、方法、属性、getter/setter 都有可见修饰符。可见修饰符在kotlin中有：private、protected、internal和public。

packages

在一个包中，函数、属性、类、对象和接口可以直接声明在顶级。

package foo
fun baz(){}
class Bar{}

默认使用public修饰符，这意味着在任何地方都可见该声明。
private 文件内可见
internal 同一module可见
protected 在顶级声明中不可用

//file name : exmaple.kt
package foo
prvate fun foo(){} //仅文件内可见

public var bar : Int = 5 //全局可见
    private set  //setter文件内可见

internal val baz = 6 //同模块可见

类和接口（和java些许类似）

对于类中的成员来讲
* private 类内部可见
* protected 继承体系可见
* internal 同一个module中，能够见到类型的均可见
* public 能够查看到类声明的均可见

注意（对于java coder）：外部类不能直接访问到内部类的私有成员在kotlin中

如果你重写了一个protected成员，这个重写的成员也有一个protected 可见的效果

open class Outer{
    private val a = 1
    protected open val b = 2
    internal val c = 3
    val d = 4 // default public

    protected class Nested{
        public val e : Int = 5
    }
}


class SubClass : Outer(){
    //a is not visiable
    //b,c and d are visiable
    // Nested and e are visibale

    override val b = 5 // b is protected
}

class Urelated(o : Outer){
    //o.a and o.b are not visiable
    //o.c and o.d are visiable
    //Outer.Nested and Nested::e are not visiable 
}

构造函数

为了指明primary构造函数的可见行，要使用下面的格式

open class Animal private constructor(a : Int){

}

局部变量

局部变量、方法和类没有可见修饰符

模块

关键字 internal 意味着同一个module时可见的。一个module时一个kotlin的编译集合
* 一个 Intellij IDEA module
* 一个 maven 项目
* 一个gradle构建集合
* 一个ant项目