Kotlin学习笔记（一）

var 与 val

/**
 *      可变变量 var
 *      var <标识符> : <类型> = <初始值>
 *
 *
 *      不可变量 val  类似 final
 *      val <标识符> : <类型> = <初始值>
 */
class Test {

    val name1:String ="A"

    var age = 18

}

编译之后的样子

public final class Test {
   @NotNull
   private final String name1 = "A";
   private int age = 18;

   @NotNull
   public final String getName1() {
      return this.name1;
   }

   public final int getAge() {
      return this.age;
   }

   public final void setAge(int var1) {
      this.age = var1;
   }
}

总结：

1. val修饰的可读，var修饰的可读可写
2. 都是静态语言，赋值后类型确定不能再修改（js是动态语言）

函数

fun <方法名> ： <返回值类型>{

}

几个例子

//  无返回值类型
fun result(){
    sout("")
}

//  有返回值的
fun add(num1: Int, num2: Int): Int {
    return num1 + num2
}

//  返回值类型推导
fun add(num1: Int, num2: Int) = num1 + num2

//  可变长 参数
fun lenMethod(vararg value: Int) {
    //  快捷键 value.for
    for (i in value) {
        println(value)
    }
}
//  使用
lenMethod(1,2,3,4)

//  lambda 表达式函数
val method:(Int,Int)->Int={num1,num2-> num1 + num2}
//  使用
var result = method(1, 2)

字符串模板

val name = "张三"
val age = 18
val sex = 'M'
println("name = $name , age = $age ,sex = $sex")

//  不用担心换行
val message="""
    aaaaa
    bbbbb
    ccccc
""".trimIndent()
println(message)

//  需求显示 $99.99
val price="""
    ${'$'}99.99
""".trimIndent()

运行结果

name = 张三 , age = 18 ,sex = M
aaaaa
bbbbb
ccccc

NULL 检查机制

//  
var info: String? = null

//  第一种补救：如果 info 为 null ，则 ？ 后面的不执行
println(info?.length)
//  第二种补救：！！ 保证一定不为 null ，如果为null会导致空指针异常
println(info!!.length)
//  第三种补救：跟java一样
if (info!=null) println(info)

//  如果你一定要输出 null ，就让你输出“你很牛逼”
print(info?.length ?: "你很牛逼")


//  ：Int？ === 允许返回 null
fun testMethod(name: String): Int? {
    if (name == "zs") {
        return 999
    }
    return null
}

区间

//  正序 1 到 9
for (i in 1..9){
    println(i)
}

//  倒叙 9 到 1
for (i in 9 downTo  1){
    println(i)
}

//  用区间做判断
var value =9
if (value in 10..20) {
    println("111")
}

比较两个值

val name1: String = "张三"
val name2: String = "张三"

//  == 等价于 java equals

printlin(name1 == name2)

// === 比较对象地址
val test1: Int? = 200
val test2: Int? = 200
//  比较的是 地址 ， ？有问号才有效，加了'?'是Integer，不加就是int---Integer有复用机制，太小返回的也是true
println(test1 === test2)

数组

    //  第一种形式
val numbers = arrayOf(1, 2, 3, 4, 5)
for (number in numbers) {
    println(number)
}

//  第二种形式
//  val number2 = Array(20,{value:Int-> (100 + value)})
val number2 = Array(20) { value:Int-> (100 + value)}
for (i in number2) {
    println(i)
}

条件 if 与 when

val num1 = 99
val num2 = 66

val max1 = if (num1>num2) num1 else num2

val max2 = if (num1>num2){
    println("num1 is max")
    //...省略200行代码
    num1
}else{
    println("num2 is max")
    //...省略200行代码
    num2
}

//   switch 的加强版 when
var value = 2
when (value) {
    1 -> println("111")
    2 -> {
        println("222")
        //...省略200行代码
    }
    3 -> println("333")
    else -> println("else")
}
when (value) {
    in 1..9 -> println(" in 1..9")
    in 10..100 -> println("in 10.100")
    else -> println("else")
}

//  根据返回结果的类型确定 result 的类型
val result = when (value) {
    1 -> {
        //...省略200行代码
        "66666"
    }
    2 -> {
        //...省略200行代码
        'M'
    }
    else -> {
        //...省略200行代码
        6666
    }
}

循环与标签

//  out@ 是自定义标签
out@for (i in 1..10) {
    for (j in 1..5) {
        println(" i = $i , j = $j")
        if (i == 5 && j == 2) {
            //  此处break会直接跳出所有循环
            break@out
        }
    }
}

class Miss{
    val I = "AAA"
    fun show() {
        println(I)
        println(this.I)
        //  系统定义的标签 
        println(this@Miss.I)
    }
}

//  集合 MutableList 是可变的，可添加的
var items: MutableList<String> = mutableListOf()

items.add("aaa")
items.add("bbb")

//  forEach 是遍历，item 是遍历时的 变量
items.forEach { item ->
    println( "item = $item ")
}


//  indices 的功能类似迭代器， 快捷键 items.indices.for
for (index in items.indices) {
    println("第 $index 位置的值是 ${items[index]}")
}

类与对象

构造方法 与 继承

//  Kotlin的class默认是public的，即 public final class Man , 不能被继承
//  主构造
class Man(id: Int){


    //  在 kotlin 中成员变量全都是没有默认值的
    //  在 Java 中成员变量是有默认值的，方法内部没有默认值
    
    //  lateinit 懒加载 没有赋值不能使用，否则报错
    //  lateinit 只能修饰 var
    lateinit var name: String
    var age: Int = 0
    
    //  次构造可以传给确定的值给主构造
    constructor() : this(11) {
        println("第一次构造")
    }

    //  次构造用主构造
    constructor(id: Int, name: String) : this(){
        println("第二次构造")
    }

    //  次构造最终还是会调用主构造
    constructor(id: Int, name: String, sex: Char) : this(id, name) {
        println("第三次构造")
    }

}


fun main() {

    //  执行一把
    val man = Man(5, "hh", 'c')
    
}

执行结果

第一次构造
第二次构造
第三次构造

接口

interface CallBack {
    fun callBack()
}

//  abstract 默认是 open的
abstract class Person : CallBack {

    abstract fun initView()

    abstract fun getName(): String

}

class Stud : Person() {
    override fun initView() {
        TODO("Not yet implemented")
    }

    override fun getName(): String {
        TODO("Not yet implemented")
    }

    override fun callBack() {
        TODO("Not yet implemented")
    }

}

数据类 == java 实体 Bean

//  可以生成 set、get、copy、tostring、equals、hashCode
//  val修饰的参数只可读 - get ，var 修饰的参数可读 - get、可写 - set
//  如果确定赋值后不再更改尽量使用 val ---- final 的好处
data class User(val id: Int, var name: String)

对应的Java类

public final class User {
   private final int id;
   @NotNull
   private String name;

   public final int getId() {
      return this.id;
   }

   @NotNull
   public final String getName() {
      return this.name;
   }

   public final void setName(@NotNull String var1) {
      Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
      this.name = var1;
   }

   public User(int id, @NotNull String name) {
      Intrinsics.checkParameterIsNotNull(name, "name");
      super();
      this.id = id;
      this.name = name;
   }
   // ------此处省略 200 行-----
}

单例类

object Engine {

    fun perform() {
        println("----")
    }

}


fun main() {
    // 使用  只会生成一次  单例
    Engine.perform()
    Engine.perform()
    Engine.perform()
}

转 java 代码实现看下

//  只要不是 open 修饰的都是不可继承的，都是 final 修饰
public final class Engine {
   public static final Engine INSTANCE;

   public final void perform() {
      String var1 = "----";
      boolean var2 = false;
      System.out.println(var1);
   }
    //  私有构造函数
   private Engine() {
   }

   static {
      Engine var0 = new Engine();
      INSTANCE = var0;
   }
}

-------- -------- 单例写法 No.1 -------- --------
java 写法

public class NetManager {

    static class Holder{
        private static NetManager INSTANCE = new NetManager();
    }

    public static Holder getHolder() {
        return getHolder();
    }

    public void show(String content) {
        System.out.println("content = " + content);
    }

}

kotlin 写法

class NetManager{

    object Holder{
        val INSTANCE = NetManager()
    }

    //  没有 static 操作 ， 可以用 派生
    companion object{

        //  内部的都相当于 Java static
        fun getInstance(): NetManager {
            return Holder.INSTANCE
        }
    }

    fun show(content:String){
        println("content = $content")
    }

}

-------- -------- 单例写法 No.2 -------- --------

懒加载模式

public class NetManager {

    private static NetManager instance;

    public static NetManager getInstance(){
        if (instance == null) {
            instance = new NetManager();
        }
        return instance;
    }

    public void show(String content) {
        System.out.println("content = " + content);
    }

}

kotlin 懒加载模式

class NetManager {

    companion object {

        private var instance: NetManager? = null

        fun getInstance(): NetManager {
            if (instance == null) {
                instance = NetManager()
            }
            //  此处需保证不为 null
            return instance!!
        }
    }

    fun show(content: String) {
        println("content = $content")
    }

}

内部类 与 嵌套类

class A{

    val a = "I"

    //  嵌套类 与 外部类 没有半毛钱关系
    class B {
        fun show(){
            //  拿不到外部类成员
            println(a)
        }

    }
    //  内部类
    inner class C{
        //  可以使用外部类
        fun show(){
            println(a)
        }
    }
}