Kotlin入门

Test.java -------Test.class-------JVM
Test.kt ----------Test.class-------JVM (编译再编译，编译较慢)

静态语言：编译期已确定。（js动态解释语言）

函数：一级公民。类外面也可以写

for循环自定义标签，嵌套循环停止：break@xxxx (@xxxx for(…))

kotlin全部变量都没有默认值；
java中成员有默认值，方法内部没有默认值

abstract 有open的特征

黄色—object----单例

嵌套类：
内部类：inner 可以拿到外层的变量值

@JvmStatic ：真静态方法

tools—>kotlin—>show kotlin byteCode : 查看kotlin对应的Java代码

//形参里面 java类
fun showClass(clazz: Class){}
//全部都是kotlin
fun showClass2(clazz:KClass){}

//调用
showClass(JavaStudent::class.java) //kotlin 和java交互 （JavaStudent是java类）
showClass2(KtStudent::class) //没有.java

方法隔离（java不能调用kotlin）： ``

fun `test`(){
  printf()
}

高阶函数：省略接口

fun show(num: Int, back:(Boolean)->Unit){
  num++;
  if(num == 2){
    back(true)
  }else{
    back(false)
  }
}
//调用
show(1){
  println(it)
}

//show中直接调用方法  ::  (变成函数类型的对象，进行参数传递)
fun myprintln(b: Boolean){
  println(b)
}
//调用
show(1, ::myprintln)

let/also/run…

//两个R  释义
fun  sum(n1: Int, n2:Int, mm:(Int, Int)->R):R{
  return mm(n1, n2)   //下面mm的返回值 true，  这里又返回给 sum函数
}
//调用
var s = sum(10, 20){i1,i2->
   println("$i1  $i2")
   "xxx"
   true    //最后一个返回的值，就是mm的返回值
}
println(s) //打印的是mm的返回值，  层层返回到最外层。

//泛型 扩展函数
fun  T.test(){
  //...
}
fun main(){
  val name = "a"
  val age = 10
  //调用
  name.test()
  age.test()
}


//'T.(String)->T'    给T增加匿名函数，返回是this    ===>对象本身，可以直接调用方法:xxx()
fun  T.mylet2(mm: T.(String)->R):R{
  return mm("")
}
//'(String)->T'      匿名函数，返回是it    ===>对象it，调用方法:it.xxx()
fun  T.mylet(mm: (String)->R):R{
  return mm("")
}

out/in (? extend/? supper : 1.上限下限；2. 能否获取/能否修改)

out/in：与上下限无关。

out =====> 不能修改，只能获取（? extend）
in =====>…

**示例一：**基础

fun main() {
    val stu2 =  Student2(4545, "Derry", 'M')
    val (v1, v2, v3) = stu2.copy()
    //自定义解构赋值
    val stu =  Student(4545, "Derry", 'M')
    val(n1, n2, n3 ,n4) = stu

    stu.show("")

    `123`()
    showClass(KtStudent::class)
    showClass2(Thread::class.java)

    val instance = SingleInstance.getInstance()
    specialStr()
    lenMethod("222","333","444")
}

//扩展函数
fun Student.show(string: String){
    println(string)
}

//自定义解构赋值
data class Student2(var id: Int, var name: String ,var sex: Char)
class Student(var id: Int, var name: String ,var sex: Char){
    // component 不能写错
    operator fun component1(): Int = id
    operator fun component2(): String = name
    operator fun component3(): Char = sex
    operator fun component4(): String = "KT Study OK"

    //运算符重载   student + student
    operator fun plus(num: Int): Int{
        return id + num
    }

}

//特殊名称方法
fun `123`(){
    print("xx")
}

//kotlin类 KtStudent
fun showClass(clazz: KClass){}
//java类  thread
fun showClass2(clazz: Class){}
class KtStudent{}


fun lenMethod(vararg names: String){
    names.forEach {
        println(it)
    }
}

fun specialStr(){
    // --- 自己不用关系 n 换行 ，不用自己调整
    val infoMesage = """
        AAAAAAAAAAA
        BBBBBBBBBBB 
    """  // 前置空格
    println(infoMesage)

    val infoMesage2 = """
        AAAAAAAAAAA
        BBBBBBBBBBB 
    """.trimIndent()  // 没空格
    println(infoMesage2)

    val infoMesage3 = """
        ?AAAAAAAAAAA
        ?BBBBBBBBBBB 
    """.trimMargin("?")  // 没空格 控制|
    println(infoMesage3)

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

fun forMethod(){
    for(i in 1..10){
        println(i)
    }
    for (i in 9 downTo 1){
        println(i)
    }
    for (i in 1 until 30 step 2 ){
        println(i)
    }
}

fun forTag(){
    //自定义标签
    aaa@for ( i in 1..10){
        for (j in 1..10){
            if(j == 3){
//                break//停止最近循环
                break@aaa
            }
        }
    }
}

fun otherMethod(){
    // ---  比较对象地址
    val test1:Int? =  10000
    val test2:Int? =  10000
    println(test1 === test2) // false

    val num = if (test1 == 1) {
        false
    } else {
        true
    }

    when (test1) {
        1000 -> println("sss")
        in 1..20 -> println("222")
    }
}


class Person(id: Int){//主构造
    //次构造
    constructor():this(-1){}
    //次构造
    constructor(id: Int, name:String):this(id){}
}

class Sub{
    val num: Int = 1
    //嵌套类
    class Sub1{
//        val s = num
    }
    //内部类
    inner class Sub2{
        val s = num
    }

}

class SingleInstance{
    //object 单例
    object Holder{
        val instance = SingleInstance()
    }
    companion object{
        //对外提供方法
        fun getInstance() = Holder.instance
    }
}

示例二：函数高级

fun main() {
    val name: String? = null
    testMethod().myRunOk {
        //回调方法是泛型的
        true
    }
    //方法体返回的是 this:String， 因为 '万能泛型.'
    name?.myRunOk {
            it-> print(it)
        print("$length")
        false
    }
    //方法体里面没有对象
    name.myRunOk2 {
        it-> print(it)
        true
    }

    //`::` 拿到函数类型的对象
    val m1 = ::testMethod
    test01(m1)

    //无限链式调用
    name.myAlso {

    }.myAlso {

    }.myAlso {

    }

    ktrun() {
        println("执行了一次 x")
    }
}


fun testMethod(){
    print("xxx")
}

fun test01(mm: ()->Unit){
    mm()
}

// 自定义线程封装
fun ktrun(
    start: Boolean = true,
    name: String ? = null,
    myRunAction: () -> Unit) : Thread {
    val thread = object : Thread() {
        override fun run() {
            super.run()
            myRunAction()
        }
    }
    name ?: "DerryThread"
    if (start)
        thread.start()
    return thread
}


fun <万能泛型> 万能泛型.myRunOk(mm: 万能泛型.(Int)->Boolean){
    mm(10)
}
fun <万能泛型> 万能泛型.myRunOk2(mm: (Int)->Boolean){
    mm(10)
}
//R：返回泛型
fun  T.myRun(mm: ()->R):R{
    return mm()
}
fun  T.myLet(mm: T.(T) -> R): R {
    // T == this   () -> R
    // mm(this) == this     vs    T.(T)  -> R
    return mm(this)
}

//返回this， 可以无限链式调用
fun  T.myAlso(mm: (T) -> Unit) : T{
    // T == this
    // it == T == this == name
    mm(this)
    return this
}

示例三：(out 只能取，不能修改。in 只能修改（存），不能获取)

fun main() {
    println("111")
    //out 只能取，不能修改   == ? extends FuClass
    val list: MutableList = ArrayList()
    //in 只能修改（存）， 不能获取   === ？ super ZiClass
    val list2:MutableList = ArrayList()
}

open class FuClass{}
class ZiClass: FuClass(){}


class TestClass {
    fun getData(): T? = null
//    fun setData(data: T){}   //报错
}

class TestClass2 {
//    fun getData(): T? = null //报错
    fun setData(data: T){}
}



===============================
public class Simple03ExtendSupper {

    public static void main(String[] args) {
        System.out.println("xxx");
        FClass fClass = new FClass();
        ZClass zClass = new ZClass();

        //1
        ArrayList list = new ArrayList();
        list.add(fClass);
        list.add(zClass);
        list.get(0);
        //2  不能修改， 只能获取
        ArrayList list2 = new ArrayList();
//        list2.add(fClass);//报错   不知道FClass的 子是谁
//        list2.add(zClass);//报错   不知道FClass的 子是谁
        FClass c = list2.get(0);
        //3  不能获取， 只能修改
        ArrayList list3 = new ArrayList();
        list3.add(zClass);
//        FClass c2 = list3.get(0);//报错   不知道 ZClass 的父是谁
//        ZClass c3 = list3.get(0);//报错   不知道 ZClass 的父是谁， 只能强转

    }
    static class FClass{}
    static class ZClass extends FClass{}
}

Kotlin入门

Java相关栏目本月热门文章