运算符重载
kotlin中每一个运算符对应一个方法。比如我们想把两个对象加起来的话，只需要把“+”对应的方法复写就可以实现了。运算符对应的方法可以通过kotlin官网http://kotlinlang.org/docs/reference查询。
fun main(args: Array<String>) {
val p1 = Person()
val p2 = Person()
p1.age = 10
p2.age = 20
//求p1和p2的年龄和
var plus = p1.plus(p2)
println(plus)
}
//重写“+”方法
class Person {
var name = "张三"
var age = 0
fun plus(person: Person): Int {
return age + person.age
}
}
类的成员
类成员可以访问并且修改，kotlin的类成员变量默认已经实现了get以及set方法。
成员的访问与修改
由于kotlin的类成员变量默认实现get以及set方法，所以类中的成员可以直接调用：
fun main(args: Array<String>) {
val stu = Student()
println(stu.age)
println(stu.name)
}
class Student {
val name = "张三"
val age = 15
}
修改类成员的可见性
在Kotlin中，若是想要类成员对于外界只能访问不能修改，则在类成员后中写入 private set。若想类成员对外界既不能访问也不能修改，则在类成员前写入private：
class Student {
var name = "张三"
private set//外界无法修改name
private var age = 15//外界无法访问、修改age
}
自定义访问器
在我们的例子中，学生的年龄不可能随意设置，比如学生是-1岁，所以需要对设置的数据进行判定，符合一定要求后才能修改。对于此类要求，我们可以用自定义访问器field：
fun main(args: Array<String>) {
var person = Student()
println(person.age)//20
person.age = 35//由于35>30，所以设置失败
println(person.age)//20
}
class Student {
var name = "张三"
var age = 20
set(value) {//value对应传递的age值
if (value > 18 && value < 30) {
//可以通过field表示这个字段
field = value
}
}
}
主构函数和次构函数
主构函数
kotlin中主构函数即构造函数，但是无法直接访问构造函数中的元素。如果想要在构造函数里面实现一些操作，需要把代码写在init里：
fun main(args: Array<String>) {
val p1 = Person("张三", 23)
val p2 = Person("李四", 25)
val p3 = Person("王五", 40)
println(p1.age)//23
println(p2.age)//25
println(p3.age)//40
}
class Person(name: String, age: Int) {
var name = ""
var age = 0
init {
this.age = age
this.name = name
}
}
var和val在主构函数参数中的作用
主构函数参数使用var和val，相当于帮我们定义了字段，参数可以直接使用。参数没有var和val修饰，参数在其他地方不能使用 。参数有var修饰，可以使用，也可以修改 。参数有val修饰，只能使用，不能修改 ：
fun main(args: Array<String>) {
val p1 = Person("张三", 23)
val p2 = Person("李四", 25)
val p3 = Person("王五", 40)
println(p1.age)
println(p2.age)
println(p3.age)
}
class Person(val name: String,val age: Int)
次构函数
次构函数必须要调用主构函数，必须要把参数传递给主构函数，且需要用constructor关键字：
class Person2(val name: String,val age: Int){
constructor(name: String, age: Int,phone:String):this (name,age)//调用主构函数将参数传递给主构函数
}
次构函数间调用
次构函数可以直接调用主构函数，也可以通过调用次构函数来间接调用主构函数：
class Person3(name:String,age: Int){
//调用主构函数
constructor(name:String,age: Int,phone: String):this(name,age)
//通过调用次构函数来间接调用主构函数
constructor(name:String,age: Int,phone: String,qq:String):this(name,age,phone)
}
次构函数参数使用
构造函数加var和val只能在主构函数里面加，次构函数中不能加。主构函数参数可以直接加上var和val使用，次构函数只能够自己定义变量进行保存。
class Person3(val name:String,val age: Int){
var phone = ""
var qq = ""
constructor(name:String,age: Int,phone: String):this(name,age)
constructor(name:String,age: Int,phone: String,qq:String):this(name,age,phone){
this.phone = phone
this.qq = qq
}
}
继承
继承是指一个对象直接使用另一对象的属性和方法。kotlin的继承和java中的继承大体相同，但需要注意以下几点：
1.需要将父类加上open关键字
2.需要加上（）：
kotlin的成员函数和成员变量对应的get以及set方法都有final修饰，不能进行继承，所以要在成员函数和成员变量前加上open关键字才能进行复写：
open class father() {
open var name = "小头爸爸"
open var age = 40
open fun sayHello() {
println("老哥 早上好")
}
}
class son : father() {
override var name: String = "大头儿子"
override var age: Int = 14
override fun sayHello() {
println("同学 早上好")
}
}
构造函数的继承
构造函数的继承除了通常的操作外，子类也需要构造函数，并且应能在父类中找到对应的字段，还需将函数传给父类。子类也可以用父类的字段：
fun main(args: Array<String>) {
var p = Person("张三", 30)
var s = Student("李四", 20, "男")
println(p.age)//30
println(s.sex)//男
println(s.name)//李四
}
open class Person(var name: String, var age: Int) {
open fun morning() {
println("早上好")
}
}
class Student(name: String, age: Int, var sex: String) : Person(name, age) {
override fun morning() {
println("晚上好")
}
}
抽象类和抽象方法
父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。包含抽象方法的类就是抽象类。抽象类不需要open关键字就可以被调用。
//人类 (抽象类)
abstract class Human {
abstract var color: String
abstract var language: String
abstract fun eat()
}
//具体实现类
class Chinese : Human() {
override var color: String = "yellow"
override var language: String = "chinese"
override fun eat() {
println("用筷子吃饭")
}
}
class USHuman : Human() {
override var color: String = "white"
override var language: String = "english"
override fun eat() {
println("用刀叉吃饭")
}
}
class AfHuman : Human() {
override var color: String = "black"
override var language: String = "葡萄牙语"
override fun eat() {
println("用手吃饭")
}
}
接口
接口的实现是在括号后面加个冒号，然后写上要实现的接口，不需要写interface。若是多个接口，就用逗号“，”隔开。
class men() : bike {
override fun rideBike() {
println("人骑车")
}
}
interface bike {
fun rideBike()
}
注意事项
1.java中接口中的字段一定要被赋值，但是Kotlin接口里的字段不能被赋值
2.java接口里面方法不能实现，kotlin可以实现
class men() : Bike, Drive {
override val license: String = "123456"
override fun drive() {
println("人开车")
}
override fun rideBike() {
println("人骑车")
}
}
interface Bike {
fun rideBike()
}
interface Drive {
val license: String
fun drive() {
println("放手刹,踩油门,走")
}
}
多态
同种功能的不同表现形式。kotlin中的多态原理同java：
abstract class Animal {
abstract var name: String
open fun bark() {
println("动物叫")
}
}
class Dog : Animal() {
override var name: String = "旺财"
override fun bark() {
println("旺财 汪汪叫")
}
}
class Cat : Animal() {
override var name: String = "汤姆"
override fun bark() {
println("汤姆 喵喵叫")
}
}
智能类型转换
在多态中，多个子类可能均与父类有差别。kotlin中可以通过智能类型推断来判断调用的字段所属于的子类，最终调用所属子类的方法。将父类引用转为子类引用，转换之前还需要判断是否是当前子类类型。一旦判断出是这个类型之后，编译器就把类型转换过去了，不需要手动转换。
fun main(args: Array<String>) {
val shepHerdDog: Dog = ShepHerdDog()//将父类引用转为子类引用
//判断是否是当前子类类型
if (!(shepHerdDog is ShepHerdDog)) return
//编译器自动转换
shepHerdDog.shepHerd()
}
abstract class Dog
class ShepHerdDog : Dog() {
fun shepHerd() {
println("牧羊犬开始放羊了...")
}
}
嵌套类、内部类
嵌套类默认都是static修饰的，属于静态类，不依赖于外部的环境，即和外部类没有关系：
fun main(args: Array<String>) {
val inClass = outClass()
}
class outClass {
var name: String = "李四"
class inClass {
fun say() {
println(name)
}
}
}
内部类需要通过Inner修饰，且需要先创建出来外部环境：
fun main(args: Array<String>) {
val inClass = outClass.inClass()
}
class outClass {
var name: String = "李四"
inner class inClass {
fun say() {
println(name)
}
}
}
内部类中使用this
如上例，若内部类中也有一个var name = "张三"，则默认情况下会打印张三，即从最近开始找。如果我们想访问外部类中的name，也就是李四。这时候就需要把打印内容改为外部类名.this.name或this@outClass.name:
class OutClass {
var name = "李四"
inner class InClass {
var name = "张三"
fun sayHello() {
println(this@OutClass.name)
//或
println(OutClass.this.name)
}
}
}
