类的声明

同Java、Python等一样，Kotlin使用class关键字来声明一个类。

class Skill {
    
}

创建一个对象实例：

val fireBallSkill = Skill()

Kotlin中创建对象不需要new。

构造函数

主要构造函数

class Skill public constructor(var name: String = "未知") {
   
}

Kotlin的主构造函数很特别，就像上面那样。既然是函数，我们同样可以为它指定默认值。参见【Kotlin-函数：http://www.jianshu.com/p/3a815c51dcb5】。如果你不需要可见性修饰符（不写表示public），可以省略constructor。关于可见性修饰符参见【Kotlin基础语法：http://www.jianshu.com/p/bc8896914df8】。那么，上面的类声明将会简化成这样：

class Skill(var name: String = "未知") {
   
}

如果你足够细心的话，也许你已经注意到了在 【主构造函数】 的参数前有一个 var 关键字。函数可不能这么搞！这又是Kotlin迷人的特性之一。通过这种主构造函数的语法，就可以完成对属性的初始化。

它相当于：

class Skill(name: String = "未知") {
   var name = name
}

当然，这种特殊的主构造函数写法存在一个大问题！不知道你想到没？...不能在主构造函数里写代码了啊！WTF？

别忙着喷，Kotlin没那么坑啦。看看怎么在初始化时添加逻辑。

class Skill(var name: String = "未知") {

   init{
       do something...
   }
}

init{ } 块中的代码会在初始化时被调用。虽然看起来有些奇怪，但是习惯就好。就像 static{ } 一样喽。

次要构造函数

在Kotlin中，次要构造函数有一个恶心的规则，++就是要显示委托给主构造函数（在主构造有至少一个参数的时候）++。看看怎么回事：

class Skill public constructor(var name: String = "未知") {

    var mp: Int? = 0
    
    // 次要构造函数
    constructor(name: String, mp: Int?) : this(name) {
        this.mp = mp
    }
}

看，次要构造函数不得不显示的通过this(name)委托给主构造函数。当然，如果主构造函数没有参数，能够简化不少。

class Equipment {

    constructor(header: String, clothes: String) {
    
    }
}

继承

在Kotlin中，所有的类都会隐式的继承Any，就像Java中所有的类都继承Object一样。

Kotlin在设计的时候遵循了《Effective Java》中的 第 17 条：++要么为继承而设计，并提供文档说明，要么就禁止继承。++ 所以Kotlin的一个类及其函数，默认是不可以继承。如果需要继承，必须加上open关键字。

open class Skill(var name: String = "未知") {
    var damage: Int? = 0
    var description: String? = "当心！这个技能强大到可能会伤到你自己！"
    var mp: Int? = 0
    constructor(name: String, mp: Int?) : this(name) {
        this.mp = mp
    }
    open fun effect() {
    }
}

Skill类和它的成员函数都想继承、重载的话，给它们加上open去吧。就上上面的代码一样。

接下来，看看如何继承它。

class FireBallSkill : Skill {
    constructor(name: String) : super(name)
    constructor(name: String, mp: Int?) : super(name, mp)

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

继承的格式就是：号后跟基类。并且，构造函数需要使用super关键字进行基类的初始化。

重载方法Kotlin提供了关键字，不必要再用注解了。就像上面重载effect()函数一样。如果不想让FireBallSkill的effect()再被继承，只需要再添加final关键字即可。

对于像Skill这样有主构造函数的基类来说，还可以这样来写继承。

class FireBallSkill(name: String) : Skill(name) {
    constructor(name: String, mp: Int?) : this(name)

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

这种情况下，你可以在子类的构造函数中初始化基类。那么，次要构造函数就可以直接委托给子类自己的构造函数进行初始化。

需要注意，Kotlin有一个规则，就是一个子类的两个以上的超类中如果包含同名open函数，那么这个函数必须被重载，否则不知道该调用那一个函数。用个官方例子说明吧：

open class A {
    open fun f() { print("A") }
    fun a() { print("a") }
}

interface B {
    fun f() { print("B") } // 接口成员默认就是“open”的
    fun b() { print("b") }
}

class C() : A(), B {
    // 编译器要求覆盖 f()：
    override fun f() {
        super<A>.f() // 调用 A.f()
        super<B>.f() // 调用 B.f()
  }
}

注意一点，Kotlin的多继承（继承类、实现接口）使用,分隔。

属性也可以重载

在Kotlin中，成员属性是可以重载的。当然，需要使用open关键字。

open class Skill(var name: String = "未知") {
    open var description: String? = "当心！这个技能强大到可能会伤到你自己！"

}

和重载方法一样，Kotlin使用override关键字重载属性。

class FireBallSkill(name: String) : Skill(name) {
    override var description: String? = "纵火狂热分子最爱使用的技能。"
}

抽象类

同Java一样，Kotlin也使用abstract关键字来定义抽象类。

abstract class Actor{
    abstract fun move()
}

class Hero: Actor() {
    override fun move() {
    }
}

对于抽象类，open关键字可以省略。很明显，抽象类就是为了继承。

object关键字

在Kotlin中，object关键字被用来声明一些特殊对象或类。

• 匿名内部类

tv_test.setOnClickListener(object : View.OnClickListener {
    override fun onClick(v: View?) {
    }
})

在Kotlin中，匿名内部类需要使用object关键字来申明，在:后跟超类。既然是匿名，千万不要尝试在obejct后加名字！

• 实现单例
  单例模式的写法从未如此简单和安全。Java中各种繁杂的单例写法可以出门右转了。

object WeatherManager{

    fun rain(){

    }

    fun sun(){

    }
}

只需一个object关键字声明即可。看看如何使用单例。

WeatherManager.rain()
WeatherManager.sun()

简便的，直接用类名就可以调用。有点像在调用静态方法，但是单例对象像纯真的孩子口中的话一样真实的创建了。

• 伴生对象
  如果上面的单例写在一个类中，并且加上companion关键字，那么这个单例就成为宿主类的伴生对象了。伴生对象是用来代替类似Java中的静态变量的，真正意义上的实现面向对象。

open class Hero: Actor() {
    override fun move() {
    }
    companion object Factory{
        fun create(): Hero = Hero()
    }
}

事实上，你还可以把伴生对象的名称Factory省略掉。看看如何使用。

val demoHero = Hero.create()

调用伴生对象的成员，就像在Java中调用类的静态成员一样。

枚举类

在Kotlin中，使用enum关键字将一个类声明为枚举类。

enum class Color(val rgb: Int) {
        RED(0xFF0000),
        GREEN(0x00FF00),
        BLUE(0x0000FF)
}

相比Java，多了个class关键字。

数据类

public class User{

    private String name;
    private int age;
    
    public void setName(String name){
        this.name = name;
    }
    
    public String getName(){
        return name;
    }
    
    public void setAge(int age){
        this.age = age;
    }
    
    public int getAge(){
        return age;
    }
}

这是Java中令人烦躁的数据类声明过程。是的，我们都特别怕写，即使在有工具帮忙的情况下，看着这么庞大的一个类也是让人难受的。看看Kotlin如何简化的吧。

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

使用data关键字，一行代码生成一个数据类。还有什么理由不爱Kotlin呢？

接口

上面你也看到了接口的运用，我们同样使用interface关键字来定义接口。注意，Kotlin中的接口和Java中有不小的差别。因为Kotlin中的接口是可以有方法体的！当然，有方法体的你不用去实现它。此外，Kotlin中的接口还能包含属性，当然它们是抽象的。你必须在实现接口的时候也实现这些个抽象属性。

interface Attack{
    var damage: Int

    fun attack()

    fun preRock(){

    }

    fun aftRock(){

    }
}

看一个实例吧。

class Mage: Attack{
    //在这实现了抽象属性
    override var damage: Int
        get() = 0
        set(value) {}

    override fun attack() {
    }

}