Implements vs extends: Kapan digunakan? Apa bedanya?

Tolong jelaskan dalam bahasa yang mudah dimengerti atau tautan ke beberapa artikel.

extendsadalah untuk memperluas kelas.

implementsadalah untuk mengimplementasikan antarmuka

Perbedaan antara antarmuka dan kelas reguler adalah bahwa dalam antarmuka Anda tidak dapat mengimplementasikan metode yang dideklarasikan. Hanya kelas yang "mengimplementasikan" antarmuka yang dapat mengimplementasikan metode. Setara C ++ dari sebuah antarmuka akan menjadi kelas abstrak (tidak persis sama tetapi cukup banyak).

Juga java tidak mendukung multiple inheritance untuk kelas. Ini diselesaikan dengan menggunakan banyak antarmuka.

 public interface ExampleInterface {
    public void doAction();
    public String doThis(int number);
 }

 public class sub implements ExampleInterface {
     public void doAction() {
       //specify what must happen
     }

     public String doThis(int number) {
       //specfiy what must happen
     }
 }

sekarang memperluas kelas

 public class SuperClass {
    public int getNb() {
         //specify what must happen
        return 1;
     }

     public int getNb2() {
         //specify what must happen
        return 2;
     }
 }

 public class SubClass extends SuperClass {
      //you can override the implementation
      @Override
      public int getNb2() {
        return 3;
     }
 }

pada kasus ini

  Subclass s = new SubClass();
  s.getNb(); //returns 1
  s.getNb2(); //returns 3

  SuperClass sup = new SuperClass();
  sup.getNb(); //returns 1
  sup.getNb2(); //returns 2

Saya sarankan Anda melakukan penelitian lebih lanjut tentang pengikatan dinamis, polimorfisme, dan pewarisan umum dalam pemrograman berorientasi objek

Saya perhatikan Anda memiliki beberapa pertanyaan C ++ di profil Anda. Jika Anda memahami konsep multiple-inheritance dari C ++ (merujuk ke kelas yang mewarisi karakteristik dari lebih dari satu kelas lain), Java tidak mengizinkan ini, tetapi ia memiliki kata kunci interface, yang seperti kelas virtual murni di C ++. Seperti yang disebutkan oleh banyak orang, Anda extendsebuah kelas (dan Anda hanya dapat memperluas dari satu), dan Anda implementsebuah antarmuka - tetapi kelas Anda dapat mengimplementasikan sebanyak mungkin antarmuka yang Anda inginkan.

Yaitu, kata kunci ini dan aturan yang mengatur penggunaannya menggambarkan kemungkinan multiple-inheritance di Java (Anda hanya dapat memiliki satu kelas super, tetapi Anda dapat mengimplementasikan beberapa antarmuka).

Secara umum mengimplementasikan digunakan untuk mengimplementasikan antarmuka dan diperluas digunakan untuk ekstensi perilaku kelas dasar atau kelas abstrak .

extends : Kelas turunan dapat memperluas kelas dasar. Anda dapat mendefinisikan kembali perilaku hubungan yang sudah mapan. Kelas turunan " adalah " tipe kelas dasar

mengimplementasikan : Anda menerapkan kontrak. Kelas yang mengimplementasikan antarmuka " memiliki " kemampuan.

Dengan rilis java 8, antarmuka dapat memiliki metode standar dalam antarmuka, yang menyediakan implementasi dalam antarmuka itu sendiri.

Lihat pertanyaan ini untuk kapan menggunakannya masing-masing:

Antarmuka vs Kelas Abstrak (OO umum)

Contoh untuk memahami banyak hal.

public class ExtendsAndImplementsDemo{
    public static void main(String args[]){

        Dog dog = new Dog("Tiger",16);
        Cat cat = new Cat("July",20);

        System.out.println("Dog:"+dog);
        System.out.println("Cat:"+cat);

        dog.remember();
        dog.protectOwner();
        Learn dl = dog;
        dl.learn();

        cat.remember();
        cat.protectOwner();

        Climb c = cat;
        c.climb();

        Man man = new Man("Ravindra",40);
        System.out.println(man);

        Climb cm = man;
        cm.climb();
        Think t = man;
        t.think();
        Learn l = man;
        l.learn();
        Apply a = man;
        a.apply();

    }
}

abstract class Animal{
    String name;
    int lifeExpentency;
    public Animal(String name,int lifeExpentency ){
        this.name = name;
        this.lifeExpentency=lifeExpentency;
    }
    public void remember(){
        System.out.println("Define your own remember");
    }
    public void protectOwner(){
        System.out.println("Define your own protectOwner");
    }

    public String toString(){
        return this.getClass().getSimpleName()+":"+name+":"+lifeExpentency;
    }
}
class Dog extends Animal implements Learn{

    public Dog(String name,int age){
        super(name,age);
    }
    public void remember(){
        System.out.println(this.getClass().getSimpleName()+" can remember for 5 minutes");
    }
    public void protectOwner(){
        System.out.println(this.getClass().getSimpleName()+ " will protect owner");
    }
    public void learn(){
        System.out.println(this.getClass().getSimpleName()+ " can learn:");
    }
}
class Cat extends Animal implements Climb {
    public Cat(String name,int age){
        super(name,age);
    }
    public void remember(){
        System.out.println(this.getClass().getSimpleName() + " can remember for 16 hours");
    }
    public void protectOwner(){
        System.out.println(this.getClass().getSimpleName()+ " won't protect owner");
    }
    public void climb(){
        System.out.println(this.getClass().getSimpleName()+ " can climb");
    }
}
interface Climb{
    public void climb();
}
interface Think {
    public void think();
}

interface Learn {
    public void learn();
}
interface Apply{
    public void apply();
}

class Man implements Think,Learn,Apply,Climb{
    String name;
    int age;

    public Man(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void think(){
        System.out.println("I can think:"+this.getClass().getSimpleName());
    }
    public void learn(){
        System.out.println("I can learn:"+this.getClass().getSimpleName());
    }
    public void apply(){
        System.out.println("I can apply:"+this.getClass().getSimpleName());
    }
    public void climb(){
        System.out.println("I can climb:"+this.getClass().getSimpleName());
    }
    public String toString(){
        return "Man :"+name+":Age:"+age;
    }
}

keluaran:

Dog:Dog:Tiger:16
Cat:Cat:July:20
Dog can remember for 5 minutes
Dog will protect owner
Dog can learn:
Cat can remember for 16 hours
Cat won't protect owner
Cat can climb
Man :Ravindra:Age:40
I can climb:Man
I can think:Man
I can learn:Man
I can apply:Man

Poin-poin penting untuk dipahami:

1. Anjing dan Kucing adalah binatang dan mereka diperluas remember() dan protectOwner() dengan berbagi name,lifeExpentencydariAnimal
2. Kucing dapat memanjat () tetapi Anjing tidak. Anjing dapat berpikir () tetapi Kucing tidak . Kemampuan khusus ini ditambahkan ke Catdan Dogdengan mengimplementasikan kemampuan itu.
3. Manusia bukan binatang tetapi dia bisa Think,Learn,Apply,Climb

Dengan melihat contoh-contoh ini, Anda dapat memahaminya

Kelas yang tidak terkait dapat memiliki kemampuan melalui antarmuka tetapi kelas terkait mengabaikan perilaku melalui ekstensi kelas dasar.

extendsadalah ketika Anda mewarisi dari kelas dasar (yaitu memperluas fungsinya).

implementsuntuk ketika Anda mengimplementasikan antarmuka .

Inilah tempat yang bagus untuk memulai: Antarmuka dan Warisan .

A classhanya dapat "mengimplementasikan" suatu interface. Kelas hanya "meluas" a class. Demikian juga, suatu interfacedapat memperpanjang yang laininterface .

A classhanya dapat memperpanjang satu sama lain class. A classdapat mengimplementasikan beberapainterface s.

Jika sebaliknya Anda lebih tertarik untuk mengetahui kapan harus menggunakan abstract classes dan interfaces, lihat utas ini: Antarmuka vs Kelas Abstrak (OO umum)

Antarmuka adalah deskripsi tindakan yang dapat dilakukan suatu objek ... misalnya ketika Anda membalik sakelar lampu, lampu menyala, Anda tidak peduli bagaimana, hanya saja fungsinya. Dalam Pemrograman Berorientasi Objek, Interface adalah deskripsi dari semua fungsi yang harus dimiliki suatu objek agar menjadi "X". Sekali lagi, sebagai contoh, apa pun yang "ACTS LIKE" lampu, harus memiliki metode turn_on () dan metode turn_off (). Tujuan dari antarmuka adalah untuk memungkinkan komputer untuk menegakkan sifat-sifat ini dan untuk mengetahui bahwa objek TIPE T (apa pun antarmuka) harus memiliki fungsi yang disebut X, Y, Z, dll.

Antarmuka adalah struktur pemrograman / sintaks yang memungkinkan komputer untuk menegakkan properti tertentu pada suatu objek (kelas). Misalnya, kita memiliki kelas mobil dan kelas skuter dan kelas truk. Masing-masing dari tiga kelas ini harus memiliki tindakan start_engine (). Bagaimana "mesin dinyalakan" untuk setiap kendaraan dibiarkan untuk setiap kelas tertentu, tetapi kenyataan bahwa mereka harus memiliki tindakan start_engine adalah domain antarmuka .

Seperti yang ditunjukkan pada gambar yang diberikan di bawah ini, kelas memperluas kelas lain, antarmuka memperluas antarmuka lain tetapi kelas mengimplementasikan antarmuka.

Untuk lebih jelasnya

Extends : Ini digunakan untuk mendapatkan atribut dari kelas induk ke dalam kelas dasar dan mungkin berisi metode yang sudah didefinisikan yang dapat ditimpa dalam kelas anak.

Implements : Ini digunakan untuk mengimplementasikan antarmuka (kelas induk dengan fungsi tanda tangan saja tetapi tidak definisi mereka) dengan mendefinisikannya di kelas anak.

Ada satu syarat khusus: "Bagaimana jika saya ingin Antarmuka baru menjadi anak dari antarmuka yang ada?". Dalam kondisi di atas, antarmuka anak memperluas antarmuka induk.

• A meluas B:

  A dan B keduanya kelas atau keduanya antarmuka

• A mengimplementasikan B

  A adalah kelas dan B adalah antarmuka

• Kasus yang tersisa di mana A adalah antarmuka dan B adalah kelas tidak sah di Jawa.

Implements digunakan untuk Interfaces dan extends digunakan untuk memperpanjang kelas.

Untuk membuatnya lebih jelas dalam istilah yang lebih mudah, antarmuka seperti suara - antarmuka - model, yang perlu Anda terapkan, ikuti, bersama dengan ide-ide Anda untuk itu.

Extend digunakan untuk kelas, di sini, Anda memperluas sesuatu yang sudah ada dengan menambahkan lebih banyak fungsi ke dalamnya.

Beberapa catatan lagi:

suatu antarmuka dapat memperluas antarmuka lain.

Dan ketika Anda perlu memilih antara mengimplementasikan antarmuka atau memperluas kelas untuk skenario tertentu, gunakan untuk mengimplementasikan antarmuka. Karena suatu kelas dapat mengimplementasikan banyak antarmuka tetapi hanya memperluas satu kelas.

Ketika subclass memperluas kelas, itu memungkinkan subclass untuk mewarisi (menggunakan kembali) dan menimpa kode yang didefinisikan dalam supertype. Ketika sebuah kelas mengimplementasikan sebuah antarmuka, itu memungkinkan suatu objek yang dibuat dari kelas untuk digunakan dalam konteks apa pun yang mengharapkan nilai antarmuka.

Tangkapan sebenarnya di sini adalah bahwa sementara kita menerapkan apa pun itu berarti kita menggunakan metode tersebut sebagaimana adanya. Tidak ada ruang untuk perubahan nilai dan tipe pengembaliannya.

Tetapi ketika kami memperluas apa pun maka itu menjadi perpanjangan dari kelas Anda. Anda dapat mengubahnya, menggunakannya, menggunakannya kembali dan itu tidak perlu mengembalikan nilai yang sama seperti di superkelas.

Kami menggunakan SubClass meluas SuperClass hanya ketika subclass ingin menggunakan beberapa fungsionalitas (metode atau variabel contoh) yang sudah dinyatakan dalam SuperClass , atau jika saya ingin sedikit mengubah fungsi SuperClass (Metode menimpa). Tetapi katakan, misalnya saya memiliki kelas Hewan ( SuperClass ) dan kelas Anjing ( SubClass ) dan ada beberapa metode yang telah saya tetapkan dalam kelas Hewan misalnya. doEat (); , doSleep (); ... dan masih banyak lagi.

Sekarang, kelas Anjing saya dapat dengan mudah memperluas kelas Hewan, jika saya ingin anjing saya menggunakan salah satu metode yang dinyatakan dalam kelas Hewan saya dapat memanggil metode itu dengan hanya membuat objek Anjing. Jadi dengan cara ini saya dapat menjamin bahwa saya memiliki anjing yang dapat makan dan tidur dan melakukan apa pun yang saya ingin anjing lakukan.

Sekarang, bayangkan, suatu hari beberapa pecinta Kucing datang ke ruang kerja kita dan dia mencoba memperluas kelas Hewan (kucing juga makan dan tidur). Dia membuat objek Cat dan mulai menggunakan metode.

Tetapi, katakanlah, seseorang mencoba membuat objek dari kelas Hewan. Anda bisa tahu bagaimana kucing tidur, Anda bisa tahu bagaimana seekor anjing makan, Anda bisa tahu bagaimana seekor gajah minum. Tapi itu tidak masuk akal dalam membuat objek kelas Hewan. Karena itu adalah templat dan kami tidak ingin ada cara makan yang umum.

Jadi sebagai gantinya, saya akan lebih memilih untuk membuat kelas abstrak yang tidak ada yang bisa instantiate tetapi dapat digunakan sebagai templat untuk kelas lain.

Jadi untuk menyimpulkan, Antarmuka hanyalah kelas abstrak (kelas abstrak murni) yang tidak mengandung implementasi metode tetapi hanya definisi (templat). Jadi siapa pun yang mengimplementasikan antarmuka hanya tahu bahwa mereka memiliki template doEat (); dan doSleep (); tetapi mereka harus mendefinisikan doEat mereka sendiri (); dan doSleep (); metode sesuai dengan kebutuhan mereka.

Anda memperluas hanya ketika Anda ingin menggunakan kembali beberapa bagian dari SuperClass (tetapi perlu diingat, Anda selalu dapat menimpa metode SuperClass Anda sesuai dengan kebutuhan Anda) dan Anda menerapkan ketika Anda ingin template dan Anda ingin mendefinisikannya sendiri (sesuai dengan kebutuhan Anda).

Saya akan berbagi dengan Anda sepotong kode: Anda mencobanya dengan set input yang berbeda dan lihat hasilnya.

class AnimalClass {

public void doEat() {

    System.out.println("Animal Eating...");
}

public void sleep() {

    System.out.println("Animal Sleeping...");
}

}

public class Dog extends AnimalClass implements AnimalInterface, Herbi{

public static void main(String[] args) {

    AnimalInterface a = new Dog();
    Dog obj = new Dog();
    obj.doEat();
    a.eating();

    obj.eating();
    obj.herbiEating();
}

public void doEat() {
    System.out.println("Dog eating...");
}

@Override
public void eating() {

    System.out.println("Eating through an interface...");
    // TODO Auto-generated method stub

}

@Override
public void herbiEating() {

    System.out.println("Herbi eating through an interface...");
    // TODO Auto-generated method stub

}


}

Antarmuka yang Ditentukan :

public interface AnimalInterface {

public void eating();

}


interface Herbi {

public void herbiEating();

}

Kedua kata kunci tersebut digunakan saat membuat kelas baru Anda sendiri dalam bahasa Java.

Perbedaan: implementsberarti Anda menggunakan elemen-elemen Antarmuka Java di kelas Anda. extendsberarti bahwa Anda membuat subkelas dari kelas dasar yang Anda perluas. Anda hanya dapat memperluas satu kelas di kelas anak Anda, tetapi Anda dapat mengimplementasikan sebanyak mungkin antarmuka yang Anda inginkan.

Lihat halaman dokumentasi oracle pada antarmuka untuk lebih jelasnya.

Ini dapat membantu memperjelas apa antarmuka itu, dan konvensi tentang menggunakannya.

Dalam istilah yang paling sederhana, extends digunakan untuk mewarisi dari sebuah kelas dan mengimplementasikannya digunakan untuk menerapkan antarmuka di kelas Anda

meluas :

public class Bicycle {
    //properties and methods
}
public class MountainBike extends Bicycle {
    //new properties and methods
}

mengimplementasikan :

public interface Relatable {
    //stuff you want to put
}
public class RectanglePlus implements Relatable {
    //your class code
}

jika Anda masih memiliki kebingungan baca ini: https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html https://docs.oracle.com/javase/tutorial/java/IandI/usinginterface.html

Kelas dan Antarmuka keduanya merupakan kontrak . Mereka menyediakan metode dan properti bagian lain dari aplikasi yang diandalkan.

Anda menentukan antarmuka saat Anda tidak tertarik dengan detail implementasi kontrak ini. Satu-satunya hal yang perlu diperhatikan adalah kontrak (antarmuka) ada.

Dalam hal ini Anda menyerahkannya ke kelas yang mengimplementasikan antarmuka untuk peduli tentang detail bagaimana kontrak terpenuhi. Hanya kelas yang dapat mengimplementasikan antarmuka.

perpanjangan digunakan ketika Anda ingin mengganti rincian kontrak yang ada. Dengan cara ini Anda mengganti satu cara untuk memenuhi kontrak dengan cara yang berbeda. Kelas dapat memperluas kelas lain, dan antarmuka dapat memperluas antarmuka lainnya.

Extendsdigunakan ketika Anda menginginkan atribut kelas induk / antarmuka di kelas anak / antarmuka Anda dan implementsdigunakan saat Anda ingin atribut antarmuka kelas Anda.

Contoh:

1. Memperpanjang menggunakan kelas

   kelas Induk {

   }

   kelas Anak meluas Orangtua {

   }

2. Memperluas menggunakan antarmuka

   antarmuka Induk {

   }

   antarmuka Anak meluas Orangtua {

   }

3. Implements

antarmuka A {

}

kelas B mengimplementasikan A {

}

Kombinasi ekstensi dan implement

interface A{

}

class B

{

}

class C implements A,extends B{

}

meluas

• kelas hanya memanjang satu kelas
• antarmuka memperluas satu atau lebih antarmuka

mengimplementasikan

• kelas mengimplementasikan satu atau lebih antarmuka
• antarmuka 'tidak bisa' mengimplementasikan apa pun

kelas abstrak juga bertindak seperti kelas, dengan ekstensi dan implementasi

Kedua kata kunci tersebut secara langsung dilampirkan dengan Inheritance itu adalah konsep inti dari OOP. Ketika kita mewarisi beberapa kelas ke kelas lain kita dapat menggunakan extends tetapi ketika kita akan mewarisi beberapa antarmuka ke kelas kita, kita tidak bisa menggunakan extends kita harus menggunakan implement dan kita bisa menggunakan extends keyword untuk mewarisi antarmuka dari antarmuka lain.