1.Interface
1.) Definição de interface
- ) Use a palavra-chave interface para definir a interface
- ) A interface Kotlin pode ser abstrata ou fornecer uma implementação padrão (ou seja, o corpo do método é opcional)
- ) As propriedades de uma interface Kotlin devem ser declaradas abstratas (não podem ser inicializadas) ou fornecer implementações de acessador. E as propriedades declaradas na interface não podem ter um campo de apoio, então o acessador declarado na interface não pode se referir ao campo, e o acessador da variável mutável declarada em var depende do campo de apoio. Portanto, o atributo var só pode ser abstrato e o atributo val pode fornecer um acessador getter
Exemplo completo:
interface MyInterface {
val prop: Int // 抽象的
val parameterA:Int=1 //会报错，编译器提示不能在接口中初始化属性
val propertyWithImplementation: String //提供访问器
get() = "foo"
var parameterA : Int
get() = 1
//报错，编译器提示不能使用幕后字段。因为 var 声明的可变变量的访问器依赖幕后字段field，所以无论getter和setter访问器都无法使用
fun bar() //抽象的方法，没有方法体
fun foo() {
// 可选的方法体
}
}
2.) Implementação de interface
- ) Em Java, a palavra-chave implements é usada para implementar a interface, e em Kotlin,
dois pontos: implementa a interface. - ) Uma classe pode implementar uma ou mais interfaces.
- ) A implementação de uma interface requer a implementação de membros abstratos da interface.
Exemplo:
class Child : MyInterface {
override fun bar() {
// 方法体
}
}
3.) Herança de interface
A herança de interfaces é basicamente a mesma que em Java.
Uma interface pode ser derivada de outras interfaces, fornecendo assim não apenas a implementação dos membros da interface pai, mas também continuando a declarar novas funções e propriedades. A implementação de tal interface requer apenas a definição das implementações dos membros ausentes.
Exemplo:
interface Named {
val name: String
}
interface Person : Named {
val firstName: String
val lastName: String
override val name: String get() = "$firstName $lastName"
}
data class Employee(
// 不必实现“name”
override val firstName: String,
override val lastName: String,
val position: Position
) : Person
4.) Problema de conflito de interface
Quando nossa classe de implementação implementa múltiplas interfaces e há métodos com o mesmo nome nessas interfaces, se quisermos chamar esses métodos da interface pai, o compilador não conseguirá distinguir qual deles queremos chamar. Portanto, você pode usar super<interface name>.method name para distinguir.
Exemplo:
interface A {
fun foo() {
print("A") }
fun bar()
}
interface B {
fun foo() {
print("B") }
fun bar() {
print("bar") }
}
class C : A {
override fun bar() {
print("bar") }
}
class D : A, B {
override fun foo() {
super<A>.foo()
super<B>.foo()
}
override fun bar() {
super<B>.bar()
}
}
5.) Interface funcional (SAM)
- ) Uma interface com apenas um método abstrato é chamada de interface funcional ou interface SAM (Single Abstract Method). Uma interface funcional pode ter vários membros não abstratos, mas apenas um membro abstrato.
- ) Use o modificador fun para declarar uma interface funcional em Kotlin.
Exemplo:
fun interface KRunnable {
fun invoke()
}
Para interfaces funcionais, a conversão SAM pode ser implementada através de expressões lambda, tornando o código mais conciso e legível. Para obter detalhes, você pode visualizar conhecimentos relevantes sobre expressões lambda.
2. Aula abstrata
As classes abstratas do Kotlin são basicamente iguais às do Java.
Nos padrões de design Java, existe um padrão de design chamado padrão de design de modelo, que é definido como:
definir o esqueleto do algoritmo em uma operação e atrasar algumas etapas do algoritmo para subclasses para que as subclasses possam operar sem alterar a estrutura do algoritmo. algumas etapas específicas do algoritmo.
Há um número fixo de etapas para concluir uma tarefa, mas cada etapa possui detalhes de implementação diferentes dependendo do objeto; você pode definir um método geral para concluir a tarefa na classe pai e chamá-lo de acordo com as etapas necessárias para concluir a tarefa. evento. Como implementar cada etapa. A implementação específica de cada etapa é completada por subclasses.
No desenvolvimento real, geralmente escrevemos uma classe base para encapsular métodos comuns e lidar com alguma lógica comum.No entanto, a lógica do programa implementa códigos diferentes de acordo com as diferentes funções de cada subclasse. Esta classe base é geralmente uma classe abstrata.
Portanto, classes abstratas podem ser entendidas como a definição de um modelo para a classe. Todas as subclasses preenchem seu próprio código com base neste modelo.
- ) Use a palavra-chave abstract para declarar uma classe abstrata
- ) Além de ter seus próprios atributos, construtores, métodos e outros componentes, uma classe abstrata também contém membros abstratos (funções abstratas e atributos abstratos).Os membros abstratos também são declarados usando a palavra-chave abstrata, e os membros abstratos são apenas definidos, mas não implementados .
- ) classes abstratas não podem ser instanciadas diretamente
- ) As subclasses de classes abstratas devem reescrever todas as propriedades e métodos (membros abstratos) modificados com abstrato
- ) Uma classe abstrata define um modelo para suas subclasses. A diferença é que as classes implementam funções diferentes
Um exemplo:
abstract class Person {
val tag="人" //普通类的属性
fun getUserInfo(){
//普通类的方法
}
abstract var userWork : String // 抽象属性
abstract fun doWork() // 抽象方法
}
class Teacher : Person() {
override var userWork : String
get() = "老师"
set(value) {
}
override fun doWork() {
}
}
- ) Uma classe abstrata pode herdar de uma classe herdada, ou seja, uma classe abstrata pode ser subclassificada. No entanto, é recomendado não modificar a classe abstrata com o modificador open, porque as funções da classe pai da classe abstrata podem ser substituídas.
open class Polygon {
open fun draw() {
}
}
abstract class Rectangle : Polygon() {
abstract override fun draw()
}