Kotlinのインターフェースにデフォルト実装を追加する方法を徹底解説

interface MyInterface {
    fun myFunction()
    val myProperty: String
}

class MyClass : MyInterface {
    override fun myFunction() {
        println("myFunctionを実装")
    }

    override val myProperty: String = "Hello"
}

interface Greeting {
    fun sayHello() {
        println("Hello, World!")
    }
}

class Person : Greeting

fun main() {
    val person = Person()
    person.sayHello() // 出力: Hello, World!
}

interface Animal {
    fun sound() {
        println("Some generic animal sound")
    }
}

class Dog : Animal

fun main() {
    val dog = Dog()
    dog.sound() // 出力: Some generic animal sound
}

class Cat : Animal {
    override fun sound() {
        println("Meow")
    }
}

fun main() {
    val cat = Cat()
    cat.sound() // 出力: Meow
}

interface Vehicle {
    fun start() {
        println("Starting the vehicle")
    }

    fun stop() {
        println("Stopping the vehicle")
    }
}

class Car : Vehicle

fun main() {
    val car = Car()
    car.start() // 出力: Starting the vehicle
    car.stop()  // 出力: Stopping the vehicle
}

interface User {
    val name: String
        get() = "Default User"
}

class Admin : User

fun main() {
    val admin = Admin()
    println(admin.name) // 出力: Default User
}

interface Greeting {
    fun sayHello() {
        println("Hello from the interface!")
    }
}

class Person : Greeting

fun main() {
    val person = Person()
    person.sayHello() // 出力: Hello from the interface!
}

interface Greeting {
    fun sayHello() {
        println("Hello from the interface!")
    }
}

class FriendlyPerson : Greeting {
    override fun sayHello() {
        println("Hi there! Nice to meet you!")
    }
}

fun main() {
    val friendlyPerson = FriendlyPerson()
    friendlyPerson.sayHello() // 出力: Hi there! Nice to meet you!
}

interface Walkable {
    fun walk() {
        println("Walking...")
    }
}

interface Talkable {
    fun talk() {
        println("Talking...")
    }
}

class Robot : Walkable, Talkable

fun main() {
    val robot = Robot()
    robot.walk() // 出力: Walking...
    robot.talk() // 出力: Talking...
}

interface User {
    val name: String
        get() = "Default User"
}

class Admin : User

fun main() {
    val admin = Admin()
    println(admin.name) // 出力: Default User
}

interface InterfaceA {
    fun showMessage() {
        println("Message from InterfaceA")
    }
}

interface InterfaceB {
    fun showMessage() {
        println("Message from InterfaceB")
    }
}

class CombinedClass : InterfaceA, InterfaceB {
    override fun showMessage() {
        // 明示的にどちらのメソッドを呼ぶか指定
        super<InterfaceA>.showMessage()
        super<InterfaceB>.showMessage()
    }
}

fun main() {
    val obj = CombinedClass()
    obj.showMessage()
    // 出力:
    // Message from InterfaceA
    // Message from InterfaceB
}

interface Walkable {
    fun move() {
        println("Walking...")
    }
}

interface Runnable {
    fun move() {
        println("Running...")
    }
}

class Human : Walkable, Runnable {
    override fun move() {
        println("Moving like a human...")
    }
}

fun main() {
    val person = Human()
    person.move() // 出力: Moving like a human...
}

class HybridMover : Walkable, Runnable {
    override fun move() {
        super<Walkable>.move()
        super<Runnable>.move()
    }
}

fun main() {
    val hybrid = HybridMover()
    hybrid.move()
    // 出力:
    // Walking...
    // Running...
}

interface Logger {
    fun log(message: String) {
        println("LOG: $message")
    }
}

class FileProcessor : Logger {
    fun processFile(fileName: String) {
        log("Processing file: $fileName")
    }
}

fun main() {
    val processor = FileProcessor()
    processor.processFile("data.txt")
    // 出力: LOG: Processing file: data.txt
}

interface Validator {
    fun validate(input: String): Boolean {
        return input.isNotBlank()
    }
}

class UserInput : Validator {
    fun submit(input: String) {
        if (validate(input)) {
            println("Input is valid: $input")
        } else {
            println("Input is invalid.")
        }
    }
}

fun main() {
    val userInput = UserInput()
    userInput.submit("Hello Kotlin") // 出力: Input is valid: Hello Kotlin
    userInput.submit("")             // 出力: Input is invalid.
}

interface ErrorHandler {
    fun handleError(error: String) {
        println("Error: $error")
    }
}

class NetworkRequest : ErrorHandler {
    fun fetchData(url: String) {
        // 何らかのエラーが発生した場合
        handleError("Failed to fetch data from $url")
    }
}

fun main() {
    val request = NetworkRequest()
    request.fetchData("https://example.com")
    // 出力: Error: Failed to fetch data from https://example.com
}

interface Printer {
    fun printMessage() {
        println("Printing a default message.")
    }
}

interface AdvancedPrinter : Printer {
    fun printAdvancedMessage() {
        println("Printing an advanced message.")
    }
}

class DocumentPrinter : AdvancedPrinter

fun main() {
    val printer = DocumentPrinter()
    printer.printMessage()        // 出力: Printing a default message.
    printer.printAdvancedMessage() // 出力: Printing an advanced message.
}

// Kotlinでインターフェースにデフォルト実装を定義
interface KotlinInterface {
    fun greet() {
        println("Hello from Kotlin!")
    }
}

public class JavaClass implements KotlinInterface {
    public static void main(String[] args) {
        JavaClass obj = new JavaClass();
        obj.greet(); // 出力: Hello from Kotlin!
    }
}

interface Printer {
    fun printMessage() {
        println("Default message from Kotlin interface")
    }
}

public class JavaPrinter implements Printer {
    public static void main(String[] args) {
        JavaPrinter printer = new JavaPrinter();
        printer.printMessage(); // 出力: Default message from Kotlin interface
    }
}

interface InterfaceA {
    fun display() {
        println("Display from InterfaceA")
    }
}

interface InterfaceB {
    fun display() {
        println("Display from InterfaceB")
    }
}

class MyClass : InterfaceA, InterfaceB

Class 'MyClass' must override public open fun display()

class MyClass : InterfaceA, InterfaceB {
    override fun display() {
        super<InterfaceA>.display()
        // または super<InterfaceB>.display() で呼び出しを指定
    }
}

interface MyInterface {
    fun abstractMethod()
}

class MyClass : MyInterface

Class 'MyClass' is not abstract and does not implement abstract member

class MyClass : MyInterface {
    override fun abstractMethod() {
        println("Implemented abstract method")
    }
}

interface MyInterface {
    val value: Int = 10 // コンパイルエラー
}

Property initializers are not allowed in interfaces

interface MyInterface {
    val value: Int
        get() = 10
}

interface MyInterface {
    fun greet() {
        println("Hello from the interface")
    }
}

class MyClass : MyInterface {
    fun greet() {
        println("Hello from MyClass")
    }
}

fun main() {
    val obj = MyClass()
    obj.greet() // 出力: Hello from MyClass
}

class MyClass : MyInterface {
    override fun greet() {
        super.greet() // デフォルト実装を呼び出す
    }
}