kotlin 尝试

[toc]

为什么

想体验一下java上的函数式编程，然后lambda真的很 难用呀，不科学的东西。 然后就看了一下jvm上一篇的东西，发现kotlin还不错

函数式编程

在函数式语言中，函数作为一等公民，可以在任何地方定义，在函数内或函数外，可以作为函数的参数和返回值，可以对函数进行组合。 纯函数式编程语言中的变量也不是命令式编程语言中的变量，即存储状态的单元，而是代数中的变量，即一个值的名称。

函数作为一等公民，可以当函数的参数，和返回值

@Test
    fun ko(){
        println("fdsa")
       // println(my1("jia"))
       // my2 是函数my1的参数,在my1 中调用了两次
        my1{my2()};
        // my4 是函数my3的参数,在my3中使用 x(),x()调用了两次,还可以加参数
        my3 { my4("my4") }
    }

    fun my4(x : Any ){
        print(x)
    }
    fun my2(){
        print("my2")
    }
    fun my1(x: () -> Unit) {

        println("dao zhe li")
        x()
        x()

    }

    fun my3(x:(a : String) -> Unit){

        x("wocao")

        x("wocao")
    }

语法

函数

fun name(参数名: 类型):返回值类型{
  var 可变变量
  val 不可变变量
  kotlin可以推测出变量类型,所以一般
  var jia =1 //这样也是可以的
  返回类型 return
}

• 在变量名前加vararg 表示可变变量, (vararg a: Int)
• lambda(匿名函数) val lam: (Int,Int) -> Int = {x,y -> x+y} 使用lam(2,3)
• 字符串模板: $+name 表示替换其值 ${nmae.function}字符串返回的值进行替换 (语法糖)

NULL检查

这个是空安全机制,对于声明可以使用?

数据结构

Int,
Double
Flout
Shout
Byte
Long

• 在 Kotlin 中，三个等号 === 表示比较对象地址，两个 == 表示比较两个值大小。

条件控制

• 感受一下这个控制及返回的值,不用写 result = a, result = b;

var result = if(a>b){
    print(a)
    a
}else {
print(b)
b
}

• 区间
  使用 小 .. 大即可
  if( a in 1..10){println(a)}
• when: 将它的参数和所有的分支条件顺序比较 类似于switch. 条件 -> 操作, else -> 操作;
  else类似于default操作
  条件: is “string” , in 区间 , 函数返回true 或 false 都可以当条件
• for (item in items): 感觉和迭代器类似
• while (boolean) {}
• return
• break
• continuue

类与对象

class MyClass{
  var name: String
  var id : Int

}
// 空类也行
class EmptyMyClass;

// 对象: kotlin没有new 所以使用如下
var wo = MyClass(); //这样即可
//变量操作使用
wo.name =""
wo.id=123

// 构造器
//主构造器
class Person construct(参数: 类型,firstName: String){
    //使用init 来对构造器进行赋值或者声明的时候就可以了
    var jia=firstName
    init{
    jia=firstName
    }
class Student(){
  constructor(name: String ,age:Int):this(name){
  // 初始化
  }
}
}
//抽象是面向对象编程的特征之一，类本身，或类中的部分成员，都可以声明为abstract的。抽象成员在类中不存在具体的实现。注意：无需对抽象类或抽象成员标注open注解。
// 抽象类 ，目前不是很懂这个语法糖的意义
open class Base {
    open fun f() {}
}

abstract class Derived : Base() {
    override abstract fun f()
}

测试的例子

 class Jia{
            var name:String =""
            var id : Int =123
            init {
                println("init start")
            }
        }
        var jia=Jia();
        jia.name="shen";
        jia.id=143345

        class Person(name : String){
            var name=name
        }
        var jia1=Person("wocao")
        println(jia1.name)

        class Person1{
            var name:String ="ddd"
            constructor(name: String){
                this.name=name
            }
        }

内部类

inner声明即可
class Jia{ inner class Jun{}} 使用: var long = Jia().Jun()

修饰符

final // 类不可继承，默认属性
enum // 枚举类
open // 类可继承，类默认是final的
annotation // 注解类

private // 仅在同一个文件中可见
protected // 同一个文件中或子类可见
public // 所有调用的地方都可见
internal // 同一个模块中可见

继承

Kotlin 中所有类都继承该 Any 类，它是所有类的超类，对于没有超类型声明的类是默认超类：
有三个函数 equale， hashCode（），toString（）

• > 如果一个类要被继承就要使用 open修饰一下 然后继承就是class Derived (p : Int): Base(p)

接口

接口中的属性只能是抽象的，不允许初始化值，接口不会保存属性值，实现接口时，必须重写属性：
interface MyInterface{ fun jia() fun jun()}

感受

就是多了很多语法糖，因为完全兼容java，所以jave很多东西都一样，然后就是函数式编程了这个不错