这一篇主要讲解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的智能转换。
