Kotlinは、インターフェースまたは抽象クラスの匿名のオブジェクトの例を作成します。

一、インターフェースと抽象類を定義する。

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

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

二、対応する匿名のオブジェクトを作成する

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

補足知識：android Kotlin継承、派生、インターフェース、構造方式、方法、属性書き換え
前言
kotlinはgoogleの公式and roidとして言語を開発して、大勢の赴くところによって、2018年底のkotlinに伝わって全面的にjavaのAndroidの中の地位を取って代わります。二つの言語を書いてもいいです。
Ktlin継承
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) {
 }
}

もう一つの書き方は、基本構造関数、二次構造関数です。

/**    **/
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 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インターフェースはJava 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がインタフェースや抽象的な匿名の対象を作った例は、小編集が皆さんに提供した内容の全部です。参考にしていただければと思います。どうぞよろしくお願いします。