1，接口
// Kotlin 接口与 Java 8 类似，使用 interface 关键字定义接口，允许方法有默认实现：
interface MyInterface {
fun bar() // 未实现
fun foo() { //已实现
// 可选的方法体
println("foo")
}
}
// 接口中的属性只能是抽象的，不允许初始化值，接口不会保存属性值，实现接口时，必须重写属性：
interface MyInterface{
var name:String //name 属性, 抽象的
}
class MyImpl:MyInterface{
override var name: String = "runoob" //重写属性
}
interface A {
fun foo() { print("A") } // 已实现
fun bar() // 未实现，没有方法体，是抽象的
}
interface B {
fun foo() { print("B") } // 已实现
fun bar() { print("bar") } // 已实现
}
class C : A {
override fun bar() { print("bar") } // 重写
}
class D : A, B {
override fun foo() {
super<A>.foo()
super<B>.foo()
}
override fun bar() {
super<B>.bar()
}
}
2，Kotlin 可以对一个类的属性和方法进行扩展，是一种静态行为，对被扩展的类代码本身不会造成任何影响
class User(var name:String)
/**扩展函数**/
fun User.Print(){
print("用户名 $name")
}
fun main(arg:Array<String>){
var user = User("Runoob")
user.Print()
}
3，Kotlin 可以创建一个只包含数据的类，关键字为 data
data class User(val name: String, val age: Int)
4，密封类用来表示受限的类继承结构：当一个值为有限几种的类型, 而不能有任何其他类型时。声明一个密封类，使用 sealed 修饰类，密封类可以有子类，但是所有的子类都必须要内嵌在密封类中。sealed 不能修饰 interface ,abstract class
sealed class Expr
data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()
fun eval(expr: Expr): Double = when (expr) {
is Const -> expr.number
is Sum -> eval(expr.e1) + eval(expr.e2)
NotANumber -> Double.NaN
// 不再需要 `else` 子句，因为我们已经覆盖了所有的情况
}
5， 范型
声明处的类型变异使用协变注解修饰符：in、out，消费者 in, 生产者 out。
class Runoob<in A, out B>(val b: B) {
fun foo(a: A): B {
return b
}
}
星号投射，其实就是*代指了所有类型，相当于Any?
class A<T>(val t: T, val t2 : T, val t3 : T)
class Apple(var name : String)
fun main(args: Array<String>) {
//使用类
val a1: A<*> = A(12, "String", Apple("苹果"))
val a2: A<Any?> = A(12, "String", Apple("苹果")) //和a1是一样的
val apple = a1.t3 //参数类型为Any
println(apple)
val apple2 = apple as Apple //强转成Apple类
println(apple2.name)
//使用数组
val l:ArrayList<*> = arrayListOf("String",1,1.2f,Apple("苹果"))
for (item in l){
println(item)
}
}
6，对象表达式
open class A(x: Int) {
public open val y: Int = x
}
interface B {……}
val ab: A = object : A(1), B {
override val y = 15
}
// 匿名对象只可以在本地和私有作用域中使用，如果是共有域将无法访问添加的成员变量
class C {
// 私有函数，所以其返回类型是匿名对象类型
private fun foo() = object {
val x: String = "x"
}
// 公有函数，所以其返回类型是 Any
fun publicFoo() = object {
val x: String = "x"
}
fun bar() {
val x1 = foo().x // 没问题
val x2 = publicFoo().x // 错误：未能解析的引用“x”
}
}
7，类的委托即一个类中定义的方法实际是调用另一个类的对象的方法来实现的。
// 创建接口
interface Base {
fun print()
}
// 实现此接口的被委托的类
class BaseImpl(val x: Int) : Base {
override fun print() { print(x) }
}
// 通过关键字 by 建立委托类
class Derived(b: Base) : Base by b
fun main(args: Array<String>) {
val b = BaseImpl(10)
Derived(b).print() // 输出 10
}
属性委托
// val/var <属性名>: <类型> by <表达式>
import kotlin.reflect.KProperty
// 定义包含属性委托的类
class Example {
var p: String by Delegate()
}
// 委托的类
class Delegate {
operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
return "$thisRef, 这里委托了 ${property.name} 属性"
}
operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
println("$thisRef 的 ${property.name} 属性赋值为 $value")
}
}
fun main(args: Array<String>) {
val e = Example()
println(e.p) // 访问该属性，调用 getValue() 函数
e.p = "Runoob" // 调用 setValue() 函数
println(e.p)
}
可观察 Observable
import kotlin.properties.Delegates
class User {
var name: String by Delegates.observable("初始值") {
prop, old, new ->
println("旧值：$old -> 新值：$new")
}
}
fun main(args: Array<String>) {
val user = User()
user.name = "第一次赋值" // 旧值：初始值 -> 新值：第一次赋值
user.name = "第二次赋值" // 旧值：第一次赋值 -> 新值：第二次赋值
}
属性委托
class Site(val map: Map<String, Any?>) {
val name: String by map
val url: String by map
}
fun main(args: Array<String>) {
// 构造函数接受一个映射参数
val site = Site(mapOf(
"name" to "菜鸟教程",
"url" to "www.runoob.com"
))
// 读取映射值
println(site.name) // 菜鸟教程
println(site.url) // www.runoob.com
}
Not Null
// 适用于那些无法在初始化阶段就确定属性值的场合。
class Foo {
var notNullBar: String by Delegates.notNull<String>()
}
foo.notNullBar = "bar"
println(foo.notNullBar)
局部委托
// 变量只会在第一次访问时计算。 如果 someCondition 失败，那么该变量根本不会计算。
fun example(computeFoo: () -> Foo) {
val memoizedFoo by lazy(computeFoo)
if (someCondition && memoizedFoo.isValid()) {
memoizedFoo.doSomething()
}
}
自定义委托
// 通过定义 provideDelegate 操作符，可以扩展创建属性实现所委托对象的逻辑。
class ResourceLoader<T>(id: ResourceID<T>) {
operator fun provideDelegate(
thisRef: MyUI,
prop: KProperty<*> // 主要是因为此处为被委托属性
): ReadOnlyProperty<MyUI, T> {
checkProperty(thisRef, prop.name)
// 创建委托
}
private fun checkProperty(thisRef: MyUI, name: String) { …… }
}
fun <T> bindResource(id: ResourceID<T>): ResourceLoader<T> { …… }
class MyUI {
val image by bindResource(ResourceID.image_id)
val text by bindResource(ResourceID.text_id)
}
网友评论