kotlin 类和对象

类

1.属性

1.1 定义属性

class Perple{
	var name : String ="" 可变属性
	val sex	 : String ="" 不可变属性
}

1.2 getter setter

var allByDefault: Int? // 错误: 需要一个初始化语句, 默认实现了 getter 和 setter 方法
var initialized = 1     类型为 Int, 默认实现了 getter 和 setter
val simple: Int?       // 类型为 Int ，默认实现 getter ，但必须在构造函数中初始化
val inferredType = 1    类型为 Int 类型,默认实现 getter

自定义服务器

var lastName: String = "zhang"
        get() = field.toUpperCase()   // 将变量赋值后转换为大写
        set

    var no: Int = 100
        get() = field                // 后端变量
        set(value) {
            if (value < 10) {       // 如果传入的值小于 10 返回该值
                field = value
            } else {
                field = -1         // 如果传入的值大于等于 10 返回 -1
            }
        }

1.3 lateinit 关键字

使用lateinit即可使属性为空
lateinit var name : String

1.4 伴生对象(相当于java的static)

一个类只能有一个伴生对象 使用companion来修饰

class People{
  	companion object CompanionObjectName{
		var name = "你好"
		fun getName():String{
			return name
		}
	}
}

class main{
	fun main(arg:Array<String>){
		调用伴生对象属性
		People.name
		调用伴生对象函数
		People.getName
		调用伴生对象本身
		People.CompanionObjectName
	}
}

2. 主构造器和初始化代码段

kotlin中只能有一个主构造器 主构造器是类头部的一部分,位于类名之后
class Perple constructor(firstName: String){
}

如果主构造器没有任何的注解和修饰符 可省略
class Perple (firstName:String){
}

主构造器中不能写代码,初始化代码可以放在初始化代码块中,
class Perple (firstName : String){
	init{
		xxx
	}
}

通过构造器定义属性
class Perple(var name: String){
}

3. 次构造器

次构造器以constructor开头
class Perpon{
	constructor(parent: Person) {
        parent.children.add(this) 
    }
}

如果有主构造器 则次构造器得代理主构造器
class Person(val name: String) {
    constructor (name: String, age:Int) : this(name) {
        // 初始化...
    }
}

声明一个空的主构造函数 ,就没有公共的构造函数
class Perple private constructor(){
}

4. 抽象类

关键字:abstract 
abstract class Derived : Base() {
    override abstract fun f()
}

5. 嵌套类

class Outer {                  // 外部类
    private val bar: Int = 1
    class Nested {             // 嵌套类
        fun foo() = 2
    }
}

fun main(args: Array<String>) {
    val demo = Outer.Nested().foo() // 调用格式：外部类.嵌套类.嵌套类方法/属性
    println(demo)    // == 2
}

6. 内部类

class Outer {
    private val bar: Int = 1
    var v = "成员属性"
    /**嵌套内部类**/
    inner class Inner {
        fun foo() = bar  // 访问外部类成员
        fun innerTest() {
            var o = this@Outer //获取外部类的成员变量
            println("内部类可以引用外部类的成员，例如：" + o.v)
        }
    }
}

fun main(args: Array<String>) {
    val demo = Outer().Inner().foo()
    println(demo) //   1
    val demo2 = Outer().Inner().innerTest()   
    println(demo2)   // 内部类可以引用外部类的成员，例如：成员属性
}

7. 类的修饰符

classModifier: 类属性修饰符，标示类本身特性。

abstract    // 抽象类  
final       // 类不可继承，默认属性
enum        // 枚举类
open        // 类可继承，类默认是final的
annotation  // 注解类

accessModifier: 访问权限修饰符

private    // 仅在同一个文件中可见
protected  // 同一个文件中或子类可见
public     // 所有调用的地方都可见
internal   // 同一个模块中可见