Kotlin与java的纠缠史

1. 背景

Jetbrains早在2010年推出Kotlin,在今年(2017)5月18,谷歌在今日举行的I/O开发者大会上宣布,将Kotlin语言作为安卓开发的一级编程语言,这个可爱的语言可于Java进行无缝混编。之前做过一段时间的C#和python开发,感觉三者之间总两两相似,不清楚是谁在模仿谁,谁在吃着谁的语法糖。

2. 差异与对比

2.1 构造器

java Kotlin
构造器 主构造器
- 次构造器
  • java版:
public class Model {

    public Model(){}

    public Model(String name){}
}
  • Kotlin版:
    • 主构造器
class KtModel constructor(name: String)

ps:如果不私有化构造器或者注解构造器,constructor可以省略,即:

 -> class KtModel (name: String)

由于Kotlin主构造器写法的出现,可以简化Java中JavaBean,关键字:data

data class KtModel(var id: Int, var name: String)
  • Kotlin版
    • 次构造器
class Model{
    var mName:String? = null
    constructor(name:String){
        mName = name
    }
}

//由于Kotlin中有参数缺省写法,比如:
class Model{
    var mName:String? = null
    constructor(name:String,age:Int = 0){
        mName = name
    }
}

//在java中实例化这个Model还是需要:
Model model = new Model("Inke",20)

//为了让java也享受到这个福利,Kotlin支持@JvmOverloads注解,为Java重载构造器
class Model{
    var mName:String? = null
    @JvmOverloads
    constructor(name:String,age:Int = 0){
        mName = name
    }
}

//此时:java调用
Model model = new Model("Inke",20);
Model model = new Model("Inke");

2.2 自定义setter和getter

由data声明的javabean默认实现了getter方法,如果变量为var类型也同时实现了getter方法,并且像equal() hashcode() toString()方法也自动复写了。除此,也支持自定义setter和getter方法,写法和c#的方式一样。

class Student(var name: String, var grade: Int) {

    // Kotlin中的enum
    enum class LEVEL {GOOD, JUSTSOSO }
    //默认规则赋值
    var level: LEVEL = if (grade > 90) LEVEL.GOOD else LEVEL.JUSTSOSO
        set(value) {
            field = value
        }
        get() = field
}
ps: 通过field代表set get的属性

2.3 条件筛选

java中对某一字段类型根据不同的值进行筛选,同使用Switch“语句”,如:

switch (itemViewType) {
            case ITEM_VIEWTYPE_LINKMSG:// 带有link字段的链接消息
                return new LinkMsgViewHolder(inflater);
            case ITEM_VIEWTYPE_TEXTMSG_BYME:// 自己的文本消息
                return new TextMsgByMeViewHolder(inflater);
            case ITEM_VIEWTYPE_TEXTMSG_BYOTHER:// 别人的文本消息
                return new TextMsgByOtherViewHolder(inflater);
            case ITEM_VIEWTYPE_PIC_MSG_ME:// 自己的图片消息
                return new PicMsgByMeViewHolder(inflater);
            case ITEM_VIEWTYPE_PIC_MSG_OTHER:// 别人的图片消息
                return new PicMsgByOtherViewHolder(inflater);
            case ITEM_VIEWTYPE_AUDIO_MSG_ME:// 自己的语音消息
            ...
            }

kotlin中对某一字段类型筛选的关键字when,但它不属于语句,它属于表达式,真的是表达式哦。

fun getWeekInfo(day: Int): String {
    //因为是函数 所以可以直接使用在return后面
    return when (day) {
        1, 2, 3, 4, 5 -> "工作日"
        6, 7 -> "周末"
        else -> "unknow"
    }
}

在Kotlin中几乎一切都是表达式,所以上面更有简化版:

fun getWeekInfo(day: Int) = when (day) {
        1, 2, 3, 4, 5 -> "工作日"
        6, 7 -> "周末"
        else -> "unknow"  //与java的default不能,else必须写,除非密封类(sealed class)可以不写,后面会详细讲解。
}

难道仅仅这些就够了,错,还有厉害的!前方高能。

fun getWeekInfo(student: Student) = when {
    student.name.equals("马云") -> "考什么试!"
    student.grade >= 60 -> "Pass"
    student.grade < 60 -> "fail"
    student is Student -> "is 相当于 instanceof"
    else -> "unknow"
}

1. when可以不一定带参数,就使用方法参数
2. when中的条件不需要同一种方式判断,只需要返回boolean类型

2.4 循环结构

语言 次数迭代 对象池迭代
java 支持 支持
kotlin 强支持 支持

java版本两种循环方式的写法

for (int i = 0; i < 10; i++) {
        //TODO
    }

for (String arg : args) {
        //TODO
    }

kotlin版本,与python写法相似

// 次数迭代
for(i in 1..10){  //[1,10]区间往上遍历
        print(i)
    }

for(i in 10 downTo 1){ // [1,10]区间往下遍历
        print(i)
    }
    
for(i in 1 until 10){ // [1,10)区间往上遍历
        print(i)
    }


for(i in 1..10 step 2){ //设置步数往上走
        print(i)
    }
    
    
    
//对象池迭代
for (arg in args){
        print(arg)
    }

2.5 引入静态方法

引入静态方法的目的:

java Kotlin
工具方法 类的扩展

引入方式:

  • java: import static com.meelive.ingkee.base.utils.guava.Preconditions.checkArgument;
  • Kotlin: import com.inke.utils.showToast

静态方法的写法

  • java:纯工具类的写法
  • kotlin:
fun Context.showToast(message: String) : Toast {
    var toast : Toast = Toast.makeText(this,message,Toast.LENGTH_SHORT)
    toast.setGravity(Gravity.CENTER,0,0)
    toast.show()
    return toast
}

作为Context类的拓展方法,在Activity,Service中,可以直接使用,面向对象的封装性显得更加的严实(个人看法)。

2.6 类型转换

java中对于类型的转化,写的特别想吐的语句如下:

Person p = new Person();
if(p instanceof Student){
    Student student = (Student) p;
    String id = student.uid;
}

然后看看Kotlin的模仿版:

val p = Person()
if (p is Student) {
    val student = p as Student
    var uid = student.uid
}

瞪大眼睛看看简化版,找不同的时间到了!

val p = Person()
if (p is Student) {
    var uid = p.uid
}

is 进行判断后,Person类实例就已经装成Student类实例了,这就是Kotlin的智能类型转化。

2.7 单例

  • java版单例(懒汉式和饿汉式),懒汉式如下:
public static RoomManager ins() {
    return SingletonHolder.INSTANCE;
}

private static class SingletonHolder {
    private static final RoomManager INSTANCE = new RoomManager();
}
  • kotlin版
class AppManager private constructor(var info: String) {
    companion object {
        private var INSTANCE: AppManager? = null
        fun getInstance(info: String): AppManager {
            if (INSTANCE == null) {
                synchronized(AppManager::class.java) {
                    if (INSTANCE == null) {
                        INSTANCE = AppManager(info)
                    }
                }
            }
            return INSTANCE!!
        }
    }
    
    fun getPhoneInfo(arg: String): String? {
        return null
    }
}

如果是无参单例,有更为简单的写法

/**
 * Created by YangLang on 2017/7/29.
 */
object AppManager {

    fun getPhoneInfo(arg: String): String? {
        return null
    }
}

2.8 正则表达式

  • java的写法
String info = "12,34,56.789";
String[] split = info.split("[,.]");
for (String s : split) {
    System.out.println(s);
}

java默认使用正则去切割
  • Kotlin写法
 var info = "12,34,56.789"
    for (s in info.split(",",".")) {
        println(s)
    }
    
kotlin 为了编程更加口头化,生活化,默认不使用正则,上面写法的理解是,把info用","或者"."进行分割。

//进一步说明
info.split(".")
1. 在java中输出为空,因为.在正则规则中为统配符
2. 在kotlin中输出为12,34,56和789,因为Kotlin默认不使用正则,所以.只是一个普通的字符。

2.9 嵌套类和内部类

说明: 嵌套类不含有外部类的引用,内部类拥有外部类的引用,正因为这样,也可以造成Activity没有释放,而内存泄漏问题。

  • java
public class Outter {

   //包含Outter类的引用,可以使用Outter的方法
    class Intter{}

    // 不包含Outter类引用,不能使用Outter的方法
    static class NotIntter{}
}
  • Kotlin
class Outter {

    inner class Intter

    class NotIntter
}

java默认为内部类,Kotlin默认为嵌套类,一定程度的避免造成内存泄漏无意识写法。

2.10 密封类

密封类的概念和C#一样,密封类可以被继承,但本身不能被实例化。所有的子类必须在同一文件中,相当于把密封类的子类都封装在一块,可以配合when使用。

sealed class BaseModel{}
class FirstModel:BaseModel(){}
class SecondModel:BaseModel(){}
fun justDo(baseModel: BaseModel) = when(baseModel){
    is FirstModel -> ""
    is SecondModel -> ""
}

没有使用else,但是必须要写全baseModel的子类,如果编写期间新创建一个类继承BaseModel,此处when直接报错,密封类的这种特性,保证编写when表达式时,可以无一疏漏的考虑到每一种情况,约束代码的编写。

2.11 代理

代理方式\语言 java Kotlin
静态代理
动态代理
属性代理 ×
标准代理 ×

这里不讲java的设计模式,主要关注Kotlin的代理模式,从类代理、属性代理、标准代理三个方面

  • 类代理

假如我们需要创建AnimatorListener的实例,Java中最常见的方式可能是匿名内部类,我们需要重载它的四个方法,虽然我们不都用,这样代码就显得多余。Kotlin中就可以用该接口得一个实现类代为重载,并处理自己的TODO。

class MyAnimatorListener(var animatorListener: Animator.AnimatorListener):Animator.AnimatorListener by animatorListener{

    override fun onAnimationEnd(animation: Animator?) {
        //TODO 可以进行预处理
        animatorListener.onAnimationEnd(animation)
    }
}

接口Animator.AnimatorListener需要的方法由传入参数animatorListener实现了,该MyAnimatorListener也通过关键字by,将需要实现的方法让animatorListener代为实现,重载方法后可以做预处理操作。
  • 属性代理

当使用val修饰属性时,表明属性为不可修改,代理类继承ReadOnlyProperty<被代理类,类型>类

当使用var修饰时,属性可修改,代理类继承ReadWriteProperty

/**
 * Created by YangLang on 2017/7/29.
 */
fun main(args: Array) {
    var p = Person("inke", 21)
    println("是否已经成人: ${p.isAdult}")
}

class Person(var name: String, var age: Int) {

    var isAdult: Boolean by isAdultProperty()
}

class isAdultProperty : ReadWriteProperty {
    override fun setValue(thisRef: Person, property: KProperty<*>, value: Boolean) {
    }

    override fun getValue(thisRef: Person, property: KProperty<*>): Boolean {
        return thisRef.age > 18
    }
}
  • 标准代理

Kotlin标准代理有lazy(),observable(),notNull().. 所有这样Kotlin自建代理都在delegates类下,主要讲lazy(懒加载) 在java中使用supplier和suppliers进行懒加载(延时求值),在kotlin中通过方法lazy直接延时求值,更快更强!!

class InfoConfig {
    val info: String by lazy {
        "Inke info"
    }
}

fun main(args: Array) {
    print(InfoConfig().info)
}

第一次获取info值时,会通过lazy函数传入的函数参数进行求值,以后再获取该值时,直接返回,所以懒加载可进行复杂计算。

2.12 属性赋初值问题

属性不管申明为val还是var都必须赋初值,我们只能被迫写成 var info:String? = null。但是实际情况下有些属性不允许赋予无意义的初值如null,我总结有三种方式处理(可能不全面):

  • lateinit var info: String(只能用在var类型上)
  • class Student(var name: String, var age: Int){ val isAudit = age > 18} (可用在var或者val上,但只是在初始化时赋一次值~)
  • val info: String by lazy {
    "Inke info"
    } (只能用在val类型上)

2.13 lambda的概要(对象引用,数组用法)

用lambda表达式创建函数“变形体”

 var add = { x: Int, y: Int -> x + y }
 print(add(1,2))

lambda缩写演史

// 1. 匿名内部类
rb_home.setOnClickListener(object:View.OnClickListener{
            override fun onClick(v: View?) {
            }
})

// 2. 如果内部类中只有一个方法,缩写成lambda表达式
 rb_home.setOnClickListener({v -> Unit})
 
// 3. 如果函数参数最后一个参数为lambda表达式,可以提取放在函数参数括号外面
 rb_home.setOnClickListener(){v -> Unit}
 
 // 4. 如果函数参数括号为空,可以省略
 rb_home.setOnClickListener{v -> Unit}
 
 // 5. 如果lambda表达式形参咩有使用,可以省略
 rb_home.setOnClickListener{Unit} <==> rb_home.setOnClickListener{//TODO}

可以根据以上的省略原则可以定义我们自己的的函数。如在java中做版本的判断,我们会写:

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
    webSettings.setAllowUniversalAccessFromFileURLs(true);
}

这样写起来不流程,而且不易复用

Kotlin上面可以这样定义函数

inline fun UP_VERSIONJELLY_BEAN(function: () -> Unit){
    if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEA){
        function()
    }
}

在使用时,可以毫不犹豫的写成这样:
UP_VERSIONJELLY_BEAN{
    //TODO
}

2.14 反射中优质提升

public class Test {

    public Test() {}
}

以上的泛型写法,在java中运行时由于类型擦除的原因,无法确定T的类型,很难获取该对象的字节码对象,不过在早两天看到Guava支持运行时获取泛型类型,通过TypeToken工具类。但是在Kotlin可以轻松解决这样问题,通过标注关键字reified。

  • TypeToken
  • reified关键字使用
inline fun  Activity.newIntent() {
    val intent = Intent(this, T::class.java)
    startActivity(intent)
}

2.15 let apply run with的区别

传送门地址

你可能感兴趣的:(Kotlin与java的纠缠史)