文章目录
- 1.field
- 2.计算属性
- 3.主构造函数
- 4.次构造函数
- 5.默认参数
- 6.初始化块
- 7.初始化顺序
- 7.延迟初始化lateinit
- 8.惰性初始化
1.field
field 关键字通常与属性的自定义 getter 和 setter 一起使用。当你需要为一个属性提供自定义的行为时，可以使用 field 来访问或设置该属性的实际存储值。
class Player {
var age: Int = 0
get() = field // 自定义 getter
set(value) { // 自定义 setter
if (value >= 0) {
field = value
} else {
println("年龄不能为负数")
}
}
}
fun main() {
val player = Player()
player.age = 30 // 正常设置
println(player.age) // 输出 30
player.age = -5 // 尝试设置无效的年龄
println(player.age) // 输出 30（因为设置失败，所以仍然是 30）
}
更复杂的自定义行为
class Person {
private var _age: Int = 0 // 私有字段
var age: Int
get() {
println("获取年龄: $_age")
return _age
}
set(value) {
if (value >= 0) {
println("设置年龄: $value")
_age = value
} else {
println("年龄不能为负数: $value")
}
}
}
fun main() {
val person = Person()
person.age = 30 // 输出: 设置年龄: 30
println(person.age) // 输出: 获取年龄: 30
// 30
person.age = -5 // 输出: 年龄不能为负数: -5
println(person.age) // 输出: 获取年龄: 30
// 30
}
- field 关键字：在自定义的 getter 和 setter 中，field 代表属性背后的实际存储字段。
- 自定义 getter 和 setter：允许你在读取和写入属性时执行额外的逻辑，如数据验证、日志记录等。
- 私有字段：为了更好地控制属性的访问，可以使用私有字段来存储实际值，并通过公开的属性提供访问接口。
2.计算属性
- 计算属性：这些属性没有后台字段来存储值，而是通过 getter 方法在每次访问时计算并返回值。
- 自定义 getter：你可以在类中定义一个没有显式初始化值的 val 属性，并为其提供一个自定义的 getter 方法。
class Rectangle(val width: Int, val height: Int) {
// 计算属性
val area: Int
get() = width * height // 自定义 getter
}
fun main() {
val rectangle = Rectangle(10, 5)
println("宽度: ${rectangle.width}") // 输出 宽度: 10
println("高度: ${rectangle.height}") // 输出 高度: 5
println("面积: ${rectangle.area}") // 输出 面积: 50
}
3.主构造函数
在People类的定义头中定义一个主构造函数，使用临时变量为Player的各个属性提供初始值，在Kotlin中，为了便于识别临时变量通常都会以下划线开头的名字命名。
class People(
_name:String,
_age:Int,
_isNormal:Boolean
) {
var name = _name
get() = field.capitalize()
set(value){
field = value.trim()
}
var age = _age
get() = field
set(value){
field = value.absoluteValue
}
var isNormal = _isNormal
}
fun main(){
val people = People("Jack", 20, true)
println(people.name)
println(people.age)
println(people.isNormal)
}
4.次构造函数
除了主构造函数还有次构造函数，我们可以定义多个次构造函数来配置不同的参数组合。
class People0(
_name:String,
var age:Int,
var isNormal:Boolean
) {
var name = _name
get() = field.capitalize()
set(value){
field = value.trim()
}
constructor(name : String) : this(name , age = 10, isNormal = false) {
this.name = name.capitalize()
}
}
fun main(){
val people0 = People0("rose")
println(people0.name) // Rose
println(people0.age) // 0
println(people0.isNormal) // false
}
5.默认参数
定义构造函数时，可以给构造函数指定默认值，如果用户调用时不提供值参，就是用这个默认值。
class People1(
_name:String,
var age:Int = 99,
var isNormal:Boolean = false
) {
var name = _name
get() = field.capitalize()
set(value){
field = value.trim()
}
constructor(name : String) : this(name , age = 10, isNormal = false) {
this.name = name.capitalize()
}
}
fun main(){
val people1 = People1(_name = "jim")
println(people1.name) // Jim
println(people1.age) // 99
println(people1.isNormal) // false
}
6.初始化块
初始化块可以设置变量或值，以及执行有效性检查，如检查传给某构造函数的值是否有效，初始化块代码会在构造类实例时执行。
class People1(
_name:String,
var age:Int = 99,
var isNormal:Boolean = false
) {
var name = _name
get() = field.capitalize()
set(value){
field = value.trim()
}
constructor(name : String) : this(name , age = 10, isNormal = false) {
this.name = name.capitalize()
}
init {
require(age > 0){"年龄设置不能小于0"}
}
}
fun main(){
val people1 = People1(_name = "jim",-1, false)
println(people1.name) // Jim
println(people1.age) // 198
println(people1.isNormal) // false
}
7.初始化顺序
- 主构造函数里声明的属性
- 类级别的属性赋值
- init初始化块里的属性赋值和函数调用
- 次构造函数里的属性赋值和函数调用
class Student(
_name : String,
val age : Int
){
var name = _name
var score = 10
var hobby = "music"
val subject : String
init {
println("initializing student...")
subject = "Chinese"
}
constructor(_name:String) : this(_name,10){
score = 100
}
}
fun main(){
val student = Student("Jack")
}
public Student(@NotNull String _name) {
Intrinsics.checkNotNullParameter(_name, "_name");
this(_name, 10);
this.score = 100;
}
public Student(@NotNull String _name, int age) {
Intrinsics.checkNotNullParameter(_name, "_name");
super();
this.age = age;
this.name = _name;
this.score = 10;
this.hobby = "music";
String var3 = "initializing student...";
System.out.println(var3);
this.subject = "Chinese";
}
7.延迟初始化lateinit
- 使用lateinit关键字相当于做了一个约定：在用它之前负责初始化
- 只要无法确认lateinit变量是否完成初始化，可以执行isInitialized检查
class Player4 {
lateinit var equipment : String
fun ready(){
equipment = "AK-47"
}
fun battle(){
if (::equipment.isInitialized){
println(equipment)
}else{
println("没有武器")
}
}
}
fun main(){
val player4 = Player4()
// player4.ready()
player4.battle()
}
8.惰性初始化
延迟初始化并不是初始化的唯一方式，你也可以暂时不初始化某个变量，知道首次使用它，叫做惰性初始化。
class Player5(_name :String) {
var name = _name
val config by lazy {
loadConfig()
}
private fun loadConfig():String{
println("loading...")
return "xxx"
}
}
fun main() {
val p = Player5("kim")
Thread.sleep(4000)
// 4s后才会打印
println(p.config)
}
![[项目详解][boost搜索引擎#2] 建立index | 安装分词工具cppjieba | 实现倒排索引](https://i-blog.csdnimg.cn/direct/572c7984df9d4a75acc2e60977a66813.png)
