类以及实例化
类在面向对象的程序语言中，重要程度不言而喻，现在我们就来看看kotlin中的类怎么玩起来
定义
class Student {
}
class Teacher
上面两种方式都是对的 如果{} 内部没有东西的话， 可以直接省略掉
构造函数
感觉构造函数比java 复杂，还分什么第一个构造函数和第二个构造函数，我靠，不都是构造函数吗，还分等级，不爽，就看以后有什么特别的地方没有，继续前行。
- 第一构造函数
主要用到关键字constructor,并且定义在class header 中 而不是body 中，
初始化时，需要在init 方法中进行
class Student constructor(name: String, age: Int) {
var name = ""
var age = 0
init {
this.name = name
this.age = age
}
fun goToSchool() {
println("Let us go to the school.")
}
fun sleep() {
println("这才是They 们的主营业务.")
}
}
- 第二构造函数
没有第一构造函数的情况下
和java的构造函数很是相似
class Animal {
var name = ""
var type = ""
constructor(name: String, type: String) {
this.name = name
this.type = type
println("This animal is $name and belong to $type")
}
constructor(name: String) {
this.name = name
this.type = "动物"
}
}
有第一构造函数的情况下
class Table(with: Int, height: Int) {
var name = ""
var with = 0
var height = 0
init {
this.name = "Hello"
this.with = with
this.height = height
println("name=$name,width=$with,height=$height")
}
constructor(name: String, with: Int, height: Int) : this(with, height) {
this.name = name
println("sencond name=$name, width=$with, height=$height")
}
constructor() : this(1, 2) {
println("empty name=$name,width=$with,height=$height")
}
}
Table(10, 11)
Table("Spub", 21, 22)
Table()
/**打印结果
name=Hello,width=10,height=11
name=Hello,width=21,height=22
sencond name=Spub, width=21, height=22
name=Hello,width=1,height=2
empty name=Hello,width=1,height=2
*/
可以看出，首先执行了init 方法，然后才会执行 constructor 方法，但是第一构造函数的值已经优先赋值了 ，可以看出第一构造函数有很大的优势，就是传入值可以优先执行。
注意：第二构造函数必须代理第一构造函数（存在的话）
实例化
class 的使用是很简单的，和java 比较 是不需要new的 这就简单了一些
Table(10, 11)
Table("Spub", 21, 22)
var table = Table()
println("A table have a name of $table.name.")
继承
每一个kotlin class 都有一个父类Any.
如果一个类要想被继承，需要在前面添加open，默认是final 不可继承的
open class Circle
class QuadriTable constructor(name: String) : Circle() {
var name = ""
init {
this.name = name
}
}
- open
如果想被继承 必须在前面加关键字open
- 父类拥有第一构造函数
open class Circle(name: String) {
var name = ""
init {
this.name = name
}
}
class SemiCircle : Circle {
constructor(name: String) : super(name)
constructor(w: Int) : super(name = "")
constructor(w: Int, h: Int) : this(w = w)
}
class Monocircle(name: String) : Circle(name) {
// constructor(name: String) : super(name); 这样定义是不行的 因为已经有第一构造函数了
constructor(w: Int) : this(name = "")
constructor(w: Int, h: Int) : this(w)
}
- 没有第一构造函数
没有构造函数时，和平常是一样的，所以略
重写
注意适用于方法和属性
- open 允许重写的方法前必须添加 open ,默认是final 不允许重写的
- override 重写标志
open class Circle {
open var x = 0
open fun sitDown() {
println("This is very good you like！")
}
/**默认是final的，不能重写*/
fun gogo() {
}
}
class SemiCircle : Circle() {
override var x = 100
override fun sitDown() {
// super.sitDown() 可选
}
}
调用父类
调用父类的function或者是property 需要利用关键字super，和java类似，没有什么特别的东西，过
重写冲突
当class 重写的方法中有相同的方法，则需要用相应的class或interface 名进行区分，具体实现如下
open class Circle {
open var x = 0
open fun sitDown() {
println("This is very good you like！")
}
open fun getShape(): Long {
return 0
}
/**默认是final的，不能重写*/
fun gogo() {
}
}
interface IShape {
fun getShape(): Long {
return 0
}
}
class Monocircle : Circle(), IShape {
override fun getShape(): Long {
super<Circle>.getShape()
super<IShape>.getShape()
return 0;
}
}
抽象类
抽象类的概念和java一致 并且只需要前面加关键字 abstract 就可以了
注意：kotlin中可以将一个非抽象方法定义为抽象方法来使用 ，但是方法体中的东西就会被清除掉了
open class Circle {
open fun getShape() {
println("This is 什么情况？")
}
}
abstract class Monocircle : Circle() {
override abstract fun getShape()
abstract fun gogo()
}
class Multicircle : Monocircle() {
override fun getShape() {
}
override fun gogo() {
}
}
工厂方法（友元方法）
在kotlin中并没有静态方法，所以如果你需要使用直接调用方法，可以使用包级方法，或者使用工厂方法，包级方法略
fun BaseMain() {
Circle.printH()
Circle.sayHello()
}
open class Circle {
companion object Hello {
fun printH() {
println("JUST print the string.")
}
fun sayHello() {
println("Say you go go 你 不go 让我很心疼.")
}
}
}
完