Skip to content
Able Blog
Home
Others
  • Home
      • 学习笔记
          • Android
            • 简历_赵思琦_Android_5年经验
                • Kotlin
                    • HandFirstKotlin程序设计
                      • 01. 快速入门
                        • 02. 基本类型和变量:关于变量
                          • 1. 变量
                            • 2. 强制类型转换
                              • 3. 数组
                                • 3.1 val可以限制变量不能指向其他数组
                                  • 3.2 val不能限制数组中的变量更引用,或者说数组中的变量重新赋值
                                    • 3.3 只读数组
                                  • 03. 函数
                                    • 04. 类和对象
                                      • 05. 子类和父类
                                        • 06. 抽象和接口
                                          • 07. 数据类
                                            • 08. 空值和异常
                                              • 09. 集合
                                                • 10. 泛型
                                                  • 11. Lambda和高阶函数
                                                    • 12. 内置高阶函数
                                                      • 12. 协程

                                                02. 基本类型和变量:关于变量

                                                author iconAblecalendar icon2022年5月6日category icon
                                                • Kotlin
                                                tag icon
                                                • 变量
                                                • 学习笔记
                                                word icon约 412 字

                                                此页内容
                                                • 1. 变量
                                                • 2. 强制类型转换
                                                • 3. 数组
                                                  • 3.1 val可以限制变量不能指向其他数组
                                                  • 3.2 val不能限制数组中的变量更引用,或者说数组中的变量重新赋值
                                                  • 3.3 只读数组

                                                # 02. 基本类型和变量:关于变量

                                                # 1. 变量

                                                1. 变量持有对象的引用,在Kotlin中基本类型也是对象。

                                                2. 虽然基本类型是对象,但是在做如下操作时

                                                var a=1;
                                                var b=a;
                                                var a=3;
                                                println(a)
                                                println(b)
                                                
                                                1
                                                2
                                                3
                                                4
                                                5

                                                输出

                                                3
                                                1
                                                
                                                1
                                                2

                                                var b=a 是取出a的值,复制他们,并将该副本保存至b。 这意味着a的变更并不会影响到b的值,和java一样。

                                                但是创建类的对象的情况

                                                class Entity{
                                                    var name: String = ""
                                                }
                                                
                                                fun main(args: Array<String>) {
                                                    var a = Entity()
                                                    a.name = "赵思琦"
                                                    var b = a
                                                    a.name="牛掰"
                                                    println(a.name)
                                                    println(b.name)
                                                }
                                                
                                                1
                                                2
                                                3
                                                4
                                                5
                                                6
                                                7
                                                8
                                                9
                                                10
                                                11
                                                12

                                                输出

                                                123
                                                123
                                                
                                                1
                                                2

                                                a也会发生改变,并不是复制,而是引用。

                                                # 2. 强制类型转换

                                                var b:Double=1.0
                                                var a:Int=b.toInt()
                                                
                                                1
                                                2

                                                将b的值复制到a的内存中,如果b的占用内存空间大于a,那么就会出现溢出的情况,这时编译器会舍弃掉超出的部分。

                                                当然,这不是直接截取。 着涉及到数值正负/位运算/二进制/2的补数。

                                                # 3. 数组

                                                    var a= arrayOf("1",2,3)
                                                
                                                1

                                                如上,它支持不同类型的变量的集合。编译器会自动推断对应的类型。

                                                数组中持有变量,而变量持有值的引用。

                                                # 3.1 val可以限制变量不能指向其他数组

                                                  val a= arrayOf("1",2,3)
                                                   a= arrayOf(1,2,3)
                                                
                                                1
                                                2

                                                # 3.2 val不能限制数组中的变量更引用,或者说数组中的变量重新赋值

                                                  val a= arrayOf(1,2,3)
                                                  a[0]=1
                                                
                                                1
                                                2

                                                # 3.3 只读数组

                                                  val a= arrayOf("1",2,3)
                                                  a[0]=1 //这里编译通过,但是会运行时异常
                                                
                                                1
                                                2
                                                edit icon编辑此页open in new window
                                                上次编辑于: 2022/5/8 23:44:01
                                                贡献者: zsqan
                                                上一页
                                                01. 快速入门
                                                下一页
                                                03. 函数
                                                默认页脚
                                                Copyright © 2022 Able