kotlin学习

kotlin和Java比较概述:

共同点:Kotlin和Java都是运行在JVM上
Kotlin优势:

语法简单

  1. Kotlin 支持类型推断,没有 Java 那样的啰嗦。
  2. 用 var 表示变量,val 表示常量更加的简洁
  3. 方法也很简单,连 function 都缩写成了 fun,平添了几分双关之意。
  4. 类的继承和实现很简单,使用:即可
  5. Kotlin 每个句子都不需要加分号 (;)

空指针安全
?和?. 的运用

var a: String = "abc"
a = null // compilation error

var b: String? = "abc"
b = null // ok

在类型后加?标识表明该变量可以为null,这时候不能直接调用变量方法,因为变量可能为null,需要做非空判断。 不加的话默认为非空变量,如果赋值为null编译报错

var a: String? = "abc"
val l = a.length  //compilation error
var b: String? = "abc"
val l = if (b != null) b.length else -1  //OK

所以一般使用通常用?.,不需要进行检查了,有人帮你做了,如果b为空引用,直接返回null,否则,就返回b.length。

var b: String? = "abc"
b?.length  // ok

支持方法扩展

/**
 *  对函数进扩展:
 *   在函数前面指定一个接受者,这里的接受者是MutabList<E>集合。
 *   为它扩展一个swap函数
 *  扩展函数的this指向接受者对象。
 *
 */
fun  <T> MutableList<T>.swap(x:Int,y:Int){
    //利用一个中间变量,互换之指定位置的值。
    val temp=this[x]
    this[x]=this[y]
    this[y]=temp
}

Lambda表达式支持

字符串模板

与 Java 交互性好

kotlin学习:
[中文翻译]https://huanglizhuo.gitbooks.io/kotlin-in-chinese/content/Basics/Basic-Types.html

  1. 数值常量中可以添加下划线分割(1.1版本新特性)
val oneMillion = 1_000_000
val creditCardNumber = 1234_5678_9012_3456L
  1. 在 java 平台上,数值被 JVM 虚拟机以字节码的方式物理存储的,除非我们需要做可空标识(比如说 Int?) 或者涉及泛型。在后者中数值是装箱过的。
    注意装箱过的数值是不保留特征的:【???】
val a: Int = 10000
print (a === a ) // 打印 'true'
val boxedA: Int? =a
val anotherBoxedA: Int? = a
print (boxedA === anotherBoxedA ) // 注意这里打印的是 'false'

然而,它们是值相等的:

val a: Int = 10000
print(a == a) // 打印 'true'
val boxedA: Int? = a
val anotherBoxedA: Int? = a
print(boxedA == anotherBoxedA) // 打印 'true'
  1. 字符类型用 Char 表示。不能直接当做数值来使用
  2. 数组在 Kotlin 中由 Array 类表示,有 get 和 set (通过运算符重载为[] )方法,和 size 属性。
    给库函数arrayOf()传递每一项的值来创建ArrayarrayOf(1, 2, 3)创建了一个[1, 2, 3] 这样的数组。也可以使用库函数arrayOfNulls()创建一个指定大小的空Array。
  3. 字符串是由 String 表示的。字符串是不变的。字符串的元素可以通过索引操作读取: s[i] 。字符串可以用 for 循环迭代。可以通过trimMargin()函数移除空格
  4. 字符串模板 字符串可以包含模板表达式,即可求值的代码片段,并将其结果连接到字符串中。模板表达式由 $ 开始并包含另一个简单的名称:
val i = 10
val s = "i = $i" // 求值为 "i = 10"

或者是一个带大括号的表达式:

val s = "abc"
val str = "$s.length is ${s.length}" // 结果为 "abc.length is 3"
  1. if 表达式
    在 Kotlin 中,if 是表达式,它可以返回一个值。因此Kotlin没有三元运算符(condition ? then : else),因为if语句已经满足了效果。
// 传统用法
var max = a
if (a < b)
    max = b
// 带 else
var max: Int
if (a > b)
    max = a
else
    max = b
// 作为表达式
val max = if (a > b) a else b

if分支可以作为块,最后一个表达式是该块的值:

val max = if (a > b){
    print("Choose a")
    a
}
else{
    print("Choose b")
    b
}
  1. When 表达式
    when 取代了 C 风格语言的 switch 。最简单的用法像下面这样
when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    else -> { // 注意这个语句块
        print("x is neither 1 nor 2")
    }
}

when会对所有的分支进行检查直到有一个条件满足。when 可以用做表达式或声明。如果用作表达式的话,那么满足条件的分支就是总表达式。如果用做声明,那么分支的值会被忽略。(像 if 表达式一样,每个分支是一个语句块,而且它的值就是最后一个表达式的值)
在其它分支都不匹配的时候默认匹配 else 分支。如果把 when 做为表达式的话 else 分支是强制的,除非编译器可以证明分支条件已经覆盖所有可能性。
如果有分支可以用同样的方式处理的话,分支条件可以连在一起:

when (x) {
    0,1 -> print("x == 0 or x == 1")
    else -> print("otherwise")
}

可以用任意表达式作为分支的条件

when (x) {
    parseInt(s) -> print("s encode x")
    else -> print("s does not encode x")
}

甚至可以用 in 或者 !in 检查值是否值在一个范围或一个集合中:

when (x) {
    in 1..10 -> print("x is in the range")
    in validNumbers -> print("x is valid")
    !in 10..20 -> print("x is outside the range")
    else -> print("none of the above")
}

也可以用 is 或者 !is 来判断值是否是某个类型。注意,由于 [smart casts],你可以不用另外的检查就可以使用相应的属性或方法。

val hasPrefix = when (x) {
    is String -> x.startsWith("prefix")
    else -> false
}

when 也可以用来代替 if-else if 。如果没有任何参数提供,那么分支的条件就是简单的布尔表达式,当条件为真时执行相应的分支:

when {
    x.isOdd() -> print("x is odd")
    x.isEven() -> print("x is even")
    else -> print("x is funny")
}
  1. break 和 continue 标签
    现在我们可以用标签实现 break 或者 continue 的快速跳转:
loop@ for (i in 1..100) {
    for (j in i..100) {
        if (...)
            break@loop
    }
}
  1. 返回到标签
    在字面函数,局部函数,以及对象表达式中,函数可以在 Kotlin 中被包裹。return 允许我们返回到外层函数。最重要的例子就是从字面函数中返回,还记得我们之前的写法吗:
fun foo() {
    ints.forEach {
        if (it  == 0) return
        print(it)
    }
}

return 表达式返回到最近的闭合函数,比如 foo
(注意这样非局部返回仅仅可以在[内联函数]中使用。如果我们需要从一个字面函数返回可以使用标签修饰 return :

fun foo() {
    ints.forEach lit@ {
        if (it ==0) return@lit
        print(it)
    }
}

现在它仅仅从字面函数中返回。经常用一种更方便的含蓄的标签:比如用和传入的 lambda 表达式名字相同的标签。

fun foo() {
    ints.forEach {
        if (it == 0) return@forEach
        print(it)
    }
}

另外,我们可以用函数表达式替代匿名函数。在函数表达式中使用 return 语句可以从函数表达式中返回。

fun foo() {
    ints.forEach(fun(value:  Int){
        if (value == 0) return
        print(value)
    })
}

当返回一个值时,解析器给了一个参考,

return@a 1

表示 “在标签 @a 返回 1 ” 而不是返回一个标签表达式 (@a 1)
命名函数自动定义标签:

foo outer() {
    foo inner() {
        return@outer
    }
}

  1. 在 Kotlin 中类用 class 声明:
class Invoice {
}
  1. 构造函数
    在 Kotlin 中类可以有一个主构造函数以及多个二级构造函数。主构造函数是类头的一部分:跟在类名后面(可以有可选的类型参数)。
    主构造函数不能包含任意代码。初始化代码可以放在以 init 做前缀的初始化块内
class Customer(name: String) {
    init {
        logger,info("Customer initialized with value ${name}")
    }
}

注意主构造函数的参数可以用在初始化块内,也可以用在类的属性初始化声明处:

class Customer(name: String) {
    val customerKry = name.toUpperCase()
}

二级构造函数
类也可以有二级构造函数,需要加前缀 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)
    }
}

如果一个非抽象类没有声明构造函数(主构造函数或二级构造函数),它会产生一个没有参数的构造函数。该构造函数的可见性是 public 。

  1. 创建类的实例
    我们可以像使用普通函数那样使用构造函数创建类实例:
val invoice = Invoice()
val customer = Customer("Joe Smith")

注意 Kotlin 没有new关键字。

  1. 继承
    Kotlin 中所有的类都有共同的父类Any ,它是一个没有父类声明的类的默认父类。Any不是 java.lang.Object;事实上它除了equals(),hashCode()以及toString()外没有任何成员了。
    声明一个明确的父类,需要在类头后加冒号再加父类:
open class Base(p: Int)
class Derived(p: Int) : Base(p)

如果类有主构造函数,则基类可以而且是必须在主构造函数中使用参数立即初始化。
如果类没有主构造函数,则必须在每一个构造函数中用 super 关键字初始化基类,或者在代理另一个构造函数做这件事。注意在这种情形中不同的二级构造函数可以调用基类不同的构造方法:

class MyView : View {
    constructor(ctx: Context) : super(ctx) {
    }
    constructor(ctx: Context, attrs: AttributeSet) : super(ctx,attrs) {
    }
}

open注解与java中的final相反:它允许别的类继承这个类。

  1. 复写方法
    像之前提到的,我们在 kotlin 中坚持做明确的事。不像 java ,kotlin 需要把可以复写的成员都明确注解出来,并且重写它们:
open class Base {
    open fun v() {}
    fun nv() {}
}
//继承
class Derived() : Base() {
    override fun v() {}
}

对于 Derived.v()来说override注解是必须的。如果没有加的话,编译器会提示。如果没有open注解,像 Base.nv(),在子类中声明一个同样的函数是不合法的,要么加override要么不要复写。在 final 类(就是没有open注解的类)中,open类型的成员是不允许的。
标记为override的成员是open的,它可以在子类中被复写。如果你不想被重写就要加 final:

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

问:

  1. 装箱拆箱?
    答:
    [装箱拆箱]http://www.cnblogs.com/IPrograming/archive/2012/08/23/CSharp_Boxing_UnBoxing.html
    装箱是值类型到引用类型或者这个值类型所实现的任何接口类型的隐式转换。 对值类型装箱会在堆中分配一个对象实例,并将该值复制到新的对象中。
int i = 123;
//值类型变成引用类型,装箱,隐式的
object obj = i;

拆箱从对象中提取值类型或者接口类型到实现该接口的值类型的显式转换。装箱时隐性的,拆箱是显式的。

int i = 123;
 //值类型变成引用类型,装箱,隐式的
object obj = i;
 //将从引用类型中提取值类型,拆箱,显式的
 int j = (int)obj;

装箱和拆箱对程序性能的影响
相对于简单的赋值而言,装箱和取消装箱过程需要进行大量的计算。 对值类型进行装箱时,必须分配并构造一个新对象。反之,拆箱所需的强制转换也需要进行大量的计算。所以在程序中应该尽量减少装箱和拆箱的操作。

推荐阅读更多精彩内容