Construtor no Kotlin (Constructor)

Neste artigo, você aprenderá sobre os construtores no Kotlin (construtor principal e secundário) e os blocos de inicialização, com a ajuda de exemplos.

O construtor é um método conciso para inicializar propriedades da classe.

É uma função membro especial chamada ao instanciar (criar) um objeto. No entanto, eles funcionam de maneira ligeiramente diferente no Kotlin.

No Kotlin, há dois construtores:

• Construtor principal - Método conciso de inicialização da classe

• Construtor secundário - Permite que você coloque outra lógica de inicialização

Construtor principal

O construtor principal é parte da cabeçalho da classe. Aqui está um exemplo:

class Person(val firstName: String, var age: Int) {
　　　　//　corpo da classe
}

O código entre parênteses é o construtor principal: (val firstName: String, var age: Int).

O construtor define duas propriedades: firstName (propriedade de leitura, pois é declarada com a palavra-chave val) e age (propriedade de leitura e escrita, pois é declarada com a palavra-chave var).

Exemplo: Construtor principal

fun main(args: Array<String>) {
　　　　val pessoa1　= Person("Joe",　25)
　　　　println("Nome = ${person1.firstName}")
　　　　println("Idade = ${person1.age")
}
class Person(val firstName: String, var age: Int) {
}

Quando o programa é executado, a saída é:

Nome = Joe
Idade =　25

Quando criamos um objeto da classe Person, passamos os valores Joe e 25Parece que Person é uma função.

Isso fará com que o person1 As propriedades firstName e age do objeto são inicializadas respectivamente com "Joe" e 25.

Existem outras maneiras de usar o construtor principal.

Construtor principal e bloco de inicialização

A sintaxe do construtor principal está restrita e não pode conter nenhum código.

Para posicionar o código de inicialização (não apenas o código de inicialização das propriedades), foi usado um bloco de inicialização. Ele começa com o prefixo init. Vamos modificar o exemplo acima com um bloco de instruções de inicialização:

fun main(args: Array<String>) {
　　　　val pessoa1　= Pessoa("joe",　25)
}
class Pessoa(fName: String, pessoaIdade: Int) {
　　　　val firstName: String
　　　　var idade: Int
　　　　//Bloco de inicialização
　　　　init {
　　　　　　　　firstName = fName.capitalize()
　　　　　　　　idade = pessoaIdade
　　　　　　　　println("Nome = $firstName")
　　　　　　　　println("Idade = $idade")
　　　　}
}

Quando o programa é executado, a saída é:

Nome = Joe
Idade =　25

Aqui, ao criar a pessoa1objeto, os parâmetros fName e pessoaIdade dentro dos parênteses recebem os valores "Joe" e 25No entanto, ao usar fName e pessoaIdade, não se usa var ou val, e elas não são propriedades da classe Pessoa.

A classe Pessoa declara duas propriedades firstName e idade.

ao criar uma pessoa1O objeto é criado, o código dentro do bloco de inicialização é executado. O bloco de inicialização não apenas inicializa suas propriedades, mas também as imprime.

Esta é outra maneira de executar a mesma tarefa：

fun main(args: Array<String>) {
　　　　val pessoa1　= Pessoa("joe",　25)
}
class Pessoa(fName: String, pessoaIdade: Int) {
　　　　val firstName = fName.capitalize()
　　　　var idade = pessoaIdade
　　　　//Bloco de inicialização
　　　　init {
　　　　　　　　println("Nome = $firstName")
　　　　　　　　println("Idade = $idade")
　　　　}
}

Para distinguir os parâmetros do construtor das propriedades, usamos nomes diferentes (fName e FirstName, bem como Personage e idade). Para os parâmetros do construtor, é mais comum usar _firstName e _idade, em vez de nomes completamente diferentes. Por exemplo：

class Pessoa(_firstName: String, _idade: Int) {
　　　　val firstName = _firstName.capitalize()
　　　　var age = _age
　　　　//　Bloco de inicialização
　　　　init {
　　　　　　　　...　..　...
　　　　}
}

Valores padrão no construtor principal

Você pode fornecer valores padrão para os parâmetros do construtor (semelhante a fornecerParâmetros padrão）。Por exemplo：

fun main(args: Array<String>) {
　　　　println("pessoa1　foi instanciada")
　　　　val pessoa1　= Pessoa("joe",　25)
　　　　println("pessoa2　foi instanciada")
　　　　val pessoa2　= Pessoa("Jack")
　　　　println("pessoa3　foi instanciada")
　　　　val pessoa3　= Pessoa()
}
class Pessoa(_firstName: String = "UNKNOWN", _idade: Int = 0) {
　　　　val firstName = _firstName.capitalize()
　　　　var age = _age
　　　　//Bloco de inicialização
　　　　init {
　　　　　　　　println("Nome = $firstName")
　　　　　　　　println("Idade = $age\n")
　　　　}
}

Quando o programa é executado, a saída é:

Nome = Joe
Idade =　25
pessoa2　instanciado
Nome = Jack
Idade = 0
pessoa3　instanciado
Nome = DESCONHECIDO
Idade = 0

Construtores secundários no Kotlin

Um classe no Kotlin pode conter um ou mais construtores secundários. Eles são criados usando a palavra-chave constructor.

Os construtores secundários no Kotlin não são muito comuns. A aplicação mais comum dos construtores secundários ocorre quando você precisa estender uma classe que fornece múltiplos construtores de inicialização de diferentes maneiras. Antes de aprender, certifique-se de que você já entendeHerança no Kotlin.

Você pode criar métodos de construtores secundários no Kotlin da seguinte forma:

class Log {
　　　　constructor(data: String) {
　　　　　　　　//　Alguns códigos
　　　　}
　　　　constructor(data: String, numberOfData: Int) {
　　　　　　　　//　Alguns códigos
　　　　}
}

Aqui, a classe Log tem dois construtores secundários, mas não um construtor principal.

Você pode estender a classe da seguinte forma:

class Log {
　　　　constructor(data: String) {
　　　　　　　　//　Código
　　　　}
　　　　constructor(data: String, numberOfData: Int) {
　　　　　　　　//　Código
　　　　}
}
class AuthLog: Log {
　　　　constructor(data: String): super(data) {
　　　　　　　　//　Código
　　　　}
　　　　constructor(data: String, numberOfData: Int): super(data, numberOfData) {
　　　　　　　　//　Código
　　　　}
}

Aqui, o construtor do subclasse AuthLog chama o construtor correspondente da classe base Log. Para isso, use super().

No Kotlin, você também pode usar this() para chamar um construtor de outro construtor da mesma classe (como no Java).

class AuthLog: Log {
　　　　constructor(data: String): this(data,　10) {
　　　　　　　　//　Código
　　　　}
　　　　constructor(data: String, numberOfData: Int): super(data, numberOfData) {
　　　　　　　　//　Código
　　　　}
}

Exemplo: Construtor secundário em Kotlin

fun main(args: Array<String>) {
　　　　val p1　= AuthLog("Senha incorreta")
}
open class Log {
　　　　var data: String = ""
　　　　var numberOfData = 0
　　　　constructor(_data: String) {
　　　　}
　　　　constructor(_data: String, _numberOfData: Int) {
　　　　　　　　data = _data
　　　　　　　　numberOfData = _numberOfData
　　　　　　　　println("$data: $numberOfData vezes")
　　　　}
}
class AuthLog: Log {
　　　　constructor(_data: String): this("From AuthLog　-> "　+　_data,　10) {
　　　　}
　　　　constructor(_data: String, _numberOfData: Int): super(_data, _numberOfData) {
　　　　}
}

Quando o programa é executado, a saída é:

From AuthLog　-Bad Password:　10　times

Atenção:Se a classe não tiver um construtor principal, o construtor secundário deve inicializar a classe base ou o delegado como outro construtor (como no exemplo acima).