Kotlin语法(类和对象)

简介:

二、类和对象:

1. 类定义:

类的声明包含类名,类头(指定类型参数,主构造函数等等),以及类主体,用大括号包裹。类头和类体是可选的;如果没有类体可以省略大括号。

class Invoice{
}

2. 构造函数:

在 Kotlin 中类可以有一个主构造函数以及多个二级构造函数。主构造函数是类头的一部分:跟在类名后面(可以有可选的参数)。

class Person(val firstName: String, val lastName: String, var age: Int){
}

初始化代码可以放在以 init 做前缀的初始化块内:

class Customer(name: String){
    init {
        logger,info("Customer initialized with value ${name}")
    }
}

如果构造函数有注解或可见性声明,则 constructor 关键字是不可少的,并且注解应该在前:

class Customer public inject constructor (name: String) {...}

3. 二级构造函数:

前缀是 constructor:

class Person {
    constructor(parent: Person) {
        parent.children.add(this)
    }
}

如果类有主构造函数,每个二级构造函数都要,或直接或间接通过另一个二级构造函数代理主构造函数。在同一个类中代理另一个构造函数使用 this 关键字:

class Person(val name: String) {
    constructor (name: String, paret: Person) : this(name) {
        parent.children.add(this)
    }
}

没有声明构造函数,则有一个默认的无参构造函数。

4. 创建类的实例:

val invoice = Invoice()
val customer = Customer("Joe Smith")

5. 继承

所有类的基类:Any,类似Java中的Object

所有非抽象类默认都是不可继承的(java中的final),如果要被子类继承,需要使用open关键字(与java中的final功能相反),继承用:操作符。

open class Base(p: Ont)
class Derived(p: Int) : Base(p)

方法如果要被重写,则也需要是open的,不想被重写就加final

open class AnotherDerived() : Base() {
    final override fun v() {}
}

方法重写规则:如果有多个相同的方法(继承或者实现自其他类,如A、B类),则必须要重写该方法,使用super范型去选择性地调用父类的实现。

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{
    override fun f() {
        super<A>.f()//调用 A.f()
        super<B>.f()//调用 B.f()
    }
}

6. 抽象类

abstract关键字,抽象类和函数默认是open的。

open class Base {
    open fun f() {}
}

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

7. 伴随对象

使用伴随对象可以直接使用类名来访问(用法类似Java中的static,但是不一样):

class MyClass {
    companion object {
        var BASE_URL: String = "BASE_URL";
    }
}

println("BASE_URL: " + MyClass.BASE_URL)

与java的static不同,运行时它们仍然是真正对象的成员实例,比如可以实现接口:

inerface Factory<T> {
    fun create(): T
}

class MyClass {
    companion object : Factory<MyClass> {
        override fun create(): MyClass = MyClass()
    }
}

8. Getter 和 Setter 函数

一般定义变量的时候有默认的getter/setter方法;如果使用$访问,则可以避开getter/setter方法。

var stringRepresentation: String
    get() = this.toString()
    set (value) {
        setDataFormString(value)
}

改变一个访问者的可见性或者注解它,可以不用改变默认的实现:

var settVisibilite: String = "abc"//非空类型必须初始化
    private set // setter 是私有的并且有默认的实现
var setterVithAnnotation: Any?
    @Inject set // 用 Inject 注解 setter

9. 接口

可以包含抽象方法,以及方法的默认实现。可以有属性但必须是抽象的。一个类或对象可以实现一个或多个接口。

interface MyInterface {
    fun bar()
    fun foo() {
        //函数体是可选的
    }
}

接口属性不能赋值,需要被子类override:

interface MyInterface {
    val property: Int //抽象属性
    fun foo() {
        println(property)
    }
}
class Child : MyInterface {
    override val property: Int = 29
}
输出:29

10. 可见性修饰词

  • private: 只在该类(以及它的成员)中可见
  • protected: 和 private 一样但在子类中也可见
  • internal: 在本模块的所有可以访问该类的均可以访问该类的所有 internal 成员
  • public: 任何地方可见

11. 数据类

使用data关键词修饰类,则会自动添加equals()/hashCodetoString[compontN()functions]对应按声明顺序出现的所有属性copy()

data class User(val name: String, val age: Int)

组件函数允许数据类在多重声明中使用:

val jane = User("jane", 35)
val (name, age) = jane
println("$name, $age years of age")

12. 内部类

类可以标记为 inner 这样就可以访问外部类的成员。内部类拥有外部类的一个对象引用:

class Outer {
    private val bar: Int = 1
    inner class Inner {
        fun foo() = bar
    }
}

val demo = Outer().Inner().foo()

13. 对象表达式

类似Java的匿名内部类,可以继承/实现多个:

var zhangsan = object : Person(), MyInterface{
        override val property: Int = 512

        override fun toString(): String {
            return "toString() modified"
        }
    }
println(zhangsan.toString())

一个没有父类的对象,我们可以这样写:

val adHoc = object {
    var x: Int = 0
    var y: Int = 0
}
print(adHoc.x + adHoc.y)

14. 代理

类代理:

interface Base {
    fun print()
}

class BaseImpl(val x: Int) : Base {
    override fun print() { printz(x) }
}

class Derived(b: Base) : Base by b

fun main() {
    val b = BaseImpl(10)
    Derived(b).print()
}

属性代理:

class Example {
    var p: String by Delegate()
}
class Delegate {
    fun get(thisRef: Any?, prop: PropertyMetadata): String {
        return "$thisRef, thank you for delegating '${prop.name}' to me !"
    }

    fun set(thisRef: Any?, prop: PropertyMatada, value: String) {
        println("$value has been assigned to '${prop.name} in $thisRef.'")
    }
}
val e = Example()
pintln(e.p)

输出:Example@33a17727, thank you for delegating ‘p’ to me!

标准代理

参考:

  1. http://kotlinlang.org/docs/reference/basic-syntax.html
  2. http://huanglizhuo.gitbooks.io/kotlin-in-chinese
本文转自天天_byconan博客园博客,原文链接:http://www.cnblogs.com/tiantianbyconan/p/4801588.html ,如需转载请自行联系原作者
相关文章
|
12天前
|
XML Java 开发者
预测一下 Kotlin 未来会有哪些新语法
预测一下 Kotlin 未来会有哪些新语法
38 0
|
12天前
|
XML JSON Android开发
[Android]使用JSONObiect和Gson相关方法实现json数据与kotlin对象的相互转换
[Android]使用JSONObiect和Gson相关方法实现json数据与kotlin对象的相互转换
58 0
|
9月前
|
安全 Java 编译器
Kotlin 学习笔记(一)—— 基本类型、函数、lambda、类与对象的写法
Kotlin 作为 Android 开发的首选语言,其基础语法和特性需要重点学习。本文概括总结了 Kotlin 的基本类型、关键字、函数、闭包、高阶函数、类与对象等核心知识点,并给出示例代码进行讲解。
154 0
Kotlin 学习笔记(一)—— 基本类型、函数、lambda、类与对象的写法
|
12月前
|
XML 安全 Java
Kotlin 基础 | 拒绝语法噪音
Kotlin 基础 | 拒绝语法噪音
49 0
|
Java Android开发 Kotlin
Android基础--kotlin(十一)Kotlin 对象表达式和对象声明
Android基础--kotlin(十一)Kotlin 对象表达式和对象声明
|
Java 编译器 Go
Kotlin学历之类与对象
Kotlin学历之类与对象
58 0
|
搜索推荐 Java Android开发
Kotlin学习日志(五)类与对象(下)
Kotlin学习日志(五)类与对象(下)
Kotlin学习日志(五)类与对象(下)
|
Java 编译器 Android开发
Kotlin学习日志(五)类与对象(中)
Kotlin学习日志(五)类与对象(中)
137 0
Kotlin学习日志(五)类与对象(中)
|
Java C语言 Android开发
Kotlin学习日志(五)类与对象(上)
Kotlin学习日志(五)类与对象(上)
Kotlin学习日志(五)类与对象(上)
|
存储 Java Kotlin
【Kotlin 初学者】类和对象-类的修饰符
1.1 前言 Kotlin 是一门面向对象的开发语言。也有着面向对象语言的特性。而面向对象的三大特性即封装、继承、多态,这是每一门面向对象语言都具有的特性。
163 0
【Kotlin 初学者】类和对象-类的修饰符