Apa sebenarnya perbedaan antara antarmuka dan kelas abstrak?

Antarmuka

Antarmuka adalah kontrak : Orang yang menulis antarmuka mengatakan, " hei, saya menerima hal-hal yang tampak seperti itu ", dan orang yang menggunakan antarmuka mengatakan " OK, kelas yang saya tulis terlihat seperti itu ".

Antarmuka adalah shell kosong . Hanya ada tanda tangan metode, yang menyiratkan bahwa metode tidak memiliki tubuh. Antarmuka tidak dapat melakukan apa pun. Itu hanya sebuah pola.

Misalnya (kode semu):

// I say all motor vehicles should look like this:
interface MotorVehicle
{
    void run();

    int getFuel();
}

// My team mate complies and writes vehicle looking that way
class Car implements MotorVehicle
{

    int fuel;

    void run()
    {
        print("Wrroooooooom");
    }


    int getFuel()
    {
        return this.fuel;
    }
}

Mengimplementasikan antarmuka mengkonsumsi CPU sangat sedikit, karena itu bukan kelas, hanya sekelompok nama, dan karena itu tidak ada pencarian mahal untuk dilakukan. Sangat bagus saat penting, seperti di perangkat yang disematkan.

Kelas abstrak

Kelas abstrak, tidak seperti antarmuka, adalah kelas. Mereka lebih mahal untuk digunakan, karena ada pencarian untuk dilakukan ketika Anda mewarisi dari mereka.

Kelas abstrak sangat mirip dengan antarmuka, tetapi mereka memiliki sesuatu yang lebih: Anda dapat mendefinisikan perilaku untuk mereka. Ini lebih tentang seseorang yang mengatakan, " kelas-kelas ini harus terlihat seperti itu, dan mereka memiliki kesamaan, jadi isilah bagian yang kosong! ".

Sebagai contoh:

// I say all motor vehicles should look like this:
abstract class MotorVehicle
{

    int fuel;

    // They ALL have fuel, so lets implement this for everybody.
    int getFuel()
    {
         return this.fuel;
    }

    // That can be very different, force them to provide their
    // own implementation.
    abstract void run();
}

// My teammate complies and writes vehicle looking that way
class Car extends MotorVehicle
{
    void run()
    {
        print("Wrroooooooom");
    }
}

Penerapan

Sementara kelas dan antarmuka abstrak seharusnya merupakan konsep yang berbeda, implementasinya membuat pernyataan itu terkadang tidak benar. Terkadang, mereka bahkan tidak seperti yang Anda pikirkan.

Di Jawa, aturan ini sangat ditegakkan, sementara di PHP, antarmuka adalah kelas abstrak tanpa metode yang dideklarasikan.

Dalam Python, kelas abstrak lebih merupakan trik pemrograman yang bisa Anda dapatkan dari modul ABC dan sebenarnya menggunakan metaclasses, dan karenanya kelas. Dan antarmuka lebih terkait dengan mengetik bebek dalam bahasa ini dan itu adalah campuran antara konvensi dan metode khusus yang memanggil deskriptor (metode __method__).

Seperti biasa dengan pemrograman, ada teori, latihan, dan latihan dalam bahasa lain :-)

Perbedaan teknis utama antara kelas abstrak dan antarmuka adalah:

• Kelas abstrak dapat memiliki konstanta, anggota, metode bertopik (metode tanpa tubuh) dan metode yang ditetapkan , sedangkan antarmuka hanya dapat memiliki konstanta dan metode bertopik .

• Metode dan anggota kelas abstrak dapat didefinisikan dengan visibilitas apa pun , sedangkan semua metode antarmuka harus didefinisikan sebagai public(mereka didefinisikan publik secara default).

• Ketika mewarisi kelas abstrak, kelas anak konkret harus mendefinisikan metode abstrak , sedangkan kelas abstrak dapat memperluas kelas abstrak lain dan metode abstrak dari kelas induk tidak harus didefinisikan.

• Demikian pula, antarmuka yang memperluas antarmuka lain tidak bertanggung jawab untuk menerapkan metode dari antarmuka induk. Ini karena antarmuka tidak dapat menentukan implementasi apa pun.

• Kelas anak hanya dapat memperluas kelas tunggal (abstrak atau konkret), sedangkan antarmuka dapat memperluas atau kelas dapat mengimplementasikan beberapa antarmuka lainnya .

• Kelas anak dapat mendefinisikan metode abstrak dengan visibilitas yang sama atau kurang restriktif , sedangkan kelas yang mengimplementasikan antarmuka harus mendefinisikan metode dengan visibilitas yang sama persis (publik).

Antarmuka hanya berisi definisi / tanda tangan fungsionalitas, dan jika kita memiliki beberapa fungsi umum serta tanda tangan umum, maka kita perlu menggunakan kelas abstrak. Dengan menggunakan kelas abstrak, kami dapat memberikan perilaku sekaligus fungsi baik secara bersamaan. Pengembang lain yang mewarisi kelas abstrak dapat menggunakan fungsi ini dengan mudah, karena mereka hanya perlu mengisinya.

Diambil dari:

http://www.dotnetbull.com/2011/11/difference-between-abstract-class-and.html

http://www.dotnetbull.com/2011/11/what-is-abstract-class-in-c-net.html http://www.dotnetbull.com/2011/11/what-is-interface-in -c-net.html

Penjelasan dapat ditemukan di sini: http://www.developer.com/lang/php/article.php/3604111/PHP-5-OOP-Interfaces-Abstract-Classes-and-the-Adapter-Pattern.htm

Kelas abstrak adalah kelas yang hanya dilaksanakan sebagian oleh programmer. Ini mungkin berisi satu atau lebih metode abstrak. Metode abstrak hanyalah definisi fungsi yang berfungsi untuk memberi tahu programmer bahwa metode tersebut harus diimplementasikan dalam kelas anak.

Antarmuka mirip dengan kelas abstrak; memang antarmuka menempati namespace yang sama dengan kelas dan kelas abstrak. Karena alasan itu, Anda tidak dapat mendefinisikan antarmuka dengan nama yang sama dengan kelas. Antarmuka adalah kelas yang sepenuhnya abstrak; tidak ada metode yang diimplementasikan dan bukannya sub-kelas dari itu, dikatakan untuk mengimplementasikan antarmuka itu.

Lagi pula saya menemukan penjelasan tentang antarmuka ini agak membingungkan. Definisi yang lebih umum adalah: Antarmuka mendefinisikan kontrak yang harus dipenuhi oleh kelas implementasi. Definisi antarmuka terdiri dari tanda tangan anggota publik, tanpa kode implementasi.

Saya tidak ingin menyoroti perbedaan, yang telah dikatakan dalam banyak jawaban (mengenai pengubah akhir statis publik untuk variabel dalam antarmuka & dukungan untuk metode pribadi yang dilindungi di kelas abstrak)

Secara sederhana, saya ingin mengatakan:

antarmuka: Untuk menerapkan kontrak dengan beberapa objek yang tidak terkait

kelas abstrak: Untuk menerapkan perilaku yang sama atau berbeda di antara beberapa objek terkait

Dari dokumentasi Oracle

Pertimbangkan menggunakan kelas abstrak jika:

1. Anda ingin berbagi kode di antara beberapa kelas yang terkait erat.
2. Anda berharap bahwa kelas yang memperluas kelas abstrak Anda memiliki banyak metode atau bidang umum, atau memerlukan pengubah akses selain publik (seperti yang dilindungi dan pribadi).
3. Anda ingin mendeklarasikan bidang non-statis atau non-final.

Pertimbangkan menggunakan antarmuka jika:

1. Anda berharap bahwa kelas yang tidak terkait akan mengimplementasikan antarmuka Anda. Sebagai contoh, banyak objek yang tidak berhubungan dapat diimplementasikanSerializable antarmuka.
2. Anda ingin menentukan perilaku tipe data tertentu, tetapi tidak peduli tentang siapa yang mengimplementasikan perilakunya.
3. Anda ingin memanfaatkan multiple inheritance of type.

kelas abstrak menetapkan "adalah" hubungan dengan kelas konkret. antarmuka menyediakan kemampuan "memiliki" untuk kelas.

Jika Anda mencari Javasebagai bahasa pemrograman, berikut adalah beberapa pembaruan lagi:

Java 8 telah mengurangi kesenjangan antara interfacedan abstractkelas sampai batas tertentu dengan menyediakan defaultfitur metode. Antarmuka tidak memiliki implementasi karena metode tidak lagi valid sekarang.

Lihat halaman dokumentasi ini untuk detail lebih lanjut.

Lihat pertanyaan SE ini untuk contoh kode untuk memahami lebih baik.

Bagaimana seharusnya saya menjelaskan perbedaan antara Interface dan kelas Abstrak?

Beberapa perbedaan penting:

Dalam bentuk tabel:

Seperti yang dikatakan oleh Joe dari javapapers :

1. Perbedaan utama adalah metode antarmuka Java abstrak dan tidak dapat diimplementasikan. Kelas abstrak Java dapat memiliki metode instan yang mengimplementasikan perilaku default.

2.Variabel yang dideklarasikan dalam antarmuka Java secara default final. Kelas abstrak dapat berisi variabel non-final.

3. Anggota antarmuka Java adalah publik secara default. Kelas abstrak Java dapat memiliki cita rasa anggota kelas seperti privat, dilindungi, dll.

4.Java antarmuka harus diimplementasikan menggunakan kata kunci "mengimplementasikan"; Kelas abstrak Java harus diperluas menggunakan kata kunci "extends".

5. Sebuah antarmuka dapat memperluas antarmuka Java lainnya saja, kelas abstrak dapat memperluas kelas Java lainnya dan mengimplementasikan beberapa antarmuka Java.

6.Sebuah kelas Java dapat mengimplementasikan banyak antarmuka tetapi hanya dapat memperpanjang satu kelas abstrak.

7.Interface benar-benar abstrak dan tidak dapat dipakai; Kelas abstrak Java juga tidak bisa dipakai, tetapi bisa dipanggil jika main () ada.

8.Dibandingkan dengan kelas abstrak java, antarmuka java lambat karena membutuhkan tipuan ekstra.

Poin utamanya adalah:

• Abstrak berorientasi objek . Ia menawarkan data dasar yang harus dimiliki 'obyek' dan / atau fungsi-fungsi yang harus dapat dilakukannya. Ini berkaitan dengan karakteristik dasar objek: apa yang dimilikinya dan apa yang dapat dilakukannya. Karenanya objek yang mewarisi dari kelas abstrak yang sama berbagi karakteristik dasar (generalisasi).
• Antarmuka berorientasi pada fungsionalitas . Ini mendefinisikan fungsionalitas objek yang seharusnya dimiliki. Apa pun objeknya, selama ia dapat melakukan fungsi-fungsi ini, yang didefinisikan dalam antarmuka, tidak apa-apa. Itu mengabaikan segala sesuatu yang lain. Objek / kelas dapat berisi beberapa (kelompok) fungsi; oleh karena itu dimungkinkan bagi suatu kelas untuk mengimplementasikan banyak antarmuka.

Saat Anda ingin memberikan perilaku polimorfik dalam hierarki warisan, gunakan kelas abstrak.

Saat Anda menginginkan perilaku polimorfik untuk kelas yang sama sekali tidak terkait, gunakan antarmuka.

Saya membangun gedung 300 lantai

Antarmuka cetak biru gedung

• Misalnya, Servlet (I)

Bangunan dibangun hingga 200 lantai - sebagian selesai --- abstrak

• Implementasi parsial, misalnya, generik dan HTTP servlet

Konstruksi bangunan selesai- beton

• Implementasi penuh, misalnya, memiliki servlet

Antarmuka

• Kami tidak tahu apa-apa tentang implementasi, hanya persyaratan. Kita bisa menggunakan antarmuka.
• Setiap metode bersifat publik dan abstrak secara default
• Ini adalah kelas abstrak 100% murni
• Jika kami menyatakan publik, kami tidak dapat mendeklarasikan pribadi dan dilindungi
• Jika kita mendeklarasikan abstrak, kita tidak dapat mendeklarasikan final, statis, disinkronkan, strictfp dan asli
• Setiap antarmuka memiliki publik, statis, dan final
• Serialisasi dan transien tidak berlaku, karena kami tidak dapat membuat instance untuk di antarmuka
• Non-volatile karena bersifat final
• Setiap variabel statis
• Ketika kita mendeklarasikan variabel di dalam antarmuka kita perlu menginisialisasi variabel saat mendeklarasikan
• Mesin virtual dan blok statis tidak diizinkan

Abstrak

• Implementasi sebagian
• Ini memiliki metode abstrak. Selain itu, menggunakan beton
• Tidak ada batasan untuk pengubah metode kelas abstrak
• Tidak ada batasan untuk pengubah variabel kelas abstrak
• Kami tidak dapat mendeklarasikan pengubah lain kecuali abstrak
• Tidak ada batasan untuk menginisialisasi variabel

Diambil dari Situs Web DurgaJobs

Mari kita ulangi pertanyaan ini:

Hal pertama yang harus Anda ketahui adalah bahwa 1/1 dan 1 * 1 menghasilkan hal yang sama, tetapi itu tidak berarti bahwa perkalian dan pembagian adalah sama. Jelas, mereka memiliki hubungan yang baik, tetapi pikiran Anda berdua berbeda.

Saya akan menunjukkan perbedaan utama, dan sisanya telah dijelaskan:

Kelas abstrak berguna untuk memodelkan hierarki kelas. Sekilas tentang persyaratan apa pun, kami sebagian jelas tentang apa yang sebenarnya harus dibangun, tetapi kami tahu apa yang harus dibangun.Jadi kelas abstrak Anda adalah kelas dasar Anda.

Antarmuka berguna untuk membiarkan hierarki atau kelas lain tahu bahwa apa yang saya mampu lakukan. Dan ketika Anda mengatakan saya mampu melakukan sesuatu, Anda harus memiliki kapasitas itu. Antarmuka akan menandainya sebagai wajib bagi kelas untuk mengimplementasikan fungsi yang sama.

Sebenarnya cukup sederhana.

Anda dapat menganggap antarmuka sebagai kelas yang hanya diperbolehkan memiliki metode abstrak dan tidak ada yang lain.

Jadi sebuah antarmuka hanya dapat "mendeklarasikan" dan tidak mendefinisikan perilaku yang Anda inginkan dari kelas tersebut.

Kelas abstrak memungkinkan Anda untuk melakukan keduanya mendeklarasikan (menggunakan metode abstrak) serta mendefinisikan (menggunakan implementasi metode lengkap) perilaku yang Anda inginkan dari kelas tersebut.

Dan kelas reguler hanya memungkinkan Anda untuk mendefinisikan, bukan menyatakan, perilaku / tindakan yang Anda inginkan untuk dimiliki oleh kelas tersebut.

Satu hal terakhir,

Di Java, Anda dapat mengimplementasikan banyak antarmuka, tetapi Anda hanya dapat memperluas satu (Kelas Abstrak atau Kelas) ...

Ini berarti warisan perilaku yang didefinisikan dibatasi hanya mengizinkan satu per kelas ... yaitu jika Anda menginginkan kelas yang dienkapsulasi perilaku dari Kelas A, B & C Anda perlu melakukan hal berikut: Kelas A meluas B, Kelas C meluas .. ini sedikit tentang cara untuk memiliki beberapa warisan ...

Antarmuka di sisi lain, Anda bisa melakukannya: antarmuka C mengimplementasikan A, B

Jadi pada dasarnya Java mendukung beberapa pewarisan hanya dalam "perilaku yang dinyatakan" yaitu antarmuka, dan hanya pewarisan tunggal dengan perilaku yang ditentukan .. kecuali jika Anda melakukan putaran tentang cara saya jelaskan ...

Semoga itu masuk akal.

Perbandingan antarmuka dengan kelas abstrak salah. Seharusnya ada dua perbandingan lain sebagai gantinya: 1) antarmuka vs kelas dan 2) abstrak vs kelas akhir .

Antarmuka vs Kelas

Antarmuka adalah kontrak antara dua objek. Misalnya, saya seorang tukang pos dan Anda adalah Paket untuk dikirimkan. Saya berharap Anda mengetahui alamat pengiriman Anda. Ketika seseorang memberi saya Paket, ia harus mengetahui alamat pengirimannya:

interface Package {
  String address();
}

Kelas adalah sekelompok objek yang mematuhi kontrak. Misalnya, saya kotak dari kelompok "Kotak" dan saya mematuhi kontrak yang diminta oleh tukang pos. Pada saat yang sama saya mematuhi kontrak lain:

class Box implements Package, Property {
  @Override
  String address() {
    return "5th Street, New York, NY";
  }
  @Override
  Human owner() {
    // this method is part of another contract
  }
}

Abstrak vs Final

Kelas abstrak adalah sekelompok objek yang tidak lengkap. Mereka tidak dapat digunakan, karena mereka kehilangan beberapa bagian. Misalnya, saya kotak sadar GPS abstrak - Saya tahu cara memeriksa posisi saya di peta:

abstract class GpsBox implements Package {
  @Override
  public abstract String address();
  protected Coordinates whereAmI() {
    // connect to GPS and return my current position
  }
}

Kelas ini, jika diwarisi / diperluas oleh kelas lain, bisa sangat berguna. Tetapi dengan sendirinya - itu tidak berguna, karena tidak dapat memiliki objek. Kelas abstrak dapat menjadi elemen pembangun kelas akhir.

Kelas akhir adalah sekelompok objek lengkap, yang dapat digunakan, tetapi tidak dapat dimodifikasi. Mereka tahu persis cara bekerja dan apa yang harus dilakukan. Misalnya, saya seorang Box yang selalu pergi ke alamat yang ditentukan selama konstruksi:

final class DirectBox implements Package {
  private final String to;
  public DirectBox(String addr) {
    this.to = addr;
  }
  @Override
  public String address() {
    return this.to;
  }
}

Di sebagian besar bahasa, seperti Java atau C ++, dimungkinkan untuk hanya memiliki kelas , baik abstrak maupun final. Kelas semacam itu bisa diwariskan dan bisa dipakai. Saya tidak berpikir ini benar-benar sejalan dengan paradigma berorientasi objek.

Sekali lagi, membandingkan antarmuka dengan kelas abstrak tidak benar.

Singkatnya perbedaannya adalah sebagai berikut:

Perbedaan Sintaksis Antarmuka dan Kelas Abstrak :

1. Metode dan anggota kelas abstrak dapat memiliki visibilitas apa pun. Semua metode antarmuka harus bersifat publik .// Tidak berlaku dari Java 9 lagi
2. Kelas anak konkret dari Kelas Abstrak harus mendefinisikan semua metode abstrak. Sebuah Abstrak kelas anak dapat memiliki metode abstrak. sebuah antarmuka memperluas kebutuhan antarmuka lain tidak menyediakan implementasi default untuk metode yang diwarisi dari antarmuka induk.
3. Kelas anak hanya dapat memperpanjang satu kelas. sebuah antarmuka dapat memperpanjang beberapa interface. Sebuah kelas dapat mengimplementasikan banyak antarmuka.
4. Kelas anak dapat mendefinisikan metode abstrak dengan visibilitas yang sama atau kurang ketat, sedangkan kelas yang mengimplementasikan antarmuka harus mendefinisikan semua metode antarmuka sebagai publik.
5. Abstrak Kelas dapat memiliki konstruktor tetapi tidak antarmuka .
6. Antarmuka dari Java 9 memiliki metode statis pribadi.

Di Antarmuka sekarang:

public static- didukung
public abstract- didukung
public default- didukung
private static- didukung
private abstract- kesalahan
private defaultkompilasi
private- kesalahan kompilasi - didukung

Satu-satunya perbedaan adalah bahwa seseorang dapat berpartisipasi dalam banyak warisan dan yang lainnya tidak.

Definisi antarmuka telah berubah seiring waktu. Apakah Anda pikir antarmuka hanya memiliki deklarasi metode saja dan hanya kontrak? Bagaimana dengan variabel final statis dan bagaimana dengan definisi default setelah Java 8?

Antarmuka diperkenalkan ke Jawa karena masalah berlian dengan banyak pewarisan dan itulah yang sebenarnya ingin mereka lakukan.

Antarmuka adalah konstruk yang dibuat untuk menghilangkan masalah pewarisan berganda dan dapat memiliki metode abstrak, definisi default, dan variabel final statis.

Lihat Mengapa Java mengizinkan variabel akhir statis di antarmuka saat mereka hanya dimaksudkan sebagai kontrak? .

Antarmuka: Belok (Belok Kiri, Belok Kanan.)

Kelas Abstrak: Roda.

Kelas: Roda Kemudi, berasal dari Roda, memaparkan Giliran Antarmuka

Salah satunya adalah untuk mengkategorikan perilaku yang dapat ditawarkan di berbagai hal, yang lain adalah untuk memodelkan ontologi hal.

Jika Anda memiliki beberapa metode umum yang dapat digunakan oleh beberapa kelas, gunakan kelas abstrak. Lain jika Anda ingin kelas untuk mengikuti cetak biru yang pasti pergi untuk antarmuka.

Contoh berikut menunjukkan ini.

Kelas abstrak di Jawa:

abstract class animals
{
    // They all love to eat. So let's implement them for everybody
    void eat()
    {
        System.out.println("Eating...");
    }
    // The make different sounds. They will provide their own implementation.
    abstract void sound();
}

class dog extends animals
{
    void sound()
    {
        System.out.println("Woof Woof");
    }
}

class cat extends animals
{
    void sound()
    {
        System.out.println("Meoww");
    }
}

Berikut ini adalah implementasi antarmuka di Jawa:

interface Shape
{
    void display();
    double area();
}

class Rectangle implements Shape 
{
    int length, width;
    Rectangle(int length, int width)
    {
        this.length = length;
        this.width = width;
    }
    @Override
    public void display() 
    {
        System.out.println("****\n* *\n* *\n****"); 
    }
    @Override
    public double area() 
    {
        return (double)(length*width);
    }
} 

class Circle implements Shape 
{
    double pi = 3.14;
    int radius;
    Circle(int radius)
    {
        this.radius = radius;
    }
    @Override
    public void display() 
    {
        System.out.println("O"); // :P
    }
    @Override
    public double area() 
    { 
        return (double)((pi*radius*radius)/2);
    }
}

Beberapa poin penting dalam singkatnya:

1. Variabel yang dideklarasikan di antarmuka Java secara default final. Kelas abstrak dapat memiliki variabel non-final.

2. Variabel yang dideklarasikan di antarmuka Java secara default statis. Kelas abstrak dapat memiliki variabel non-statis.

3. Anggota antarmuka Java bersifat publik secara default. Kelas abstrak Java dapat memiliki cita rasa anggota kelas seperti privat, dilindungi, dll.

Banyak pengembang junior membuat kesalahan dengan memikirkan antarmuka, kelas abstrak dan konkret sebagai sedikit variasi dari hal yang sama, dan memilih salah satunya murni dengan alasan teknis: Apakah saya memerlukan pewarisan berganda? Apakah saya perlu tempat untuk meletakkan metode umum? Apakah saya perlu repot dengan sesuatu selain kelas yang konkret? Ini salah, dan tersembunyi dalam pertanyaan-pertanyaan ini adalah masalah utama: "Saya" . Ketika Anda menulis kode untuk diri sendiri, Anda jarang memikirkan pengembang lain saat ini atau di masa depan yang sedang mengerjakan atau dengan kode Anda.

Antarmuka dan kelas abstrak, meskipun tampaknya serupa dari sudut pandang teknis, memiliki arti dan tujuan yang sama sekali berbeda.

Ringkasan

1. Antarmuka mendefinisikan kontrak yang beberapa implementasi akan memenuhi untuk Anda .

2. Kelas abstrak menyediakan perilaku default yang dapat digunakan kembali oleh implementasi Anda .

Ringkasan alternatif

1. Antarmuka adalah untuk mendefinisikan API publik
2. Kelas abstrak adalah untuk penggunaan internal, dan untuk mendefinisikan SPI

Tentang pentingnya menyembunyikan detail implementasi

Kelas konkret melakukan pekerjaan yang sebenarnya, dengan cara yang sangat spesifik. Sebagai contoh, sebuah ArrayListmenggunakan area memori yang berdekatan untuk menyimpan daftar objek dalam cara yang kompak yang menawarkan akses acak cepat, iterasi, dan perubahan di tempat, tetapi mengerikan dalam penyisipan, penghapusan, dan kadang-kadang bahkan penambahan; sementara itu, aLinkedList menggunakan node yang ditautkan ganda untuk menyimpan daftar objek, yang alih-alih menawarkan iterasi cepat, perubahan di tempat, dan penyisipan / penghapusan / penambahan, tetapi mengerikan pada akses acak. Kedua jenis daftar ini dioptimalkan untuk berbagai kasus penggunaan, dan sangat penting bagaimana Anda akan menggunakannya. Saat Anda mencoba memeras kinerja dari daftar yang sangat berinteraksi dengan Anda, dan ketika memilih jenis daftar terserah Anda, Anda harus hati-hati memilih yang mana yang Anda instantiating.

Di sisi lain, pengguna tingkat tinggi dari daftar tidak benar-benar peduli bagaimana itu sebenarnya diterapkan, dan mereka harus diisolasi dari perincian ini. Mari kita bayangkan bahwa Java tidak mengekspos Listantarmuka, tetapi hanya memiliki Listkelas nyata yang sebenarnya LinkedListsekarang. Semua pengembang Java akan menyesuaikan kode mereka agar sesuai dengan detail implementasi: hindari akses acak, tambahkan cache untuk mempercepat akses, atau cukup implementasi ulang ArrayListsendiri, meskipun itu tidak sesuai dengan semua kode lain yang benar-benar berfungsi denganList hanya . Itu akan mengerikan ... Tapi sekarang bayangkan bahwa master Java benar-benar menyadari bahwa daftar tertaut mengerikan untuk sebagian besar kasus penggunaan aktual, dan memutuskan untuk beralih ke daftar array hanya untuk merekaListkelas tersedia. Ini akan memengaruhi kinerja setiap program Java di dunia, dan orang-orang tidak akan senang karenanya. Dan penyebab utamanya adalah detail implementasi tersedia, dan pengembang berasumsi bahwa detail itu adalah kontrak permanen yang dapat mereka andalkan. Inilah sebabnya mengapa penting untuk menyembunyikan detail implementasi, dan hanya mendefinisikan kontrak abstrak. Ini adalah tujuan dari sebuah antarmuka: tentukan input apa yang diterima suatu metode, dan output seperti apa yang diharapkan, tanpa memaparkan semua nyali yang akan menggoda programmer untuk mengubah kode mereka agar sesuai dengan detail internal yang mungkin berubah dengan pembaruan di masa mendatang. .

Kelas abstrak berada di tengah-tengah antara antarmuka dan kelas konkret. Seharusnya membantu implementasi berbagi kode umum atau membosankan. Misalnya, AbstractCollectionmemberikan implementasi dasar untuk isEmptyberdasarkan ukuran adalah 0, containsseperti iterate dan bandingkan, addAllseperti diulang add, dan sebagainya. Ini memungkinkan implementasi fokus pada bagian-bagian penting yang membedakan di antara mereka: bagaimana sebenarnya menyimpan dan mengambil data.

API versus SPI

Antarmuka adalah gateway kohesi rendah antara berbagai bagian kode. Mereka memungkinkan perpustakaan ada dan berkembang tanpa merusak setiap pengguna perpustakaan ketika sesuatu berubah secara internal. Ini disebut Antarmuka Pemrograman Aplikasi , bukan Kelas Pemrograman Aplikasi. Pada skala yang lebih kecil, mereka juga memungkinkan banyak pengembang untuk berkolaborasi dengan sukses pada proyek skala besar, dengan memisahkan modul yang berbeda melalui antarmuka yang terdokumentasi dengan baik.

Kelas abstrak adalah pembantu kohesi tinggi yang akan digunakan saat mengimplementasikan antarmuka, dengan asumsi beberapa tingkat detail implementasi. Atau, kelas abstrak digunakan untuk mendefinisikan SPI, Antarmuka Penyedia Layanan.

Perbedaan antara API dan SPI adalah halus, tetapi penting: untuk API, fokusnya adalah pada siapa yang menggunakannya , dan untuk SPI fokusnya adalah pada siapa yang mengimplementasikannya .

Menambahkan metode ke API mudah, semua pengguna API yang ada masih akan dikompilasi. Menambahkan metode ke SPI sulit, karena setiap penyedia layanan (implementasi konkret) harus menerapkan metode baru. Jika antarmuka digunakan untuk mendefinisikan SPI, penyedia harus merilis versi baru setiap kali kontrak SPI berubah. Jika kelas abstrak digunakan sebagai gantinya, metode baru dapat didefinisikan dalam hal metode abstrak yang ada, atau sebagai throw not implemented exceptionbertopik kosong , yang setidaknya akan memungkinkan versi yang lebih lama dari implementasi layanan untuk tetap dikompilasi dan dijalankan.

Catatan tentang Java 8 dan metode default

Meskipun Java 8 memperkenalkan metode default untuk antarmuka, yang membuat garis antara antarmuka dan kelas abstrak bahkan lebih blurrier, ini bukan agar implementasi dapat menggunakan kembali kode, tetapi untuk membuatnya lebih mudah untuk mengubah antarmuka yang berfungsi baik sebagai API dan sebagai SPI (atau salah digunakan untuk mendefinisikan SPI, bukan kelas abstrak).

Yang mana yang akan digunakan?

1. Apakah benda itu seharusnya digunakan untuk umum oleh bagian lain dari kode, atau oleh kode eksternal lainnya? Tambahkan antarmuka untuk menyembunyikan detail implementasi dari kontrak abstrak publik, yang merupakan perilaku umum hal tersebut.
2. Adalah hal sesuatu yang seharusnya memiliki beberapa implementasi dengan banyak kode kesamaan? Buat antarmuka dan implementasi abstrak, tidak lengkap.
3. Apakah akan ada hanya satu implementasi, dan tidak ada orang lain yang akan menggunakannya? Jadikan itu kelas yang konkret.
   1. "ever" sudah lama, Anda bisa memainkannya dengan aman dan masih menambahkan antarmuka di atasnya.

Sebuah akibat wajar: sebaliknya sering salah dilakukan: ketika menggunakan sesuatu , selalu mencoba menggunakan kelas / antarmuka paling umum yang sebenarnya Anda butuhkan. Dengan kata lain, jangan mendeklarasikan variabel Anda sebagai ArrayList theList = new ArrayList(), kecuali Anda benar-benar memiliki ketergantungan yang sangat kuat pada itu menjadi daftar array , dan tidak ada jenis daftar lain yang akan memotongnya untuk Anda. Gunakan List theList = new ArrayListsebagai gantinya, atau bahkan Collection theCollection = new ArrayListjika fakta bahwa itu adalah daftar, dan bukan jenis koleksi lain apa pun sebenarnya tidak masalah.

Bukan benar-benar jawaban untuk pertanyaan awal, tetapi begitu Anda memiliki jawaban untuk perbedaan di antara mereka, Anda akan memasukkan dilema kapan-untuk-menggunakan-setiap: Kapan menggunakan antarmuka atau kelas abstrak? Kapan harus menggunakan keduanya?

Saya memiliki pengetahuan yang terbatas tentang OOP, tetapi melihat antarmuka sebagai setara dengan kata sifat dalam tata bahasa telah bekerja untuk saya sampai sekarang (koreksi saya jika metode ini palsu!). Misalnya, nama antarmuka seperti atribut atau kemampuan yang dapat Anda berikan ke kelas, dan kelas dapat memiliki banyak dari mereka: ISerializable, ICountable, IList, ICacheable, IHappy, ...

Warisan digunakan untuk dua tujuan:

• Untuk memungkinkan objek menganggap anggota data tipe induk dan implementasi metode sebagai miliknya.

• Untuk memungkinkan referensi ke objek dari satu jenis yang akan digunakan oleh kode yang mengharapkan referensi ke objek supertype.

Dalam bahasa / kerangka kerja yang mendukung multiple inheritance yang digeneralisasi, seringkali ada sedikit kebutuhan untuk mengklasifikasikan suatu tipe sebagai "antarmuka" atau "kelas abstrak". Bahasa populer dan kerangka kerja, bagaimanapun, akan memungkinkan suatu jenis untuk menganggap anggota data satu sama lain atau implementasi metode sebagai miliknya meskipun mereka memungkinkan suatu jenis untuk menjadi pengganti untuk sejumlah jenis lainnya yang sewenang-wenang.

Kelas abstrak mungkin memiliki anggota data dan implementasi metode, tetapi hanya bisa diwarisi oleh kelas yang tidak mewarisi dari kelas lain. Antarmuka hampir tidak membatasi pada tipe yang mengimplementasikannya, tetapi tidak dapat menyertakan anggota data atau implementasi metode.

Ada kalanya berguna untuk jenis yang dapat diganti untuk banyak hal yang berbeda; ada saat-saat lain ketika objek berguna untuk menganggap anggota data tipe induk dan implementasi metode sebagai milik mereka. Membuat perbedaan antara antarmuka dan kelas abstrak memungkinkan masing-masing kemampuan yang akan digunakan dalam kasus di mana itu paling relevan.

Poin-Poin Utama:

• Kelas abstrak dapat memiliki properti, bidang Data, Metode (lengkap / tidak lengkap) keduanya.
• Jika metode atau Properti mendefinisikan kata kunci abstrak yang harus menimpa di kelas turunan (berfungsi sebagai fungsi yang sangat erat)
• Jika menentukan kata kunci abstrak untuk metode atau properti di kelas abstrak, Anda tidak dapat menentukan tubuh metode dan mendapatkan / menetapkan nilai untuk properti dan yang harus menimpa di kelas turunan.
• Kelas abstrak tidak mendukung multiple inheritance.
• Kelas abstrak berisi Konstruktor.
• Kelas abstrak dapat berisi pengubah akses untuk subs, fungsi, properti.
• Hanya Anggota Lengkap kelas abstrak yang bisa menjadi Static.
• Antarmuka dapat mewarisi dari antarmuka lain saja dan tidak dapat mewarisi dari kelas abstrak, di mana sebagai kelas abstrak dapat mewarisi dari kelas abstrak lain atau antarmuka lain.

Keuntungan:

• Ini adalah semacam kontrak yang memaksa semua subclass untuk menjalankan hierarki atau standar yang sama.
• Jika berbagai implementasi dari jenis yang sama dan menggunakan perilaku atau status umum maka kelas abstrak lebih baik untuk digunakan.
• Jika kita menambahkan metode baru ke kelas abstrak maka kita memiliki opsi untuk menyediakan implementasi default dan oleh karena itu semua kode yang ada dapat berfungsi dengan baik.
• Ini memungkinkan eksekusi cepat dari antarmuka. (Antarmuka Membutuhkan lebih banyak waktu untuk menemukan metode aktual di kelas yang sesuai.)
• Dapat digunakan untuk kopling yang ketat dan longgar.

temukan detailnya di sini ... http://pradeepatkari.wordpress.com/2014/11/20/interface-and-abstract-class-in-c-oops/

Cara terpendek untuk menyimpulkannya adalah bahwa interfaceadalah:

1. Sepenuhnya abstrak, terlepas dari defaultdan staticmetode; sementara ia memiliki definisi (tanda tangan metode + implementasi) untuk defaultdan staticmetode, itu hanya memiliki deklarasi (tanda tangan metode) untuk metode lain.
2. Tunduk pada aturan lebih lemah dari kelas (kelas dapat mengimplementasikan beberapa interfaces, dan interfacedapat mewarisi dari banyak interfaces). Semua variabel secara implisit konstan, apakah ditentukan sebagai public static finalatau tidak. Semua anggota secara implisit public, apakah ditentukan seperti itu atau tidak.
3. Umumnya digunakan sebagai jaminan bahwa kelas implementasi akan memiliki fitur yang ditentukan dan / atau kompatibel dengan kelas lain yang mengimplementasikan antarmuka yang sama.

Sementara itu, abstractkelas adalah:

1. Di mana saja dari sepenuhnya abstrak hingga sepenuhnya dilaksanakan, dengan kecenderungan memiliki satu atau lebih abstractmetode. Dapat berisi deklarasi dan definisi, dengan deklarasi yang ditandai sebagai abstract.
2. Kelas penuh, dan tunduk pada aturan yang mengatur kelas lain (hanya dapat mewarisi dari satu kelas), dengan ketentuan bahwa itu tidak dapat dipakai (karena tidak ada jaminan bahwa itu sepenuhnya dilaksanakan). Dapat memiliki variabel anggota yang tidak konstan. Dapat menerapkan kontrol akses anggota, membatasi anggota sebagai protected, private, atau paket swasta (tidak ditentukan).
3. Biasanya digunakan baik untuk menyediakan sebanyak mungkin implementasi yang dapat dibagikan oleh beberapa subclass, atau untuk menyediakan sebanyak mungkin implementasi yang dapat disediakan oleh programmer.

Atau, jika kita ingin merebusnya semua ke satu kalimat: Sebuah interfaceadalah apa kelas yang mengimplementasikan memiliki , tapi abstractkelas adalah apa subclass adalah .

Saya ingin menambahkan satu lagi perbedaan yang masuk akal. Misalnya, Anda memiliki kerangka kerja dengan ribuan baris kode. Sekarang jika Anda ingin menambahkan fitur baru di seluruh kode menggunakan metode enhUI (), maka lebih baik menambahkan metode itu di kelas abstrak daripada di antarmuka. Karena, jika Anda menambahkan metode ini dalam antarmuka maka Anda harus mengimplementasikannya di semua kelas yang diimplementasikan tetapi tidak demikian halnya jika Anda menambahkan metode dalam kelas abstrak.

Untuk memberikan jawaban yang sederhana namun jelas, ada baiknya mengatur konteks: Anda menggunakan keduanya ketika Anda tidak ingin memberikan implementasi penuh.

Perbedaan utama kemudian adalah antarmuka tidak memiliki implementasi sama sekali (hanya metode tanpa tubuh) sedangkan kelas abstrak dapat memiliki anggota dan metode dengan tubuh juga, yaitu sebagian dapat diimplementasikan.

Perbedaan antara kelas abstrak dan antarmuka atas nama implementasi nyata.

Antarmuka : Ini adalah kata kunci dan digunakan untuk menentukan template atau cetak biru dari suatu objek dan memaksa semua sub kelas akan mengikuti prototipe yang sama, seperti untuk implementasi, semua sub kelas bebas untuk mengimplementasikan fungsi sesuai itu persyaratan.

Beberapa kasus penggunaan lain di mana kita harus menggunakan antarmuka.

Komunikasi antara dua objek eksternal (Integrasi pihak ketiga dalam aplikasi kita) dilakukan melalui Antarmuka di sini Antarmuka berfungsi sebagai Kontrak.

Kelas Abstrak: Abstrak, itu adalah kata kunci dan ketika kita menggunakan kata kunci ini sebelum kelas apa pun maka itu menjadi kelas abstrak. Ini terutama digunakan ketika kita perlu mendefinisikan template serta beberapa fungsi default dari suatu objek yang diikuti oleh semua sub kelas dan dengan cara ini menghapus kode yang berlebihan dan satu lagi kasus penggunaan di mana kita dapat menggunakan kelas abstrak , seperti yang kita inginkan tidak ada kelas lain yang dapat secara langsung instantiate objek kelas, hanya kelas turunan yang dapat menggunakan fungsionalitas.

Contoh Kelas Abstrak:

 public abstract class DesireCar
  {

 //It is an abstract method that defines the prototype.
     public abstract void Color();

  // It is a default implementation of a Wheel method as all the desire cars have the same no. of wheels.   
 // and hence no need to define this in all the sub classes in this way it saves the code duplicasy     

  public void Wheel() {          

               Console.WriteLine("Car has four wheel");
                }
           }


    **Here is the sub classes:**

     public class DesireCar1 : DesireCar
        {
            public override void Color()
            {
                Console.WriteLine("This is a red color Desire car");
            }
        }

        public class DesireCar2 : DesireCar
        {
            public override void Color()
            {
                Console.WriteLine("This is a red white Desire car");
            }
        }

Contoh Antarmuka:

  public interface IShape
        {
          // Defines the prototype(template) 
            void Draw();
        }


  // All the sub classes follow the same template but implementation can be different.

    public class Circle : IShape
    {
        public void Draw()
        {
            Console.WriteLine("This is a Circle");
        }
    }

    public class Rectangle : IShape
    {
        public void Draw()
        {
            Console.WriteLine("This is a Rectangle");
        }
    }

Anda dapat menemukan perbedaan yang jelas antara antarmuka dan kelas abstrak.

Antarmuka

• Antarmuka hanya berisi metode abstrak.
• Paksa pengguna untuk menerapkan semua metode saat mengimplementasikan antarmuka.
• Hanya berisi variabel final dan statis.
• Deklarasikan menggunakan kata kunci antarmuka.
• Semua metode antarmuka harus didefinisikan sebagai publik.
• Antarmuka dapat diperluas atau suatu kelas dapat mengimplementasikan beberapa antarmuka lainnya.

Kelas abstrak

• Kelas abstrak berisi metode abstrak dan non-abstrak.

• Tidak memaksa pengguna untuk menerapkan semua metode saat mewarisi kelas abstrak.

• Berisi semua jenis variabel termasuk primitif dan non-primitif

• Deklarasikan menggunakan kata kunci abstrak.

• Metode dan anggota kelas abstrak dapat didefinisikan dengan visibilitas apa pun.

• Kelas anak hanya dapat memperpanjang satu kelas (abstrak atau konkret).

Kelas abstrak adalah kelas yang objeknya tidak bisa dibuat atau kelas yang tidak bisa dipakai. Metode abstrak membuat abstrak kelas. Kelas abstrak perlu diwariskan untuk mengganti metode yang dideklarasikan di kelas abstrak. Tidak ada batasan pada penentu akses. Kelas abstrak dapat memiliki konstruktor dan metode konkret lainnya (metode non abstarct) di dalamnya tetapi antarmuka tidak dapat memilikinya.

Antarmuka adalah cetak biru / templat metode (mis. Sebuah rumah di atas kertas diberikan (antarmuka rumah) dan arsitek yang berbeda akan menggunakan ide-idenya untuk membangunnya (kelas arsitek yang mengimplementasikan antarmuka rumah). Ini adalah kumpulan dari metode abstrak, metode default, metode statis, variabel akhir, dan kelas bertingkat. Semua anggota akan menjadi penentu akses final atau publik, terlindungi, dan pribadi tidak diizinkan. Tidak boleh membuat objek. Kelas harus dibuat agar dapat menggunakan mengimplementasikan antarmuka dan juga untuk menimpa metode abstrak yang dinyatakan dalam antarmuka. Antarmuka adalah contoh yang baik dari kopling longgar (polimorfisme dinamis / pengikatan dinamis). Sebuah antarmuka mengimplementasikan polimorfisme dan abstraksi. Ini memberitahu apa yang harus dilakukan tetapi bagaimana melakukan didefinisikan oleh kelas implementasi. Misalnya, adasa perusahaan mobil dan ingin beberapa fitur sama untuk semua mobil yang diproduksi sehingga untuk itu perusahaan akan membuat kendaraan antarmuka yang akan memiliki fitur-fitur dan kelas mobil yang berbeda (seperti Maruti Suzkhi, Maruti 800) akan menimpa fitur-fitur (fungsi).

Kenapa antarmuka ketika kita sudah memiliki kelas abstrak? Java hanya mendukung pewarisan multilevel dan hierarki, tetapi dengan bantuan antarmuka, kami dapat menerapkan pewarisan berganda.

Dalam istilah kepraktisan (JAVA), perbedaan utama antara kelas abstrak dan antarmuka adalah kelas Abstrak dapat menahan keadaan. Selain memegang status kami dapat mencapai operasi lainnya dengan Antarmuka juga.

Dalam antarmuka semua metode harus hanya definisi, tidak satu pun harus diimplementasikan.

Tetapi dalam kelas abstrak harus ada metode abstrak dengan hanya definisi, tetapi metode lain dapat juga di kelas abstrak dengan implementasi ...

Kami memiliki berbagai perbedaan struktural / sintaksis antara antarmuka dan kelas abstrak. Beberapa perbedaan lagi

[1] Perbedaan berdasarkan skenario :

Kelas abstrak digunakan dalam skenario ketika kami ingin membatasi pengguna untuk membuat objek dari kelas induk DAN kami percaya akan ada lebih banyak metode abstrak yang akan ditambahkan di masa depan.

Antarmuka harus digunakan ketika kami yakin tidak akan ada lagi metode abstrak yang disediakan. Maka hanya antarmuka yang diterbitkan.

[2] Perbedaan konseptual :

"Apakah kita perlu menyediakan metode yang lebih abstrak di masa depan" jika YA membuatnya kelas abstrak dan jika TIDAK membuatnya Antarmuka.

(Paling tepat dan valid hingga java 1.7)

biasanya kelas Abstrak digunakan untuk inti sesuatu tetapi antarmuka yang digunakan untuk menambahkan perangkat.

ketika Anda ingin membuat tipe dasar untuk kendaraan Anda harus menggunakan kelas abstrak tetapi jika Anda ingin menambahkan beberapa fungsionalitas atau properti yang bukan bagian dari konsep dasar kendaraan Anda harus menggunakan antarmuka, misalnya Anda ingin menambahkan fungsi "ToJSON ()" .

antarmuka memiliki berbagai abstraksi daripada kelas abstrak. Anda dapat melihat ini dalam melewati argumen. lihat contoh ini:

jika Anda menggunakan kendaraan sebagai argumen, Anda hanya dapat menggunakan salah satu jenis turunannya (kategori kendaraan yang sama dengan kategori bus atau mobil). tetapi ketika Anda menggunakan antarmuka IMoveable sebagai argumen Anda memiliki lebih banyak pilihan.