Kotlin语法入门-数据类、伴生类、枚举类(9)

Kotlin语法入门-数据类、伴生类、枚举类(9)

九、数据类、伴生类、枚举类

1、数据类

特点：数据类的主构造函数必须要有参数，还有添加data关键字

data class A(val name: String, val age: Int) 
1

使用：其中有个方法叫copy可以进行对象的复制（普通class对象是没有copy方法的）

打印的时候直接使用对象，因为底层实现了**toString()**方法，普通对象使用必须复写toString()方法。

fun main() {
    var a = A("刘德华", 17)
    var copy = a.copy("李建")
    println(a) //直接使用对象，因为底层实现了toString()方法
    println(copy)
}

data class A(val name: String, val age: Int){}
1
2
3
4
5
6
7
8

运行结果：

通过var copy = a.copy(“李建”)这个函数，进行复制A对象这个数据对象，并且传入值“李建”，但是没有传入age值，这是因为其底层实现将变化的值进行修改，默认值就不变，copy方法实现源码如下：

data class 常用于后端请求的响应之类的，常用于数据模型的使用。

2、伴生类

2.1、定义伴生类

伴生类（companion class）是Kotlin中的一个特殊类，它与普通类不同，可以包含类似Java中的静态成员和方法。

在Kotlin中，类不能有静态成员，但是可以使用伴生类来模拟静态成员和方法的行为。伴生类可以访问其所属类的私有成员，并且可以通过类名直接访问其伴生对象的成员。

伴生类的成员可以通过类名直接访问，而不需要创建类的实例。

fun main() {
  A.Companion.print()
}
 class A() {
    companion object {
        fun print() {
            println("A")
        }
    }
}
1
2
3
4
5
6
7
8
9
10

伴生类也支持接口实现，类的继承等。

2.2、@JvmStatic注解

• @JvmStatic注解用于将伴生对象中的成员标记为静态成员，使得这些成员可以在Java代码中直接通过类名访问，而不需要通过实例化对象来访问。

• 在Kotlin中，伴生对象的成员默认是在包含伴生对象的类的内部访问的，因此如果想要在Java代码中直接访问伴生对象的成员，就需要使用@JvmStatic注解来标记这些成员。

• 这样可以更好地与Java代码进行互操作，使得Kotlin代码更加灵活和易于使用。

代码示例：

kotlin代码：

fun main() {

}
 class A() {
    companion object {
        @JvmStatic
        fun print1() {
            println("print1")
        }

        fun print2() {
            println("print2")
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

java代码：

public class JavaMain {
    public static void main(String[] args) {
        A.Companion.print1();
        A.print1();
        A.Companion.print2();
    }
}

1
2
3
4
5
6
7
8

输出，相当远只是不用多写一个Companion：

2.3、const关键字

• 在Kotlin中，const关键字用于声明常量。

• 在伴生类中，如果想要声明一个常量，可以使用const关键字来修饰伴生对象中的属性。

• 被const修饰的属性必须是基本数据类型或String类型，并且必须在编译时就能确定其值。

例如：

class MyClass {
    companion object {
        const val PI = 3.14
    }
}
1
2
3
4
5

在上面的例子中，PI被声明为一个常量，其值为3.14。在使用时，可以通过类名直接访问这个常量，而不需要实例化对象。

常量在编译时会被替换为其实际值，因此在运行时不会存在常量的实例。常量的值在编译时就已经确定，不会发生变化。

3、枚举类

3.1、定义

定义与Java没太大区别：

fun main() {
    Test.NAME
}

enum class Test {
    NAME,
    AGE
}
1
2
3
4
5
6
7
8

与Java不一样的地方：

3.2、传参

fun main() {
    println(Test.NAME)
    println(Test.NAME.value)
    println(Test.NAME.name)
}

enum class Test(val value: String) {
    NAME("name"),
    AGE("age")
}
1
2
3
4
5
6
7
8
9
10

fun main() {
    println(Test.NAME.value)
    println(Test.AGE.value)
}

enum class Test(val value: String="value") {
    NAME(), //没有值则使用默认值
    AGE("age")
}
1
2
3
4
5
6
7
8
9

3.3、继承与实现

fun main() {
    Test.NAME.testInterfaceTest()
    Test.AGE.testInterfaceTest()
}

enum class Test() : TestInterface {
    NAME() {
        override fun testInterfaceTest() {
            println("NAME testInterfaceTest...")
        }
    },
    AGE() {
        override fun testInterfaceTest() {
            println("AGE testInterfaceTest...")
        }
    }
}

interface TestInterface {
    fun testInterfaceTest()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

可以理解为在一个类A中套用了许多静态类，然后就是调用静态类的过程。

本质上枚举成员是继承自枚举对象的。

当然，Java中也可以随便调用：