Kotlin实战(一)

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/zping0808/article/details/85016903

1、简介

Kotlin 是一个用于现代多平台应用的静态编程语言,由 JetBrains 开发。
Kotlin可以编译成Java字节码,也可以编译成JavaScript,方便在没有JVM的设备上运行。
Kotlin已正式成为Android官方支持开发语言(Google IO 2017宣布)。

分享关于kotlin的几个网站

2、基本使用

2.1、第一个Kotlin程序(定义函数)

使用控制台打印出“Hello,Kotlin!”

fun main(args: Array<String>): Unit {
    //打印Hello,Kotlin!
    println("Hello,Kotlin!")
}

fun 固定写法

main 函数名(main函数)

args 函数参数名,可以随便写(如a,bb)

Array 参数类型 此处表示字符串数组类型

Unit 函数返回值 ,此处Unit表示无返回值,可以省略不写

println(“Hello,Kotlin!”) 函数体

2.2、基本数据类型

Kotlin 提供了如下的内置类型来表示数字(与 Java 很相近):

类型(Type) 位宽度(Bit width)
Double 64
Float 32
Long 64
Int 32
Short 16
Byte 8
//基本数据类型定义如下
val byte:Byte=10
val int:Int=100
val long:Long=1L
val double:Double=1.123
val float:Float=1.21212F
val short:Short=10

//布尔(Boolean)类型 它有两个值:true 与 false
val boolean:Boolean=false
//字符(Char)类型 它有两个值:true 与 false
val char:Char='A'

2.3、字面常量

数值常量字面值有以下几种:

  • 十进制: 123
    Long 类型用大写 L 标记: 123L

  • 十六进制: 0x0F

  • 二进制: 0b00001011

    注意: 不支持八进制

Kotlin 同样支持浮点数的常规表示方法:

默认 double:123.5、123.5e10
Float 用 f 或者 F 标记: 123.5f

2.4、数字字面值中的下划线(自1.1版本起)

可以使用下划线使数字常量更易读

val oneMillion = 1_000_000
val creditCardNumber = 1234_5678_9012_3456L
val socialSecurityNumber = 999_99_9999L
val hexBytes = 0xFF_EC_DE_5E
val bytes = 0b11010010_01101001_10010100_10010010
println(oneMillion)//1000000
println(creditCardNumber)//1234567890123456
println(socialSecurityNumber)//999999999
println(hexBytes)//4293713502
println(bytes)//3530134674

2.5、" == " 和 " === "的区别

kotlin java
== equal
=== ==
val a: Int = 999
val b: Int? = a
val c: Int? = a
println(b == c)    //true
println(b === c)   //false

这个和java中运行结果是在意料之中, == 比较数值, 而===比较的是地址, 前者为true, 后者为false. 那么看下面这段代码的运行情况:

val a: Int = 999
val b: Int = a
val c: Int = a
println(b == c)     // true
println(b === c)    // true

这段代码和第一段代码的区别就是IntInt?的区别, 为什么=== 的运算结果会不一样呢? 再看下面这段代码

val a: Int? = 999
val b: Int? = a
val c: Int? = a
println(b == c)    //true
println(b === c)   //true

这段代码和第一段代码的区别就是第一行的Int?Int的区别, 而运行出来的结果 === 也是true。

下面这个就是对上述现象的最好的解释

注意一点: 在 java 平台上,数值被 JVM 虚拟机以字节码的方式物理存储的,除非我们需要做可空标识(比如说 Int?) 或者涉及泛型,在后者中数值是装箱的。也就是说如果我们使用的是val a : Int = 999, 这种方式, 其实a就是个数值, 不涉及装箱的问题, 不是个对象, 而如果我们使用的是val a: Int? = 999, 这样的话, a是一个Int型对象, 涉及到装箱问题, 这样就很好解释为什么第一段代码的===是false, 因为a是数值, 而b, c是装箱后的对象, 而第二段代码a, b, c都是数值, 第三段代码a, b, c都是同一个对象

2.6、基本数据类型取值范围

val maxShort=Short.MAX_VALUE
val minShort=Short.MIN_VALUE
//Short最小值-32768,最大值32767
println("Short最小值$minShort,最大值$maxShort")

val maxInt=Int.MAX_VALUE
val minInt=Int.MIN_VALUE
//Int最小值-2147483648,最大值2147483647
println("Int最小值$minInt,最大值$maxInt")

val maxByte=Byte.MAX_VALUE
val minByte=Byte.MIN_VALUE
//Byte最小值-128,最大值127
println("Byte最小值$minByte,最大值$maxByte")

val maxLong=Long.MAX_VALUE
val minLong=Long.MIN_VALUE
//Long最小值-2147483648,最大值2147483647
println("Long最小值$minInt,最大值$maxInt")

val maxFloat=Float.MAX_VALUE
val minFloat=Float.MIN_VALUE
//Float最小值-2147483648,最大值2147483647
println("Float最小值$minInt,最大值$maxInt")

val maxDouble=Double.MAX_VALUE
val minDouble=Double.MIN_VALUE
//Double最小值-2147483648,最大值2147483647
println("Double最小值$minInt,最大值$maxInt")

2.7、Kotlin调用Java

val m=212.3234343454546546
println(m)
//省略new关键字
val bigDecimal = BigDecimal("212.3234343454546546")
println(bigDecimal)

2.8、智能类型推断和类型转换

/*----------------------kotlin智能类型推断------------------------*/
//    类型安全的语言:类型一但确定,不再改变了
// kotlin 自动推断为Int类型
    var a=10
    var b:Byte=10
    var c=10L//Long
    var d=20F//Float
    var e=1.234//Double

    /*----------------------类型转换------------------------*/
    // String和int类型转换
    val a1="10"
    println(a1.toInt())
    //long类型和int类型转换
    val a2=100L
    print(a2.toInt()
    //int类型和long类型转换
    val a3=10
    print(a3.toLong())

每个数值类型都支持下面的转换:

  • toByte(): Byte
  • toShort(): Short
  • toInt(): Int
  • toLong(): Long
  • toFloat(): Float
  • toDouble(): Double
  • toChar(): Char

2.9、可变变量和不可变变量

//可变变量
var a=10
a=11
//不可变变量
val b=1

var是一个可变变量,这是一个可以通过重新分配来更改为另一个值的变量。这种声明变量的方式和Java中声明变量的方式一样。

val是一个只读变量,这种声明变量的方式相当于java中的final变量。一个val创建的时候必须初始化,因为以后不能被改变。

不可变对象也可以说是线程安全的,因为它们无法去改变,也不需要去定义访问控制,因为所有线程访问到的对象都是同一个。所以在Kotlin中,如果我们想使用不可变性,我们编码时思考的方式需要有一些改变。一个重要的概念是:尽可能地使用val。除了个别情况(特别是在Android中,有很多类我们是不会去直接调用构造函数的),大多数时候是可以的。如果使用var一般都需要判空。

Kotlin实战(二)

没有更多推荐了,返回首页

私密
私密原因:
请选择设置私密原因
  • 广告
  • 抄袭
  • 版权
  • 政治
  • 色情
  • 无意义
  • 其他
其他原因:
120
出错啦
系统繁忙,请稍后再试

关闭