从零学习kotlin之基础类型

kotlin基础类型

1.分隔符

（1）分号 ；

​ 每行不强制要求以 “；”结尾，但是如果一行内有多个语句，则前面 的语句必须以；结尾

​ kotlin运行一条语句跨多行，但是字符串变量名不能换行。

var str =
” fkit” 
／／表达式可以跨多行
str += 
” abc “

//字符串或者变量名不能换行
var str="11
	22"

（2）花括号

​ 定义代码块{}

（3）方括号

​ 用于访问数组、集合元素，如

    //数组的第四个元素赋值
    a[3] = 3	
    //map key设置为“kotlin“	
    scores["kotlin"]=92

（4）圆括号

（5）空格

（6）原点

2.标志符

​ 标识符区分大小写，可以由字母、数字以及下划线_组成。这里的字母不局限于英文字母，可以包含中文等。

​ 开头不能以数字，不能包含空格。

3.关键字

​ kotlin关键字可以分成三类：硬关键字、软关键字、修饰关键字

（1）硬关键字

​ 这些关键字无论在什么情况下都不能用作标识符。

as一一 用于做类型转换或为 import 语句指定别名

as?一一类型安全的类型转换运算符。
break一一中断循环
class一一声明类。
continue 一忽略本次循环剩下的语句，重新开始下一次循环。
do一一用于 do while 循环
else一一在 if 分支中使用
false一一在 Boolean 类型中表示假 的直接量。
for一一用于 for 循环
fun 一一声 明函数
if－在 if 分支中使用
in 一一在 for 循环中使用； in 还可作为双目运算符，检查 一个值是否处于区间或集合 内；
in 也可 在when 表达式中使用； in 还可用于修饰泛型参数，表明该泛型参数支持逆变
!in 一一可作为双目运算符 的反义词：！in 也可在 when 表达式中使用
is 一一用于做类型检查（类 Java instanceof) 或在 when 表达式中使用
!is一一 用于做类型检查（ is 的反义词〉或在 when 表达式中使用
null 一一 代表空的直接量。
object ------用于声明对象表达式或定义命名对象
package一一用于为当 前文件指定包
return 一一声明函数的返回
super一－用于引用父类实现的方法或属性，或者在子类构造器中调用父类构造器
this 一一 代表当前类的对象或在构造器中调用当前类的其他构造器
throw一一用于抛出异常
true 一一在 Boolean 类型中表示真的直接量。
try一一开始异常处理
typealias一一用于定义类型别名。
val 一声明只读属性或变量。
var一一声明可变属性或变量。
when一一用于 when 表达式。while一一－用于 while 循环或 do while 循环

（2）软关键字

​ 这些关键字可以在它们不起作用的上下文中用作标识符。

by一一用于将接口或祖先类的实现代理给其他对象。
catch 一一在异常处理中用于捕捉异常
constructor一一用于声明构造器。
delegate 一用于指定该注解修饰委托属性存储其委托实例的字段
dynamic一一主要用于在 Kotlin/JavaScript 中引用 一个动态类型
field 一一用于指定该注解修饰属性的幕后字段。
file 一一用于指定该注解修饰该源文件本身
finally一一异常处理中的 finally
get一一用于声明属性的 getter 方法，或者用于指定该注解修饰属性的 getter 方法
import一一用于导包。
init一一用于声明初始化块
param 一一用于指定该注解修饰构造器参数
property一一用于指定该注解修饰整个属性（这种目标的注解对 Java 不可见，因为 Java
并没有真正的属性）。
receiveris一一用于指定该注解修饰扩展方法或扩展属性的接收者
set一一用于声明属性的 setter 方法，或者用于指定该注解修饰属性的 setter 方法
setparam 一一用于指定该注解修饰 setter 方法的参数
where一一用于为泛型参数增加限制。

（3）修饰关键字

​ 这些关键字也可以在代码中用作标识符。

abstract一一用于修饰抽象类或抽象成员
annotation 一一用于修饰一个注解类。
companion 一一用于声明一个伴生对象
const一一用于声明编译时常量
crossinline一一用于禁止在传给内联函数的 Lambd 表达式中执行非局部返回
data一一用于声明数据类。
enum一一用于声明枚举
external一一用于声明某个方法不由 Kotlin 实现（与 Java 的 native 相似〉。
final 一一用于禁止被重写
infix一一声明该函数能以双目运算符的格式执行
inline 一一用于声明内联函数， Lambda 表达式可在内联函数中执行局部返回。
inner一一用于声明内部类，内部类可以访问外部类的实例
internal 一一用于表示被修饰的声明只能在当前模块内可见
lateinit-------用于修饰 non-null 属性，用于指定该属性可在构造器以外的地方
初始化
noinline一一用于禁止内联函数中个别 Lambda 表达式被内联化
open 一一用于修饰类，表示该类可派生子类；或者用于修饰成员，表示该成员可以被
重写。
out一一用于修饰泛型参数，表明该泛型参数支持协变。
override一一用于声明重写父类的成员
private ------private 访问权限
protected --------protected 访问权限
public-------public 访问权限。
reified 一一用于修饰内联函数中的泛型形参，接下来在该函数中就可像使用普通类型
一样使用该类型参数。
sealed一一用于声明一个密封类。
suspend 一一用于标识一个函数后 Lambda 表达式可作为暂停。
tailrec一一用于修饰一个函数可作为尾随递归函数使用。
vararg 一一用于修饰形参，表明该参数是个数可变

4.整型

​ 整型有四种Int（32位）、Short（16位）、Byte（8位）、Long（64位）。

​ 当一个很大值被声明时，会默认为Long类型。如果此时声明为Int或者Short类型时，编译器会报错。如下所示。

//报错
var bigInteger:Int=11111111111111111;
//正确
var bigInteger:Long=11111111111111111；

​ 整型和java不同的是，整型不是基本数据类型，而是引用类型，继承自Number类。在变量类型后面加上？，一方面能表示可空，另一方面 普通的类型会映射成java的基本数据类型 如Int类型 会映射为java 的int类型；而带？的类型 则映射成java的包装类型 ，如Int？映射成java的Integer类型。

​ 如下所示， ==代表值的比较，===代表地址的比较 ，不带？的Int映射到java中就是基本数据类型的比较，因此地址肯定相同。而到？映射到java中就是包装类型Integer ，不同对象有不同的地址，自然返回false。

fun main() {
    var integet1: Int = 11111;
    var integet2: Int = 11111;
    //true
    println(integet1===integet2);
    var integet3: Int? = 11111;
    var integet4: Int? = 11111;
		//false
    println(integet3===integet4);

}

​ kotlin支持三种进制，分别是十进制 二进制（0b开头）以及十六进制（0x开头）

5. 浮点型

​ 浮点类型可以保护小数，存储比Long更大的数值，浮点型有两种Float和Double。

​ Float 32位，当精度要求不高可以使用

​ Double 64位，当精度要求高或者存储数值大时使用。

​ 此外浮点数有两种表达方式，分别是十进制形式以及科学计数法。

​ 十进制形式：必须包含. 如3.14 25.3等

​ 科学计数法：例如5.12e2 代表的就是 5.12*10^2。注：只有浮点类型的数字才能使用科学技术法表示，比如52100代表的是Int类型，而521e2代表浮点类型。系统提供了三个特殊的浮点类型，正无穷大（-Infinity）、负无穷大（-Infinity）以及非数（NaN）。比如利用正数除以0.0得到正无穷，0.0除以0.0或者对负数开方得到非数，需要注意的是只有浮点才可以这么做。如果把正数除以0（整型）此时会报错。

​ 另外所有的正无穷大的值相同，负无穷大也相同；非数与任何数值都不相同，包括自己。

6.字符型

​ 字符型有三种表示方式。

• 直接通过单个字符来指定 如’a’
• 通过转移字符来制定’’\n’
• 使用Unicode来表示字符值，’\uXXXX’的一个十六进制的整数来代表，如’\u000a’代表换行符。可以表示65536个字符，其中前256个字符等同于ASCII码的字符

​ 需要注意的是和java中不同的是，kotlin中的Char类型变量不能当作整数值使用，整型变量也不能赋值给Char类型。比如如下写法在kotlin中就会报错。

char ch=41;

​ Kotlin运行数值类型通过toChar()方式转化成字符。此外虽然Char类型不能当作数值进行算数技术，但是为char类型提供了加减的支持，有两种方式：

​ （1）字符 + 数字 = 字符 （Char）

​ （2）字符 + 字符 = 数字（Int）

val ch: Char = 'a';
val ch2: Char = 'b';
//输出e
println(ch + 4);
//输出-1
println(ch-ch2);

​ 如果不知道什么时候能变成数值什么时候不能的话，可以暂时理解成 等号不行，加减可以。

7.数据类型转化

（1）整数的转化

​ kotlin不支持小转大的隐式转化

//java中正常运行
 byte a=11;
 int b=a;
//kotlin报错
var btye:Byte=1;
var integet1: Int = btye;

​ 换句来说，所有的数据类型转化必须显式转化。kotlin为所有的数据类型，都提供了以下方法:toByte() toShort() toInt() toLong() toFloat() toChar() 等。

​ 将较大的数值赋值给较小的数据类型时，编译器会报错，当大的数据类型显示转化成小的数据类型时，会发生溢出的情况，比如将int类型转化成byte类型，此时会发生溢出。

val num=150;
//num2=-106
val num2:Byte=num.toByte();

​ 虽然kotlin没有隐式转化，但是在表达式中能根据上下文进行自动的转化。计算时，会将表达式中的变量提升到表达式中最高等级的数据类型（Byte和Short默认会提升为Int）计算。

val num:Byte=10;
val num2:Short=150;
//此时num3 是Int类型 
val num3=num+num2;

val num:Byte=10;
val num2:Long=150;
//此时num3 是Int+Long=Long类型 
val num3=num+num2;

​

（2）浮点数和整数的转化

​ 浮点和整型之间的转化也需要显示转化。转化时由小的数据类型转成大的数据类型比较安全，他们的从小到大的排序是：Byte、Short、Int、Long、Float、Double。

（3）类型自动提升

​ 这个在前面已经说到了，这里就简单地提一下一个典型的错误。

var num:Short=5;
num=num-2;

​ 第一行中声明了一个Short类型的变量num。

​ 第二行中等号左边是short类型，等号右边是 num-2表达式是Int类型，原因是表达式计算中会将short类型提升为Int类型，因此等号右边是Int类型。所以将一个Int类型赋值给Short类型就会报错。

​ 正确写法

var num:Short=5;
num=(num-2).toShort();

8.Boolean类型

​ kotlin中布尔类型取true或者false，不能由0或者非0进行转化

9.Elvis运算

​ 实际上是if else的简写。

var b: String? =” fkit” 
／／先判断不为null，然后访问length属性
var lenl =if (b !=null) b.length else -1 
println (lenl); 
b = null 
／／使用Elvis运算符
var len2 = b?.length ?: -1 
println(len2);

​ ?: 作用 是判断是否左边的表达式是否为null，如果是的话，就是返回后面的-1否则就正常返回b.length的值。另外return和throw都是表达式，可以跟在?:后，当作为null时的处理。

10.变量声明

• 有两个关键字var 和val

  var用于变量

  val用于常量（类似于java里的final类型，一旦被赋初值就不能改变）

  它们声明的方式都相同 【关键字】【变量名】：【类型】（？）=【值】

  【】代表必写 （）代表可选 ?代表该变量可空，在后面进行更详细的介绍。

  举个例子

  val a: Int = 1
  

常量与变量都可以没有初始化值,但是在引用前必须初始化，如不声明时初始化，则必须提供变量类型。

例如

val c: Int      // 如果不在声明时初始化则必须提供变量类型
c = 1           // 明确赋值

编译器支持自动类型判断,即声明时可以不指定类型,由编译器判断。

var x = 5        // 系统自动推断变量类型为Int
x += 1           // 变量可修改

11.函数声明

• 函数格式 【fun】 【方法名称】【（变量 1 ：变量类型1,变量 2：变量类型 2） 】（：返回类型）{

  ​ //方法体

  }

  举个例子，该方法 参数 a b都是Int 类型，返回值也为Int类型

  fun sum(a: Int, b: Int): Int {   // Int 参数，返回值 Int
      return a + b
  }
  

• 方法可以为无返回值 此时返回类型为Unit 可以省略

• 当表达式作为函数体时，返回类型可以参略，但public方法不可以

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

• 可变长参数函数

可用vararg

fun vars(vararg v:Int){
    for(vt in v){
        print(vt)
    }
}

// 测试
fun main(args: Array<String>) {
    vars(1,2,3,4,5)  // 输出12345
}

• lambda表达式

  不用lambda

   // 源代码    
   fun test(a : Int , b : Int) : Int{
   		 return a + b
   }
  

  使用lambda

  val test: (Int, Int) -> Int = {x,y -> x+y}
  

  或者

   val test = {a : Int , b : Int -> a + b}
  

• 特点：lambda表达式总是被大括号包围，参数在->前，函数体在->后，如图所示。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0gL9TLnL-1598752388450)(/Users/bjhl/Documents/工程考试模块学习笔记/20181101134054622.png)]

• 语法如下

		1. 无参数的情况 ：
    val/var 变量名 = { 操作的代码 }
    例如
		// 源代码
   	fun test(){ println("无参数") }
    // lambda代码
    val test = { println("无参数") }
   

 2. 有参数的情况
    val/var 变量名 : (参数的类型，参数类型，...) -> 返回值类型 = {参数1，参数2，... -> 操作参数的代码 }
    例如
        // 源代码
    fun test(a : Int , b : Int) : Int{
        return a + b
    }

    // lambda
    val test : (Int , Int) -> Int = {a , b -> a + b}
   
   

或者

    可等价于 val/var 变量名 = { 参数1 ： 类型，参数2 : 类型, ... -> 操作参数的代码 }
    // 此种写法：即表达式的返回值类型会根据操作的代码自推导出来。
		val test = {a : Int , b : Int -> a + b}

 3. lambda表达式作为函数中的参数的时候，这里举一个例子：
    fun test(a : Int, 参数名 : (参数1 ： 类型，参数2 : 类型, ... ) -> 表达式返回类型){
        ...
    }
    

12.字符串模板

$表示变量值如$a 代表a的值，${p.fun()}表示返回fun的值

例如

var a = 1
// 模板中的简单名称：
val s1 = "a is $a" //s1 = a is 1

    var a = 1
// 模板中的简单名称：
    val s1 = "a is $a"
    a=2
    //这里${s1.replace("is", "was")}代表 返回s1把is替换为was后返回的值
    val s2 = "${s1.replace("is", "was")}, but now is $a"//s2 = a was 1, but now is 2

13.NULL检查机制

kotlin对于可为空的变量，采取了两种处理措施。

1）变量后面加！！，当使用为null的变量时，会类似java一样抛出空异常

var age: String?=null;
//抛出空指针异常
val ages = age!!.toInt()
fun main() {
    print(ages)
}
//报错信息
Exception in thread "main" java.lang.ExceptionInInitializerError
Caused by: kotlin.KotlinNullPointerException
	at MainKt.<clinit>(Main.kt:3)

2）变量后面加？,表示该变量可以为空，不作处理返回null或者配合?:进行判空后的处理

例如

var age: String?=null
//如果为空，返回hello
val ages = age?:"hello";
fun main() {
    print(ages)
}

14.类型的检测和转化

通过关键字is可以检测一个表达式是否是某类型的实例，类似java的 instanceof。

当通过is检测后，会自动转为该类型

fun getStringLength(obj: Any): Int? {
  if (obj is String) {
    // 做过类型判断以后，obj会被系统自动转换为String类型
    return obj.length 
  }

  //在这里还有一种方法，与Java中instanceof不同，使用!is
  // if (obj !is String){
  //   // XXX
  // }

  // 这里的obj仍然是Any类型的引用
  return null
}

15.区间

通过…和in关键字可以实现区间上的遍历

例如

for (i in 1..4) print(i) // 输出“1234”

for (i in 4 downTo 1) print(i) // 输出“4321”

此外可以设置步长，通过step设置

// 使用 step 指定步长
for (i in 1..4 step 2) print(i) // 输出“13”

for (i in 4 downTo 1 step 2) print(i) // 输出“42”

until设置左闭右开区间

// 使用 until 函数排除结束元素
for (i in 1 until 10) {   // i in [1, 10) 排除了 10
     println(i)
}