前言

前面几篇文章我们学习了Kotlin的一些基础概念，如何声明变量、函数以及一些初阶函数的用法，这让我们对Kotlin有了个最基本的认知概念，接下来让我们学习一下如何在Koltin中声明一个类和接口吧。

类

• 声明

Kotlin中类的声明和Java没有什么太大的区别，直接class A就可以了，和Java不同的是，Kotlin中类和方法的声明默认是public final的，所以使用默认声明的class是不可以被继承的，如果想要声明的类可以被继承的话，需要使用修饰符open来修饰类。

class X {   //此类不可被继承
    fun test(){   //此方法不可被重写    
    }
}  

open class X { //此类可继承
    open fun test(){  //此方法可被重写
    }
} 

class Y：X（）{} //此类不可被继承

open class W:X(){  //此类可被继承
    override fun test(){   //此方法可被重写，不需要再次声明open
        super.test()
        Log.d("","")
    }
}

class Z:Y(){  //报错，Y依然是final的，不可被继承
}

这里需要注意一点：Y类继承了X类，但Y类默认依然是final的，是不可被继承的，要想Y可以被继承，仍需在Y类名前加上open，但如果重写的是成员，那么被重写后的成员默认是open的，是可以接着被子类重写的

• 构造方法

我们来看个简单的例子：
code1-1：

class User constructor(name: String, address: String) {
    val name: String
    var address: String

    init {
        this.name = name
        this.address = address
    }
}

code1-1中我们可以看到，有2个关键字：constructor和init。constructor是构造方法的声明。init是初始化语句块，里面包含了类创建时执行的代码，通常和主构造函数一起使用，所以你可以看到变量name address在声明后没有初始化也没有报错，就是因为在init初始化语句块中初始化了。

这种直接跟在类名后声明的构造方法，Kotlin称为主构造方法（在类体外声明），在类体内部声明的构造方法Kotlin称为从构造方法。

如果主构造方法没有注解或者可见性修饰符，可以省略掉constructor关键字。

class User(name: String, address: String) {
    val name: String
    var address: String

    init {
        this.name = name
        this.address = address
    }
}

类的成员属性可以用相应的构造方法参数来声明，在构造方法参数的前面加上变量修饰符就可以了，让我们再来优化一下构造方法

class User(val name: String, var address: String) {
    fun test(){
        name.length
    }
}

如果你不想暴露你的构造函数，你可以用private修饰符修饰你的构造方法，这种情况下，constructor关键字就不可以省略了

class User private constructor(val name: String, var address: String) {
}

从构造函数，在Java中多用来重载和提供参数默认值，Kotlin中不建议使用多个从构造函数来重载，我们可以使用前面文章说到的参数默认值来代替多个从构造函数。

//Java多个构造方法
class User {
    private String name;
    private String address;
    private int age;

    public User(String name, String address) {
        this(name, address, 0);
    }

    public User(String name, String address, int age) {
        this.name = name;
        this.address = address;
        this.age = age;
    }
}
new User("张三", "北京");
new User("李四", "上海", 25);

//Kotlin可以使用参数默认值来代替多个构造方法
class User(val name: String, var address: String, val age: Int = 0) {
}
User("张三", "北京")
User("李四", "上海", 25)

当所有的构造参数都有默认值时，编译器会生成一个额外的不带参数的构造方法来使用所有的默认值

class User(val name: String = "", var address: String = "", val age: Int = 0)

User()
User("张三", "北京")
User("李四", "上海", 25)

• 继承

Kotlin的继承和Java有些区别，Kotlin继承没有了关键字extends，替而代之的是：

open class User(val name: String)

class VipUser(name: String, var vipLevel: Int) : User(name) {
}

当继承的父类没有构造方法时，会生成一个空参数的默认构造方法

open class User

class VipUser(var vipLevel: Int) : User() 

这里可能会有同学想不明白，在继承父类的时候，子类构造方法里面的成员属性，为什么有的用了变量关键字val var而有的没有用，这是因为我们在父类的构造方法里面如果已经声明了这个变量了，那么在子类的构造方法中就不需要声明变量关键字了，如果你有特需需求，在子类中需要重写某个变量，那你可以给此变量加上override关键字，当然父类中此变量的修饰符也要改成open

open class User(open val name: String = "")

class VipUser(override val name: String, var vipLevel: Int) : User(name) {
}

• 静态内部类

Kotlin的静态内部类和Java有些出入，Java的静态内部类，需要你在嵌套类的类名前用static修饰符，但Kotlin默认嵌套类就是静态内部类

//Java
class User{
    static class Address{
        
    }
}
new User.Address();

//Kotlin
class User(open val name: String = "") {
    class Address {
    }
}
User.Address()

• 内部类

对于内部类而言，Java默认嵌套类就是内部类，Kotlin则需要inner修饰符

//Java
class User {
    class Address {

    }
}
new User().new Address();

//Kotlin
open class User(open val name: String = "") {
    inner class Address {
    }
}
User().Address()

接口

Kotlin的接口和Java中并没有什么太大的区别，稍微不同的地方就在于，Kotlin的接口中，方法可以有默认实现，且不需要default关键字

//Java写法
interface A{
    default void test(){
        Log.d("","");
    }
    
    void testTwo();
}

//Kotin写法
interface A {
    fun test() {
        Log.d("", "")
    }

    fun testTwo()
}

记住这点就可以啦，其余使用和Java没有什么区别。

总结

没啥好总结的，溜了溜了，我是你们的小院里栽颗树，对Kotlin有兴趣的可以点波关注，会持续更新哦~