Kotlin的类型系统

fun strLen(s:String) = s.length
//使用可能为null的实参调用StrLen是不允许的，在编译期就会被标记成错误
>>>strLen(null)
ERROR:Null can not be a value of a non-null type String

Type?  =  Type  or  null

//表达式 s?.toUpperCase()  等同于下面这种烦琐的写法
if(s!=null) s.toUpperCase() else null

				foo != null
				----------->		foo.bar()
foo?.bar()
				foo == null
			    ----------->		null

				foo != null
				----------->		foo
foo ?: bar
				foo == null
			    ----------->		bar

				foo is type
				----------->		foo as Type
foo as? Type
				foo !is Type
			    ----------->		null

				foo != null
				----------->		foo 
foo!!
				foo == null
			    ----------->		null

				foo != null
				----------->		在lambda内部it是非空的	
foo?.let{
 ..it .. }
				foo == null
			    ----------->		什么都不会发生

val email:String? = "adu@163.com"
fun sendEmailTo(email:String){
        println("email:$email")
 }
 
 //1、email非空时调用，在lambda中把email当作非空实参使用
 email?.let{ email -> sendEmailTo(email)}
 
 //2、使用自动生成的名字it
 email?.let{ sendEmailTo(it) }

val person:Person? = getTheBestPerosnInTheWorld()
if (perosn != null) sendEmailTo(person.email)
//和功能相同但没有额外变量的代码
getTheBestPerosnInTheWorld()?.let{ sendEmailTo(it.email)}
//这个函数返回null，所以lambda中的代码永远不会执行
fun getTheBestPerosnInTheWorld() : Person? = null

class MyService {
        fun performAction() :String = "foo"
}
class MyTest {
    private lateinit var myService: MyService
    @Before
    fun setUp() {
        myService = MainActivity.MyService()
    }
    @Test fun testAction() {
        Assert.assertEquals("foo",myService.performAction())
    }
}

fun verifyUserInput (input:String?){
		//这里不需要安全调用
        if (input.isNullOrBlank()) {
            println("Please fill in the required fields")
        }
}
>>>verifyUserInput(" ")
Please fill in the required fields
>>>verifyUserInput(null)//这个接收者调用isNullorBlank并不会导致任何异常
Please fill in the required fields

//处理可空的参数类型
fun<T> printHashCode(t:T) {
	//因为“t”可能为null，所以必须使用安全调用
   println(t?.hashCode())
}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       
>>> printHashCode(null)	//“T”被推导成“Any?”
>>> null

//为类型参数声明非空上界
fun<T: Any> printHashCode(t:T) { //现在T就不是可空的
	
   println(t.hashCode())
}
>>> printHashCode(null)	//这段代码是无法编译的，不能传递null，期望是非空值
>>> ERROR

val i: Int = 1
Val list: List<Int> = listOf(1,2,3)

data class Person(val name: String,val age:Int? = null) {
    fun isOlderThan(other: Person):Boolean？{
        if (age == null || other.age == null)
            return null
        return age > other.age
    }
}

val i =1
val l:Long = i	//错误：类型不匹配
//因此，必须显式地进行转换
val i =1
val l:Long = i.toLong()

val x =1
println(x in listof(1L,2L,3L))	//假设Kotlin支持隐式转换的话仍是false
println(x.toLong() in listof(1L,2L,3L))//true

println("42".toInt())
>>42

interface Processor<T> {
	fun process() : T
}
class NoResultProcessor : Processor<Unit> {
	//返回Unit，但可以省略类型说明
	override fun process() {
	//do stuff
	//这里不需要显式的return
}

val s = person.name ?: throw IllegalArgumentException("Name required)

fun readNumbers(reader: BufferedReader):List<Int?>{
        val result = ArrayList<Int?>() //创建包含可空Int值的列表
        for (line in reader.lineSequence()) {
            try {
                val number = line.toInt()
                result.add(number)      //向列表添加整数（非空值）
            }catch (e:NumberFormatException){
                result.add(null)        //向列表添加null，因为当前行不能被解析成整数
            }
        }
        return result
    }

fun addValidNumbers(numbers:List<Int?>) {
        val validNumbers = numbers.filterNotNull()
        println("sum of valid numbers: ${validNumbers.sum()}")
        println("Invalid numbers: ${numbers.size - validNumbers.size}")
}