El camino para aprender Kotlin (4): clases, constructores, objetos

prefacio

Hay una gran diferencia entre las clases de kotlin y las clases de Java, y también es un enfoque del aprendizaje de kotlin. A continuación se presenta la introducción de las clases de kotlin y los puntos de conocimiento relacionados.

1. Variables y métodos de clases y miembros

1.1 Modificadores de acceso

Los amigos que estén familiarizados con Java deben saber que Java tiene estos modificadores de acceso: privado, predeterminado (predeterminado), protegido, público.
La siguiente es una tabla de modificadores de acceso Java:

modificador de acceso	misma clase	mismo paquete	subclase	en cualquier lugar
privado	Sí	No	No	No
predeterminado (predeterminado)	Sí	Sí	No	No
protegido	Sí	Sí	Sí	No
público	Sí	Sí	Sí	Sí
(Sí: accesible, No: no accesible)

Entonces, ¿qué pasa con los modificadores de acceso de kotlin?
En kotlin, cambie el valor predeterminado (predeterminado) a public y agregue internal, y los demás son los mismos que Java.

La siguiente es la tabla de modificadores de acceso de kotlin:

modificador de acceso	misma clase	mismo paquete	subclase	mismo modulo	en cualquier lugar
privado	Sí	No	No	No	No
protegido	Sí	Sí	Sí	No	No
interno	Sí	Sí	Sí	Sí	No
público (predeterminado)	Sí	Sí	Sí	Sí	Sí

Para el modificador de clase, se debe enfatizar:

1. internal, el alcance de este modificador es un módulo. El llamado módulo puede considerarse como un componente, un paquete de soporte de terceros, y las variables o clases modificadas por internal no pueden ser utilizadas por otros módulos.
2. La clase class es por defecto (sin ningún modificador) public final, lo que significa que por defecto, 1. La clase es pública y otras clases pueden acceder a ella 2. La clase no se puede heredar .

1.2 Clases y Objetos

La siguiente es la clase más simple.

// 定义了一个Person类
// kotlin默认访问权限修饰符就是public
class Person {
    
    
}

fun main(){
    
    
    val person = Person() // 创建一个Person对象
    // val person0:Person = Person() // 带类型的声明
    println(person) // person对象
}

La creación de objetos en kotlin es mucho más simple que en Java, e incluso no es necesario escribir la nueva palabra clave.

1.3 Variables miembro y métodos miembro

class Person {
    
    
	// 成员变量
    var name:String = "Jack"
    var age:Int = 23
    
    // 只读
    val id = 1001
	
	// 成员函数
    fun eat(food:String){
    
    
        println("eat $food")
    }
}

fun main(){
    
    
    val person = Person()
//  var person = Person() // 创建一个只读的Person对象
    println(person.name)
    println(person.age)
    println(person.id)
    person.eat("rice");
}

producción:

Jack
23
1001
eat rice

En el ejemplo de código anterior, tanto las variables miembro como los métodos miembros son públicos, por lo que se pueden llamar directamente en la función principal. Los lectores también pueden intentar cambiar a privado para modificar.

2. Constructor

Todavía hay una gran brecha entre el constructor de Kotlin y el constructor de Java. El constructor de Kotlin se divide principalmente en constructor primario y constructor secundario, que se presentarán uno por uno a continuación.

2.1 Constructor primario

Kotlin, como Java, tiene un constructor predeterminado que no admite argumentos. Si se especifican parámetros, la escritura general es la siguiente:

La forma general de escribir un constructor primario con parámetros es la siguiente:

// 自动创建同名的成员变量name和age，同时默认是public属性的
class Person constructor(var name:String, var age:Int){
    
    
}

fun main(){
    
    
    val person = Person("Jack", 23)
    println("name is ${
      
      person.name} age is ${
      
      person.age}")
}

producción:

name is Jack age is 23

Hay algunas cosas a tener en cuenta sobre el código anterior:

1. constructor(var name:String, var age:Int)Es el constructor principal de esta clase. constructorLas palabras clave se pueden omitir.
2. Entre ellos, var name:String, var age:Intse creará automáticamente en la clase una variable miembro con el mismo nombre ( valla modificada es la misma), y el valor inicializado es el valor del parámetro del constructor.
3. Para los parámetros del constructor principal var name:String, var age:Int. Si no se agrega var, no se creará una variable miembro con el mismo nombre, sino que solo representará los parámetros de la función.

Cualquiera que haya escrito Java sabe que las clases de Java se pueden inicializar en el cuerpo de la función del constructor:

public class Person {
    
    
    public Person() {
    
    
    	// 构造函数的函数体，这个可以省略
    }
}

Entonces, ¿Kotlin tiene una funcionalidad similar? ¡La respuesta es sí! Esto requiere una introducción al uso de Kotlin init{}.

class Person constructor(name:String, age:Int){
    
    
	// 成员变量
    var mName:String = ""
    var mAge:Int = -1;
    // init代码块
    init {
    
    
    	// 类似Java构造函数体
        mName = name
        mAge = age
        // 其他的初始化过程
    }
}

fun main(){
    
    
    val person = Person("Jack", 23)
    println("name is ${
      
      person.mName} age is ${
      
      person.mAge}")
}

El ejemplo anterior es el init{}uso correcto, puede init{}implementar la función de inicialización de la clase en él, al igual que usar el cuerpo de la función del constructor de Java.

Como se mencionó anteriormente, para simplificar el código del constructor principal, constructorse puede omitir Kotlin como palabra clave:

class Person(var name:String, var age:Int){
    
    
}

Hacerlo puede hacer que el código sea más conciso. Por supuesto, las palabras clave del constructor principal constructorno son inútiles. Cuando necesite agregar derechos de acceso al constructor, debe agregarlo constructor.

// 直接将构造函数修饰为private
class Person private constructor(var name:String, var age:Int){
    
    
}

fun main(){
    
    
	// 由于设置构造函数为privae,无法创建对象。
    val person = Person("Jack", 23) // 报错
    println("name is ${
      
      person.name} age is ${
      
      person.age}")
}

Dado que el constructor principal puede agregar modificadores de acceso, también se pueden agregar el nombre y la edad de las variables miembro:

// 相当于成员变量name和age设置为private
class Person constructor(private var name:String, private var age:Int){
    
    
}

fun main(){
    
    
    val person = Person("Jack", 23)
    // 由于成员变量name和age设置为private，所以这里报错
    println("name is ${
      
      person.name} age is ${
      
      person.age}")
}

Lo anterior es cómo usar el constructor principal. A través del ejemplo anterior, puedes concluir una oración. En Kotlin, el constructor principal es el punto de entrada de la clase .

2.2 Constructores secundarios

Para Java, sabemos que el constructor puede estar sobrecargado, y lo mismo ocurre con Kotlin, hay una sobrecarga del constructor, que es el constructor secundario.

class Person (var name:String, var age:Int){
    
    

    // 次构造函数
    constructor(name: String):this(name, 22)

    // 次构造函数
    constructor(age: Int):this("Jack", age)
    
// private constructor(age: Int):this("Jack", age)
}

fun main(){
    
    
    val person0 = Person("Jack")
    println("name is ${
      
      person0.name} age is ${
      
      person0.age}")

    val person1 = Person(23)
    println("name is ${
      
      person1.name} age is ${
      
      person1.age}")
}

Al igual que el constructor primario, el constructor secundario también puede estar precedido por un modificador de acceso.
Hay una regla muy importante para el constructor secundario, es decir, el constructor secundario debe llamar directa o indirectamente al constructor primario,
el siguiente código es un ejemplo incorrecto:

class Person (var name:String, var age:Int){
    
    

    // 次构造函数
    constructor(name: String):this(name, 22)

    // 次构造函数
    constructor(age: Int) // 报错
}

Este error se produce si el constructor secundario no llama al constructor principalPrimary constructor call expected

3. esta palabra clave

thisPalabras clave Además de las utilizadas anteriormente para apuntar al constructor principal, thislas palabras clave también representan objetos de la clase actual.

/**
 * 这里的this都代表当前类的对象
 */
class Person (name:String, age:Int){
    
    
    var name:String = "name"
    var age:Int = 22
    init {
    
    
        this.name = name
        this.age = age
    }

    fun selfIntroduce(){
    
    
    	// 这里也可以省略this
        println("I am ${
      
      this.name}, ${
      
      this.age} years old")
    }
}

fun main(){
    
    
    val person = Person("Jack", 23)
    person.selfIntroduce()
}

producción:

I am Jack, 23 years old

Otro uso de esto es con un calificador.Este this@xxxuso se usa principalmente para clases anónimas y clases internas, y se complementará más adelante cuando se presenten clases anónimas y clases internas.

Finalizar

Lo anterior trata sobre el uso simple y la introducción de clases, constructores y objetos de kotlin. Bienvenido a corregir errores y compartir.