Skip to content
Able Blog
Home
Others
  • Home
      • 学习笔记
          • Android
            • 简历_赵思琦_Android_5年经验
                • Kotlin
                    • HandFirstKotlin程序设计
                      • 01. 快速入门
                        • 02. 基本类型和变量:关于变量
                          • 03. 函数
                            • 04. 类和对象
                              • 1. 构造函数
                                • 2. 初始化块
                                  • 3. get和set
                                    • 4. 总结
                                    • 05. 子类和父类
                                      • 06. 抽象和接口
                                        • 07. 数据类
                                          • 08. 空值和异常
                                            • 09. 集合
                                              • 10. 泛型
                                                • 11. Lambda和高阶函数
                                                  • 12. 内置高阶函数
                                                    • 12. 协程

                                              04. 类和对象

                                              author iconAblecalendar icon2022年5月8日category icon
                                              • Kotlin
                                              tag icon
                                              • 类
                                              • 对象
                                              • 学习笔记
                                              word icon约 362 字

                                              此页内容
                                              • 1. 构造函数
                                              • 2. 初始化块
                                              • 3. get和set
                                              • 4. 总结

                                              # 04. 类和对象

                                              • 属性: 对象自身的特点

                                              延迟属性:lateinit

                                              • 方法: 对象的行为

                                              # 1. 构造函数

                                              • 主构造函数:类头的一部分,最先调用
                                              class Person constructor(firstName: String) { /*……*/ }
                                              
                                              1
                                              • 次构造函数:可以由多个,根据代码顺序调用
                                                constructor(name: String){
                                                      println("初始代码块构造")
                                              
                                                  }
                                              
                                              1
                                              2
                                              3
                                              4

                                              # 2. 初始化块

                                              按照类中代码的顺序运行

                                              # 3. get和set

                                              get和set方法,在对象被初始化,使用属性时调用。

                                              class B {
                                                  constructor() {
                                                      println("构造调用")
                                                  }
                                              }
                                              
                                              class People(name: String) {
                                                  init {
                                                      println("初始代码块1")
                                                  }
                                                  init {
                                                      println("初始代码块2")
                                                  }
                                                  var name: String = name
                                                      set(value) {
                                                          if (value.length > 5)
                                                              field = value
                                                      }
                                                      get() = field
                                              
                                                  val b:B =B()
                                                  init {
                                                      println("初始代码块3")
                                                  }
                                              }
                                              
                                              fun main(args: Array<String>) {
                                                  val people = People("赵思琦")
                                                  println(people.name)
                                              }
                                              
                                              1
                                              2
                                              3
                                              4
                                              5
                                              6
                                              7
                                              8
                                              9
                                              10
                                              11
                                              12
                                              13
                                              14
                                              15
                                              16
                                              17
                                              18
                                              19
                                              20
                                              21
                                              22
                                              23
                                              24
                                              25
                                              26
                                              27
                                              28
                                              29
                                              30

                                              # 4. 总结

                                              类中的属性,可以认为是变量的集合。

                                              而方法,是控制这些变量的行为。

                                              而对象,是将类实例化后的东西,创建对象时在内存中开辟了这些变量总和大小的内存空间。

                                              而面向对象的编程方法,简单来说,就是将需要重复创建的变量,找出他们的共同特性,组装成变量的集合(类),然后使用方法/函数,控制他们的行为及变化。

                                              或是另一种理解

                                              类是模板,是变量待使用的状态。当真正初始化,创建为对象时,才创建这个模板中的变量。

                                              edit icon编辑此页open in new window
                                              上次编辑于: 2022/5/9 23:34:01
                                              贡献者: zsqan
                                              上一页
                                              03. 函数
                                              下一页
                                              05. 子类和父类
                                              默认页脚
                                              Copyright © 2022 Able