整数型和类型推断
/**
* 数字类型
* 类型名 含义 位数
* Long 长整型 64
* Int 整数 32
* Short 短整数 16
* Byte 字节 8
* Double 双精度小数 64
* Float 浮点数(小数) 32
*/
var name: Int =3 //由于kotlin有类型推断系统,所以Int可以不用写
var longNumber = 1266666L
var doubleNumber = 22.64
var floatNumber = 12.3F
var byteNumber = 0xACF
//kotlin不支持自动扩展数字范围,转换必须手动进行
//toByte() toShort() toInt() toLong() toFloat() toDouble() toChar()
var int1 = 9999
var long = int1.toLong()
var float1 = 78.7674F
var double = float1.toDouble()
//位运算:左移运算、右移运算、无符号右移运算、逻辑与运算、逻辑或运算、异或运算和取反运算。和java不同的是,这些不是内建运算符
//而是用中缀函数来代替的
var number1 = 1 shl 2 //左移二
var number2 = 1 shr 2 //右移二
var number3 = 1 ushr 2 //无符号右移二
var number4 = 1 and 0x00001111 //逻辑与1111
var number5 = 1 or 0x00001111 //逻辑或1111
var number6 = 1 xor 0x00001111 //异或1111
var number7 = 1.inv() //取反
浮点数(小数)
Kotlin中小数默认是Double类型,
可以使用toInt()方法把小数截断成整数,不是四舍五入,而是完全砍掉。如:3.14.toInt()结果是3
fun main(args: Array<String>) {
var pi = 3.141592653589793238
println(pi)
}
布尔类型:Boolean
fun main(args: Array<String>) {
var vip = false
vip = true
var price = false
price =true
if (vip){
println("欢迎vip会员")
}else{
println("请充值")
}
}
元组:可以把多个值同时赋值给一个变量,或者给多个变量同时赋值
Kotlin中元组只有二元和三元,也就是最多一次容纳3个值
fun main(args: Array<String>) {
var course = Triple(3,"学会","Kotlin")
var price = Pair("学费",0)
println("${course.first}天${course.second}${course.third}}")
println(",${price.first}${price.second}元!")
}
可空类型:所有"实体的"类型与空的组合
写法:Int? String? Boolean? ?指空值null
fun main(args: Array<String>) {
var addr:String? = "北京朝阳望京soho"
var sex:Boolean?
sex = false
if (sex != null && sex == true){
println("先生,您好")
}else{
println("美女,您好!")
}
}
基础操作符:有一元、二元、三元操作符。三元操作符只有一个、基本不用
fun main(args: Array<String>) {
/**
* 一元操作符
* 对于一个变量值取负数,只需要在前面跟一个"-"号
*/
var a = 3
a = -100
var b = + a
var c = - a
println("${b},${c}")
/**
* 二元操作符
*
*/
var d = a + c
println(d)
/**
* 比较操作符:有4种,> >= < <=
*/
println(2 > 3)
println(3 >= 3)
println(2 < 3)
println(2 <= 3)
}
异常处理和类初始化
Kotlin中异常处理和java几乎一模一样,kotlin中所有的异常都是非必检的
必检异常:必须定义成方法的一部分或者在方法内部处理
非必检异常:没什么必要加入到方法中的异常
fun main(args: Array<String>) {
//类初始化:不需要new
var file1 = File("/usr/bin/ruby")
var data = Date(20170702)
}
//异常处理
fun readFile(path :Path):Unit{
val input = Files.newInputStream(path)
try {
var byte = input.read()
while (byte != -1){
println(byte)
byte = input.read()
}
}catch (e : IOException){
println("读取文件错误,因为:${e.message}")
}finally {
input.close()
}
}
引用相等和结构相等
引用相等:是指两个无关联的对象指向了内存中的同一个实例
结构相等:两个对象分别位于内存中的不同区域但是他们的值是相同的
fun main(args: Array<String>) {
//引用相等,使用=== 或 !==操作符
var file1 = File("/usr/bin/ruby")
var file2 = File("/usr/bin/ruby")
var sameRefer = (file1 === file2)
println(sameRefer) //打印false
//结构相等,使用== 和 != 操作符
val sameStruct = (file1 == file2)
println(sameStruct) //打印true
}
区间:区间是有一个起始值和终止值的间隔。
任意可以比较大小的类型都可以创建一个区间,使用".."操作符
fun main(args: Array<String>) {
val v = "a".."z"
val y = 1..100
//一旦区间创建好,就可以用in操作符来测试指定的一个值是否包含在其中
var d = "d" in v
var c = 38 in y
//downTo()函数可以创建一个倒序排列的区间
val f = 10.downTo(0)
//一旦区间创建,可以更改区间生成一个新区间。更改区间中的每一个单项前进的幅度,即步进(step),使用step函数
val z = y.step(2) //1到100间的奇数
for (i in z){
println(i)
if (i == 99)break
println(",")
}
//不能用负数创建一个递减的区间,区间可以用reversed()函数进行翻转,这个函数返回一个从终止值到起始值、步进反向的区间
var a = (1..100).step(2).reversed()
for (i in a){
print(i)
if (i == 1) break
print(",")
}
}
控制流作为表达式
fun main(args: Array<String>) {
val a = 5
var b = 3
val isToday = if (a > b) true else false
println(isToday)
//同样的技巧也可以用在try-catch中
val readSuccess = try {
return
}catch (e : IOException){
false
}
//when表达式
isMinOrMax(5)
isZeroOrOne(2)
isPositive(3)
}
when表达式:是java中switch的升级版,不仅可以对值进行判断,还可以对函数判断和区间判断
fun isMinOrMax(x : Int) :Boolean{
val isZero = when (x) {
Int.MIN_VALUE -> true
Int.MAX_VALUE -> true
else -> false
}
return isZero
}
fun isZeroOrOne(x:Int) = when (x) {
0,1 -> true
else -> false
}
fun isPositive(x: Int)= when (x){
Math.abs(x) -> true
else -> false
}
fun aa(x: Int)= when (x){
in -9..9 -> true
else -> false
}
fun bb(x: Int)=when (x){
in arrayOf(1,2,3,4,5,6) -> true
else -> false
}
//when中还可以用只能类型转换,只能类型转换可以让编译器在运行时校验变量类型
fun cc(any :Any):Boolean{
return when(any){
is String -> any.startsWith("Kotlin")
else -> false
}
}
//无参数when语句:类似于多分支的if(){}else{}语句
fun dd(a:Int,b:Int){
when{
a < b -> println("a小于b")
a > b -> println("a大于b")
else -> println("a等于b")
}
}
函数返回:使用return关键字
fun main(args: Array<String>) {
}
fun addTwoDouble(a:Double,b:Double):Double{
return a + b
}
fun maxNumber(a:Int,b:Int,c:Int):Int{
fun maxNumber(a: Int,b: Int):Int{
if (a > b)
return a
else
return b
}
return maxNumber(maxNumber(a,b),maxNumber(b,c))
}
fun number(){
val list = listOf(-1,0,2,5,99)
list.forEach(fun (x){
if (x < 9) println(x)
else return
})
println("此行继续会执行!")
}
kotlin超类:any
ktolin中最上层类型是Any,任意类型,相当于java中的object
Unit类型等价于java中的void
kotlin增加了一个最底层类型--Nothing,这个类型没有实例
any类型是所有类型的父类,Nothing类型是所有类型的子类
fun main(args: Array<String>) {
}
循环:kotlin中有两种循环:while和for循环
fun main(args: Array<String>) {
while (true){
println("这个事无限循环")
}
//kotlin中for循环用于迭代任何一个预定义或者扩展了一个名为iterator的函数,所有集合类型都提供了这个函数
val list1 = listOf(1,2,3,4)
for (k in list1){
println(k)
}
var set1 = setOf(1,2,3,4)
for (k in set1){
println(k)
}
var array1 = arrayOf(1,2,3,4)
for (k in array1){
println(k)
}
var aa = 1..10
for (k in aa){
for (j in 1..8){
println(k * j)
}
}
val slogan = "123456"
for (char in slogan){
println(char)
}
//数组有一个索引集合的扩展函数indices,可以用来迭代一个数组的索引
val fiveNumbers = arrayOf(1,2,3,4,5)
for (index in fiveNumbers.indices){
println(index)
}
}