Antarmuka vs Kelas Abstrak (OO umum)

Saya baru-baru ini memiliki dua wawancara telepon di mana saya ditanya tentang perbedaan antara Interface dan kelas Abstrak. Saya telah menjelaskan setiap aspek dari mereka yang dapat saya pikirkan, tetapi tampaknya mereka menunggu saya untuk menyebutkan sesuatu yang spesifik, dan saya tidak tahu apa itu.

Dari pengalaman saya, saya pikir yang berikut ini benar. Jika saya kehilangan poin utama, tolong beri tahu saya.

Antarmuka:

Setiap Metode tunggal yang dideklarasikan dalam Antarmuka harus diimplementasikan dalam subkelas. Hanya Peristiwa, Delegasi, Properti (C #), dan Metode yang bisa ada di Interface. Sebuah kelas dapat mengimplementasikan beberapa Antarmuka.

Kelas Abstrak:

Hanya metode abstrak yang harus diimplementasikan oleh subkelas. Kelas abstrak dapat memiliki metode normal dengan implementasi. Kelas abstrak juga dapat memiliki variabel kelas selain Peristiwa, Delegasi, Properti, dan Metode. Kelas hanya dapat mengimplementasikan satu kelas abstrak hanya karena tidak adanya Multi-inheritance di C #.

1. Setelah semua itu, pewawancara datang dengan pertanyaan "Bagaimana jika Anda memiliki kelas abstrak dengan hanya metode abstrak? Bagaimana itu berbeda dari antarmuka?" Saya tidak tahu jawabannya tapi saya pikir itu adalah warisan seperti yang disebutkan di atas kan?

2. Pewawancara lain bertanya kepada saya bagaimana jika Anda memiliki variabel Publik di dalam antarmuka, bagaimana hal itu berbeda dari di Kelas Abstrak? Saya bersikeras Anda tidak dapat memiliki variabel publik di dalam antarmuka. Saya tidak tahu apa yang ingin dia dengar tetapi dia juga tidak puas.

Lihat Juga :

• Kapan harus menggunakan antarmuka, bukan kelas abstrak dan sebaliknya

• Kelas Antarmuka vs. Abstrak

• Bagaimana Anda memutuskan antara menggunakan Kelas Abstrak dan Antarmuka?

• Apa perbedaan antara antarmuka dan kelas abstrak?

Sementara pertanyaan Anda menunjukkan itu untuk "OO umum", sepertinya benar-benar berfokus pada penggunaan .NET dari istilah ini.

Dalam. NET (mirip untuk Java):

• antarmuka tidak dapat memiliki negara atau implementasi
• kelas yang mengimplementasikan antarmuka harus menyediakan implementasi dari semua metode antarmuka itu
• kelas abstrak dapat berisi status (anggota data) dan / atau implementasi (metode)
• kelas abstrak dapat diwarisi tanpa menerapkan metode abstrak (meskipun kelas turunannya adalah abstrak itu sendiri)
• interface mungkin multi-inherit, kelas abstrak mungkin tidak (ini mungkin alasan konkret utama untuk ada secara terpisah dari kelas abtract - mereka mengizinkan implementasi multiple inheritance yang menghilangkan banyak masalah MI umum).

Sebagai istilah OO umum, perbedaannya tidak harus didefinisikan dengan baik. Sebagai contoh, ada programmer C ++ yang mungkin memiliki definisi kaku yang sama (interface adalah subset ketat dari kelas abstrak yang tidak dapat berisi implementasi), sementara beberapa mungkin mengatakan bahwa kelas abstrak dengan beberapa implementasi standar masih merupakan antarmuka atau non-abstrak kelas masih bisa mendefinisikan antarmuka.

Memang, ada idiom C ++ yang disebut Non-Virtual Interface (NVI) di mana metode publik adalah metode non-virtual yang 'dibuang' ke metode virtual pribadi:

• http://www.gotw.ca/publications/mill18.htm
• http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Non-Virtual_Interface

Bagaimana dengan analogi: ketika saya di Angkatan Udara, saya pergi ke pelatihan pilot dan menjadi pilot USAF (Angkatan Udara AS). Pada saat itu saya tidak memenuhi syarat untuk menerbangkan apa pun, dan harus mengikuti pelatihan jenis pesawat. Setelah saya memenuhi syarat, saya adalah seorang pilot (kelas abstrak) dan pilot C-141 (kelas beton). Di salah satu tugas saya, saya diberi tugas tambahan: Petugas Keselamatan. Sekarang saya masih seorang pilot dan pilot C-141, tetapi saya juga melakukan tugas-tugas Petugas Keselamatan (saya menerapkan ISafetyOfficer, jadi untuk berbicara). Seorang pilot tidak diharuskan menjadi petugas keselamatan, orang lain bisa melakukannya juga.

Semua pilot USAF harus mengikuti peraturan Angkatan Udara tertentu, dan semua pilot C-141 (atau F-16, atau T-38) adalah pilot USAF. Siapa pun bisa menjadi petugas keamanan. Jadi, untuk meringkas:

• Pilot: kelas abstrak
• C-141 Pilot: kelas beton
• Petugas Keamanan: antarmuka

catatan tambahan: ini dimaksudkan sebagai analogi untuk membantu menjelaskan konsep, bukan rekomendasi pengkodean. Lihat berbagai komentar di bawah, pembahasannya menarik.

Saya pikir jawaban yang mereka cari adalah perbedaan filosofis mendasar atau OPPS.

Warisan kelas abstrak digunakan ketika kelas turunan berbagi properti inti dan perilaku kelas abstrak. Jenis perilaku yang sebenarnya mendefinisikan kelas.

Di sisi lain warisan antarmuka digunakan ketika kelas-kelas berbagi perilaku periferal, yang tidak perlu mendefinisikan kelas turunan.

Untuk misalnya. Mobil dan Truk berbagi banyak properti inti dan perilaku kelas abstrak Automobile, tetapi mereka juga berbagi beberapa perilaku periferal seperti Menghasilkan knalpot yang bahkan kelas non-mobil seperti Bor atau PowerGenerators berbagi dan tidak serta merta mendefinisikan Mobil atau Truk , jadi Car, Truck, Driller dan PowerGenerator semuanya dapat berbagi antarmuka IExhaust yang sama.

Pendek: Kelas abstrak digunakan untuk memodelkan hierarki kelas dengan kelas yang serupa (Misalnya Hewan dapat kelas abstrak dan Manusia, Singa, Harimau dapat kelas turunan konkret)

DAN

Antarmuka digunakan untuk Komunikasi antara 2 kelas yang sama / tidak serupa yang tidak peduli dengan jenis kelas yang mengimplementasikan Antarmuka (misalnya Tinggi dapat menjadi properti antarmuka dan dapat diimplementasikan oleh Manusia, Bangunan, Pohon. Tidak masalah jika Anda dapat makan , Anda bisa berenang, Anda bisa mati atau apa pun .. itu penting hanya hal yang Anda perlu memiliki Tinggi (implementasi di kelas Anda)).

Ada beberapa perbedaan lainnya -

Antarmuka tidak dapat memiliki implementasi konkret. Kelas dasar abstrak bisa. Ini memungkinkan Anda untuk memberikan implementasi konkret di sana. Ini dapat memungkinkan kelas dasar abstrak untuk benar-benar memberikan kontrak yang lebih ketat, sedangkan antarmuka hanya menggambarkan bagaimana kelas digunakan. (Kelas dasar abstrak dapat memiliki anggota non-virtual yang mendefinisikan perilaku, yang memberikan lebih banyak kontrol kepada penulis kelas dasar.)

Lebih dari satu antarmuka dapat diimplementasikan pada suatu kelas. Kelas hanya bisa berasal dari satu kelas dasar abstrak. Hal ini memungkinkan untuk hierarki polimorfik menggunakan antarmuka, tetapi tidak kelas dasar abstrak. Ini juga memungkinkan untuk pseudo-multi-inheritance menggunakan antarmuka.

Kelas dasar abstrak dapat dimodifikasi dalam v2 + tanpa merusak API. Perubahan pada antarmuka merusak perubahan.

[C # /. NET Specific] Antarmuka, tidak seperti kelas dasar abstrak, dapat diterapkan ke tipe nilai (struct). Structs tidak dapat diwarisi dari kelas dasar abstrak. Ini memungkinkan kontrak perilaku / pedoman penggunaan diterapkan pada tipe nilai.

Warisan
Pertimbangkan mobil dan bus. Mereka adalah dua kendaraan yang berbeda. Tapi tetap saja, mereka berbagi beberapa sifat umum seperti mereka memiliki kemudi, rem, roda gigi, mesin dll.
Jadi dengan konsep warisan, ini dapat direpresentasikan sebagai berikut ...

public class Vehicle {
    private Driver driver;
    private Seat[] seatArray; //In java and most of the Object Oriented Programming(OOP) languages, square brackets are used to denote arrays(Collections).
    //You can define as many properties as you want here ...
}

Sekarang Sepeda ...

public class Bicycle extends Vehicle {
    //You define properties which are unique to bicycles here ...
    private Pedal pedal;
}

Dan sebuah mobil ...

public class Car extends Vehicle {
    private Engine engine;
    private Door[] doors;
}

Itu semua tentang Warisan . Kami menggunakannya untuk mengklasifikasikan objek ke bentuk Basis yang lebih sederhana dan anak-anak mereka seperti yang kita lihat di atas.

Kelas Abstrak

Kelas abstrak adalah objek yang tidak lengkap . Untuk memahaminya lebih jauh, mari kita pertimbangkan analogi kendaraan sekali lagi.
Kendaraan dapat dikendarai. Baik? Tetapi kendaraan yang berbeda digerakkan dengan cara yang berbeda ... Misalnya, Anda tidak dapat mengendarai mobil sama seperti Anda mengendarai Sepeda.
Lantas bagaimana cara merepresentasikan fungsi penggerak kendaraan? Lebih sulit untuk memeriksa jenis kendaraan apa itu dan mengendarainya dengan fungsinya sendiri; Anda harus mengubah kelas Driver lagi dan lagi ketika menambahkan jenis kendaraan baru.
Di sinilah peran kelas dan metode abstrak. Anda dapat mendefinisikan metode drive sebagai abstrak untuk memberi tahu bahwa setiap anak yang diwariskan harus mengimplementasikan fungsi ini.
Jadi, jika Anda memodifikasi kelas kendaraan ...

//......Code of Vehicle Class
abstract public void drive();
//.....Code continues

Sepeda dan Mobil juga harus menentukan cara mengendarainya. Jika tidak, kode tidak akan dikompilasi dan kesalahan dilemparkan.
Singkatnya .. kelas abstrak adalah kelas sebagian tidak lengkap dengan beberapa fungsi tidak lengkap, yang harus diwariskan oleh anak-anak warisan mereka sendiri.

Antarmuka Antarmuka sama sekali tidak lengkap. Mereka tidak memiliki properti apa pun. Mereka hanya menunjukkan bahwa anak-anak yang diwariskan mampu melakukan sesuatu ...
Misalkan Anda memiliki berbagai jenis ponsel dengan Anda. Masing-masing dari mereka memiliki cara berbeda untuk melakukan fungsi yang berbeda; Mis: panggil seseorang. Pembuat telepon menentukan cara melakukannya. Di sini ponsel dapat memanggil nomor - artinya dial-bisa. Mari kita wakili ini sebagai antarmuka.

public interface Dialable {
    public void dial(Number n);
}

Di sini pembuat Dialable mendefinisikan cara memanggil nomor. Anda hanya perlu memberikan nomor untuk dial.

// Makers define how exactly dialable work inside.

Dialable PHONE1 = new Dialable() {
    public void dial(Number n) {
        //Do the phone1's own way to dial a number
    }
}

Dialable PHONE2 = new Dialable() {
    public void dial(Number n) {
        //Do the phone2's own way to dial a number
    }
}


//Suppose there is a function written by someone else, which expects a Dialable
......
public static void main(String[] args) {
    Dialable myDialable = SomeLibrary.PHONE1;
    SomeOtherLibrary.doSomethingUsingADialable(myDialable);
}
.....

Dengan ini menggunakan antarmuka bukan kelas abstrak, penulis fungsi yang menggunakan Dialable tidak perlu khawatir tentang propertinya. Contoh: Apakah memiliki layar sentuh atau papan tombol, Apakah ini telepon darat atau telepon seluler tetap. Anda hanya perlu tahu apakah itu bisa diputar; apakah itu mewarisi (atau mengimplementasikan) antarmuka Dialable.

Dan yang lebih penting , jika suatu hari Anda mengganti Dialable dengan yang lain

......
public static void main(String[] args) {
    Dialable myDialable = SomeLibrary.PHONE2; // <-- changed from PHONE1 to PHONE2
    SomeOtherLibrary.doSomethingUsingADialable(myDialable);
}
.....

Anda dapat memastikan bahwa kode masih berfungsi dengan baik karena fungsi yang menggunakan dialable tidak (dan tidak bisa) bergantung pada detail selain yang ditentukan dalam antarmuka Dialable. Keduanya mengimplementasikan antarmuka Dialable dan itulah satu-satunya fungsi yang diperhatikan.

Antarmuka biasanya digunakan oleh pengembang untuk memastikan interoperabilitas (digunakan secara bergantian) di antara objek, sejauh mereka berbagi fungsi umum (sama seperti Anda dapat mengubah ke telepon rumah atau ponsel, sejauh Anda hanya perlu menekan nomor). Singkatnya, antarmuka adalah versi kelas abstrak yang jauh lebih sederhana, tanpa properti apa pun.
Juga, perhatikan bahwa Anda dapat mengimplementasikan (mewarisi) sebanyak mungkin antarmuka yang Anda inginkan tetapi Anda hanya dapat memperluas (mewarisi) kelas induk tunggal.

Info Lebih Lanjut Kelas abstrak vs. Antarmuka

Jika Anda menganggap javasebagai bahasa OOP untuk menjawab pertanyaan ini, rilis Java 8 menyebabkan beberapa konten dalam jawaban di atas sebagai usang. Sekarang antarmuka java dapat memiliki metode standar dengan implementasi konkret.

Situs web Oracle menyediakan perbedaan utama antara interfacedan abstractkelas.

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 mengimplementasikan Serializableantarmuka.
2. Anda ingin menentukan perilaku tipe data tertentu, tetapi tidak peduli tentang siapa yang mengimplementasikan perilakunya.
3. Anda ingin memanfaatkan multiple inheritance of type.

Secara sederhana, saya ingin menggunakan

antarmuka: Untuk menerapkan kontrak dengan beberapa objek yang tidak terkait

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

Lihat contoh kode untuk memahami berbagai hal dengan jelas: Bagaimana seharusnya saya menjelaskan perbedaan antara kelas Interface dan abstrak?

Pewawancara menggonggong pohon aneh. Untuk bahasa seperti C # dan Java, ada perbedaan, tetapi dalam bahasa lain seperti C ++ tidak ada. Teori OO tidak membedakan keduanya, hanya sintaksis bahasa.

Kelas abstrak adalah kelas dengan implementasi dan antarmuka (metode virtual murni) yang akan diwariskan. Antarmuka umumnya tidak memiliki implementasi apa pun tetapi hanya fungsi virtual murni.

Dalam C # atau Java kelas abstrak tanpa implementasi berbeda dari antarmuka hanya dalam sintaks yang digunakan untuk mewarisi darinya dan fakta bahwa Anda hanya dapat mewarisi dari satu.

Dengan mengimplementasikan antarmuka Anda mencapai komposisi ("memiliki-a" hubungan) alih-alih warisan ("is-a" hubungan). Itu adalah prinsip penting untuk diingat ketika datang ke hal-hal seperti pola desain di mana Anda perlu menggunakan antarmuka untuk mencapai komposisi perilaku, bukan warisan.

saya akan menjelaskan Detail Kedalaman antarmuka dan class.if Abstrak Anda tahu gambaran umum tentang antarmuka dan kelas abstrak, maka pertanyaan pertama tiba di pikiran Anda ketika kita harus menggunakan Interface dan kapan kita harus menggunakan kelas Abstrak. Jadi silakan periksa penjelasan di bawah ini tentang kelas Interface dan Abstract.

1. Kapan kita harus menggunakan Interface?

   jika Anda tidak tahu tentang implementasi hanya kami memiliki spesifikasi persyaratan maka kami pergi dengan Interface

2. Kapan kita harus menggunakan Kelas Abstrak?

   jika Anda tahu implementasi tetapi tidak sepenuhnya (implementasi sebagian) maka kita pergi dengan kelas abstrak.

   Antarmuka

   setiap metode dengan abstrak publik standar berarti antarmuka adalah 100% abstrak murni.

   Abstrak

   dapat memiliki metode Beton dan metode Abstrak, apa itu metode Beton, yang memiliki implementasi di kelas Abstrak, kelas abstrak adalah kelas yang dinyatakan abstrak — mungkin atau mungkin tidak termasuk metode abstrak.

   Antarmuka

   Kami tidak dapat menyatakan antarmuka sebagai pribadi, terlindungi

   P. Mengapa kami tidak mendeklarasikan Interface sebagai pribadi dan terlindungi?

   Karena secara default metode antarmuka adalah abstrak publik dan karena itu kami tidak menyatakan antarmuka sebagai pribadi dan terlindungi.

   Metode antarmuka
   juga kami tidak dapat menyatakan antarmuka sebagai pribadi, dilindungi, final, statis, disinkronkan, asli .....

   saya akan memberikan alasan: mengapa kita tidak mendeklarasikan metode yang disinkronkan karena kita tidak dapat membuat objek antarmuka dan sinkronisasi bekerja pada objek sehingga dan alasan mengapa kita tidak mendeklarasikan metode yang disinkronkan Konsep transien juga tidak berlaku karena pekerjaan transien dengan disinkronkan.

   Abstrak

   kami dengan senang hati menggunakan statis final publik, swasta .... berarti tidak ada batasan yang berlaku secara abstrak.

   Antarmuka

   Variabel dideklarasikan di Antarmuka sebagai final statis publik secara default sehingga kami juga tidak dinyatakan sebagai variabel pribadi, terlindungi.

   Pengubah volatil juga tidak berlaku di antarmuka karena variabel antarmuka secara default variabel final dan final statis publik Anda tidak dapat mengubah nilai setelah menetapkan nilai menjadi variabel dan setelah Anda mendeklarasikan variabel ke antarmuka Anda harus menetapkan variabel.

   Dan variabel volatile terus berubah sehingga itu adalah opp. untuk final itu alasan kami tidak menggunakan variabel volatile di antarmuka.

   Abstrak

   Variabel abstrak tidak perlu dinyatakan final statis publik.

semoga artikel ini bermanfaat.

Berbicara secara konseptual, menjaga implementasi khusus bahasa, aturan, manfaat dan mencapai tujuan pemrograman apa pun dengan menggunakan siapa pun atau keduanya, dapat atau tidak dapat memiliki kode / data / properti, bla bla, warisan tunggal atau ganda, disamping semua

1- Abstrak (atau abstrak murni) Kelas dimaksudkan untuk mengimplementasikan hierarki. Jika objek bisnis Anda terlihat agak mirip secara struktural, hanya mewakili jenis hubungan orangtua-anak (hierarki), maka kelas pewarisan / abstrak akan digunakan. Jika model bisnis Anda tidak memiliki hierarki maka pewarisan tidak boleh digunakan (di sini saya tidak berbicara tentang logika pemrograman misalnya beberapa pola desain memerlukan pewarisan). Secara konseptual, kelas abstrak adalah metode untuk mengimplementasikan hierarki model bisnis dalam OOP, itu tidak ada hubungannya dengan Antarmuka, sebenarnya membandingkan kelas Abstrak dengan Antarmuka tidak ada artinya karena keduanya secara konseptual sama sekali berbeda, itu ditanyakan dalam wawancara hanya untuk memeriksa konsep karena kelihatannya keduanya menyediakan fungsionalitas yang agak sama ketika implementasi yang bersangkutan dan kami programmer biasanya lebih menekankan pada pengkodean. [Ingatlah juga bahwa Abstraksi berbeda dari Kelas Abstrak].

2- an Antarmuka adalah kontrak, fungsionalitas bisnis lengkap yang diwakili oleh satu atau lebih set fungsi. Itulah mengapa ini diterapkan dan tidak diwariskan. Objek bisnis (bagian dari hierarki atau tidak) dapat memiliki sejumlah fungsi bisnis lengkap. Ini tidak ada hubungannya dengan kelas abstrak yang berarti warisan secara umum. Misalnya, manusia dapat MENJALANKAN, seekor gajah dapat MENJALANKAN, seekor burung dapat MENJALANKAN, dan sebagainya, semua objek dari hierarki yang berbeda ini akan mengimplementasikan antarmuka RUN atau antarmuka EAT atau SPEAK. Jangan masuk ke implementasi karena Anda mungkin mengimplementasikannya sebagai memiliki kelas abstrak untuk setiap jenis yang mengimplementasikan antarmuka ini. Objek hierarki apa pun dapat memiliki fungsi (antarmuka) yang tidak ada hubungannya dengan hierarki.

Saya percaya, Antarmuka tidak diciptakan untuk mencapai beberapa warisan atau untuk mengekspos perilaku publik, dan juga, kelas abstrak murni tidak mengesampingkan antarmuka tetapi Antarmuka adalah fungsi yang dapat dilakukan objek (melalui fungsi antarmuka itu) dan Kelas Abstrak mewakili suatu induk dari hierarki untuk menghasilkan anak-anak yang memiliki struktur inti (properti + fungsi) dari orangtua

Ketika Anda ditanya tentang perbedaannya, itu sebenarnya perbedaan konseptual bukan perbedaan dalam implementasi spesifik bahasa kecuali diminta secara eksplisit.

Saya percaya, kedua pewawancara mengharapkan satu garis perbedaan langsung antara keduanya dan ketika Anda gagal mereka mencoba mengarahkan Anda ke perbedaan ini dengan menerapkan SATU sebagai LAINNYA.

Bagaimana jika Anda memiliki kelas abstrak dengan metode abstrak saja?

Untuk .Net,

Jawaban Anda terhadap pewawancara kedua juga merupakan jawaban untuk yang pertama ... Kelas abstrak dapat memiliki implementasi, DAN negara, antarmuka tidak dapat ...

EDIT: Pada catatan lain, saya bahkan tidak akan menggunakan frase 'subclass' (atau frase 'inheritance') untuk menggambarkan kelas yang 'didefinisikan untuk mengimplementasikan' sebuah antarmuka. Bagi saya, antarmuka adalah definisi kontrak yang harus dipatuhi oleh kelas jika telah didefinisikan untuk 'mengimplementasikan' antarmuka itu. Itu tidak mewarisi apa pun ... Anda harus menambahkan semuanya sendiri, secara eksplisit.

Antarmuka : harus digunakan jika Anda ingin menyiratkan aturan tentang komponen yang mungkin terkait atau tidak

Pro:

1. Mengizinkan beberapa pewarisan
2. Memberikan abstraksi dengan tidak mengekspos objek apa yang digunakan dalam konteks
3. memberikan konsistensi dengan tanda tangan spesifik kontrak

Cons:

1. Harus menerapkan semua kontrak yang ditentukan
2. Tidak dapat memiliki variabel atau delegasi
3. Setelah didefinisikan tidak dapat diubah tanpa merusak semua kelas

Kelas Abstrak : harus digunakan di mana Anda ingin memiliki beberapa perilaku dasar atau standar atau implementasi untuk komponen yang terkait satu sama lain

Pro:

1. Lebih cepat dari antarmuka
2. Memiliki fleksibilitas dalam implementasi (Anda dapat mengimplementasikannya sepenuhnya atau sebagian)
3. Dapat dengan mudah diubah tanpa merusak kelas yang diturunkan

Cons:

1. Tidak bisa dipakai
2. Tidak mendukung multiple inheritance

Saya pikir mereka tidak menyukai respons Anda karena Anda memberikan perbedaan teknis alih-alih desain. Pertanyaannya seperti pertanyaan troll untuk saya. Bahkan, antarmuka dan kelas abstrak memiliki sifat yang sama sekali berbeda sehingga Anda tidak dapat benar-benar membandingkannya. Saya akan memberi Anda visi saya tentang apa peran antarmuka dan apa peran kelas abstrak.

antarmuka: digunakan untuk memastikan kontrak dan membuat kopling rendah antar kelas untuk memiliki aplikasi yang lebih dapat dikelola, terukur dan dapat diuji.

kelas abstrak: hanya digunakan untuk memfaktisasi beberapa kode antar kelas dengan responsabilitas yang sama. Perhatikan bahwa ini adalah alasan utama mengapa multiple-inheritance adalah hal yang buruk dalam OOP, karena kelas tidak seharusnya menangani banyak tanggung jawab (gunakan komposisi sebagai gantinya).

Jadi interface memiliki peran arsitektural yang nyata sedangkan kelas abstrak hampir hanya detail implementasi (jika Anda menggunakannya dengan benar tentu saja).

After all that, the interviewer came up with the question "What if you had an 
Abstract class with only abstract methods? How would that be different
from an interface?" 

Documents dengan jelas mengatakan bahwa jika kelas abstrak hanya berisi deklarasi metode abstrak, itu harus dinyatakan sebagai antarmuka.

An another interviewer asked me what if you had a Public variable inside
the interface, how would that be different than in Abstract Class?

Variabel di Antarmuka secara statis publik dan final. Pertanyaan dapat dibingkai seperti bagaimana jika semua variabel di kelas abstrak adalah publik? Yah mereka masih bisa menjadi tidak statis dan tidak final tidak seperti variabel dalam antarmuka.

Akhirnya saya akan menambahkan satu poin lagi ke yang disebutkan di atas - kelas abstrak masih kelas dan jatuh di pohon warisan tunggal sedangkan antarmuka dapat hadir dalam banyak pewarisan.

1. Antarmuka:
   • Kami tidak menerapkan (atau mendefinisikan) metode, kami melakukannya di kelas turunan.
   • Kami tidak mendeklarasikan variabel anggota dalam antarmuka.
   • Antarmuka mengungkapkan hubungan HAS-A. Itu berarti mereka adalah topeng benda.
2. Kelas abstrak:
   • Kita dapat mendeklarasikan dan mendefinisikan metode dalam kelas abstrak.
   • Kami menyembunyikan konstruktornya. Itu berarti tidak ada objek yang dibuat darinya secara langsung.
   • Kelas abstrak dapat menampung variabel anggota.
   • Kelas turunan mewariskan ke kelas abstrak yang berarti objek dari kelas turunan tidak bertopeng, itu diturunkan ke kelas abstrak. Hubungan dalam kasus ini adalah IS-A.

Ini pendapat saya.

Disalin dari CLR via C # oleh Jeffrey Richter ...

Saya sering mendengar pertanyaan, "Haruskah saya mendesain tipe dasar atau antarmuka?" Jawabannya tidak selalu jelas.

Berikut adalah beberapa panduan yang mungkin membantu Anda:

■■ IS-A vs. Hubungan CAN-DO Suatu tipe hanya dapat mewarisi satu implementasi. Jika tipe turunan tidak dapat mengklaim hubungan IS-A dengan tipe dasar, jangan gunakan tipe dasar; gunakan antarmuka. Antarmuka menyiratkan hubungan CAN-DO. Jika fungsionalitas CAN-DO tampaknya milik berbagai jenis objek, gunakan antarmuka. Misalnya, suatu tipe dapat mengonversi instans dari dirinya sendiri ke tipe lain (IConvertible), suatu tipe dapat membuat serial contoh itu sendiri (ISerializable), dll. Perhatikan bahwa tipe nilai harus diturunkan dari System.ValueType, dan oleh karena itu, mereka tidak dapat diturunkan dari kelas dasar yang sewenang-wenang. Dalam hal ini, Anda harus menggunakan hubungan CAN-DO dan mendefinisikan antarmuka.

■■ Kemudahan penggunaan Biasanya lebih mudah bagi Anda sebagai pengembang untuk menentukan tipe baru yang berasal dari tipe dasar daripada menerapkan semua metode antarmuka. Tipe dasar dapat menyediakan banyak fungsi, sehingga tipe turunan mungkin hanya membutuhkan modifikasi yang relatif kecil untuk perilakunya. Jika Anda menyediakan antarmuka, tipe baru harus mengimplementasikan semua anggota.

■■ Implementasi yang konsisten Tidak peduli seberapa baik kontrak antarmuka didokumentasikan, sangat tidak mungkin bahwa setiap orang akan menerapkan kontrak 100 persen dengan benar. Bahkan, COM menderita masalah ini, itulah sebabnya beberapa objek COM bekerja dengan benar hanya dengan Microsoft Word atau Windows Internet Explorer. Dengan menyediakan tipe dasar dengan implementasi default yang baik, Anda mulai menggunakan tipe yang berfungsi dan diuji dengan baik; Anda kemudian dapat memodifikasi bagian yang perlu modifikasi.

■■ Versi Jika Anda menambahkan metode ke tipe dasar, tipe turunan mewarisi metode baru, Anda mulai menggunakan tipe yang berfungsi, dan kode sumber pengguna bahkan tidak perlu dikompilasi ulang. Menambahkan anggota baru ke antarmuka memaksa pewaris antarmuka untuk mengubah kode sumbernya dan mengkompilasi ulang.

Antarmuka mendefinisikan kontrak untuk layanan atau serangkaian layanan. Mereka menyediakan polimorfisme secara horizontal di mana dua kelas yang benar-benar tidak terkait dapat mengimplementasikan antarmuka yang sama tetapi digunakan secara bergantian sebagai parameter dari jenis antarmuka yang mereka implementasikan, karena kedua kelas telah berjanji untuk memenuhi serangkaian layanan yang ditentukan oleh antarmuka. Antarmuka tidak memberikan detail implementasi.

Kelas abstrak mendefinisikan struktur dasar untuk sub cabang, dan implementasi parsial opsional. Kelas abstrak menyediakan polimorfisme secara vertikal, tetapi terarah, bahwa setiap kelas yang mewarisi kelas abstrak dapat diperlakukan sebagai turunan dari kelas abstrak tersebut tetapi tidak sebaliknya. Kelas abstrak dapat dan sering mengandung rincian implementasi, tetapi tidak dapat dibuat sendiri - hanya subclass mereka yang dapat "baru".

C # memang memungkinkan untuk warisan antarmuka juga, ingatlah.

Sebagian besar jawaban berfokus pada perbedaan teknis antara Kelas Abstrak dan Antarmuka, tetapi karena secara teknis, antarmuka pada dasarnya adalah sejenis kelas abstrak (satu tanpa data atau implementasi), saya pikir perbedaan konseptual jauh lebih menarik, dan mungkin itulah yang pewawancara mengejar.

Sebuah Antarmuka adalah kesepakatan . Ini menentukan: "ini adalah bagaimana kita akan berbicara satu sama lain". Itu tidak dapat memiliki implementasi apa pun karena itu tidak seharusnya memiliki implementasi apa pun. Itu kontrak. Ini seperti .hfile header di C.

Sebuah Kelas Abstrak adalah implementasi lengkap . Kelas mungkin atau mungkin tidak mengimplementasikan antarmuka, dan kelas abstrak tidak harus mengimplementasikannya sepenuhnya. Kelas abstrak tanpa implementasi apa pun tidak berguna, tetapi sepenuhnya legal.

Pada dasarnya setiap kelas, abstrak atau tidak, adalah tentang apa yang , sedangkan antarmuka adalah tentang bagaimana Anda menggunakannya . Sebagai contoh: Animalmungkin kelas abstrak yang menerapkan beberapa fungsi metabolisme dasar, dan menentukan metode abstrak untuk bernafas dan bergerak tanpa memberikan implementasi, karena ia tidak tahu apakah ia harus bernapas melalui insang atau paru-paru, dan apakah ia terbang, berenang, berjalan atau merangkak. Mount, di sisi lain, mungkin saja sebuah Antarmuka, yang menentukan bahwa Anda dapat menunggangi hewan, tanpa mengetahui jenis hewan apa itu (atau apakah itu binatang sama sekali!).

Fakta bahwa di balik layar, sebuah antarmuka pada dasarnya adalah kelas abstrak dengan hanya metode abstrak, tidak masalah. Secara konseptual, mereka mengisi peran yang sama sekali berbeda.

Karena Anda mungkin telah mendapatkan pengetahuan teoretis dari para ahli, saya tidak menghabiskan banyak kata untuk mengulang semua yang ada di sini, tetapi izinkan saya menjelaskan dengan contoh sederhana di mana kita dapat menggunakan / tidak dapat menggunakan Interfacedan Abstract class.

Pertimbangkan Anda sedang merancang aplikasi untuk mendaftar semua fitur Mobil. Di berbagai titik Anda membutuhkan pewarisan yang sama, karena beberapa properti seperti DigitalFuelMeter, Pendingin Ruangan, Penyesuaian kursi, dll. Adalah hal yang umum untuk semua mobil. Demikian juga, kita memerlukan pewarisan untuk beberapa kelas hanya karena beberapa properti seperti sistem pengereman (ABS, EBD) hanya berlaku untuk beberapa mobil.

Kelas di bawah ini bertindak sebagai kelas dasar untuk semua mobil:

public class Cars
{
    public string DigitalFuelMeter()
    {
        return "I have DigitalFuelMeter";
    }

    public string AirCondition()
    {
        return "I have AC";
    }

    public string SeatAdjust()
    {
        return "I can Adjust seat";
    }
}

Anggaplah kita memiliki kelas yang terpisah untuk setiap Mobil.

public class Alto : Cars
{
    // Have all the features of Car class    
}

public class Verna : Cars
{
    // Have all the features of Car class + Car need to inherit ABS as the Braking technology feature which is not in Cars        
}

public class Cruze : Cars
{
    // Have all the features of Car class + Car need to inherit EBD as the Braking technology feature which is not in Cars        
}

Pertimbangkan kita membutuhkan metode untuk mewarisi teknologi Pengereman untuk mobil Verna dan Cruze (tidak berlaku untuk Alto). Meski sama-sama menggunakan teknologi pengereman, "teknologinya" berbeda. Jadi kami membuat kelas abstrak di mana metode ini akan dinyatakan sebagai Abstrak dan harus diimplementasikan di kelas anak-anaknya.

public abstract class Brake
{
    public abstract string GetBrakeTechnology();
}

Sekarang kami mencoba mewarisi dari kelas abstrak ini dan jenis sistem pengereman diterapkan di Verna dan Cruze:

public class Verna : Cars,Brake
{
    public override string GetBrakeTechnology()
    {
        return "I use ABS system for braking";
    }       
}

public class Cruze : Cars,Brake
{
    public override string GetBrakeTechnology()
    {
       return "I use EBD system for braking";
    }         
}

Lihat masalah di dua kelas di atas? Mereka mewarisi dari beberapa kelas yang C # .Net tidak mengizinkan meskipun metode ini diterapkan pada anak-anak. Di sinilah kebutuhan Interface.

interface IBrakeTechnology
{
    string GetBrakeTechnology();
}

Dan implementasinya diberikan di bawah ini:

public class Verna : Cars, IBrakeTechnology
{
    public string GetBrakeTechnology()
    {
        return "I use ABS system for braking";
    }
}

public class Cruze : Cars, IBrakeTechnology
{
   public string GetBrakeTechnology()
   {
       return "I use EBD system for braking";
   }        
}

Sekarang Verna dan Cruze dapat mencapai banyak warisan dengan jenis teknologi pengeremannya sendiri dengan bantuan Antarmuka.

Antarmuka adalah cara yang ringan untuk menegakkan perilaku tertentu. Itu adalah salah satu cara untuk berpikir.

Jawaban ini terlalu panjang.

• Antarmuka adalah untuk mendefinisikan perilaku.

• Kelas abstrak adalah untuk mendefinisikan sesuatu itu sendiri, termasuk perilakunya. Itu sebabnya kami terkadang membuat kelas abstrak dengan beberapa properti tambahan mewarisi antarmuka.

Ini juga menjelaskan mengapa Java hanya mendukung pewarisan tunggal untuk kelas tetapi tidak membatasi antarmuka. Karena benda konkret tidak bisa menjadi hal yang berbeda, tetapi dapat memiliki perilaku yang berbeda.

1) Sebuah antarmuka dapat dilihat sebagai Kelas Abstrak murni, adalah sama, tetapi meskipun demikian, tidak sama untuk mengimplementasikan antarmuka dan mewarisi dari kelas abstrak. Saat Anda mewarisi dari kelas abstrak murni ini, Anda mendefinisikan hierarki -> warisan, jika Anda mengimplementasikan antarmuka yang bukan, dan Anda dapat mengimplementasikan sebanyak mungkin antarmuka yang Anda inginkan, tetapi Anda hanya dapat mewarisi dari satu kelas.

2) Anda bisa mendefinisikan properti dalam sebuah antarmuka, sehingga kelas yang mengimplementasikan antarmuka itu harus memiliki properti itu.

Sebagai contoh:

  public interface IVariable
  {
      string name {get; set;}
  }

Kelas yang mengimplementasikan antarmuka itu harus memiliki properti seperti itu.

Meskipun pertanyaan ini sudah cukup lama, saya ingin menambahkan satu hal lain yang mendukung antarmuka:

Antarmuka dapat disuntikkan menggunakan alat Injeksi Ketergantungan mana injeksi kelas Abstrak didukung oleh sangat sedikit.

Dari jawaban saya yang lain , sebagian besar berurusan dengan kapan harus menggunakan satu versus yang lain:

Dalam pengalaman saya, antarmuka paling baik digunakan ketika Anda memiliki beberapa kelas yang masing-masing perlu menanggapi metode atau metode yang sama sehingga mereka dapat digunakan secara bergantian oleh kode lain yang akan ditulis terhadap antarmuka umum kelas-kelas tersebut. Penggunaan antarmuka yang terbaik adalah ketika protokol penting tetapi logika yang mendasari mungkin berbeda untuk setiap kelas. Jika Anda akan menggandakan logika, pertimbangkan kelas abstrak atau warisan kelas standar sebagai gantinya.

Tipe Antarmuka vs. Kelas Dasar Abstrak

Diadaptasi dari buku Pro C # 5.0 dan .NET 4.5 Framework .

Jenis antarmuka mungkin tampak sangat mirip dengan kelas dasar abstrak. Ingatlah bahwa ketika suatu kelas ditandai sebagai abstrak, ia dapat mendefinisikan sejumlah anggota abstrak untuk menyediakan antarmuka polimorfik untuk semua jenis turunan. Namun, bahkan ketika sebuah kelas mendefinisikan satu set anggota abstrak, itu juga bebas untuk menentukan sejumlah konstruktor, data lapangan, anggota nonabstrak (dengan implementasi), dan sebagainya. Antarmuka, di sisi lain, hanya berisi definisi anggota abstrak. Antarmuka polimorfik yang dibuat oleh kelas induk abstrak menderita dari satu batasan utama yaitu hanya tipe turunan yang mendukung anggota yang ditentukan oleh induk abstrak. Namun, dalam sistem perangkat lunak yang lebih besar, sangat umum untuk mengembangkan beberapa hierarki kelas yang tidak memiliki induk yang sama di luar System.Object. Mengingat bahwa anggota abstrak dalam kelas dasar abstrak hanya berlaku untuk tipe turunan, kami tidak memiliki cara untuk mengonfigurasi jenis dalam hierarki yang berbeda untuk mendukung antarmuka polimorfik yang sama. Sebagai contoh, anggap Anda telah mendefinisikan kelas abstrak berikut:

public abstract class CloneableType
{
// Only derived types can support this
// "polymorphic interface." Classes in other
// hierarchies have no access to this abstract
// member.
   public abstract object Clone();
}

Dengan definisi ini, hanya anggota yang memperluas CloneableType yang dapat mendukung metode Clone (). Jika Anda membuat kumpulan kelas baru yang tidak memperluas kelas dasar ini, Anda tidak bisa mendapatkan antarmuka polimorfik ini. Juga, Anda mungkin ingat bahwa C # tidak mendukung multiple inheritance untuk kelas. Oleh karena itu, jika Anda ingin membuat MiniVan yang merupakan-Mobil dan merupakan-CloneableType, Anda tidak dapat melakukannya:

// Nope! Multiple inheritance is not possible in C#
// for classes.
public class MiniVan : Car, CloneableType
{
}

Seperti yang Anda tebak, tipe antarmuka datang untuk menyelamatkan. Setelah antarmuka didefinisikan, antarmuka dapat diimplementasikan oleh kelas atau struktur apa pun, dalam hierarki apa pun, dalam ruang nama apa pun atau perakitan apa pun (ditulis dalam bahasa pemrograman .NET apa pun). Seperti yang Anda lihat, antarmuka sangat polimorfik. Pertimbangkan antarmuka .NET standar bernama ICloneable, yang didefinisikan dalam System namespace. Antarmuka ini mendefinisikan metode tunggal bernama Clone ():

public interface ICloneable
{
object Clone();
}

Jawaban untuk pertanyaan kedua: publicvariabel didefinisikan dalam interfaceadalah static finalsecara default sedangkan publicvariabel di abstractkelas adalah variabel instansi.

Tentunya penting untuk memahami perilaku antarmuka dan kelas abstrak dalam OOP (dan bagaimana bahasa menanganinya), tetapi saya pikir juga penting untuk memahami apa arti setiap istilah. Bisakah Anda bayangkan ifperintah tidak bekerja persis seperti arti dari istilah itu? Juga, sebenarnya beberapa bahasa mengurangi, bahkan lebih lagi, perbedaan antara antarmuka dan abstrak ... jika suatu hari kedua istilah tersebut beroperasi hampir secara identik, setidaknya Anda dapat menentukan sendiri di mana (dan mengapa) salah satu dari mereka harus Digunakan untuk.

Jika Anda membaca beberapa kamus dan font lain, Anda mungkin menemukan arti berbeda untuk istilah yang sama tetapi memiliki beberapa definisi umum. Saya pikir dua makna yang saya temukan di situs ini benar-benar bagus dan cocok.

Antarmuka:

Suatu hal atau keadaan yang memungkinkan elemen yang terpisah dan kadang-kadang tidak kompatibel untuk berkoordinasi secara efektif.

Abstrak:

Sesuatu yang memusatkan pada dirinya sendiri kualitas-kualitas esensial dari sesuatu yang lebih luas atau lebih umum, atau dari beberapa hal; esensi.

Contoh:

Anda membeli mobil dan butuh bahan bakar.

Model mobil Anda adalah XYZ, yang bergenre ABC, jadi itu adalah mobil beton, contoh spesifik dari mobil. Mobil bukanlah benda nyata. Bahkan, itu adalah seperangkat standar abstrak (kualitas) untuk membuat objek tertentu. Singkatnya, Mobil adalah kelas abstrak , ini adalah "sesuatu yang memusatkan pada dirinya sendiri kualitas esensial dari sesuatu yang lebih luas atau lebih umum" .

Satu-satunya bahan bakar yang cocok dengan spesifikasi manual mobil harus digunakan untuk mengisi tangki mobil. Pada kenyataannya, tidak ada yang membatasi Anda untuk memasukkan bahan bakar tetapi mesin akan bekerja dengan baik hanya dengan bahan bakar yang ditentukan, jadi lebih baik untuk mengikuti persyaratannya. Persyaratan mengatakan bahwa ia menerima, seperti mobil lain dengan genre yang sama ABC, satu set bahan bakar standar.

Dalam tampilan Berorientasi Objek, bahan bakar untuk genre ABCtidak boleh dinyatakan sebagai kelas karena tidak ada bahan bakar konkret untuk genre mobil tertentu di luar sana. Meskipun mobil Anda dapat menerima Bahan Bakar kelas abstrak atau VehicularFuel, Anda harus ingat bahwa hanya bahan bakar kendaraan Anda saja yang memenuhi spesifikasi, yang menerapkan persyaratan dalam manual mobil Anda. Singkatnya, mereka harus mengimplementasikan antarmuka ABCGenreFuel , yang "... mengaktifkan elemen yang terpisah dan terkadang tidak kompatibel untuk berkoordinasi secara efektif" .

Tambahan

Selain itu, saya pikir Anda harus mengingat arti dari istilah kelas, yaitu (dari situs yang sama yang disebutkan sebelumnya):

Kelas:

Sejumlah orang atau benda dianggap membentuk kelompok dengan alasan atribut, karakteristik, kualitas, atau sifat yang sama; jenis;

Dengan cara ini, sebuah kelas (atau kelas abstrak) seharusnya tidak hanya mewakili atribut umum (seperti antarmuka), tetapi beberapa jenis grup dengan atribut umum. Antarmuka tidak perlu mewakili sejenis. Itu harus mewakili atribut umum. Dengan cara ini, saya pikir kelas dan kelas abstrak dapat digunakan untuk mewakili hal-hal yang seharusnya tidak sering mengubah aspeknya, seperti manusia sebagai mamalia, karena ia mewakili beberapa jenis. Jenis tidak boleh mengubah diri mereka sesering itu.

Dari Coding Perspective

Antarmuka dapat menggantikan Kelas Abstrak jika Kelas Abstrak hanya memiliki metode abstrak. Kalau tidak mengubah kelas Abstrak ke antarmuka berarti bahwa Anda akan kehilangan kode re-usability yang disediakan Warisan.

Dari Perspektif Desain

Simpan sebagai Kelas Abstrak jika itu adalah hubungan "Apakah" dan Anda memerlukan subset atau semua fungsi. Simpan sebagai Antarmuka jika hubungan "Harus Dilakukan".

Putuskan apa yang Anda butuhkan: hanya penegakan kebijakan, atau penggunaan kembali kode DAN kebijakan.

Beberapa perbedaan lain:

Kelas abstrak dapat memiliki metode statis, properti, bidang dll. Dan operator, antarmuka tidak bisa. Operator cor memungkinkan casting ke / dari kelas abstrak tetapi tidak mengizinkan casting ke / dari antarmuka.

Jadi cukup banyak Anda dapat menggunakan kelas abstrak sendiri bahkan jika itu tidak pernah diterapkan (melalui anggota statisnya) dan Anda tidak dapat menggunakan antarmuka sendiri dengan cara apa pun.