Kotlin类和对象

1-类的定义

类的定义常见三种形式

class ClassTest {
}
class Empty  //空类
class ClassOne(){
    
}

2-属性

2.1-属性的定义

class ClassTwo{
    //属性定义
    var name:String = "chao"//可变
    val city:String = "sh"//不可变

    val obj = ClassTwo() // Kotlin 中没有 new 关键字

    public fun test(){
        obj.city  // 属性的调用
    }
}

2.2-getter和setter

class Person {
    var name: String = "CHAO"
        get() = field.toLowerCase()
        set

    var no: Int = 10
        get() = field // 后端变量
        set(value) {
            if (value < 10) {
                field = value
            } else {
                field = 0
            }
        }
}
fun main(){
    var p : Person = Person()
    p.name = "CHAO"
    println("name:${p.name}") //name:chao

    p.no = 7
    println("no:${p.no}") //no:7

    p.no = 11
    println("no:${p.no}")//no:0
}

3-构造器

主构造函数和次构造函数的使用如下：

class ConstructorTest  constructor(name: String) {  // 主构造函数
    // 大括号内是类体构成
    var url: String = "http://www.baidu.com"
    var country: String = "CN"
    var siteName = name

    init {
        println("初始化网站名: ${name}")
    }
    // 次构造函数
    constructor (name: String, alexa: Int) : this(name) {
        println("Alexa 是 $alexa")
    }

    fun printTest() {
        println("我是类的函数")
    }
}

fun main(args: Array<String>) {
    val ct =  ConstructorTest("百度", 100)
    println(ct.siteName)
    println(ct.url)
    println(ct.country)
    ct.printTest()
}

输出结果：

初始化网站名: 百度
Alexa 是 100
百度
http://www.baidu.com
CN
我是类的函数

4-类的修饰符

 

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

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

• accessModifier: 访问权限修饰符

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

5-其他特殊类

抽象类，嵌套类，嵌套内部类，匿名内部类

5.1-抽象类

//抽象类
abstract class AbstractClasa {
    abstract fun f()
}

5.2-嵌套类

//嵌套类
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
}

5.3-嵌套内部类

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

5.4-匿名内部类

//匿名内部类
class Test {
    var v = "成员属性"

    fun setInterFace(test: TestInterFace) {
        test.test()
    }
}
interface TestInterFace {
    fun test()
}

fun main(args: Array<String>) {
    var test = Test()

    /**
     * 采用对象表达式来创建接口对象，即匿名内部类的实例。
     */
    test.setInterFace(object : TestInterFace {
        override fun test() {
            println("对象表达式创建匿名内部类的实例")
        }
    })
}