学习一下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) : Fooclass 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<A>.f() // call to A.f()        super<B>.f() // call to B.f()    }}