赞
踩
可以多次赋值的变量是可变变量,用关键字var表示:
var <标识符> : <类型> = <初始化值> 注意,在kotlin中成员变量不会赋默认值,不像java一样,必须手动添加默认值。
- var name : String ="yuanzhen"
- name ="yuanzhen1"
- var age : Int =20
- age =30
- println("name:$name,age:$age")
- 输出:
- name:yuanzhen1,age:30
只能赋值一次的变量,是不可变变量,用关键字val表示,类似于java里面的final:
val <标识符> : <类型> = <初始化值> 注意,在kotlin中成员变量不会赋默认值,不像java一样,必须手动添加默认值。
kotlin可以根据传入的值,自动推导出变量类型:
- var name ="yuanzhen" //类型推导
- name ="yuanzhen1"
- var age =20 //类型推导
- age =30
kotlin中的Unit相当于java中的void ,如果函数的返回值为Unit,可以不用写返回值
kotlin中使用fun关键字定义函数
定义一个有参数和返回值的函数:
- fun test(name1:String ,name2:String):String{
- return name1+name2
- }
调用:
- println(test("yuan","zhen"))
- //输出 yuanzhen
也可以根据类型推导,直接写成:
fun test(name1:String ,name2:String) =name1+name2
可变参数用关键字vararg表示:
- fun lenMethod(vararg value: Int) {
- for (i in value) {
- println(i)
- }
- }
调用:
lenMethod(1, 2, 3, 4, 5, 6, 7)
在kotlin中,$表示一个变量名或者变量值,$name 表示变量值,如果变量值有多个,可以写为:${name1+name2}
- var name ="yuanzhen1" //类型推导
- var name1 ="yuanzhen"
- println("${name+name1}")
输出:yuanzhen1yuanzhen
换行:""" """ 自己不用关心换行:
- val infoMesage = """
- AAAAAAAAAAA
- BBBBBBBBBBB
- CCCCCCCCCCC
- DDDDDDDDDDD
- EEEEEEEEEEE
- """ // 前置空格
- println(infoMesage)
- val infoMesage2 = """
- AAAAAAAAAAA
- BBBBBBBBBBB
- CCCCCCCCCCC
- DDDDDDDDDDD
- EEEEEEEEEEE
- """.trimIndent() // 没空格
- println(infoMesage2)
- val infoMesage3 = """
- ?AAAAAAAAAAA
- ?BBBBBBBBBBB
- ?CCCCCCCCCCC
- ?DDDDDDDDDDD
- ?EEEEEEEEEEE
- """.trimMargin("?") // 没空格 控制?
- println(infoMesage3)
输出:
-
- AAAAAAAAAAA
- BBBBBBBBBBB
- CCCCCCCCCCC
- DDDDDDDDDDD
- EEEEEEEEEEE
-
- AAAAAAAAAAA
- BBBBBBBBBBB
- CCCCCCCCCCC
- DDDDDDDDDDD
- EEEEEEEEEEE
- AAAAAAAAAAA
- BBBBBBBBBBB
- CCCCCCCCCCC
- DDDDDDDDDDD
- EEEEEEEEEEE
在kotlin中,如果你这么定义一个变量,一定会报错的
因为这是kotlin特有的机制,不允许直接赋空值。那么要怎么做呢?
var age:Int?=null
加个?的意思就相当于 我发出了一个广播,告诉所有人这个值可能是空的,必须要有处理措施。
第一种处理措施:
- var age:Int?=null
- val i = age?.and(2)
- println("$i")
输出:null
age?.and(2)的意思就是如果age是null,那就不执行?后面的内容了
第二种处理措施:
- var age:Int?=null
- age!!.and(2)
!!的意思就是我不管,我就强行执行and方法,出了事我负责。
第三种处理措施:
就跟java一样,自己判断处理
- var age:Int?=null
- if(age !=null){
- age.and(2)
- }
区间用..来表示
- // 1 到 9
- for (i in 1..9) {
- println(i)
- }
输出 1 2 3 4 5 6 7 8 9
那如果这样写呢?
- for (i in 9..1) {
- println(i)
- }
注意:这样是不会输出的,因为没有9到1这种写法,那如果非要输出9到1呢?
- for (i in 9 downTo 1) {
- println(i)
- }
要用downTo
还可以指定步长:
- for (i in 1..20 step 2) {
- println(i)
- }
输出:1 3 5 7 9 11 13 15 17 19 每隔2输出一个值
排除最后一个元素:
- for (i in 1 until 10) {
- println(i)
- }
输出:1 2 3 4 5 6 7 8 9
在java中比较两个字符串,用equls来比较,但是在kotlin中,用==来比较字符串的值
- val name1: String = "张三"
- val name2: String = "张三"
-
- println(name1 == name2)
比较对象地址用===表示
- // --- 比较对象地址
- val test1:Int? = 10000
- val test2:Int? = 10000
- println(test1 === test2)
输出false
在java中数组有三种创建方式:
- int[] array = {1,2,3};
- int[] array1 = new int[3];
- int[] array2 = new int[]{7,8,9};
在kotlin中 数组有两种方式:
第一种:
val numbers = arrayOf(1, 2, 3, 4, 5, 6, 7, 8)
第二种:
- val numbers2 = Array(10, {value: Int -> (value + 200) })
- for (value in numbers2) {
- println(value)
- }
输出:
200
201
202
203
204
205
206
207
208
209
为什么会这样呢? 因为value的默认值是0,之后会依次加一。
比较大小值,可以这样写:
- val number1: Int = 99
- val number2: Int = 88
- // 表达式 比 大小 最大值
- val maxValue = if (number1 > number2) number1 else number2
- println(maxValue)
输出99
如果要执行多行代码,还可以这样写:
- val max: Int = if (number1 > number2) {
- println("number1是最大的")
- number1
- } else {
- println("number2是最大的")
- number2
- }
注意:返回值不需要加return关键字
when相当于java中的switch case,只不过用法更加灵活
用于某个值:
- val number5 = 5
- when(number5) {
- 1 -> println("一")
- 2 -> println("二")
- 3 -> println("三")
- 4 -> println("四")
- 5 -> println("五")
- else -> println("其他")
- }
用于区间:
- val number = 700
- when(number) {
- in 1..100 -> println("1..100")
- in 200..500 -> println("200..500")
- else -> println("其他")
- }
用于执行多行代码 并且有返回值:
- val number = 3
- val result = when (number) {
- 1 -> {
- println("很开心")
- "今天是星期一"
- 99
- }
- 2 -> {
- println("很开心")
- "今天是星期二"
- 88
- }
- 3 -> {
- println("很开心")
- "今天是星期三"
- true
- 100
- }
- else -> 99
- }
自定义标签:在kotlin中,我们可以自定义一个标签,用来控制程序的执行流程等
- yuanzhen@ for (i in 1..20) {
- for (j in 1..20) {
- println("i:$i, j:$j")
- if (i == 5) {
- // break // j循环 给break
- break@yuanzhen // i循环 给break
- }
- }
- }
一个类中自带的标签:
- class Yuan {
-
- val I = "aa"
-
- fun show() {
- println(I)
- println(this.I)
- println(this@Yuan.I)
- }
-
- }
在kotlin中,要遍历一个list,通常有三种方式:
var items = listOf<String>("aaa", "bbb", "ccc")
方式一:
- for (item in items) {
- println(item)
- }
方式二:
- items.forEach {
- println(it)
- }
方式三:
- for (index in items.indices) {
- println("下标:$index, 对应的值:${items[index]}")
- }
在kotlin中,创建一个类,如果前面不写修饰符,默认就是public final
- // 默认就是public final
- class Empty
这样是不能被继承的,要想被继承,就必须加上open
open class Person{}
在java中,会有一个默认的构造函数,并且可以重载无数个构造函数。
但是在kotlin中,它会有一个默认的主构造函数,其余的都是次构造。
上面的Person类,相当于有一个默认的主构造:
- open class Person() // 主构造
- {
-
- }
那如果我们要给主构造增加一个参数呢?
- open class Person(id: Int) // 主构造
- {
- }
那如果还要增加好几个次构造呢?
- open class Person(id: Int) // 主构造
- {
-
- // 次构造
- constructor(id: Int, name: String) : this(id) {
-
- }
-
- // 次构造
- constructor(id: Int, sex: Char) : this(id) {
-
- }
-
- // 次构造
- constructor() : this(222) {
-
- }
-
- }
次构造必须继承主构造,同时把参数传给主构造
在使用时,可以这么用:
- val person = Person() // 次构造
- val person2 = Person(23456) // 主构造
- Person(234, "yy") // 次构造
- Person(234, 'M') // 次构造
继承父类用:表示
- class Student(id: Int) : Person(id) // 主构造
- {
- // 再Kotlin 全部都是没有默认值的
-
- // 再Java 成员有默认值,但是方法内部没有默认值
-
- // lateinit 懒加载 不用立马赋值,在使用的时候赋值, 没有赋值 就不能使用,否则报错
- lateinit var name : String
- var age: Int = 0
- }
在kotlin中,接口和抽象类默认都是open的
- interface Callback {
-
- fun callbackMethod() : Boolean
-
- }
- interface Callback2 {
-
- fun callbackMethod() : Boolean
-
- }
- abstract class Person : Callback , Callback2 {
-
- abstract fun getLayoutID() : Int
-
- abstract fun initView()
-
- }
- class Student : Person() {
-
- override fun getLayoutID(): Int = 888
-
- override fun initView() { }
-
- override fun callbackMethod(): Boolean = false
- }
与java差别不大
数据类是kotlin中独有的,在java中,我们要写数据类,通常会手写很多属性和方法等。
在kotlin中,我们只需要用数据类定义属性就可以,不用关心get,set等方法,内部会自动帮我们生成。
- // 会自动生成get set 构造 equals hashCode toString copy
- data class User(val id: Int, val name: String, val sex: Char)
- val user = User(99, "lisi", 'M')
- //copy 函数
- val(myID, myName, mySex) = user.copy()
- println("myID:$myID, myName:$myName, mySex:$mySex")
在kotlin中,object只实例一次,相当于单例
- object MyEngine {
-
- fun m() {
- println("M run")
- }
-
- fun show() {
- println("我就只有一个实例")
- }
- }
companion :意思是同伴对象。相当于java的static.
下面来看一下kotlin中的单例模式怎么写:
方式一:
- class NetManager {
-
- // 只有一个实例
- object Holder {
-
- val instance = NetManager()
-
- }
-
- // 看不到 static 可以 派生操作
- companion object {
-
- // 全部都是 相当于 Java static
-
- fun getInstance() : NetManager = Holder.instance
- }
-
- fun show(name: String) {
- println("show:$name");
- }
-
- }
方式二:
- class NetManager2 {
-
- companion object {
-
- private var instance: NetManager2? = null
-
- // 返回值:允许你返回null
- fun getInstance(): NetManager2? {
- if (instance == null) {
- instance = NetManager2()
- }
-
- // 如果是null,也返回回去了
- return instance
-
- // 第二种补救: 我来负责 instance 肯定不为null
- // return instance!!
- }
-
- }
-
-
- fun show(name: String) {
- println("show:$name");
- }
-
- }
嵌套类,就是在类的内部又写了一个类,但是它不是内部类,拿不到外部类的成员。
- class Sub {
- fun show() {
- println()
- }
- class A {
- class B {
- class C {
- }
- }
- }
- }
在kotlin中,内部类用关键字inner来表示。
- class Sub {
- fun show() {
- println()
- }
- class A {
- class B {
- class C {
- }
- }
- }
- }
- // 这个才是内部类
- inner class Sub2 {
- fun show() {
- println(I)
- }
- }
- }
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。