以下是本人的学习笔记，入有任何不妥之处，随时欢迎拍砖指正。
谢谢 ^_^
1. 类
Kotlin 中使用关键字 class 声明类
class Invoice {
}
//如果没有具体的内容甚至可以这样定义
class Invoice
2. 构造函数
在 Kotlin 中类可以有一个主构造函数和一个或多个次构造函数
class Person constructor(firstName: String) {
}
如果主构造函数没有任何注解或者可见性修饰符，可以省略这个 constructor 关键字。
class Person(firstName: String) {
}
主构造函数中不能有内容，如果需要初始化，使用init关键字
class Person(firstName: String) {
init {
println("Customer initialized with value ${firstName}")
}
}
我们通过以下方式创建 Person
val p = Person("12")
// 输出结果
I/System.out: Customer initialized with value 12
3. 次构造函数
也可以用constructor作为前缀来生成次构造函数。
class Parent {
constructor(parent: Child) {
println("Customer initialized with parent")
}
}
class Child(firstName: String) {
init {
println("Customer initialized with value ${firstName}")
}
}
通过以下方式创建
val name = Parent(Child("Xiao Ming"))
// 输出结果
I/System.out: Customer initialized with value Xiao Ming
I/System.out: Customer initialized with parent
类如果没有任何参数，那么默认是 public 的，如果需要私有就在上边加『private』 修饰符
class Person private constructor ()
当构造函数被『private』所修饰时，无法创建对象
编译会报错，提示 Person 已被私有化。
下面是构造函数上有默认的值提供，构造器会提供一个空参函数来初始化，并使用默认值。
class Person (val PersonName: String = "")
我们通过以下方式创建 Person
val p = Person()
4. 继承
Kotlin 中所有类都有一个共同的超类 Any
class Parent // 从 Any 隐式继承
被open关键字修饰的类允许其他类从这个类继承
open class Parent(p: Int)
class Child(p: Int) : Parent(p)
4.1 覆盖方法
当子类被open修饰时，才可以被继承，默认情况（即没有 open） 下是 final 修饰的无法继承。
当被open 修饰的类中有被open修饰的方法时，可以被子类重写，用 override 来修饰。如下例中的 paly( )
open class Parent(p: Int) {
open fun play() {}
fun doHomeWork() {}
}
class Child(p: Int) : Parent(p) {
override fun play() {
super.play()
}
}
如果想让 play 只被重写一次那么，需要加final
也就是说当类中的方法被 final 修饰时，子类无法继承
class Child(p: Int) : Parent(p) {
final override fun play() {
super.play()
}
}
当类没有被 open所修饰(也就是默认 final 修饰)，那么类中的方法也不能用open 修饰
4.2 覆盖属性
属性也可以被覆盖，可以用一个 var 属性覆盖一个 val 属性，但反之则不行。
interface Foo {
val count: Int
}
class Bar1(override val count: Int) : Foo
class Bar2 : Foo {
override var count: Int = 0
}
4.3 覆盖规则
kotlin 中，接口可选的去实现里面的方法。
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()
}
}
上面例子中类 C 继承了类 A 和接口 B ，类 C 可以调用 a()，b()，而f()存在歧义，C 不知道他该继承谁的方法，所以我们需要对相同名称的方法进行重写覆盖，这样我们就可以通过自定义方法的形式来消除歧义。
关于我
一只成长中的图图。
感谢
参考自:
https://www.kotlincn.net/docs/tutorials/android-plugin.html
https://huanglizhuo.gitbooks.io/kotlin-in-chinese/content/GettingStarted/Basic-Syntax.html
