一、抽象类与接口(abstract,interface)

• 1.抽象类
• 1.可以简单的理解为：实现一部分协议的半成品（类可以看成成品），比类抽象点，比接口具体点；
• 2.抽象类是有类的特征的；
• 3.抽象类可以有属性，可以有方法，并且方法可以有方法体；
• 4.要想重写抽象类中的具体方法，需要将此方法用open修饰符修饰，才能重写；
• 5.必须由子类继承后使用；
• 6.抽象类默认就是open的，里面的抽象方法默认也是open的；具体方法如果想要被子类重写必须要用open修饰；

abstract class C {
    //抽象类可以有状态--成员变量和具体方法
    var i = 0 //这个值可以变

    open fun test() {

    }

    //抽象方法不能有函数体，必须由子类实现
    abstract fun abstractMethod()
}

/**
 * 如果继承的是抽象类或者类，必须写上父类的构造方法
 */
class D: C() {
    override fun abstractMethod() {

    }

    //要想复写抽象类的具体方法，必须加上修饰符open，否则访问不到
    override fun test() {
        super.test()
    }

}

• 2.接口
• 1.可以简单的理解为：协议，规定；
• 2.在kotlin可以给接口方法一个默认实现，但是默认实现不能有状态，状态必须在实现类中定义；
• 3.Kotlin的接口与Object-C的Protocol比较类似；
• 4.接口不能有状态；
• 5.必须由类对其进行实现后使用；
• 反应事物的能力；

interface TestInterface {
    //可以定义，但是不能初始化
    //这里相当于定义了一个setI()和getI()的接口方法，不是真正定义了一个状态变量，
    //因为不能写get方法
    val i :Int
    //接口只能有无状态的默认实现
    fun interfaceMethod(){
        println(i)
    }

}

class ImplTest : TestInterface {
    //必须实现成员变量，否则编译报错
    override val i: Int
        get() = 0 


    //由于TestInterface中的方法有个默认实现，在这里可以不用实现此方法
//    override fun interfaceMethod() {
//        super.interfaceMethod()
//    }
}

//成员变量的实现还可以用构造器的方式实现
interface TestInterface {
    val i :Int

    fun interfaceMethod(){
        println(i)
    }

}

class ImplTest(override val i: Int) : TestInterface {
    //必须实现成员变量，否则编译报错
//    override val i: Int
//        get() = 0


    //由于TestInterface中的方法有个默认实现，在这里可以不用实现此方法
//    override fun interfaceMethod() {
//        super.interfaceMethod()
//    }
}

总结：
1.抽象类具有类的特征，可以有内部的状态（也就是可以有成员变量和具体方法）；接口可以有不能初始化的成员变量，这个成员变量其实就是一个接口方法；也就是说抽象类有状态，接口没有状态；抽象类有方法实现，接口只能有无状态的默认实现；
2.单继承多实现；
3.抽象类反映事物的本质，不管男人、女人，本质都是人；
4.接口反映事物的能力，能力可以有多个，但是你还是你--说的是抽象类；
5.如果要用抽象类和接口描述一个东西，那这个东西的中心词前面的修饰词就是接口要负责的部分，中心词是抽象类负责的部分；

举个例子：Mac 笔记本 电脑
那么中心词是“电脑”--电脑用抽象类定义；
Mac和笔记本是修饰词--用接口定义；

接口与抽象类的共性：
1.比较抽象，不能直接实例化；
2.需要由子类或者实现类实现他们的抽象方法；
3.父类（接口）变量可以接受子类（实现类）的实例赋值；也就是父类的引用指向子类；

备注：如果不是抽象类，想要被继承的话，必须加上open关键字，否则无法被继承，默认为final；类中的方法想要被覆写，也要先open；abstrac类、abstract方法和接口、接口方法不需要写open，默认就是open

/**
 * 如果想要被继承，必须用open修饰
 * 属性想要被覆写，也必须open修饰
 */
open class Person(open val age: Int,open var name:String){

    //如果方法想要被子类重写，必须用open修饰
    open fun work(){

    }

}

//覆写属性时，必须用voerride
class MaNong(override val age: Int,name:String): Person(age,name) {

    //子类重写父类的方法，必须要用override修饰
    override fun work() {
        super.work()
    }

}

class Enginer(age: Int,name:String) : Person(age,name){

    //覆写属性的第二种方式
    //val修饰的属性只有get方法，因为不可变，不能有set方法
    override val age: Int
        get() = 0//重新赋值

    override var name: String = ""
        get() = super.name
        set(value) {
            field = value
        }
}

• 通过by关键字实现接口代理

interface Driver{
    fun drive()
}

interface Writer{
    fun write()
}

class ImpDriver :Driver {
    override fun drive() {
        println("驾驶")
    }
}

class ImpWriter:Writer {
    override fun write() {
        println("写作")
    }
}

/**
 * 通过by关键字实现接口代理
 */
class ImplPreson(val driver: Driver,val writer: Writer):Driver by driver,Writer by writer{
    //通过使用by关键字进行接口代理，下面的方法不用实现
//    override fun drive() {
//        driver.drive()
//    }
//
//    override fun write() {
//        writer.write()
//    }
}

fun main(args: Array<String>) {
    var driver = ImpDriver()
    var writer = ImpWriter()
    var person = ImplPreson(driver,writer)
    person.drive()
    person.write()
}

二、类的鼻祖-object-单例

1.在实际的使用中只有一个对象--也就是kotlin中的单例;相当于java中的最简单的单例实现；
2.使用时可以和普通的类一样，可以有成员和方法，只是class的一种特殊情形；
3.可以实现接口，继承类；

interface Play{
    fun play()

}

abstract class Sleep {
    abstract fun sleep()
}

object Manager :Play,Sleep(){
    override fun play() {

    }

    override fun sleep() {
    }

    lateinit var name:String
    fun work() {

    }
}

fun main(args: Array<String>) {
    Manager.work()
    Manager.sleep()
    Manager.name = "android"
}

三、伴生对象与静态成员--companion object

1.用来实现静态方法和静态属性;
2.如果想和Java中静态方法和属性的调用一直的话，可以在静态属性上添加@ JvmField，在静态方法上添加@ JvmStatic
实现方式如下：

fun main(args: Array<String>) {

    var latitude = Latitude.ofDouble(3.0)
    var copy = Latitude.copy(latitude)
    println( Latitude.param )
}

class Latitude private constructor(val value: Double)
{
    companion object {

        @JvmField
        //静态属性
        val param:Double = 100.0

        @JvmStatic
        //静态方法
        fun ofDouble(double: Double):Latitude {
            return Latitude(double)
        }

        fun copy(latitude: Latitude):Latitude{
            return Latitude(latitude.value)
        }
    }
}

总结：
1.每个类都对应一个伴生对象，相当于类对应的静态成员；
2.伴生对象的成员全局独一份，这个是针对于类来说的；
3.伴生对象的成员相当于我们Java中的静态成员；
3.静态成员尽量使用包级函数、包级变量代替；
4.在Java中调用kotlin中的伴生对象时，kotlin中的伴生对象使用JvmField和JvmStatic注释可以保证使用时调用一致性；

四、方法重载和默认参数--overload

1.方法重载--方法名相同，参数不同；与返回值无关；
JVM函数签名：只与函数名和参数列表相关；与返回值无关；

class Overloads {
    fun a(): Int {

        return 0
    }

    fun a(param: Int ): Int {
        return param
    }

}

fun main(args: Array<String>) {
    var overload = Overloads()
    overload.a()
    overload.a(10)
}

2.方法重载可以转换为默认参数；
可以为任意位置的参数设置默认参数；函数调用产生混淆时用具名函数

class Overloads {
//    fun a(): Int {
//
//        return 0
//    }
    //这个注解是为了给Java中调用kotlin中的重载方法使用
    @JvmOverloads
    fun a(param: Int = 0): Int {
        return param
    }

}

fun main(args: Array<String>) {
    var overload = Overloads()
    overload.a()//不传任何参数，会使用默认参数0
    overload.a(10)
}

五、扩展成员

1.为现有类添加方法、属性；

fun X.y():Z{...}
val X.m 注意扩展属性不能初始化，类似接口属性

2.Java调用扩展成员类似调用静态方法；

下面展示扩展属性和扩展方法：具体的看下面的示例：

fun main(args: Array<String>) {
    println("abc".copy(4))
    //输出值：abcabcabcabc

    println("abc".param)
    //输出值：扩展属性
}

/**
 * 扩展方法使用XXX.方法名
 * 那么在方法中this就代表XXX
 */
fun String.copy(int: Int) :String{
    var stringBuilder = StringBuilder()
    for (i in 0 until int) {
        stringBuilder.append(this)
    }
    return stringBuilder.toString()
}

/**
 * 扩展属性只用val修饰,只能有get方法；用var修饰虽然有set方法，但是无法使用field
 * 它的意思是所有的字符串都有个param属性，其实就是调用了get方法
 */
val String.param : String
 get() = "扩展属性"

var Int.params:Int
 set(value) {}
 get() = 100

六、属性代理

定义方法：
val/var <property name>:<Type> by <expression>
Type类型可以不写，让编译器自行推导；
expression代表的代理对象；
代理者需要实现相应的setValue/getValue方法；
代理的val只实现setValue方法，代理var的需要实现setValue和getValue方法；

import kotlin.reflect.KProperty

/**
 * Created by serenitynanian on 2017/7/14.
 * 属性代理
 */
class Delegates{

    //一旦被lazy by了，就相当于只有在第一次访问到hello时才会初始化
    //lazy就是代理，对于val的变量的代理，必须实现getValue方法
    val hello by lazy {
        "Hello world"
    }

    //对hello1进行获取的时候，相当于hello1的值交给了X的getValue
    val hello1 by X()

    //对hello2设置值的时候，相当于调用了X的setValue；
    //对hello2进行获取的时候，相当于调用了X的getValue方法
    var hello2 by X()
}

class X{
    private var value:String? = null
    //下面的这个方法拷贝的lazy中的getValue方法，进行了一点改造
    /**
     * thisRef代表的是Delegates对象 property.name代表的是代理的变量名
     */
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String{
        println("getValue------>$thisRef-------->$property")
        return value?:" no value"
    }

    //setValue方法最少需要三个参数
    operator fun setValue(thisRef: Any?, property: KProperty<*>,value:String){
        println("getValue------>$thisRef-------->$property------>$value")
        this.value = value
    }

}

fun main(args: Array<String>) {
    val delegates = Delegates()

    println(delegates.hello)
    println(delegates.hello1)
    println(delegates.hello2)
    delegates.hello2 = "set value ing..."
    println(delegates.hello2)
    /**
     *打印值：
     * Hello world
    getValue------>kotlindemo.Delegates@548c4f57-------->property hello1 (Kotlin reflection is not available)
    no value
    getValue------>kotlindemo.Delegates@548c4f57-------->property hello2 (Kotlin reflection is not available)
    no value
    getValue------>kotlindemo.Delegates@548c4f57-------->property hello2 (Kotlin reflection is not available)------>set value ing...
    getValue------>kotlindemo.Delegates@548c4f57-------->property hello2 (Kotlin reflection is not available)
    set value ing...
     */

}

七、数据类（allOpen,noArg插件）

这个数据类类似Javabean，里面默认实现了get和set、toString方法，但是不同点是这个data class是被final修饰的，不能被继承，并且未提供无参的构造方法，所以不能完全替代javabean；为了能够实现javabean，官方提供了两个插件--allopen和noArg；
具体配置如下：
在项目下的build.gradle文件中配置如下：

配置如图.png

配置后需要自定义注解类：

annotation class Poko

import annotations.Poko

/**
 * Created by serenitynanian on 2017/7/17.
 * 数据类（allOpen,noArg)类似java中的javabean
 * 但是不同点是：看字节码这个被data修饰的类是final的，不能被继承，并且未提供无参构造方法
 * Javabean可以被继承并且有无参构造方法；
 *
 */
@Poko
data class Country(var id:Int,var name:String)

/**
 * 这个类说明了component并不是data class的专利，只是data class自动给它生成了component
 * 如果我们类中需要，我们就自己定义即可
 */
class Componnent1{
    operator fun component1():String{
        return "component1"
    }

    operator fun component2():Int{
        return 100
    }

    operator fun component3():Int{
        return 22
    }
}

fun main(args: Array<String>) {
    var country = Country(0,"chain")
    println(country)
    println(country.component1())
    println(country.component2())

    var(country_id,country_name) = country
    println(country_id)
    println(country_name)

//    for ((index, value) in args.withIndex()) {
//        println("Index----->"+index)
//        println("Value------>"+value)
//    }

    var component = Componnent1()
    var (a,b,c) = component
    println("$a$b$c")

}

noArg给我们生成了无参的构造方法；
allOpen给我们生成了不是final类型的类；

不过这都是在编译器生成的，所以在代码中使用无参的是不能使用的，只能通过运行时反射得到，比如使用realm就可以使用这两个插件

八、内部类（this@Outter,this@Inner)

1.静态内部类不持有外部类的引用；
2.非静态内部类持有外部类的引用或状态；
3.kotlin中默认的内部类是静态的内部类；如果想使其为非静态的用inner关键字修饰
4.非静态内部类访问外部类的属性，用this@Outter.属性名;类似java中的外部类名.this.属性名；
5.如果内部类的实例需要依赖外部类的实例，就使用非静态内部类；如果内部类只是逻辑上与外部类有关联，那么实例的存在不依赖于外部类，就可以使用静态内部类；
6.kotlin中的匿名内部类，可以继承一个类，实现多个接口：object：类名（），接口{方法体};编译时生成类名，类似Outter$1.class

open class Outter{

    var a :Int = 0

    open fun OutterMethod() {

    }

    //默认静态的
    class StaticInner{
        fun hello() {

        }
    }
    //inner修饰后为非静态的
    inner class NoStaticInner{

        var a:Int = 5

        fun hello(){
            //为了保证引用到外部类的属性，用this.Outter.属性名
            println(this@Outter.a)

            println(this@NoStaticInner.a)//引用内部的a属性
            println(this.a)//引用内部的a属性
        }
    }
}

interface OnClickListener{
    fun onClick()
}

class View{

    var onClickListener:OnClickListener? = null
}

fun main(args: Array<String>) {
    //从这可以看出Inner默认的就是静态内部类
    //如果让Inner为非静态的，用inner修饰即可
    var staticInner = Outter.StaticInner()

    //用外部类的实例实例化
    var inner = Outter().NoStaticInner()

    var view = View()
    //kotlin中的匿名内部类可以继承一个类，实现多个接口
    view.onClickListener = object :Outter(),OnClickListener{
        override fun onClick() {

        }

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

九、枚举

实例的个数确定，枚举也是类；
可以修改构造，添加成员；
可以提升代码的整洁，但是会损耗点性能；（比如说一些可以直接用int代表的，如果用枚举，会多消耗内存）；

/**
 * Created by serenitynanian on 2017/7/17.
 */
enum class Season(var desc:String) {

    SPRING("春天"), SUMMER("夏天"), FALL("秋天"), WINTER("冬天");//如果下面有方法，这里必须写分好

    fun getTag() {
        //name是枚举自己的默认属性，比如第一个name为：SPRING
        println("$name------$desc")
    }
}

/**
 * 这个类就类似枚举类
 */
class Test private constructor()
{
    companion object {
        val SPRING = Test()
        val SUMMER = Test()
        val FALL = Test()
        val WINTER = Test()
    }
}

fun main(args: Array<String>) {
    println(Season.SPRING.getTag())
    println(Season.SPRING.ordinal)//此对象在整个枚举类中的次序
    println(Season.valueOf("SPRING"))//获得Spring对象
    Season.values().map(::print)//打印出所有对象
}

十、密封类（sealed classs）-子类有限的类，枚举是实例可数

1.其子类只能定义在与sealed class同一文件中或者在seal class内部（kotlin版本小于1.1）；