学习一下Kotlin(一)

前言

Kotlin出来有几个年头了,不温不火,google粑粑在今年I/O大会上宣布Kotlin成为Android的官方语言(可能是谷歌和甲骨文Java神仙打架后,做出的调整),算是在android开发的老司机和新司机的脑子里都留下了印象。


Class and Objects

( 受面向对象语言的荼毒比较深,我还是比较喜欢先看一下它的Class和Object)

   class  Hello{
    }

这申明熟悉的感觉,没毛病。


构造函数

根据官方文档指出一个class能够有一个primary constructor以及多个secondary constructors (面向对象的一个特征出来了),基本的一个class的构造方法,也就是primary constructo 一个constructor关键字

   class Hello constructor(test: String){
   }

不过根据官方文档还说明一点:如果primary constructor没有任何的注释说明或者有用的修饰,那么constructor可以省略

  class Hello (test:String){}

另外基本的构造方法不能包含任何胆码,我们能够通过init关键字来进行初始化(挺人性化的设计)

  class Hello(test:String){
      init{
        logger.info("Hello init with value ${test}")
       }
  }

小提示: 构造方法的变量能够在init初始化的中,也能够通过申明变量引用

class Customer(name: String) {
    val customerKey = name
}

同时也能这么玩

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

(var和val的区别说变量时再区别,构造方法里变量申明也可以用 val)

上面说的都是没有那些有用的修饰符或者有用的修饰符,如果有那么constructor 就不可以省略,把Visibility Modifiers 搁到constructor之前就可以

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

那么被官方成为Secondary Constructors 就是大家熟悉的这样

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

如果一个class有一个primary constructor,那么每一个secondary constructor需要一个this关键字引用这个变量

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

如果你的定义一个class 没有构造方法,那么你的constructor就是public ,如果想要定义个私有的构造方法就用private(和Java的一样)

class DontCreateMe private constructor () {
}
实例化一个class

kotlin没有new这个关键字,实例化一个类

 val hello = Hello()
 val custom = Customer("hello world");
继承和复写方法
class MyView : View {
    constructor(ctx: Context) : super(ctx)

    constructor(ctx: Context, attrs: AttributeSet) :        super(ctx, attrs)
}

看一下下面的(open关键字,需要继承复写方法用),老司机们看例子,就不用介绍了还是一个override关键字

open class Base {
    open fun v() {}
    fun nv() {}
}
class Derived() : Base() {
    override fun v() {}
}
open class Foo {
    open val x: Int get { ... }
}

class Bar1 : Foo() {
    override val x: Int = ...
}

如果进制复写一个方法,那么就引用一个final 关键字

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

还是 abstract

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

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

(又是val和var的区别)

interface Foo {
    val count: Int
}

class Bar1(override val count: Int) : Foo

class Bar2 : Foo {
    override var count: Int = 0
}

复写规则:
看例子,比口述强,一个super关键字

open class A {
    open fun f() { print("A") }
    fun a() { print("a") }
}

interface B {
    fun f() { print("B") } // interface members are 'open' by default
    fun b() { print("b") }
}

class C() : A(), B {
    // The compiler requires f() to be overridden:
    override fun f() {
        super.f() // call to A.f()
        super.f() // call to B.f()
    }
}

你可能感兴趣的:(android,android,android开发,Kotlin)