Kotlin基础学习-入门篇

编程之家收集整理的这篇文章主要介绍了Kotlin基础学习-入门篇编程之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

本篇文章来自郭霖大佬的第一行代码中的Kotlin教程,笔者只是在学习Kotlin过程中记录学习过程。

Kotlin系列已更新:

Kotlin基础学习-入门篇

Kotlin基础学习-第二篇

Kotlin进阶学习-第三篇

Kotlin进阶学习-第四篇

Kotlin进阶学习-第五篇

kotlin的历史

Kotlin由JetBrains公司开发设计,2011年公布第一版,2012年开源。

2016年发布1.0正式版,并且JetBrains在IDEA加入对Kotlin的支持,安卓自此又有新的选择。

2019年谷歌宣布Kotlin成为安卓第一开发语言,安卓程序员由javaKotlin已经迫在眉睫。

Kotlin的工作原理

语言分为解释型和编译型两种

语言类型

编译型

编译器直接将源代码一次性编译成二进制文件,计算机可直接执行,例如C,C++

优点:一次编译,即可运行,运行期不需要编译,运行效率高。

缺点:不同操作系统需要不同的机器码,且修改代码需要真个模块重新编译

解释型

程序运行时,解释器会将源码一行一行实时解析成二进制再执行。例如JS,Python

优点:平台兼容性好,安装对应的虚拟机即可运行。

缺点:运行时需要解释执行,效率较低。

Java的语言类型

java准确来说属于混合型语言,但更偏向于解释型。

编译java存在JITAOTJIT即时编译将可将热点代码直接编译成机器码,AOT预先编译可再安装时把代码编译成机器码

解释java运行时需编译成class文件java虚拟机再解释执行.class

Kotlin的运行原理

java虚拟机只认class文件 虚拟机不会关心classjava文件编译来的,还是其他文件编译来的。那此时我们创造一套自己的语法规则,再做一个对应的编译器,,则可让我们的语言跑在java虚拟机上。Kotlin则是此原理,运行前会先编译成class,再供java虚拟机运行。

创建Kotlin项目

打开android studio,在选择语言时,选择Kotlin

在包下创建kotlin文件

创建File命名为HelloWorld

敲入下面代码则可运行打印Hello World!

package com.hbsd.demo


fun main() {
    println("Hello World!")
}

运行结果如下:

下面进入语法学习

语法

变量

变量的声明

Kotlin使用var,val来声明变量,注意:Kotlin不再需要;来结尾

var 可变变量,对应java非final变量

var b = @H_60_404@1

val不可变变量,对应javafinal变量

val a = @H_60_404@1

两种变量并未声明类型,这是因为Kotlin存在类型推导机制,上述的a,b认为Int。假设想声明具体类型,则需下面的方式

var c: Int = @H_60_404@1

基本类型

Kotlin不再存在基本类型,将全部使用对象类型

Java基本类型 Kotlin对象类型 对象类型说明
int Int 整型
long Long 长整型
short Short 短整型
float Float 单精度浮点型
double Double 双精度浮点型
boolean Boolean 布尔型
char Char 字符型
byte Byte 字节型

var和val的本质区别

打开Kotlin对应的Java文件

再点击下方按钮

则可查看对应的Java文件

public final class HelloWorldKt {
    private static final int a = @H_60_404@1;
    private static int b = @H_60_404@2;
    private static int c = @H_60_404@10;
    
    ...
}

发现val a对应的为finalvar bvar c 对应的为非final

Kotlin此设计的原因则是防止非final的滥用,若一个变量永远不被修改则有必要给其加上final,使其他人看代码时更好理解。

后期我们写代码时则可先使用val,若真的需要修改再改为var

函数

函数的声明

无参无返回值

fun test() {
}

有参有返回值

参数的类型需要写在形参名后面中间使用:连接多个参数使用,分割",“返回值使用”:"拼接

fun add(a: Int, b: Int): Int {
    return a + b
}

声明技巧

函数体只有一行代码时可直接使用下面方式声明方法

fun add (a: Int, b: Int): Int = a + b 

Kotlin存在类型推导,返回值类型也可省略

fun add (a: Int, b: Int) = a + b

函数调用

fun main() {
    test()
    println(add(@H_60_404@1, @H_60_404@2))
}

//运行结果
//test
//3

if语句

Kotlin中的选择控制有两种方式。ifwhen

if

Javaif区别不大,实现一个返回最大值的函数

fun max(a: Int, b: Int): Int {
    if (a > b) return a
    else return b
}

Kotlin的if可以包含返回值,if语句的最后一行会作为返回值返回

fun max(a: Int, b: Int): Int {
    return if (a > b) a else b
}

上述我们说过一行代码可省略返回值

fun max(a: Int, b: Int) = if (a > b) a else b

查看对应的Java文件,其上述实现都与下面代码等价

public static final int max(int a, int b) {
   return a > b ? a : b;
}

when

实现一个查询成绩的函数用户传入名字,返回成绩级别

if实现

Kotlinif语句必须要有else,不然会报错

fun getscore(name: String) = if (name == "Tom") "不及格"
else if (name == "Jim") "及格"
else if (name == "Pony") "良好"
else if (name == "Tony") "优秀"
else "名字非法"

Kotlin==等价于Javaequals比较的时是对象里的内容=== 等价于Java==,比较的为对象的引用。

when实现

也必须实现else,否则报错

fun getscore(name: String) = when(name) {
    "Tom" -> "不及格"
    "Jim" -> "及格"
    "Pony" -> "良好"
    "Tony" -> "优秀"
    else -> "名字非法"
}

when支持参数检查

fun checkNumber(num: Number) {
    when (num) {
        is Int -> println("Int")
        is Double -> println("Double")
        else -> println("others")
    }
}

when可不传递形参

使用Boolean使when更加灵活

fun getscore(name: String) = when {
    name == "Tom" -> "不及格"
    name == "Jim" -> "及格"
    name == "Pony" -> "良好"
    name == "Tony" -> "优秀"
    else -> "名字非法"
}

-> 后不仅可以只执行一行代码,可以多行,看一个比较复杂的例子:

fun getscore(name: String) = when {
    //若name以Tom开头则命中此分支
    name.startsWith("Tom") -> {
        //处理
        println("你好,我是Tom开头的同学")
        "不及格"
    }
    name == "Jim" -> "及格"
    name == "Pony" -> "良好"
    name == "Tony" -> "优秀"
    else -> "名字非法"
}

循环语句

Kotlin有两种循环方式,whilefor-inwhilejava中的while没有区别,for-in是对Java for-each的加强,Kotlin舍弃了for-i的写法

while不再赘述,在学习for-in之前需要明确一个概念-区间

val range = @H_60_404@0..@H_60_404@10 //区间代表[0,10]

for-in需借助区间来使用

fun main() {
    val range = @H_60_404@0..@H_60_404@10
    for (i in range) { //也可直接for (i in 0..10)
        println(i)
    }
    //输出结果为 从0打印到10
}

0..10 代表双闭区间,如果想使用左闭右开呢,需要借助until关键字

fun main() {
    for (i in @H_60_404@0 until @H_60_404@10) {
        println(i)
    }
    //输出结果为 从0打印到9
}

上述实现是逐步进行相当于i++Kotlin支持跳步

fun main() {
    for (i in  @H_60_404@0 until @H_60_404@10 step @H_60_404@2) {
        println(i)
    }
    //输出结果为0,2,4,6,8
}

上述实现都是升序,Kotlin也可降序循环

fun main() {
    for (i in  @H_60_404@10 downTo @H_60_404@1) {
        println(i)
    }
    //输出结果为10 - 1
}

for-in不仅可对区间进行遍历,还可对集合进行遍历,后续在集合处进行展示。

类和对象

类的创建和对象的初始化

在创建页面选择Class创建

创建Person类,并声明nameage,创建printInfo方法

class Person {
    var name = ""
    var age = @H_60_404@0
    fun printInfo() {
        println(name +"'s age is " + age)
    }
}

main方法中声明一个Person对象并调用printInfo方法

fun main() {
    val person = Person()
    person.name = "zjm"
    person.age = @H_60_404@20
    person.printInfo()
}
//结果如下zjm's age is 20

继承

声明Student类继承PersonKotlin中继承使用**:**,后接父类的构造,为什么需要构造后续讲解

class Student : Person(){ //此时Person报错
    var number = ""
    var grade = @H_60_404@0
    fun study() {
        println(name + "is studying")
    }
}

Person类当前不可继承,查看Person对应的java文件

public final class Person {
    ...
}

Person类为final不可被继承,因此需借助open关键字

只需在Person类前加上open

open class Person {
	...
}

此时Personjava文件变为

public class Person {
	...
}

此时Student将不再报错

构造

构造分为主构造和此构造

主构造

主构造直接写在类后面

修改Student

class Student(val number: String, val grade: Int) : Person(){
	...
}

在创建Student对象时,如下创建

val student = Student("1234", @H_60_404@90)

因之前Person还有nameage,下面修改Person类的主构造

open class Person(val name: String, val age: Int) {
    ...
}

此时Student报错,因为继承Person时,后边使用的是Person()无参构造,上面我们修改Person的构造,则不存在无参构造了。

修改Student

class Student(name: String,  age: Int, val number: String, val grade: Int) : Person(name, age){
   	...
}

此时不在报错,声明方式如下

val student = Student("zjm", @H_60_404@20, "1234", @H_60_404@90)

在构造时需要进行特殊处理怎么办,Kotlin提供了init结构体,主构造的逻辑可在init中处理

open class Person(val name: String, val age: Int) {
    init {
        println("name is" + name)
        println("age is" + age)
    }
}

上述修改都为主构造,那如果类想有多个构造怎么办,此时需借助次构造

次构造

此时实现Student的另外两个构造

三个参数的构造,nameagenumbergrade不传参认为``0

无参构造,字符串认为"",int认为0

class Student(name: String, age){
    constructor(name: String, age: Int, number: String) : this(name, age, number, @H_60_404@0) {
        
    }
    constructor() : this("", @H_60_404@0, "", @H_60_404@0) {
        
    }
    ...
}

创建如下:

fun main() {
    val student1 = Student("zjm", "123", @H_60_404@90)
    val student2 = Student("zjm", "123")
    val student3 = Student()
}

无主构造

若类不使用主构造,则后续继承类也不需要使用构造即可去掉继承类的(),次构造可以调用父类构造super进行初始化,但是次构造的参数在其他地方无法引用

class Student : Person {
    constructor(name: String, number: String) : super(name, age) {

    }
	fun study() {
        //name,age可使用
        println(name + "is studying")
        //使用number则会报错,若number是主构造的参数则可引用
        //println(number) 报红
    }
}

接口

接口的定义

Java中的接口定义类似

interface Study {
    fun study()
    fun readBooks()
    fun doHomework()
}

接口的继承

继承接口只需在后用","拼接,需实现Study声明的全部函数

class Student(name: String, age), Study{
    
    ...

    override fun study() {
        Todo("Not yet implemented")
    }

    override fun readBooks() {
        Todo("Not yet implemented")
    }

    override fun doHomework() {
        Todo("Not yet implemented")
    }
}

Kotlin支持接口方法认实现,JDK1.8以后也支持功能方法认实现则继承类无需必须实现此方法

interface Study {
    fun study() {
        println("study")
    }
    fun readBooks()
    fun doHomework()
}

权限修饰符

JavaKotlin的不同如下表所示:

修饰符 Java Kotlin
public 所有类可见 所有类可见(认)
private 当前类可见 当前类可见
protected 当前类,子类,同包下类可见 当前类,子类可见
default 同包下类可见(认)
internal 同模块下的类可见

Kotlin引入internal,摒弃了default

使用:

类上

public open class Person(val name: String, val age: Int){...}

变量上

private val value = @H_60_404@1

方法

private fun test() {
    
}

数据类和单例类

数据类

数据类则只处理数据相关,与Java Bean类似,通常需要实现其getsethashCodeequalstoString方法

下面实现UserBean,包含idnamepwd属性

Java编写入如下:

public class UserBean {
    private String id;
    private String name;
    private String pwd;

    public UserBean() {

    }

    public UserBean(String id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        UserBean userBean = (UserBean) o;
        return Objects.equals(id, userBean.id) && Objects.equals(name, userBean.name) && Objects.equals(pwd, userBean.pwd);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, pwd);
    }

    @Override
    public String toString() {
        return "UserBean{" +
                "id='" + id + '\'' +
                ",name='" + name + '\'' +
                ",pwd='" + pwd + '\'' +
                '}';
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
}

Kotlin编写此类将变得非常简单,新建一个kt文件,选择如下:

@H_795_3404@

一行代码即可搞定,Kotlin会自动实现上述方法

data class UserBean(val id: String, val name: String, val pwd: String)

若无data关键字,上述方法hashCodeequalstoString)无法正常运行,去掉data查看Kotlin对应的java文件

public final class UserBean {
   @NotNull
   private final String id;
   @NotNull
   private final String name;
   @NotNull
   private final String pwd;

   @NotNull
   public final String getId() {
      return this.id;
   }

   @NotNull
   public final String getName() {
      return this.name;
   }

   @NotNull
   public final String getPwd() {
      return this.pwd;
   }

   public UserBean(@NotNull String id, @NotNull String name, @NotNull String pwd) {
      Intrinsics.checkNotNullParameter(id, "id");
      Intrinsics.checkNotNullParameter(name, "name");
      Intrinsics.checkNotNullParameter(pwd, "pwd");
      super();
      this.id = id;
      this.name = name;
      this.pwd = pwd;
   }
}

发现上面代码既无hashCodeequalstoString也无set

加上data且把变量改为var,对应的java文件如下:

public final class UserBean {
   @NotNull
   private String id;
   @NotNull
   private String name;
   @NotNull
   private String pwd;

   @NotNull
   public final String getId() {
      return this.id;
   }

   public final void setId(@NotNull String var1) {
      Intrinsics.checkNotNullParameter(var1, "<set-?>");
      this.id = var1;
   }

   @NotNull
   public final String getName() {
      return this.name;
   }

   public final void setName(@NotNull String var1) {
      Intrinsics.checkNotNullParameter(var1, "<set-?>");
      this.name = var1;
   }

   @NotNull
   public final String getPwd() {
      return this.pwd;
   }

   public final void setPwd(@NotNull String var1) {
      Intrinsics.checkNotNullParameter(var1, "<set-?>");
      this.pwd = var1;
   }

   public UserBean(@NotNull String id, "pwd");
      super();
      this.id = id;
      this.name = name;
      this.pwd = pwd;
   }

   @NotNull
   public final String component1() {
      return this.id;
   }

   @NotNull
   public final String component2() {
      return this.name;
   }

   @NotNull
   public final String component3() {
      return this.pwd;
   }

   @NotNull
   public final UserBean copy(@NotNull String id, "pwd");
      return new UserBean(id, pwd);
   }

   // $FF: synthetic method
   public static UserBean copy$default(UserBean var0, String var1, String var2, String var3, int var4, Object var5) {
      if ((var4 & @H_60_404@1) != @H_60_404@0) {
         var1 = var0.id;
      }

      if ((var4 & @H_60_404@2) != @H_60_404@0) {
         var2 = var0.name;
      }

      if ((var4 & @H_60_404@4) != @H_60_404@0) {
         var3 = var0.pwd;
      }

      return var0.copy(var1, var2, var3);
   }

   @NotNull
   public String toString() {
      return "UserBean(id=" + this.id + ",name=" + this.name + ",pwd=" + this.pwd + ")";
   }

   public int hashCode() {
      String var10000 = this.id;
      int var1 = (var10000 != null ? var10000.hashCode() : @H_60_404@0) * @H_60_404@31;
      String var10001 = this.name;
      var1 = (var1 + (var10001 != null ? var10001.hashCode() : @H_60_404@0)) * @H_60_404@31;
      var10001 = this.pwd;
      return var1 + (var10001 != null ? var10001.hashCode() : @H_60_404@0);
   }

   public boolean equals(@Nullable Object var1) {
      if (this != var1) {
         if (var1 instanceof UserBean) {
            UserBean var2 = (UserBean)var1;
            if (Intrinsics.areEqual(this.id, var2.id) && Intrinsics.areEqual(this.name, var2.name) && Intrinsics.areEqual(this.pwd, var2.pwd)) {
               return true;
            }
         }

         return false;
      } else {
         return true;
      }
   }
}

此时则和手动编写的java bean功能一样了,所有方法都可正常运行

单例类

目前Java使用最广的单例模式的实现如下:

public class Singleton {
    private Singleton() {
    }
    
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
    public void test() {
        ...
    }
}

Kotlin中创建单例类需选择Object

生成代码如下:

object Singleton {
    fun test() {
        ...
    }
}

其对应的java文件如下,和上述使用最多的java单例实现类似

public final class Singleton {
   @NotNull
   public static final Singleton INSTANCE;

   public final void test() {
   }

   private Singleton() {
   }

   static {
      Singleton var0 = new Singleton();
      INSTANCE = var0;
   }
}

使用如下:

fun main() {
    Singleton.test() //对应的java代码为Singleton.INSTANCE.test();
}

Lambda

许多高级语言都支持Lambdajavajdk1.8以后才支持Lamda语法,LamdaKotlin的灵魂所在,此小节对Lambda的基础进行学习,并借助集合练习。

集合的创建和遍历

List

fun main() {
    //常规创建
    val list = ArrayList<Int>()
    list.add(@H_60_404@1)
    list.add(@H_60_404@2)
    list.add(@H_60_404@3)
    
    //listof不可变,后续不可添加删除,只能查
    val list1 = listof<Int>(@H_60_404@1, @H_60_404@2, @H_60_404@3 ,@H_60_404@4 ,@H_60_404@5)
    list1.add(@H_60_404@6)//报错
    
    //mutablelistof,后续可添加删除
    val list2 = mutablelistof<Int>(@H_60_404@1,@H_60_404@5)
    list2.add(@H_60_404@6)
    
    //循环
    for (value in list2) {
        println(value)
    }
}

Set

set用法List类似,只是把listof替换为mapOf

Map

fun main() {
    val map = HashMap<String, String>()
    map.put("1", "zjm")
    map.put("2", "ljn")
    //Kotlin中map支持类似下标的赋值和访问
    map["3"] = "lsb"
    map["4"] = "lyx"
    println(map["2"])
    println(map.get("1"))

    //不可变
    val map1 = mapOf<String, String>("1" to "zjm", "2" to "ljn")
    map1["3"] = "lsb" //报错
    
    //可变
    val map2 = mutableMapOf<String, "2" to "ljn")
    map2["3"] = "lsb"
    
    for ((key, value) in map) {
        println(key + "   " + value)
    }
    
}

Lambda的使用

方法在传递参数时都是普通变量,而Lambda可以传递一段代码

Lambda表达式的语法结构

{参数名1: 参数类型, 参数名2:参数类型 -> 函数体}

Kotlinlist提供了maxByOrNull函数,返回当前list中xx最大的元素,XX是我们定义的条件,可能为长度,可能是别的,我们拿长度举例。

若不使用maxBy,实现如下

fun main() {
    val list = listof<String>("a", "aba", "aabb", "a")
    var maxStr = ""
    for (str in list) {
        if (str.length > maxStr.length) {
            maxStr = str;
        }
    }
    println(maxStr)
}

maxByOrNull一个普通方法,需要一个Lambda参数,下面结合Lambda使用maxByOrNull

fun main() {
    val list = listof<String>("a", "a")
    var lambda = {str: String -> str.length}
    var maxStr = list.maxByOrNull(lambda)
    println(maxStr)
}

直接当成参数也可传递

var maxStr = list.maxByOrNull({str: String -> str.length})

Lambda方法的最后一个参数,则可将{}提到外面

var maxStr = list.maxByOrNull() {str: String -> str.length}

若有且仅有一个参数且是Lambda,则可去掉()

var maxStr = list.maxByOrNull {str: String -> str.length}

Kotlin拥有出色的类型推导机制,Lambda参数过多时可省略参数类型

var maxStr = list.maxByOrNull {str -> str.length}

Lambda只有一个参数,则可用it替代参数名

var maxStr = list.maxByOrNull {it.length}

集合还有许多此类函数

创建list,后续操作都由此list转换

val list = listof<String>("a", "a")

map 映射,返回新集合,将集合中的元素映射成另一个

val newList = list.map { it.toupperCase() }//将集合中的元素都准换成大写

filter过滤,返回新集合,将集合中的元素进行筛选

val newList = list.filter { it.length > @H_60_404@3 }//筛选出长度大于3的元素

any返回Boolean,集合中是否存在元素满足Lambda的条件,有则返回true,无则false

val isAny = list.any {it.length > @H_60_404@10} //返回false

all返回Boolean,集合中元素是否全部满足满足Lambda的条件,有则返回true,无则false

val isAll = list.all {it.length > @H_60_404@0} //返回true

Lambda的简单使用到这就结束了

Java函数式API的使用

Kotlin调用Java方法,若该方法接收一个Java单抽象方法接口参数,则可使用函数APIJava单抽象方法接口指的是接口只声明一个方法,若有多个方法则无法使用函数API

Java单抽象方法接口例如Runnable

public interface Runnable {
    void run();
}

Java中启动一个线程如下:

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("test");
    }
}).start();

Kotlin启动线程如下:

Kotlin摒弃了new,若想声明匿名内部类必须使用object

Thread(object : Runnable {
    override fun run() {
        println("test")
    }
}).start()

RunnableJava单抽象方法接口,可对代码进行简化

Thread(Runnable {
        println("test")
    }).start()

Runnable接口只用一个方法,使用Lambda也不会有歧义,Kotlin知道此Lambda一定实现的为run函数,借用Lambda进一步简化:

Thread({
    println("test")
}).start()

又因Thread只需一个参数Runnable参数,则可省略()

Thread {
    println("test")
}.start()

与上类似的,click也使用上述方法

button.setonClickListener { println("test") }

这种方式可极大缩减代码

空指针检查机制

国外统计程序出现最多的异常为空指针异常,Kotlin存在编译时检查系统帮助我们发现空指针异常。

查看下面Java代码

public void doStudy(Study study) {
    study.doHomework();
    study.readBooks();
}

上述代码时存在空指针风险的,传入null,则程序崩溃,对其进行改进

public void doStudy(Study study) {
    if (study != null) {
        study.doHomework();
        study.readBooks();
    }
}

对于Kotlin来讲任何参数和变量不能为空

fun study(study: Study) {
    study.doHomework()
    study.readBooks()
}

fun main() {
    study(null) //报错
    study(Student()) //正确
}

Kotlin把空指针异常的检查提前到了编译期,若空指针则编译期就会崩溃,避免在运行期出现问题

若我们有特殊的需求可能需要传递null参数,参数则按照下面声明

fun study(study: Study?) {
    study.doHomework() //报错
    study.readBooks()	//报错
}

?的意思则是当前参数可为空,如果可为空的话,则此对象调用方法必须要保证对象不为空,上面代码没有保证,则报错修改如下

fun study(study: Study?) {
    if (study != null) {
        study.doHomework()
        study.readBooks()
    }
}

也可借助判空辅助工具

判空辅助工具

?.

其含义是前面对象不为空才执行.后面的方法

fun study(study: Study?) {
    study?.doHomework()
    study?.readBooks()
}

?:

其含义是前不为空则返回问号前的值,为空则返回后的值

比如

val c = if (a !=null ) {
    a
} else {
    b
}

借助?:则可简化为

val c = a ?: b

再比如

fun getTextLength(text: String?): Int {
    if (text != null) {
        return text.length
    }
    return @H_60_404@0
}

借助?: 则可简化为

fun getTextLength(text: String?) = text?.length ?: @H_60_404@0

!!

有些时候我们想要强行通过编译,就需要依靠!!,这时就是程序员来保证安全

fun study(study: Study?) {
    //假设此时为空抛出异常,则和java一样
    study!!.doHomework()
    study!!.readBooks()
}

let函数

let不是关键字,而是一个函数,提供了函数API的编程接口,会将调用者作为参数传递到Lambda表达式,调用之后会立马执行Lambda表达式的逻辑

obj.let { it -> //it就是obj
    //编写操作
}

比如上面函数

fun study(study: Study?) {
    study.doHomework()  //报错
    study.readBooks()	//报错
}

借助let则可改为

fun study(study: Study?) {
    //此时靠?.则保证了study肯定不为空,才会执行let函数
    study?.let {
        //it为study
        it.doHomework()
        it.readBooks()
    }
}

全局判空注意事项

//全局变量
var study: Study? = null
fun study() {
    //报错
    if (study != null) {
        study.readBooks()
        study.doHomework()
    }
}

全局变量随时有可能被其他线程修改,即使判空处理也不能保证其没有空指针风险,而let则可规避上述问题

var study: Study? = null
fun study() {
    study?.let {
        it.doHomework()
        it.readBooks()
    }
}

内嵌表达式

之前我们拼接字符串都是下面这样

var name = "zjm"
var age = @H_60_404@20
println("My name is " + name + ". I am " + age + ".")
//打印结果
//My name is zjm. I am 20.

现在靠着Kotlin提供的内嵌表达式则不需要拼接,只需要下面这样则可实现

var name = "zjm"
var age = @H_60_404@20
println("My name is $name. I am $age." )
//打印结果
//My name is zjm. I am 20.

内嵌表达式还支持复杂的操作

${程序员想要的操作}

var name = "zjm"
var age = @H_60_404@20
println("My name is ${if (@H_60_404@1 < @H_60_404@2) "zjm" else "ljn"}. I am $age." )
//打印结果
//My name is zjm. I am 20.

函数的参数认值

Kotlin支持函数存在认值,使用如下

fun main() {
    myPrint(@H_60_404@1)
    myPrint(@H_60_404@1, "lalala")
}

fun myPrint(value: Int, str: String = "hello") {
    println("num is $value,str is $str")
}

//结果如下
//num is 1,str is hello
//num is 1,str is lalala

value想为认值,则会报错,因为在使用时传入的第一个参数他认为是int的,传入字符串会类型不匹配

fun main() {
    myPrint("zjm")//报错
}

fun myPrint(value: Int = @H_60_404@100, str: String) {
    println("num is $value,str is $str")
}

Kotlin提供了一种键值对传参来解决上述问题

fun main() {
    myPrint(str = "zjm") //正确调用
}

fun myPrint(value: Int = @H_60_404@100,str is $str")
}

回顾之前的主次构造,Student如下

class Student(name: String, @H_60_404@0) {

    }
    ...
}

上述的此构造借助参数认值技巧是可以不写的,将第四个参数认值为0 即可

class Student(name: String, val grade: Int = @H_60_404@0) : Person(name, age){
	...
}

上述关于Kotlin的使用,已经够日常开发需要,后续笔者会更新一些进阶使用

原 创 不 易 , 还 希 望 各 位 大 佬 支 持 一 下 \textcolor{blue}{原创不易,还希望各位大佬支持一下}

总结

以上是编程之家为你收集整理的Kotlin基础学习-入门篇全部内容,希望文章能够帮你解决Kotlin基础学习-入门篇所遇到的程序开发问题。

如果觉得编程之家网站内容还不错,欢迎将编程之家网站推荐给程序员好友。

原文地址:https://blog.csdn.net/zjm807778317

版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。

Android相关文章

前面我发过一篇文章,脱离了Spring询问大家能不能继续开发,结果文章下面的评论和回复都告诉我大家伙的基础打得很牢固,该咋写还是咋写。看得我在这内卷的时代瞬间躺...
手机等智能设备是现代生活中的重要角色,我们会在这些智能设备上做登录账户,设置偏好,拍摄照片,保存联系人等日常操作。这些数据耗费了我们很多时间和精力,对我们而言极...
大家肯定也都或多或少的写过一些Groovy代码,但由于不支持代码提示及编译时检查,使用Groovy开发的体验并不太好,Android Gradle插件4.0之后...
手机厂商还没卷完Android 12,Android 13就悄然声息地来了,距离Google 2008年9月22日发布Android 1.0,已过去13个年头。
手机厂商还没卷完Android 12,Android 13就悄然声息地来了,距离Google 2008年9月22日发布Android 1.0,已过去13个年头。
Android跨进程要掌握的是Binder, 而同一进程中最重要的应该就是Handler 消息通信机制了。我这么说,大家不知道是否认同,如果认同,还希望能给一个...
在分析源码之前,我想你应该对 Android 打包流程已经有基础的了解,至少了解了下图的打包过程:
上篇文章《Android安卓进阶技术分享之AGP工作原理》和大家分析了 AGP(Android Gradle Plugin) 做了哪些事,了解到 AGP 就是为...
众所周知,现在程序员因为工作、个人兴趣等对各种系统的需求越来越大,部分人电脑做的还是双系统。其中,比较常见的有各种模拟器、虚拟机在windows上面跑Andro...
传统意义上的协程是单线程的,面对io密集型任务他的内存消耗更少,进而效率高。但是面对计算密集型的任务不如多线程并行运算效率高。
21世纪,安卓虚拟机正在一步步的走入我们的生活,小到个人部分朋友在电脑上使用安卓虚拟机玩手游,大到安卓从业人员在虚拟机上面跑程序。不得不承认,对于每一位Andr...
作为Android中 至关重要 的机制之一,十多年来,分析它的文章不断,大量的内容已经被挖掘过了。所以: