Kotlin笔记

2018-08-05 本文已影响10人金馆长说

函数

kotlin 函数以fun来标识,使用方式和java一样，同一类使用直接调用，如果是通过类引用则使用 '类名.model()' 来引用

fun mode(){
        //...
    }

当前类使用

 var value = model()

其他类

类名.mode()

根据返回的值自动推断类型 return string Type

fun model() = "jinwei" + 20

根据返回的值自动推断类型 return int Type

 fun model2() = 32

等价于 fun model3()

fun model3() = Unit

变量

 fun test() {
        // 创建一个 Array<String> 初始化为 ["0", "1", "4", "9", "16"]
        val asc = Array(5) { i -> (i * i).toString() }


        //初始化string数组，只有一个元素
        val arrayOf = arrayOf(String)
        //初始化MainClass数组，只有一个元素
        val arrayOf1 = arrayOf(MainClass)

        //指定大小，元素为null的数组
        val arrayOfNulls = arrayOfNulls<String>(size = 2)
    }

字符串

fun stringTest() {
        val s = "Hello, world!"
        println("$s.length is ${s.length}") // 输出“abc.length is 3”
    }

区间

0..10执行0-10直接的数

 for (item in 0..10) {

        }

倒序
执行4-1之间的数

for (i in 4 downTo 1) print(i)

step
step 3代表每隔3打印一次打印124

 for (i in 1..10 step 3) println(i)

要创建一个不包括其结束元素的区间，可以使用 until 函数

        for (i in 1 until 10) {
            // i in [1, 10) 排除了 10
            println(i)
        }

对象表达式
类似于java中的匿名内部类

       //这是一个对象
        var a = object {
            fun create() {}
        }

        object C {}

伴生对象
这是一个伴生对象，可以直接通过类名来使用A内部的方法和变量

    companion object A {
          fun create() {}
      }

数据类
数据类通过data 来标识类，特有以下特点。
编译器自动从主构造函数中声明的所有属性导出以下成员：

equals()/hashCode() 对；
toString() 格式是 "User(name=John, age=42)"；
componentN() 函数按声明顺序对应于所有属性；
copy() 函数（见下文）。

data class JinBean(var name: String, var age: Int) {}

普通对象是不会具有这类特性的。

            var data = JinBean("JINWEI", 20)
            var data2 = data.copy()
            data2.age = 22
            println(data.toString())
            println(data2.toString())

输出 20
输出 22
通过copy没有影响到对方的值，如果没有data的话。这里的输出会是一样的，因为他们指向的引用到是同一个对象。

内部类

 class TT2 {

        var aa = 220

        //内部类无法访问外部成员
        class tt2 {
            fun m2() {
//                aa = 20////无法访问
            }
        }


        //inner标记的类会带有一个外部类对象的引用，可以访问外部成员。
        inner class tt3 {

            fun m2() {
                aa = 20
            }
        }
    }

解构

定义一个实体类

 data class P2(var age: Int, var name: String) {

        var number = 2

        operator fun component3(): Int {
            return number
        }
    }

解构声明,意思就是通过var(x,x) = p的方式把对象的构造参数，通过拆解的方式单独声明一个变量。

  var pp: P2 = P2(20, "jw")
  var (age, name) = pp
  println(age)
  println(name)

在Kotlin-数据类中，我们已经了解到编译器会根据主构造器中声明的全部属性, 自动推断产生componentN() 函数群, 这些函数与类的属性对应, 函数名中的数字1到N,与属性的声明顺序一致
解构声明在编译时将被分解为以下代码:

val name = person.component1()
val age = person.component2()

解构for循环

            var p1 = P2(20, "jw")
            var p2 = P2(20, "jw")
            var p3 = P2(20, "jw")
            val listOf = listOf(p1, p2, p3)
            for ((name, age) in listOf) {
                println("age=$age name=$name")
            }

自定义componentN，默认解构只会解构造函数里面的变量，如果需要解构我们自己的成员变量，就需要自定义了。
对于自定义的componentN()，需要注意以下几点：

componentN()函数需要标记为 operator , 才可以在解构声明中使用
componentN()函数的返回值类型必须与属性类型一致

  var p4 = P2(20, "jw")
  p4.number = 200
  var (name, age, sex) = p4
  println("age=$age name=$name number$sex")

           var p11 = P2(210, "jw")
            var p22 = P2(210, "jw")
            var p32 = P2(210, "jw")
            val mutableMapOf = mutableMapOf<String, P2>()
            mutableMapOf.put("1", p11)
            mutableMapOf.put("2", p22)
            mutableMapOf.put("3", p32)
            for ((age, name) in mutableMapOf) {
                println("age=$age name=$name ")
            }

安全类型转换
如果对象不是目标类型，那么常规类型转换可能会导致 ClassCastException。另一个选择是使用安全的类型转换，如果尝试转换不成功则返回 null：

 var v1: String? = ""
 var v2: Int? = v1 as Int

这样转换会出现异常
Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
    at kt.JAVA2$Companion.main(JAVA2.kt:57)
    at kt.JAVA2.main(JAVA2.kt)

使用安全转换

 var v1: String? = ""
 var v2: Int? = v1 as? Int

as?这样转换不会报错，会返回null。

Kotlin笔记

函数

变量

标签

猜你喜欢

热点阅读