Σε αυτό το άρθρο, θα μάθετε για διεπαφές και πώς να το εφαρμόσετε στο Kotlin με τη βοήθεια παραδειγμάτων.
Οι διεπαφές Kotlin είναι παρόμοιες με τις διεπαφές στην Java 8. Μπορούν να περιέχουν ορισμούς αφηρημένων μεθόδων, καθώς και υλοποιήσεις μη αφηρημένων μεθόδων. Ωστόσο, δεν μπορούν να περιέχουν καμία κατάσταση.
Δηλαδή, η διασύνδεση μπορεί να έχει ιδιότητα, αλλά πρέπει να είναι αφηρημένη ή να παρέχει παρεμβάσεις.
Προτεινόμενη ανάγνωση: Kotlin Abstract Class
Οι αφηρημένες τάξεις στο Kotlin είναι παρόμοιες με τη διεπαφή με μια σημαντική διαφορά. Δεν είναι υποχρεωτικό οι ιδιότητες μιας αφηρημένης κλάσης να είναι αφηρημένες ή να παρέχουν εφαρμογές υλοποίησης.
Πώς να ορίσετε μια διεπαφή;
Η λέξη-κλειδί interfaceχρησιμοποιείται για τον καθορισμό διεπαφών στο Kotlin. Για παράδειγμα,
διεπαφή MyInterface (δοκιμή var: String // abstract property fun foo () // abstract method fun hello () = "Hello there" // μέθοδος με προεπιλεγμένη εφαρμογή)
Εδώ,
- δημιουργείται μια διεπαφή MyInterface.
- η διεπαφή έχει μια δοκιμή αφηρημένης ιδιότητας και μια αφηρημένη μέθοδο
foo(). - η διεπαφή έχει επίσης μια μη αφηρημένη μέθοδο
hello().
Πώς να εφαρμόσετε διεπαφή;
Δείτε πώς μια κλάση ή αντικείμενο μπορεί να εφαρμόσει τη διεπαφή:
διεπαφή MyInterface (δοκιμή val: Int // abstract property fun foo (): String // abstract method (Return String) fun hello () (// method with default implement // body (optional))) class InterfaceImp: MyInterface (παράκαμψη val test: Int = 25 παράκαμψη fun foo () = "Lol" // άλλος κωδικός)
Εδώ, μια κλάση InterfaceImp εφαρμόζει τη διασύνδεση MyInterface.
Η τάξη παρακάμπτει αφηρημένα μέλη (δοκιμαστική ιδιότητα και foo()μέθοδος) της διεπαφής.
Παράδειγμα: Πώς λειτουργεί η διεπαφή;
interface MyInterface ( val test: Int fun foo() : String fun hello() ( println("Hello there, pal!") ) ) class InterfaceImp : MyInterface ( override val test: Int = 25 override fun foo() = "Lol" ) fun main(args: Array) ( val obj = InterfaceImp() println("test = $(obj.test)") print("Calling hello(): ") obj.hello() print("Calling and printing foo(): ") println(obj.foo()) )
Όταν εκτελείτε το πρόγραμμα, η έξοδος θα είναι:
test = 25 Κλήση γεια (): Γεια σου, φίλε! Κλήση και εκτύπωση foo (): Lol
Όπως αναφέρθηκε παραπάνω, μια διεπαφή μπορεί επίσης να έχει μια ιδιότητα που παρέχει εφαρμογή πρόσβασης. Για παράδειγμα,
interface MyInterface ( // property with implementation val prop: Int get() = 23 ) class InterfaceImp : MyInterface ( // class body ) fun main(args: Array) ( val obj = InterfaceImp() println(obj.prop) )
Όταν εκτελείτε το πρόγραμμα, η έξοδος θα είναι:
23
Εδώ, το στήριγμα δεν είναι αφηρημένο. Ωστόσο, είναι έγκυρο εντός της διεπαφής, επειδή παρέχει εφαρμογή για τον βοηθητή.
Ωστόσο, δεν μπορείτε να κάνετε κάτι σαν val prop: Int = 23μέσα στη διεπαφή.
Εφαρμογή δύο ή περισσότερων διεπαφών σε μια τάξη
Το Kotlin δεν επιτρέπει πραγματική πολλαπλή κληρονομιά. Ωστόσο, είναι δυνατό να εφαρμοστούν δύο ή περισσότερες διεπαφές σε μία κλάση. Για παράδειγμα,
interface A ( fun callMe() ( println("From interface A") ) ) interface B ( fun callMeToo() ( println("From interface B") ) ) // implements two interfaces A and B class Child: A, B fun main(args: Array) ( val obj = Child() obj.callMe() obj.callMeToo() )
Όταν εκτελείτε το πρόγραμμα, η έξοδος θα είναι:
Από διεπαφή Α Από διεπαφή Β
Επίλυση επιτακτικών διενέξεων (Πολλαπλή διεπαφή)
Ας υποθέσουμε ότι δύο διεπαφές (Α και Β) έχουν μια μη αφηρημένη μέθοδο με το ίδιο όνομα (ας πούμε callMe()μέθοδος). Εφαρμόσατε αυτές τις δύο διεπαφές σε μια τάξη (ας πούμε C). Τώρα, εάν καλέσετε τη callMe()μέθοδο χρησιμοποιώντας το αντικείμενο της κλάσης Γ, ο μεταγλωττιστής θα εμφανίσει σφάλμα. Για παράδειγμα,
interface A ( fun callMe() ( println("From interface A") ) ) interface B ( fun callMe() ( println("From interface B") ) ) class Child: A, B fun main(args: Array) ( val obj = Child() obj.callMe() )
Εδώ είναι το σφάλμα:
Σφάλμα: (14, 1) Kotlin: Η κλάση «C» πρέπει να παρακάμψει το κοινό ανοιχτό διασκεδαστικό callMe (): Η μονάδα ορίζεται στο Α επειδή κληρονομεί πολλές μεθόδους διεπαφής του
Για να επιλύσετε αυτό το ζήτημα, πρέπει να παρέχετε τη δική σας εφαρμογή. Δείτε πώς:
interface A ( fun callMe() ( println("From interface A") ) ) interface B ( fun callMe() ( println("From interface B") ) ) class C: A, B ( override fun callMe() ( super.callMe() super.callMe() ) ) fun main(args: Array) ( val obj = C() obj.callMe() )
Τώρα όταν εκτελείτε το πρόγραμμα, η έξοδος θα είναι:
Από διεπαφή Α Από διεπαφή Β
Εδώ, παρέχεται ρητή εφαρμογή της callMe()μεθόδου στην τάξη Γ.
κλάση C: A, B (παράκαμψη διασκέδασης callMe () (super.callMe () super .callMe ()))
Η δήλωση super.callMe()καλεί τη callMe()μέθοδο της κλάσης Α. Ομοίως, καλεί τη μέθοδο της τάξης .super.callMe()callMe()B
