Kotlin学习

目录

学习小结

一、Kotlin基础语法

1.1函数书写方法

1.1.1基本函数写法

1.1.2变长参数函数写法

1.1.3表达式函数写法

1.1.4匿名函数(lambda)写法

1.2变量定义

1.2.1可变变量写法

1.2.2不可变变量写法

1.3字符串模板

1.4NULL检查机制

1.5类型判断

1.6区间

1.7基本数据类型

1.7.1 6种基本数据类型

1.7.2 基本类型比较

1.7.3 基本类型的转换

1.7.4位移

1.7.5其他类型

1.8 判断语句if

1.8.1简化的三元表达式

1.8.2判断是否在区间内

1.8.3When语句

1.9循环控制

1.9.1 for循环

1.9.2 while循环

1.9.3标签@

1.10 类

1.10.1初始化一个类

1.10.2内部类和嵌套类

1.10.3类修饰符和类限定符

1.10.4类的继承

1.11接口

1.12扩展


学习小结

Kotlin具备Java面向对象的特性,可以进行类、方法、属性等的定义。在部分语句写法上,Kotlin比Java更简洁,如不需要使用";”来分割每行代码,不需要使用new关键字来实例化类,可直接使用“:父类名”进行类的继承等。另外,Kotlin还具备一些很方便的特性,如可以在不继承某个类的情况下直接使用“类名.方法名(){}”等方式增加该类的方法和属性,这些特性使Kotlin在类的扩展上变得更加方便。

一、Kotlin基础语法

1.1函数书写方法

1.1.1基本函数写法

fun 函数名(参数1:参数类型,参数2:参数类型):返回值类型{
        
    //此处省略函数内容
    
    return 返回值

}

1.1.2变长参数函数写法

fun 函数名(vararg 参数1:参数类型):返回值类型{
        
    //此处省略函数内容

    
    return 参数1[0]

}

1.1.3表达式函数写法

fun 函数名:(参数1:类型1,参数2:类型2)= 参数1+参数2 

1.1.4匿名函数(lambda)写法

fun 函数名:(参数类型1,参数类型2)->参数类型3={
    return 参数3  
}

1.2变量定义

1.2.1可变变量写法

var 参数名1:参数类型1=初始值1
var 参数名2:参数类型2
参数名2=初始值2
参数名2=参数名2+1
var 参数名3=初始值3

1.2.2不可变变量写法

val 变量1:变量类型1=初始值1

1.3字符串模板

val 变量1=初始值1
val 变量2="${变量1}"
var 变量3="${变量1.replace("${变量1}",初始值2)}"

1.4NULL检查机制

val 变量1:变量类型1?=初始值1    //加?表示可以为空
val 变量2=变量1?.int()         //加?表示如果变量1为空就停止执行.后面的内容,返回空
val 变量3=变量1!!.int()        //加?表示如果变量1为空就停止执行.后面的内容,报异常
val 变量4=变量1?.int()?:-1     

1.5类型判断

val 变量1:变量类型1=初始值1
if(变量1 is 变量类型1)           //使用is判断类型,相当于instanceOf
    变量1=初始值2

1.6区间

for(i in 1..4 step 2)         //..表示从1开始,每次加两个值,加到4
    print(i)                  // 输出13
for(i in 4 downTo 1)          //downTo表示从4开始,每次减少一个值,减到1
    print(i)                  // 输出4321
for(i in 1 until 10)          //until表示从1加到9
    print(i)                  // 输出123456789

1.7基本数据类型

1.7.1 6种基本数据类型

包括 Byte(8位) Short(16位) Int(32位) Long(64位) Float(32位) Double(64位),注意基本类型的首字母都是大写,与java相比,没有char和boolean

1.7.2 基本类型比较

Kotlin只有包装类型,“==”比较的是两个类型值的大小,“===”比较的是两个类型地址的大小

1.7.3 基本类型的转换

通过基本类型变量.toInt()可进行基本类型的转换

1.7.4位移

Kotlin的位移和java的写法不同,具体如下:

var x=3
x=x shr(2)    //右移两位  x=0
x=x shl(2)    //左移两位  x=0
x=x ushr(2)   //无符号右移两位,最高位直接补0,会使x变为正数。
x=x and(x)    //与
x=x or(x)     //或
x=x xor(x)    //异或
x=x inv()     //反转

1.7.5其他类型

var x:Char='a'       //字符
var y:Boolean=true   //布尔
var z=arrayOf(1,2,3) //数组
var a="abc"          //字符串

1.8 判断语句if

Kotlin的判断语句与java判断语句的写法相同,不同的是:

1.8.1简化的三元表达式

var x:Int=if(3>2) 3 else 2

1.8.2判断是否在区间内

var x:Int=3
if(x in 1..8) 
    x=x+1
else
    x=x-1

1.8.3When语句

类似于Java的switch语句,其写法为

var x:Int=3
When(x){
    in 1..3-> x=x+1     //判断是否在某个区间内
    4 -> x=x+2          //相当于case(4):
    else->{             //相当于default:
        x=x+3
    }
}

1.9循环控制

1.9.1 for循环

Kotlin for循环写法和java不同

var k:Int=0
for(i in 1..8 ){
    k=k+1
}

1.9.2 while循环

var x:Int=0
while(x<100){
    x=x+1
}

1.9.3标签@

使用标签可以指定break,continue,return等语句执行后的返回位置

var x:Int=0
list@ for(i in 1..100){
    for(j in 1..10){
        if(x>100)
            continue @list    //将跳转到外层循环
        x=x+1
    }
}

1.10 类

1.10.1初始化一个类

class Apple constructor(str:String){     //主构造函数
    init{
        birthDate=str                    //初始化代码
    }
    var price:Double
    var birthDate:String
    constructor(birth:String,price:Double):this(birth){     //次构造函数
        
    }
}

fun main(args:Array<String>?){
    val testApple:Apple=Apple("20220413")
    testApple.price=123.5
}

1.10.2内部类和嵌套类

嵌套类就是直接在类内部声明的一个类,内部类在嵌套类的基础上class前增加了inner关键字,它持有外部类的引用:

class OuterClass{
    val x:Int=3
    inner class InnerClass{       //内部类,可调用外部类成员变量
        fun test(){
            print(x)
        }
    } 
    class Test{                   //嵌套类,不能调用外部类成员变量
        fun test(){               
        
        }
    }
}

1.10.3类修饰符和类限定符

类修饰符包括abstract(抽象),final(不可继承,类默认是final),enum(枚举类),annotation(注解类),open(类可继承)几种,和java相比多了一个open修饰符。

访问权限修饰符包括private,protected,public,internal(同一个模块可见),和java相比,多了一个internal关键字,该关键字的功能类似于java中的默认访问权限符。

1.10.4类的继承

Kotlin所有的类都继承自Any类,类似于java中所有的类都继承自Object类,因此他们默认具有toString()、hashcode()、equals()方法,如果想要一个类可以被继承,则需要在声明该类的时候加open修饰符,如果想在子类继承这个类的过程中重写该类的方法,则该类的方法在声明时也需要加open,子类在重写时要加override关键字,一个类继承另一个类的步骤如下:

open class Father(firstName:String){
    val x:Int
    open fun talk(){
        print("Hello")
    }
}

class Son(firstName:String,secondName:String):Father(firstNmae){    
    //子类的“:”后边写要继承的类,同时子类必须在构造函数中初始化父类的构造函数
    override val x:Int=3      //属性重写
    override fun talk(){      //方法重写
        print("Hi")
    }
    constructor(firstNmae:String,secondNmae:String,idCard:String):Super(fristNmae){
        //二级构造函数中重写了父构造函数的方法
    }
}

1.11接口

接口的声明和java一样,使用interface进行声明,不同的是,接口中的变量都是抽象变量,不能赋初始值,但接口中的方法可以有默认的实现方法

interface FatherA{
    fun talk(){
        print("Hello")       //接口中方法有默认实现
    }
    fun play()
}

interface FatherB{
    fun talk()
    fun play()
}

class Son:FatherA,FatherB{   //子类继承多个接口
    override fun talk(){
        super<FatherA>.talk()      //调用父类FatherA的函数 
        print("Father")
    }
}

1.12扩展

扩展是一个很方便的方法,它可以在不继承某个类的情况下给该类增加方法,属性,但是又不会覆盖掉原有的方法,具体写法如下:

class ClassA{
    fun talk(){
        print("Hello")
    }
}
class ClassB{
    fun ClassA.play(){      //在ClassB类中对ClassA类的方法进行扩展
        talk()              //扩展过程中可以调用ClassA类中的方法
        print(" World")     
    }
}

1.13反射

kotlin中获取一个类的class对象的方式为:

class Test{}
val clazz=Test::class.java

  • 0
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值