• 接口
  kotlin中的接口既可以定义抽象方法,也可以实现。和抽象类不同的是，接口无法保存状态，接口中定义的属性要么是抽象的要么提供访问器实现且不能有幕后字段

interface ITest {
    val a: Int
    //提供访问器实现
    val b: String
        get() = "tianyuyaodai"
    
    //抽象方法
    fun test()
    
    fun test1() {
        Log.d("djc", "do something")
    }
}

对接口的实现：

class MainActivity : AppCompatActivity(), ITest {
    override val a = 1
    
    override fun test() {
        //do something
    }

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

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
}

• 覆盖冲突
  当我们接口ITest里有一个实现了的方法test1（）,接口IRepeat里也有一个实现方法test1（） 然后我们的一个类分别实现上述两个接口。

interface ITest {

    fun test1() {
        Log.d("djc", "test : do something")
    }
}

interface IRepeat {
    fun test1(){
        Log.d("djc","test1 : do something")
    }

}

class MainActivity : AppCompatActivity(), ITest, IRepeat {


    override fun test1() {
        super<ITest>.test1()
        super<IRepeat>.test1()
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
}

我们可以用super<接口>.方法这样的形式指明具体的接口，我们来看下输出结果

打印结果

• 可见性修饰符
  在kotlin中有4种可见性修饰符，分别是：public,private,protect,internal
  下面引用文档上的说明来讲解

函数、属性和类、对象和接口可以在顶层声明，即直接在包内：

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

1. 如果属性，方法，类前面没有任何可见性修饰符，则默认为public，则你的声明随处可见
2. 如果属性，方法，类前面声明为private,那么只在声明它的文件内可见
3. 如果属性，方法，类前面声明为protect(包不适用)，那么只在它的派生类中可见
4. internal在相同的模块中可见，这个模块的概念下面引用官方文档的解释
5. 局部声明：局部变量，函数，类不能有可见性修饰符

注意 对于Java用户：Kotlin 中外部类不能访问内部类的 private 成员。
如果你覆盖一个 protected 成员并且没有显式指定其可见性，该成员还会是 protected 可
见性。

• 模块

可见性修饰符 internal 意味着该成员只在相同模块内可见。更具体地说， 一个模块是编译
在一起的一套 Kotlin 文件：
一个 IntelliJ IDEA 模块；
一个 Maven 项目；
一个 Gradle 源集；
一次 ＜kotlinc＞ Ant 任务执行所编译的一套文件。

也就是说就Android开发而言整个Module里都是可见的。

• 数据类
  其实就是我们平时开发里的bean类，在kotlin中用关键字data修饰

data class Person(var age: Int, var name: String)

编译器自动从主构造函数的属性中生成以下成员

1. equals()/hashcode()
2. toString()
3. copy()
4. componentN()

注意 ： 如果在类体里显示的定义了上述成员函数或者继承其基类型，则编译器不生成该成员
同时为了保证代码的一致性和有意义，数据类必须满足下列要求：

1. 主构造函数只要要有一个参数，同时主构造的参数需要标记为val或者var
2. 数据类只能实现接口（从1.1起）
3. 数据类不能是开放的（open），密封，内部，抽象的

下面主要讲讲3和4两个方法的作用
首先来说说copy（）方法 有时候我们想复制某个对象，改变它的部分属性，但是其他属性保持不变。这个时候就可以使用copy()

        val data = Person(18, "Queen")
        //复制data对象，并修改age属性
        val copy = data.copy(age = 12)
        Log.d("Queen", "$copy")

打印结果如下：可以看到age属性确实改为了12

打印结果

• 解构声明
  将一个对象拆分成许多变量，就拿上面的例子说明：

        //解构声明
        val (age, name) = copy

这种写法称为解构声明，一个解构声明实质上

val name =  data.component1()
val age = data.conponent2()

所以数据类生成的成员conponent是方便使用解构声明

• 嵌套类

class Outter {
    class Nested {
        fun getValue(): Int {
            return 2
        }
    }
}

调用:

       val value = Outter.Nested().getValue()
        Log.d("QKN", "$value")

• 内部类
  内部类可以访问外部类的成员

class Outter {
    val a: Int = 5

    inner class Inner{
        fun getValue(): Int {
            return a
        }
    }
}

调用:

        val value = Outter().Inner().getValue()
        Log.d("QKN", "$value")

• 匿名内部类
  采用对象表达式的写法

tv.setOnClickListener(object : View.OnClickListener{
            override fun onClick(p0: View?) {
                
            }
        })

对象表达式会在稍后的文章中说明,如果对象是函数式接口(即只有一个抽象方法),那么可以使用lambda表达式声明

总结

真是写得好累,看来我还是太懒了,马上国庆放假了,争取国庆期间把kotlin的语法撸完😂