Kotlin 인터페이스 나 추상 클래스 의 익명 대상 인 스 턴 스 만 들 기

1.인터페이스 와 추상 류 를 정의 합 니 다.

interface IPerson{
 //    
 fun getName():String
 //     ID
 fun getID():String
}

abstract class BaseAnimal{
 abstract fun getVoice():String
}

2.대응 하 는 익명 대상 만 들 기

 object : IPerson {
   override fun getName(): String = "jason"
   override fun getID(): String = "00000123"
  }
 
  object : BaseAnimal() {
   override fun getVoice() = "   "
  }

보충 지식:android Kotlin 계승,파생,인터페이스,구조 방식,방법,속성 재 작성
머리말
kotlin 은 구 글 의 공식 안 드 로 이 드 개발 언어 로 서 대세 의 추 세 를 보이 고 있다.2018 년 말 에 kotlin 은 자바 가 안 드 로 이 드 에서 의 위 치 를 전면적으로 대체 해 야 한 다 는 것 에 따 르 면 이것 도 걱정 하지 않 는 다.왜냐하면 kotin 과 자바 가 100%상호작용 을 할 수 있 기 때문이다.두 가지 언어 로 작성 해도 된다.
Kotlin 계승
1.open 키 워드 를 사용 하여 수식
2.메 인 구조 함수 가 클래스 뒤에 설 명 된 함수 에 바짝 붙 어 있다.

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

}

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

}

//       

calss Student : Person {

 constructor(ctx: Context) : super(ctx) {
 } 

 constructor(ctx: Context, attrs: AttributeSet) : super(ctx,attrs) {
 }
}

다른 쓰기,기본 구조 함수,2 차 구조 함수

/**    **/
open class Person(name:String){
 /**      **/
 constructor(name:String,age:Int):this(name){
  //   
  println("-------        ---------")
 }
}

/**     Person  **/
class Student:Person{

 /**      **/
 constructor(name:String,age:Int,no:String,score:Int):super(name,age){
  println("-------         ---------")
  println("   ： ${name}")
  println("  ： ${age}")
  println("   ： ${no}")
  println("  ： ${score}")
 }
}

fun main(args: Array<String>) {
 var s = Student("Runoob", 18, "S12345", 89)
}

방법 재 작성
기본 fun 함수 기본 final 수정자,하위 클래스 에서 다시 쓸 수 없습니다.
open 수식 기 호 를 붙 여야 합 니 다.
방법 획득,동명 방법 획득
다른 클래스 나 인터페이스(계승 실현 방법),같은 이름 의 방법 은 하위 클래스 에 호출 을 표시 해 야 합 니 다.

 open class A {
 open fun f () { print("A") }
 fun a() { print("a") }
}

interface B {
 fun f() { print("B") } //           open  
 fun b() { print("b") }
}

class C() : A() , B{
 override fun f() {
  super<A>.f()//   A.f()
  super<B>.f()//   B.f()
 }
}

fun main(args: Array<String>) {
 val c = C()
 c.f();
}

 open class A {
 open fun f () { print("A") }
 fun a() { print("a") }
}

interface B {
 fun f() { print("B") } //           open  
 fun b() { print("b") }
}
class C() : A() , B{
 override fun f() {
  super<A>.f()//   A.f()
  super<B>.f()//   B.f()
 }
}
fun main(args: Array<String>) {
 val c = C()
 c.f();
}

속성 재 작성
속성 재 작성 은 override 키 워드 를 사용 합 니 다.속성 은 호 환 형식 이 있어 야 합 니 다.모든 성명 의 속성 은 초기 화 프로그램 이나 getter 방법 으로 재 작성 할 수 있 습 니 다.

open class Foo {
 open val x: Int get { …… }
}
class Bar1 : Foo() {
 override val x: Int = ……
}

var 속성 으로 val 속성 을 다시 쓸 수 있 지만 반대로 안 됩 니 다.val 속성 자체 가 getter 방법 을 정 의 했 기 때문에 var 속성 으로 재 작성 하면 파생 클래스 에서 setter 방법 을 추가 로 설명 합 니 다.
주 구조 함수 에서 override 키 워드 를 속성 성명 의 일부분 으로 사용 할 수 있 습 니 다.

interface Foo {
 val count: Int
}
class Bar1(override val count: Int) : Foo
class Bar2 : Foo {
 override var count: Int = 0
}

Kotlin 인터페이스
Kotlin 인 터 페 이 스 는 자바 8 과 유사 합 니 다.interface 키 워드 를 사용 하여 인 터 페 이 스 를 정의 합 니 다.기본 구현 방법 은 다음 과 같 습 니 다.

interface MyInterface {
 fun bar() //    
 fun foo() { //   
  //       
  println("foo")
 }
}

인터페이스 속성
인터페이스 에 있 는 속성 은 추상 적일 수 있 습 니 다.값 을 초기 화 할 수 없습니다.인 터 페 이 스 는 속성 값 을 저장 하지 않 습 니 다.인 터 페 이 스 를 실현 할 때 속성 을 다시 써 야 합 니 다.

interface MyInterface{
 var name:String //name   ,    
}

class MyImpl:MyInterface{
 override var name: String = "runoob" //    
}

함수 재 작성
여러 개의 인 터 페 이 스 를 실현 할 때 같은 방법 으로 여러 개의 실현 문 제 를 계승 할 수 있다.예 를 들 면:
실례

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()
 }
}

fun main(args: Array<String>) {
 val d = D()
 d.foo();
 d.bar();
}

출력 결 과 는:ABbar인 스 턴 스 에서 인터페이스 A 와 B 는 모두 방법 foo()와 bar()를 정 의 했 고 둘 다 foo()를 실 현 했 으 며 B 는 bar()를 실현 했다.C 는 A 를 실현 하 는 구체 적 인 유형 이기 때문에 반드시 bar()를 다시 쓰 고 이 추상 적 인 방법 을 실현 해 야 한다.
그러나 우리 가 A 와 B 에서 D 를 파생 한다 면 우 리 는 여러 개의 인터페이스 계승 을 실현 하 는 모든 방법 을 필요 로 하고 D 가 어떻게 이 를 실현 해 야 하 는 지 를 가 리 켜 야 한다.
이 규칙 은 하나의 실현(bar()을 계승 하 는 방법 뿐만 아니 라 여러 개의 실현(foo()을 계승 하 는 방법 에 도 적용 된다.
이상 의 Kotlin 이 인 터 페 이 스 를 만 들 거나 추상 적 인 익명 의 대상 인 스 턴 스 는 바로 편집장 이 여러분 에 게 공유 한 모든 내용 입 니 다.참고 가 되 고 저 희 를 많이 사랑 해 주 셨 으 면 좋 겠 습 니 다.