简述
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中的类，构造，类属性，继承就学习完了，为了避免博客太长，下面另开博客继续讲解抽象类与接口。进入下一章节
