简述

Kotlin同java一样也是一门面向对象的语言，作为比java更高级的语言，当然有它独有的特点：

*构造函数有主次之分
*不需要new 关键字
*所有类都有一个共同的超类 Any
*默认情况下所有类都是final 不可继承，想要被继承就要用到open、abstract关键字
*类的方法和属性同样被final关键字限制不能被继承和重写
*被继承的属性或方法必须加override关键字，并且父类里要声明为 open，但接口就不需要声明
*Kotlin 中的类如果是空类，没有任何语句，则可以省略大括号
*类不存在static方法，如果需要就要用到伴生对象
*接口与 Java 8 类似，既包含抽象方法的声明，也包含实现。
*Kotlin 中有四个可见性修饰符：private、protected、internal和public
*Kotlin 在不继承类的情况下支持扩展函数和扩展属性
*不光有枚举，还有数据类，密封类
*支持类委托，事实证明类委托是继承以外更好的实现方式

看到这是不是觉得有很多东西要学，一份耕耘一份收获，继续往下，go！下面将对具体的特点展开讲解。

类构造

1. 主构造函数写在类头中，有且只有一个

例1：这个类定义一个 String 类型的成员变量 name，然后定义了带有一个 String 类型参数的构造函数，这个构造函数把参数列表中的 name 赋给了成员变量 name。

//用constructor关键字定义带有一个 String 类型参数的主构造函数。
class Person constructor( name :String) {
    val name :String
    init{                            //使用 init 关键字定义主构造函数的行为
        this.name=name
    }
}

这么写也不比java 省多少事撒，作为现代语言肯定不能就这么算了，当然你可以简化成这样

class Person(val name :String)

这样就够简洁了吧，但这么写就有了默认的约束：1.如果主构造函数没有任何修饰符，则可以去掉 constructor 关键字 2.如果主构造函数中定义的参数使用 val （只读）或者 var（读写） 修饰，则会创建与这个参数同名的成员变量，并使用传入的参数值初始化这个成员变量

例2:如果一个非抽象类没有声明任何（主或次）构造函数，它会有一个生成的不带参数的主构造函数。构造函数的可见性是 public。如果你不希望你的类有一个公有构造函数，你需要声明一个带有非默认可见性的空的主构造函数：

class DontCreateMe private constructor() {
}

例3:如果构造函数有注解或可见性修饰符，这个constructor关键字是必需的，并且这些修饰符在它前面：

class Customer public @Inject constructor( name : String) { …… }

例4: 主构造的参数可以在初始化块中使用。它们也可以在类体内声明的属性初始化器中使用：

class Customer(name : String) {
    val customerKey= name.toUpperCase()
}

2. 次构造函数写在类语句中，可以有多个，也可以没有。

例1：声明前缀有constructor的次构造函数

class Person{   
     constructor(parent : Person) { 
           parent.children.add(this)    
     }

例2:如果类有一个主构造函数，每个次构造函数需要委托给主构造函数， 可以直接委托或者通过别的次构造函数间接委托。委托到同一个类的另一个构造函数用this关键字即可

class Person(val name : String) {   
        var old :Int=0
        constructor(name : String , parent : Person , old :Int) : this(name) {  //加粗的就是委托代码
              parent.children.add(this) 
              this.old=old
        }
}

例3:次构造函数不能在参数列表中声明并初始化成员变量，还是上面的代码，“old : Int”前面为什么没有 val ，因为次构造函数会改动 old 的值，所以 old 必须声明为 var

属性

与java相比，java中包下面有类，接口等。而Kotlin中在包下面是可以直接有属性的，并且所有非抽象属性都强制要求初始化，没有初始化的属性无法通过编译（除标记为 lateinit var 的属性外），下面将对属性的声明，getter/setter ，类外属性、以及延迟属性进行Demo 代码详解：

声明

用var声明可变，或者用val 声明不可变，在Kotlin中完整的声明格式如下：

[修饰符] val|var 属性名[: 属性类型][= 初始化赋值]
      [get() = getter 语句]
      [set() = setter 语句]

例1：Person类定义了name属性，String类型，初始化为空, 这里省略了Getter，Setter。虽然省略了，通常可以通过person.name 调用，看似没有调用getter，但实际应用中，Kotlin会自动调用，而且是强制的。

class Person{
     var name: String =""
}

例2:通过上面我们知道，Kotlin会默认生成Getter、Setter，如果要修改Getter，Setter方法的话，如下：

class Person{
      var name: String =""
           get() = field.toUpperCase()   //这里field 可以看成是name字段的中介，它的变化会反应在当前的name字段上，姑且你把它看成是name字段的别名吧。
           set(value){           
                  field ="Name: $value"
           }
}

如果需要在getter和setter中访问这个属性自身的值，它需要创建一个backing field。可以使用field这个预留字段来访问，它会被编译器找到正在使用的并自动创建。

类外属性

在 Kotlin 类外定义的属性有两种，一是直接写在类外并初始化的包级属性，二是使用const val定义的编译期常量。

例1:包级属性下编译这个文件，实际上会形成两个类，一个是我们定义的 Person 类，另一个是“文件类”PersonKt。

// oop.Person.kt
class Person(val name :String)
val maxID=Int.MAX_VALUE

maxID 被编译为这个类私有的静态字段，并拥有一个默认的 getter 方法。在java中是直接通过类名.maxID,而在Kotlin中是这么用的：

// Kotlin 调用包级属性
import oop.maxID// 因为是包级变量，所以使用“包名.属性名”的方式导入
val a=maxID// 直接调用，不需要标明变量所在的文件

例2:编译期常量与包级属性类似，看代码：

// oop.Person.kt
const val maxID=Int.MAX_VALUE // 将 maxID 声明为编译期常量

与java相比，Kotlin中 常量有几个限制：

1.只能定义在类外或对象（Object）内；
2.只能使用 String 或原生类型（Int、Double 等）初始化；
3.不能自定义 getter（直接调用，不需要 getter）

还有一点注意：Kotlin 中，使用在注解参数中的属性，只能是编译期常量（其他形式的属性都不能使用在注解的参数里）：

const val DEPRECATED_MESSAGE = "This is deprecated."

@Deprecated(DEPRECATED_MESSAGE) fun foo() {……}

延迟属性

Kotlin中为什么要有延迟属性呢？那是因为Kotlin中类内属性，默认情况下都是要强制初始化的，但在实际应用中，确实有一些属性不需要初始化，为了避免编译器错误，这时候就需要用lateinit修饰符标记该属性。

例如：这里就是对hello属性进行延迟初始化。

class Person(val name:String){
    lateinit var hello :String
    fun initHello(){
          hello="Hello, my name is $name"
    }
}

在使用过程中需要注意：一定要先调用initHello()方法之后在去使用hello属性，否则就会报错。

继承

与java相比，Kotlin的超类是Any。在没有父类的情况下默认继承，下面主要列举显示继承：

例1：父类Base有一主构造，在被Derived类继承过程中，必须同样覆盖主构造方法，否则会报错，这点跟java一样。注意：被继承的类必须声明open关键字

open class Base(p :Int)
class Derived(p :Int) : Base(p)

例2:  如果没有主构造函数，那么每个次构造函数必须使用super关键字初始化其基类型，或委托给另一个构造函数做到这一点。

class MyView :View {
        constructor(ctx : Context) : super(ctx)   
        constructor(ctx : Context, attrs : AttributeSet) : super(ctx, attrs)
}

例3：java中经常要覆盖父类的方法去实现一些业务逻辑，在Kotlin中除非是抽象类的方法是默认可以覆盖的，正常的使用open修饰的父类，它的方法也要声明为open后才能被子类覆盖。

open class Person(val name :String){
    open var age=0  //要被继承就必须添加open关键字
    open fun say()= "My name is $name, $age years old."
}

class Student(name : String ) : Person(name){
    override var age=0    //继承的属性必须加override  下面方法同样适用
    override fun say()="I'm a student named $name, $age years old."
}

在覆盖属性的时候需要注意：不允许用 val 属性覆盖 var 属性，这点仔细理解下确实是这个道理，就像java里的 父类protected修饰的方法，子类中只能是protected或者public，肯定不能private。

例4：如果继承的父类与继承的接口中有同样的函数怎么办，这个时候就要子类必须表明自己的实现，是都覆盖，还是覆盖其中之一。下面代码演示：

//接口

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

open class A{
    open fun f(){  //open修饰可以被子类继承
        print("A")
    }
    fun a(){  //不可被继承
        print("a")
     }
}

class C : A() , B { // 编译器要求覆盖 f()： 下面的实现调用其中之一也是可以的
      override fun f(){
            super.f() // 调用 A.f()
            super.f()// 调用 B.f()
      }
}

总结

到此为止，Kotlin中的类，构造，类属性，继承就学习完了，为了避免博客太长，下面另开博客继续讲解抽象类与接口。进入下一章节