Skip to content
Able Blog
Home
Others
  • Home
      • 学习笔记
          • Android
            • 简历_赵思琦_Android_5年经验
                • Kotlin
                    • HandFirstKotlin程序设计
                      • 01. 快速入门
                        • 02. 基本类型和变量:关于变量
                          • 03. 函数
                            • 04. 类和对象
                              • 05. 子类和父类
                                • 06. 抽象和接口
                                  • 07. 数据类
                                    • 1. 数据类的来源
                                      • 1.1 equals(any:Any) Boolean
                                        • 1.2 hashcode():Int
                                          • 1.3 toString():String
                                            • 1.4 重写/生成这些方法
                                            • 2. 数据类的coye方法
                                              • 3. componentN方法
                                                • 3.1 依次获取数据类中属性的值
                                                  • 3.2 将属性值依次赋值给变量
                                                  • 4. 使用默认参数
                                                    • 4.1 构造函数中使用
                                                      • 4.2 普通函数中也可使用
                                                        • 4.3 辅助构造函数
                                                        • 5. 数据类的使用技巧及注意事项
                                                        • 08. 空值和异常
                                                          • 09. 集合
                                                            • 10. 泛型
                                                              • 11. Lambda和高阶函数
                                                                • 12. 内置高阶函数
                                                                  • 12. 协程

                                                            07. 数据类

                                                            author iconAblecalendar icon2022年5月11日category icon
                                                            • Kotlin
                                                            tag icon
                                                            • 学习笔记
                                                            word icon约 584 字

                                                            此页内容
                                                            • 1. 数据类的来源
                                                              • 1.1 equals(any:Any) Boolean
                                                              • 1.2 hashcode():Int
                                                              • 1.3 toString():String
                                                              • 1.4 重写/生成这些方法
                                                            • 2. 数据类的coye方法
                                                            • 3. componentN方法
                                                              • 3.1 依次获取数据类中属性的值
                                                              • 3.2 将属性值依次赋值给变量
                                                            • 4. 使用默认参数
                                                              • 4.1 构造函数中使用
                                                              • 4.2 普通函数中也可使用
                                                              • 4.3 辅助构造函数
                                                            • 5. 数据类的使用技巧及注意事项

                                                            # 07. 数据类

                                                            # 1. 数据类的来源

                                                            数据类来源于所有类的父类:Any。 也就是说所有类都是多态的。他们拥有一些共同的行为(方法/函数),但数据类重写了一些方法

                                                            # 1.1 equals(any:Any) Boolean

                                                            # 1.1.1 普通类

                                                            equals等价于==,比对了他们的引用,是否是同一个对象。

                                                            # 1.1.2 数据类

                                                            比对了对象与对象属性的值,如果他们相同,那么返回true。 而不是比对引用,如需对比引用 可使用 === 操作符

                                                            并且:如果属性在构造方法外不会被比对

                                                            # 1.2 hashcode():Int

                                                            哈希码值往往被某些数据结构应用于更高效的存储或获取值。

                                                            # 1.2.1 普通类

                                                            引用不同hashcode也不同

                                                            # 1.2.2 数据类

                                                            属性的值相同hashcode也相同

                                                            # 1.3 toString():String

                                                            # 1.3.1 普通类

                                                            内存地址

                                                            # 1.3.2 数据类

                                                            类的属性的的值的拼接

                                                            # 1.4 重写/生成这些方法

                                                            idea中操作 代码->生成

                                                            # 2. 数据类的coye方法

                                                            复制了对象的副本,在复制对象副本时,可以对val属性重新写入值

                                                            data class People(var name:String,var age:Int)
                                                            
                                                            fun main(args: Array<String>) {
                                                                val people=People("赵思琦",27)
                                                                val peopleCopy = people.copy(name = "李景风")
                                                                println(peopleCopy)
                                                            }
                                                            
                                                            1
                                                            2
                                                            3
                                                            4
                                                            5
                                                            6
                                                            7

                                                            输出:

                                                            People(name=李景风, age=27)
                                                            
                                                            1

                                                            # 3. componentN方法

                                                            # 3.1 依次获取数据类中属性的值

                                                                val people = People("赵思琦", 27) 
                                                                println(people.component1())  // 等同于people.name
                                                                println(people.component2())  // 等同于people.age
                                                            
                                                            1
                                                            2
                                                            3

                                                            # 3.2 将属性值依次赋值给变量

                                                              val people = People("赵思琦", 27)
                                                                val (name)=people
                                                                val (name1,age1)=people
                                                                println(name1)
                                                                println(name)
                                                                println(age1)
                                                            
                                                            1
                                                            2
                                                            3
                                                            4
                                                            5
                                                            6

                                                            # 4. 使用默认参数

                                                            # 4.1 构造函数中使用

                                                            构造函数中的参数/任何函数的参数都可以被赋初始值, 在使用时,可以根据自己的需要对属性重新赋值。

                                                            data class People(var name: String="赵思琦", var age: Int=27)
                                                            
                                                            fun main(args: Array<String>) {
                                                                val people = People(name = "zzzz")
                                                                println(people)
                                                            }
                                                            
                                                            1
                                                            2
                                                            3
                                                            4
                                                            5
                                                            6

                                                            # 4.2 普通函数中也可使用

                                                            fun show(str:String ="随便输出"){
                                                                println(str)
                                                            }
                                                            
                                                            1
                                                            2
                                                            3

                                                            # 4.3 辅助构造函数

                                                            data class People(var name: String, var age: Int){
                                                                constructor(age: Int) :this("赵思琦",age)
                                                            }
                                                            
                                                            fun main(args: Array<String>) {
                                                                val people = People(27)
                                                                println(people)
                                                            }
                                                            
                                                            1
                                                            2
                                                            3
                                                            4
                                                            5
                                                            6
                                                            7
                                                            8

                                                            # 5. 数据类的使用技巧及注意事项

                                                            • 数据类在kotlin1.1以后可以继承其他类 , 但不能被继承。

                                                            • 数据类可以实现接口

                                                            edit icon编辑此页open in new window
                                                            上次编辑于: 2022/5/11 23:45:36
                                                            贡献者: zsqan
                                                            上一页
                                                            06. 抽象和接口
                                                            下一页
                                                            08. 空值和异常
                                                            默认页脚
                                                            Copyright © 2022 Able