kotlin相比java的区别和优势_kotlin和java的区别

一、在Android项目中开发，以前会有java开发，现在官方推荐使用kotlin。那么kotlin相比java到底有那些优势呢？往下看

二、类，方法，变量的区别

1.类定义：

Java中 继承类用关键字extends，实现接口用关键字implements 例如：

public class User extends A implements B , C{ }

构造方法

public User(){}
 
public User(String name){
    this.name = name
}

创建对象 User user = new User()

konlin中 继承类和实现接口都用：例如：

class User : A , B , C{ }

构造方法

class User(){
 constructor(name:String) : this()
}
class User(name:String)
class User(val name:String)

创建对象 val user = User()

2.方法定义：

Java中 

public Sting getName(){}
 
public void setName(Sting name){}

konlin中 

fun getName():String{}
 
fun setName(name:String){}

3.变量的定义：

java中

private static final String TAG = "tag";
 
private String name;

konlin中静态变量和静态方法需要在companion object {}中定义。变量中用var修饰代表可变，用val修饰代表不可变。

 companion object {
        private const val TAG = "tag"
    }
 
private var name:String?=null
 
private val user: User by lazy { User() }

三、判空的处理

当一个类型后面加？代表变量可以为null。当调用变量时，需要加?或者!! 例如：

定义private var name:String?=null

调用 name?.toString() 表示如果name为null,不会调用toString()方法，直接返回null。

name!!.toString() 表示name强制不会为null。但是当name为nul时，调用会报空指针

name?:"默认值"  表示如果name为null，则返回默认值

四、扩展函数

fun String.toRequestBody(): RequestBody {
    val map: HashMap<String, String> = HashMap()
    map["ids"] = this
    return RequestBody.create(
        "application/json; charset=utf-8".toMediaTypeOrNull(),
        Gson().toJson(map)
    )
}

对String类添加toRequestBody()方法，类似于java中继承String类，然后添加一个toRequestBody()方法。konlin中对字符串，集合添加了很多扩展函数，用起来非常方便。

五、高阶函数

1.方法体的定义和传递。相等于java中的接口，然后接口中有一个方法

private var func: ((Int) -> Unit)? = null
 
fun setListener(func: ((Int) -> Unit)?){
    tihs.func = func
}

2.自带的高级函数

public inline fun <T, R> T.let(block: (T) -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block(this)
}
 
public inline fun <T> T.also(block: (T) -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block(this)
    return this
}
 
public inline fun <T, R> T.run(block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}
 
public inline fun <T> T.apply(block: T.() -> Unit): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    block()
    return this
}

六、协程

        kotln中协程相当于java中的线程，但是比线程轻量级，而且调用简单，还可以挂起

//常用的CoroutineScope
1.val job = GlobalScope.launch {
    // 协程逻辑
}
 
2.val job = lifecycleScope.launch {
    // 协程逻辑
}
 
3.val job = viewModelScope.launch {
    // 协程逻辑
}
 
4.val scope = MainScope()
scope.launch(Dispatchers.IO) {
         // 处理业务
         delay(500)
         // 处理业务
      }
 
 
5. val scope = CoroutineScope(Dispatchers.Main)
 
6.val scope = CoroutineScope(CoroutineName(TAG))

七、其他

1.kotlin中没有三元判断符，但是可以直接用 if else

var name：String?=null
val result = if(name =="哈哈") 1 else 2