Kotlin详尽语法分析（未完待续）

川长思鸟来 2022-05-28 03:37 226阅读 0赞

[待续][Link 1]  
一、Kotlin友好的语法  
Kotlin不是诞生于学术界的一些不可思议难以理解的语法，它的语法类似于很多面向对象的语法，并且非常易于理解。  
但是它又与传统的面向对象的Java有些区别，例如kotlin的val、var变量的声明。  
例如：

二、相似友好的语法

/** * @author:wangdong * @description:Foo demo */
    class Foo { 
    
        //val 声明的变量是不可以改变的
        val b: String = "b"
        //var 声明是可以改变的
        var i: Int = 0
    
        //可以根据等号右边的类型，自动判断赋予左边变量的类型
        fun hello(){
            val str = "hello"
            print("$str world")
        }
    
        //根据传入的变量，求和
        fun sum(x: Int,y: Int): Int{
            return x + y;
        }
    
        //根据传人的变量，求最大值
        //如果a大于b,则返回a,否则返回b
        fun maxOf(a: Float, b: Float) = if(a > b) a else b
    
    }

三、字符串的插入和计算  
在字符串的插入和计算方面，类似于Java的String.format()。  
例如：

fun stringDemo(){
            val x = 4;
            val y = 7;
            print("sum of $x and $y is ${ x + y}")
            //会输出"sum of 4 and 7 is 11"
        }

四、  
Kotlin will infer your types wherever you feel it will improve readability:  
如果没有指定变量的类型的话，Kotlin可以根据改善阅读，自动赋予变量的类型

fun inferenceDemo() {
            val a = "abc"  //会自动推测为String类型
            var b = 4      //会自动推测为String类型
    
            val c: Double = 0.7  //明确的c的类型为Double
            val d: List<String> = ArrayList() //明确d的类型为List<String>
        }

五、  
更灵活的类型转化

/** * @author:wangdong * @description:第一个kotlin项目 */
    fun main(args: Array<String>) {
    
        var obj = "Hello";
        //会将小写字母转化成大写输出
        if (obj is String) {
            print(obj.toUpperCase())     // obj is now known to be a String
        }
    }

输出结果  
![这里写图片描述][70]

六、更直观的相等比较

//因为两个对象属性完全一样
    val john1 = Person("John")
    val john2 = Person("John")
    //判断结构相等用==
    john1 == john2    // true (structural equality)
    //判断引用相等用===
    john1 === john2   // false (referential equality)

七、灵活变化的参数和方法运用  
可以通过类，调用方法传入指定类型的参数

fun build(title: String, width: Int = 800, height: Int = 600) {
        Frame(title, width, height)
    }

八、更多样化的方法调用方式  
下面来模拟调用第七步中的build方法，三种方式都是一样的

build("PacMan", 400, 300)                           // equivalent
    build(title = "PacMan", width = 400, height = 300)  // equivalent
    //参数顺序如果颠倒了，则需要指定前缀
    build(width = 400, height = 300, title = "PacMan")  // equivalent

九、更灵活的表达在When判断语句

/**
     * @author:wangdong
     * @description:第一个kotlin项目
     */
    fun main(args: Array<String>) {
    
        var x = 2
        //根据x的值走对应的一行，下面走x is 2
        when (x) {
            1 -> print("x is 1")
            2 -> print("x is 2")
            3, 4 -> print("x is 3 or 4")
            in 5..10 -> print("x is 5, 6, 7, 8, 9, or 10")
            else -> print("x is out of range")
        }
    }

它在一个表达式或者一个声明中都是有用的  
例如：

fun main(args: Array<String>) {
    
        var obj = "20"
        val res: Boolean = when {
            obj == null -> false
            //走这一层
            obj is String -> true
            else -> throw IllegalStateException()
        }
        print(res)
    }

最终输出的结构true

十、更灵活的Bean实体类中的set和get方法

class Frame { 
        var width: Int = 800
        var height: Int = 600
    
        val pixels: Int
            get() = width * height
    }

调用类Frame中的get方法，得到的结果就是480000

十一、更灵活的对象创建和复制  
It’s a POJO complete with toString(), equals(), hashCode(), and copy(), and unlike in Java it won’t take up 100 lines of code:  
比Java的创建和赋值方便太多了

/** * @author:wangdong * @description:第一个kotlin项目 */
    fun main(args: Array<String>) {
    
        data class Person(val name: String, var email: String, var age: Int)
    
        val john = Person("John","John@gmail.com",121)
    
        print(john)
    }

输出结果：

Person(name=John, email=John@gmail.com, age=121)

十二、更灵活的预先重载的方法  
A predefined set of operators can be overloaded to improve readability:  
例如：

/** * @author:wangdong * @description:第一个kotlin项目 */
    fun main(args: Array<String>) {
    
        data class Vec(val x: Float,val y: Float){ 
    
            operator fun plus(v: Vec) = Vec(x + v.x, y + v.y)
        }
    
        val v = Vec(2.5f,3f) + Vec(4f, 1f)
    
        print(v)
    }

输出的结果是Vec(x=6.5, y=4.0)  
具体咱们来debug看一下  
![这里写图片描述][70 1]  
可以简单理解为x+x，y+y

本次暂时分享到这里了。

[Link 1]: https://medium.com/@magnus.chatt/why-you-should-totally-switch-to-kotlin-c7bbde9e10d5
[70]: /images/20220528/d03b5aebf0b3464eab2732b76bdeaa22.png
[70 1]: /images/20220528/20627c81f4de424296c2813593c9d282.png