Kotlin入坑基础篇二

Kotlin入坑基础篇一

这一篇主要讲解kotlin进阶，内容主要有以下：
空安全
kotlin单例
函数扩展
智能转换

空安全

Kotlin中添加了对空的保护

fun testKotlinNPE() {
        var s: String = "Hubery"
        s = null//会导致编译不过
        var s2: String? = "Hubery"
        s2 = null//s2可以为空，能够编译通过

        print(s.length)//因为不为空，所以直接调用length不会出现异常

        print(s2.length)//编译不通过，会要求添加?.或者!!.进行调用
        print(s2!!.length)//编译能够通过，不过s2如果是null，那么将会导致调用length的时候出现空指针
        print(s2?.length)//使用安全操作符，如果s2为null，那么就不会调用length，也就不会导致异常，不过需要注意的是s2?.length可能整体为null；如果别的地方使用需要注意

        //Elvis操作符   
        val i = s2?.length ?:0//如果s2为空，那么就不会调用.length方法，而直接返回右边的0
    }

使用Elvis操作符，可以val i = s2?.length ?:0如果s2为空，那么就不会调用.length方法，而直接返回右边的0。

kotlin单例

我们都知道单例分为懒汉式与饿汉式，同时可以对单例进行线程同步等；
我们先来看看一个java的例子：

/**
 * Created by hubery on 2018/7/18.
 * 饿汉模式
 */
public class DemoSingleton {
    private static DemoSingleton INSTANCE = new DemoSingleton();

    public static DemoSingleton getInstance() {
        return INSTANCE;
    }
}

上面展示的例子就是java的饿汉式模式；那么kotlin的饿汉模式是怎么样的呢？

/**
 * Created by hubery on 2018/7/18.
 * kotlin的恶汉模式
 */
object DemoSingleton

没有看错就只有一句话，关键字object修饰。当然这里因为类里面没有方法因此省略了{},因为懒汉式是非线程安全的，多线程中使用可能会出现创建多个对象，因此，我们需要用到懒汉式单例，我们把上面的例子稍微改造一下：

public class DemoSingleton {
    private static DemoSingleton INSTANCE;

    public static DemoSingleton getInstance() {
        if(INSTANCE == null){
            INSTANCE = new DemoSingleton();
        }
        return INSTANCE;
    }
}

上面的java例子也就相比之前的饿汉式多了一个null的判断，再看看kotlin的实现：

/**
 * Created by hubery on 2018/7/18.
 * kotlin的懒汉式单例
 */
class DemoSingleton {
    companion object {
        val INSTANCE by lazy(LazyThreadSafetyMode.NONE) {
            DemoSingleton()
        }
    }
}

kotlin的懒汉式单例中使用到了伴生对象companion object，它相当于java中的公共静态，然后使用到了LazyThreadSafetyMode枚举里面的NONE；

public enum class LazyThreadSafetyMode {
    /**
     * Locks are used to ensure that only a single thread can initialize the [Lazy] instance.
     */
    SYNCHRONIZED,
    /**
     * Initializer function can be called several times on concurrent access to uninitialized [Lazy] instance value,
     * but only the first returned value will be used as the value of [Lazy] instance.
     */
    PUBLICATION,
    /**
     * No locks are used to synchronize an access to the [Lazy] instance value; if the instance is accessed from multiple threads, its behavior is undefined.
     *
     * This mode should not be used unless the [Lazy] instance is guaranteed never to be initialized from more than one thread.
     */
    NONE,
}

通过上面的注释，可以看出NONE表示是没有加锁，因此不是线程安全的，当然也可以使用SYNCHRONIZED,PUBLICATION。

上面的例子都会有线程安全问题，现在我们继续对代码进行改进，使用SYNCHRONIZED进行加锁：

/**
 * Created by hubery on 2018/7/18.
 * 懒汉模式
 */
public class DemoSingleton {
    private static DemoSingleton INSTANCE;

    public static synchronized DemoSingleton getInstance() {
        if(INSTANCE == null){
            INSTANCE = new DemoSingleton();
        }
        return INSTANCE;
    }
}

同样的kotlin也可以使用synchronized进行加锁：

/**
 * Created by hubery on 2018/7/18.
 * kotlin的懒汉式单例
 */
class DemoSingleton {
    companion object {
        private var INSTANCE:DemoSingleton? = null

        @Synchronized
        fun getInstance():DemoSingleton{
            if(INSTANCE == null){
                INSTANCE = DemoSingleton()
            }
            return INSTANCE!!
        }
    }
}

kotlin中使用的是@Synchronized注解方式达到同步的效果；同样的，我们知道上面的例子同样存在不足，我们要实现只有第一次获取的时候才会加锁，那么我们使用双重检测。

/**
 * Created by hubery on 2018/7/18.
 * 懒汉模式
 */
public class DemoSingleton {
    private static volatile DemoSingleton INSTANCE;
    public static DemoSingleton getInstance() {
        if (INSTANCE == null) {
            synchronized (DemoSingleton.class) {
                if (INSTANCE == null) {
                    INSTANCE = new DemoSingleton();
                }
            }
        }
        return INSTANCE;
    }
}

使用kotlin实现

/**
 * Created by hubery on 2018/7/18.
 * kotlin的懒汉式单例
 */
class DemoSingleton {
    companion object {
        val INSTANCE by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
            DemoSingleton()
        }
    }
}

最后说一下内部类式

public class DemoSingleton {
    private DemoSingleton() {
    }

    private static class Instance {
        private static DemoSingleton singleton = new DemoSingleton();
    }

    public static DemoSingleton getInstance() {
        return Instance.singleton;
    }
}

kotlin的写法

class DemoSingleton {
    companion object {
        fun getInstance() = Instance.INSTANCE
    }

    private object Instance {
        val INSTANCE = DemoSingleton()
    }
}

利用了classloader的机制来保证初始化instance时只有一个线程，所以也是线程安全的，同时没有性能损耗。
对比kotlin和java的单例，总体说来kotlin的单例比java单例实现代码更加的简洁，且kotlin语言对单例的支持更加的友好。

函数扩展

扩展函数可以在已有类中添加新的方法，不会对原类做修改，扩展函数定义形式。其中扩展函数的参数可以为空。

fun 扩展函数的对象.扩展函数的名字(扩展函数的参数){

}

先来看看基本的函数扩展：

open class Personal(var name: String) {
}

/**
 * 扩展函数
 */
fun Personal.test(name: String): String {
    return "这是一个扩展类，名字=$name"
}

/**
 * 方法测试
 */
fun test(){
    var personal = Personal("Hubery")
    personal.test("test()")
}

上面的例子展示了为Personal对象扩展一个test方法；

扩展函数是静态解析的，并不是接收者类型的虚拟成员，在调用扩展函数时，具体被调用的的是哪一个函数，由调用函数的的对象表达式来决定的，而不是动态的类型决定的:

扩展函数不仅可以扩展方法，还可以对属性进行扩展，或者伴生类进行函数或者属性进行扩展。

智能转换

关于智能转换，我们用一个例子来说明，先来看看java中的例子：

public interface Ball {
        void pay(String name);
    }

    class BasketBall implements Ball {
        @Override
        public void pay(String name) {
        }
    }

    class FootBall implements Ball {
        @Override
        public void pay(String name) {
        }
    }

    void test(Ball ball) {
        if (ball instanceof BasketBall) {//篮球
            BasketBall basketBall = (BasketBall) ball;
            basketBall.pay("篮球");
        } else if (ball instanceof FootBall) {
            FootBall footBall = (FootBall) ball;
            footBall.pay("足球");
        }
    }

定义一个Ball接口，那么分别用BasketBall,FootBall去实现它，在测试的时候，分别用instanceof去判断，然后再分别强转成相应的类型。

interface Ball {
    fun pay(name: String) {
        print("pay() 我们正在玩$name")
    }
}

class BasketBall : Ball {
    override fun pay(name: String) {
        super.pay(name)
    }

    fun basketBallPay() {

    }
}

class FootBall : Ball {
    override fun pay(name: String) {
        super.pay(name)
    }

    fun footBallPay() {

    }
}

fun test(ball: Ball) {
    if (ball is BasketBall) {
        var basketBall = ball.basketBallPay()
        ball.pay("篮球")
    } else if (ball is FootBall) {
        var footBall = ball.footBallPay()
        ball.pay("足球")
    }
}

由上面可以看到，kotlin在使用的时候不同于java需要强制转换，kotlin它合并了类型检查和转换。这就是kotlin的智能转换。