Apa perbedaan yang tepat antara enkapsulasi dan abstraksi?

Sebagian besar jawaban di sini fokus pada OOP tetapi enkapsulasi dimulai lebih awal:

• Setiap fungsi adalah enkapsulasi ; dalam pseudocode:

  point x = { 1, 4 }
  point y = { 23, 42 }
  
  numeric d = distance(x, y)
  

  Di sini, distancemerangkum perhitungan jarak (Euclidean) antara dua titik di pesawat: ia menyembunyikan detail implementasi. Ini enkapsulasi, murni dan sederhana.

• Abstraksi adalah proses generalisasi : mengambil implementasi konkret dan membuatnya berlaku untuk jenis data yang berbeda, meskipun agak terkait. Contoh klasik abstraksi adalahqsortfungsiCuntuk mengurutkan data:

  Masalahnya qsortadalah bahwa ia tidak peduli tentang data yang disortirnya - pada kenyataannya, ia tidak tahu data yang disortir. Sebaliknya, tipe inputnya adalah pointer tipless ( void*) yang merupakan cara C untuk mengatakan "Saya tidak peduli dengan tipe data" (ini juga disebut tipe erasure). Poin penting adalah bahwa implementasi qsortselalu tetap sama, terlepas dari tipe data. Satu-satunya hal yang harus diubah adalah fungsi bandingkan, yang berbeda dari tipe data ke tipe data. qsortOleh karena itu mengharapkan pengguna untuk menyediakan fungsi bandingkan kata sebagai argumen fungsi.

Enkapsulasi dan abstraksi berjalan beriringan sehingga Anda bisa menegaskan bahwa mereka benar-benar tidak dapat dipisahkan. Untuk tujuan praktis, ini mungkin benar; yang mengatakan, inilah enkapsulasi yang tidak banyak abstraksi:

class point {
    numeric x
    numeric y
}

Kami merangkum koordinat titik, tetapi kami tidak secara abstrak memisahkan mereka, di luar pengelompokan secara logis.

Dan inilah contoh abstraksi yang bukan enkapsulasi:

T pi<T> = 3.1415926535

Ini adalah variabel generik pi dengan nilai yang diberikan (π), dan deklarasi tidak peduli dengan tipe variabel yang tepat. Memang, saya akan kesulitan menemukan sesuatu seperti ini dalam kode nyata: abstraksi selalu menggunakan enkapsulasi. Namun, di atas tidak benar-benar ada di C ++ (14), melalui template variabel (= template generik untuk variabel); dengan sintaks yang sedikit lebih kompleks, misalnya:

template <typename T> constexpr T pi = T{3.1415926535};

Enkapsulasi menyembunyikan detail implementasi yang mungkin atau mungkin tidak untuk perilaku umum atau khusus.

Abstraksi memberikan generalisasi (katakanlah, lebih dari seperangkat perilaku).

Ini bacaan yang bagus: Abstraksi, Enkapsulasi, dan Menyembunyikan Informasi oleh Edward V. Berard dari Object Agency.

Banyak jawaban dan contoh mereka menyesatkan.

Enkapsulasi adalah pengemasan data dan fungsi yang beroperasi pada data tersebut ke dalam satu komponen dan membatasi akses ke beberapa komponen objek.
Enkapsulasi berarti bahwa representasi internal suatu objek umumnya tersembunyi dari pandangan di luar definisi objek.

Abstraksi adalah mekanisme yang mewakili fitur-fitur penting tanpa menyertakan detail implementasi.

Enkapsulasi: - Menyembunyikan informasi .
Abstraksi: - Implementasi persembunyian .

Contoh:

class foo{
    private:
        int a, b;
    public:
        foo(int x=0, int y=0): a(x), b(y) {}

        int add(){    
            return a+b;   
        } 
}  

Representasi internal dari setiap objek fookelas tersembunyi di luar kelas. -> Enkapsulasi.
Setiap anggota yang dapat diakses (data / fungsi) dari suatu objek foodibatasi dan hanya dapat diakses oleh objek itu saja.

foo foo_obj(3, 4);
int sum = foo_obj.add();

Implementasi metode adddisembunyikan. -> Abstraksi.

enkapsulasi memasukkan beberapa barang ke dalam kotak dan memberi Anda lubang intip; ini menjaga Anda dari mucking dengan roda gigi.

abstraksi flat-out mengabaikan detail yang tidak penting, seperti apakah benda memiliki roda gigi, ratchet, roda gila, atau inti nuklir; mereka hanya "pergi"

contoh enkapsulasi:

• celana dalam
• kotak alat
• dompet
• tas tangan
• kapsul
• karbonit beku
• sebuah kotak, dengan atau tanpa tombol di atasnya
• a burrito (secara teknis, tortilla di sekitar burrito)

contoh abstraksi:

• "kelompok sesuatu" adalah abstraksi (yang kami sebut agregasi)
• "hal-hal yang mengandung hal-hal lain" adalah abstraksi (yang kita sebut komposisi)
• "wadah" adalah jenis lain dari "benda-benda yang mengandung benda-benda lain" abstraksi; perhatikan bahwa semua contoh enkapsulasi adalah jenis wadah, tetapi tidak semua wadah menunjukkan / menyediakan enkapsulasi. Keranjang, misalnya, adalah wadah yang tidak merangkum isinya.

Enkapsulasi berarti menyembunyikan data seperti menggunakan pengambil dan penyetel, dll.

Abstraksi berarti menyembunyikan implementasi menggunakan kelas dan antarmuka abstrak dll.

Abstraksi adalah istilah umum. yaitu Enkapsulasi adalah bagian dari Abstraksi.

• Contoh 2:
  The solusi arsitek adalah orang yang menciptakan tingkat tinggi abstrak desain teknis dari seluruh solusi, dan desain ini kemudian diserahkan kepada para tim pengembangan untuk implementasi .

  Di sini, arsitek solusi bertindak sebagai tim abstrak dan pengembang bertindak sebagai Enkapsulasi.

• Contoh 3: Enkapsulasi (jaringan) data pengguna

Kesopanan

Abstraksi (atau modularitas) - Jenis memungkinkan pemrogram untuk berpikir pada tingkat yang lebih tinggi daripada bit atau byte, tidak mengganggu dengan implementasi tingkat rendah. Sebagai contoh, pemrogram dapat mulai menganggap string sebagai serangkaian nilai karakter alih-alih sebagai array byte semata. Lebih tinggi lagi, tipe memungkinkan pemrogram untuk memikirkan dan mengekspresikan antarmuka antara dua subsistem ukuran apa pun. Hal ini memungkinkan lebih banyak level lokalisasi sehingga definisi yang diperlukan untuk interoperabilitas subsistem tetap konsisten ketika kedua subsistem berkomunikasi. Sumber

Banyak jawaban yang baik diberikan di atas tetapi saya akan menyajikan sudut pandang saya (Jawa) di sini.

Enkapsulasi Data berarti membungkus dan mengendalikan akses data yang dikelompokkan secara logis dalam suatu kelas. Biasanya dikaitkan dengan kata kunci lain - Menyembunyikan Data . Ini dicapai di Jawa menggunakan pengubah akses .

Contoh sederhana akan mendefinisikan variabel pribadi dan memberikan akses ke sana menggunakan metode pengambil dan penyetel atau membuat metode pribadi karena hanya digunakan dengan kelas. Tidak perlu bagi pengguna untuk mengetahui tentang metode dan variabel ini.

Catatan : Seharusnya tidak disalahpahami bahwa enkapsulasi adalah tentang penyembunyian data saja. Ketika kami mengatakan enkapsulasi, penekanannya harus pada pengelompokan atau pengemasan atau bundling data dan perilaku terkait bersama-sama.

Abstraksi Data di sisi lain adalah konsep generalisasi sehingga logika kompleks di bawahnya tidak terkena pengguna. Di Jawa ini dicapai dengan menggunakan antarmuka dan kelas abstrak .

Contoh -

Katakanlah kita memiliki antarmuka Animal dan ia memiliki fungsi makeSound () . Ada dua kelas konkret Dog and Cat yang mengimplementasikan antarmuka ini. Kelas-kelas konkret ini memiliki implementasi fungsi makeSound () yang terpisah. Sekarang katakanlah kita punya hewan (Kami mendapatkan ini dari beberapa modul eksternal). Semua pengguna tahu bahwa objek yang diterimanya adalah Hewan dan itu adalah tanggung jawab pengguna untuk mencetak suara hewan. Salah satu cara brute force adalah untuk memeriksa objek yang diterima untuk mengidentifikasi jenis itu, maka typecast ke jenis hewan dan kemudian memanggil makeSound () di atasnya. Tapi cara yang lebih rapi adalah mengabstraksi sesuatu . Gunakan Hewan sebagai areferensi polimorfik dan panggil makeSound () di atasnya. Pada saat runtime tergantung pada apa jenis objek sebenarnya fungsi yang tepat akan dipanggil.

Lebih detail di sini .

Logika kompleks ada di papan sirkuit yang dirangkum dalam touchpad dan antarmuka yang bagus (tombol) disediakan untuk abstrak keluar kepada pengguna.

NB: Tautan di atas adalah ke blog pribadi saya.

• Abstraksi memungkinkan Anda fokus pada apa yang dilakukan objek alih-alih bagaimana melakukannya
• Enkapsulasi berarti menyembunyikan detail internal atau mekanisme tentang bagaimana suatu objek melakukan sesuatu.

Seperti ketika Anda mengendarai mobil, Anda tahu apa yang dilakukan pedal gas tetapi Anda mungkin tidak tahu proses di belakangnya karena dirangkum.

Biarkan saya memberi contoh dalam C #. Misalkan Anda memiliki bilangan bulat:

int Number = 5;
string aStrNumber = Number.ToString();

Anda bisa menggunakan metode seperti Number.ToString () yang mengembalikan Anda representasi karakter dari angka 5, dan menyimpannya dalam objek string. Metode ini memberi tahu Anda apa yang dilakukannya alih-alih bagaimana melakukannya.

Ini adalah konsep yang agak kabur yang tidak unik untuk Ilmu Komputer dan pemrograman. Saya ingin memberikan beberapa pemikiran tambahan yang dapat membantu orang lain memahami konsep-konsep penting ini.

Jawaban singkat

Enkapsulasi - Menyembunyikan dan / atau membatasi akses ke bagian tertentu dari suatu sistem, sambil mengekspos antarmuka yang diperlukan.

Abstraksi - Mempertimbangkan sesuatu dengan karakteristik tertentu dihilangkan, terlepas dari realitas konkret, objek tertentu, atau kejadian aktual, sehingga mengurangi kompleksitas.

Kesamaan utama adalah bahwa teknik-teknik ini bertujuan untuk meningkatkan pemahaman dan kegunaan.

Utama perbedaan adalah bahwa abstraksi merupakan sarana yang mewakili hal-hal yang lebih sederhana (sering membuat representasi yang lebih luas yang berlaku), sedangkan enkapsulasi adalah metode mengubah cara hal-hal lain berinteraksi dengan sesuatu.

Jawaban panjang

Enkapsulasi

Berikut adalah contoh enkapsulasi yang diharapkan membuat segalanya lebih jelas:

Di sini kita memiliki Arduino Uno, dan Arduino Uno di dalam selungkup. Enklosur adalah representasi yang hebat tentang enkapsulasi.

Enkapsulasi bertujuan untuk melindungi komponen-komponen tertentu dari pengaruh dan pengetahuan luar serta mengekspos komponen-komponen yang harus dihubungkan dengan hal-hal lain. Dalam istilah pemrograman, ini melibatkan informasi persembunyian meskipun pengubah akses , yang berubah sejauh mana variabel dan / atau sifat tertentu dapat dibaca dan ditulis.

Tetapi di luar itu, enkapsulasi juga bertujuan untuk menyediakan antarmuka eksternal yang jauh lebih efektif. Dengan contoh Arduino kami, ini dapat mencakup tombol dan layar yang bagus yang membuat interaksi pengguna dengan perangkat lebih sederhana. Mereka memberi pengguna cara-cara sederhana untuk memengaruhi perilaku perangkat dan mendapatkan informasi bermanfaat tentang operasinya yang jika tidak demikian akan jauh lebih sulit.

Dalam pemrograman, ini melibatkan pengelompokan berbagai komponen menjadi konstruk dipisahkan, seperti function, class, atau object. Ini juga termasuk menyediakan sarana untuk berinteraksi dengan konstruksi tersebut, serta metode untuk mendapatkan informasi yang berguna tentang mereka.

Enkapsulasi membantu programmer dalam banyak cara tambahan, yang paling penting adalah peningkatan rawatan dan pengujian kode.

Abstraksi

Meskipun banyak jawaban lain di sini mendefinisikan abstraksi sebagai generalisasi, saya pribadi berpikir bahwa definisi itu salah arah. Saya akan mengatakan bahwa generalisasi sebenarnya adalah jenis abstraksi yang spesifik , bukan sebaliknya. Dengan kata lain, semua generalisasi adalah abstraksi, tetapi semua abstraksi tidak harus generalisasi.

Inilah yang saya suka pikirkan tentang abstraksi:

Apakah Anda akan mengatakan gambar ada pohon? Kemungkinannya adalah Anda akan melakukannya. Tetapi apakah ini benar - benar sebuah pohon? Ya tentu saja tidak! Itu sekelompok piksel yang dibuat agar terlihat seperti sesuatu yang kita sebut pohon. Kita dapat mengatakan bahwa itu merupakan abstraksi dari pohon asli. Perhatikan bahwa beberapa detail visual pohon dihilangkan. Juga, itu tidak tumbuh, mengkonsumsi air, atau menghasilkan oksigen. Bagaimana mungkin? itu hanya banyak warna pada layar, yang diwakili oleh byte di memori komputer Anda.

Dan inilah esensi dari abstraksi. Ini adalah cara menyederhanakan hal-hal sehingga lebih mudah dipahami. Setiap gagasan yang melintas dalam benak Anda adalah abstraksi realitas. Citra mental Anda tentang sebuah pohon tidak lebih dari pohon yang sebenarnya dari jpeg ini.

Dalam pemrograman, kita dapat menggunakan ini untuk keuntungan kita dengan menciptakan Treekelas dengan metode untuk simulasi pertumbuhan, konsumsi air, dan produksi oksigen. Ciptaan kami akan menjadi sesuatu yang mewakili pengalaman kami tentang pohon yang sebenarnya, dan hanya mencakup elemen-elemen yang benar-benar kami pedulikan untuk simulasi khusus kami. Kami menggunakan abstraksi sebagai cara untuk mewakili pengalaman kami tentang sesuatu dengan byte dan matematika.

Kelas Abstrak

Abstraksi dalam pemrograman juga memungkinkan kita untuk mempertimbangkan kesamaan antara beberapa tipe objek "konkret" (tipe yang benar-benar ada) dan mendefinisikan kesamaan tersebut dalam entitas yang unik. Sebagai contoh, Treekelas kami mungkin mewarisi dari abstract class Plant, yang memiliki beberapa properti dan metode yang berlaku untuk semua kelas seperti tanaman kami, tetapi menghapus yang khusus untuk setiap jenis tanaman. Ini secara signifikan dapat mengurangi duplikasi kode, dan meningkatkan pemeliharaan.

Perbedaan praktis dari abstract classdan polos classadalah bahwa secara konseptual tidak ada contoh "nyata" dari abstract class. Tidak masuk akal untuk membangun Plantobjek karena itu tidak cukup spesifik. Setiap "nyata" Plantjuga jenis yang lebih spesifik Plant.

Juga, jika kita ingin program kita menjadi lebih realistis, kita mungkin ingin mempertimbangkan fakta bahwa Treekelas kita mungkin terlalu abstrak itu sendiri. Pada kenyataannya, setiap Treeadalah jenis yang lebih spesifik Tree, sehingga kami bisa membuat kelas untuk jenis-jenis seperti Birch, Maple, dll yang mewarisi dari kami, mungkin sekarang abstract, Treekelas.

JVM

Contoh abstraksi lain yang bagus adalah Java Virtual Machine (JVM) , yang menyediakan komputer virtual atau abstrak untuk menjalankan kode Java. Ini pada dasarnya menghilangkan semua komponen platform spesifik dari suatu sistem, dan menyediakan antarmuka abstrak "komputer" tanpa memperhatikan sistem apa pun pada khususnya.

Perbedaan

Enkapsulasi berbeda dari abstraksi karena tidak ada hubungannya dengan seberapa 'nyata' atau 'akuratnya sesuatu itu. Itu tidak menghapus komponen sesuatu untuk membuatnya lebih sederhana atau lebih banyak diterapkan. Sebaliknya ia dapat menyembunyikan komponen tertentu untuk mencapai tujuan yang sama.

Enkapsulasi : Menyembunyikan detail implementasi yang tidak diinginkan / tidak diharapkan / kesopanan dari pengguna objek yang sebenarnya. misalnya

List<string> list = new List<string>();
list.Sort(); /* Here, which sorting algorithm is used and hows its 
implemented is not useful to the user who wants to perform sort, that's 
why its hidden from the user of list. */

Abstraksi : Adalah cara menyediakan generalisasi dan karenanya merupakan cara umum untuk bekerja dengan objek yang sangat beragam. misalnya

class Aeroplane : IFlyable, IFuelable, IMachine
{ // Aeroplane's Design says:
  // Aeroplane is a flying object
  // Aeroplane can be fueled
  // Aeroplane is a Machine
}
// But the code related to Pilot, or Driver of Aeroplane is not bothered 
// about Machine or Fuel. Hence,
// pilot code:
IFlyable flyingObj = new Aeroplane();
flyingObj.Fly();
// fighter Pilot related code
IFlyable flyingObj2 = new FighterAeroplane();
flyingObj2.Fly();
// UFO related code 
IFlyable ufoObj = new UFO();
ufoObj.Fly();
// **All the 3 Above codes are genaralized using IFlyable,
// Interface Abstraction**
// Fly related code knows how to fly, irrespective of the type of 
// flying object they are.

// Similarly, Fuel related code:
// Fueling an Aeroplane
IFuelable fuelableObj = new Aeroplane();
fuelableObj.FillFuel();
// Fueling a Car
IFuelable fuelableObj2 = new Car(); // class Car : IFuelable { }
fuelableObj2.FillFuel();

// ** Fueling code does not need know what kind of vehicle it is, so far 
// as it can Fill Fuel**

Perbedaan Antara Abstraksi dan Enkapsulasi.

Abstraksi: Gagasan untuk menyajikan sesuatu dengan cara yang disederhanakan / berbeda, yang lebih mudah dimengerti dan digunakan atau lebih sesuai dengan situasi.

Pertimbangkan kelas yang mengirim email ... menggunakan abstraksi untuk menunjukkan dirinya kepada Anda sebagai semacam pembawa pesan, sehingga Anda dapat menghubungi emailSender.send (mail, penerima). Apa yang sebenarnya dilakukannya - memilih POP3 / SMTP, server panggilan, terjemahan MIME, dll., Disarikan. Anda hanya melihat bocah pembawa pesan Anda.

Enkapsulasi: Gagasan mengamankan dan menyembunyikan data dan metode yang pribadi untuk suatu objek. Ini lebih berkaitan dengan membuat sesuatu yang independen dan sangat mudah.

Ambil saya, misalnya. Saya merangkum detak jantung saya dari seluruh dunia. Karena saya tidak ingin orang lain mengubah variabel itu, dan saya tidak perlu orang lain untuk mengaturnya agar saya berfungsi. Ini sangat penting bagi saya, tetapi Anda tidak perlu tahu apa itu, dan Anda mungkin tidak peduli.

Lihatlah ke sekeliling Anda akan menemukan bahwa hampir semua yang Anda sentuh adalah contoh abstraksi dan enkapsulasi. Ponsel Anda, misalnya, menyajikan kepada Anda abstraksi untuk dapat mengambil apa yang Anda katakan dan katakan kepada orang lain - menutupi GSM, arsitektur prosesor, frekuensi radio, dan jutaan hal lain yang tidak Anda pahami atau pedulikan. Itu juga merangkum data tertentu dari Anda, seperti nomor seri, nomor ID, frekuensi, dll.

Itu semua membuat dunia menjadi tempat tinggal yang lebih baik: D

Abstraksi: Hanya informasi yang diperlukan yang ditampilkan. Mari kita fokus pada contoh beralih di komputer. Pengguna tidak harus tahu apa yang terjadi ketika sistem masih memuat (informasi itu disembunyikan dari pengguna).

Mari kita ambil contoh lain, yaitu ATM. Pelanggan tidak perlu tahu bagaimana mesin membaca PIN dan memproses transaksi, yang perlu ia lakukan hanyalah memasukkan PIN, mengambil uang tunai dan pergi.

Enkapsulasi: Berurusan dengan menyembunyikan data sensitif dari suatu clas karenanya memprivatisasi bagian darinya. Ini adalah cara menjaga beberapa informasi pribadi untuk kliennya dengan tidak mengizinkan akses dari luar.

Contoh lain:

Misalkan saya membuat kelas Rectangle abadi seperti ini:

class Rectangle {
 public:
  Rectangle(int width, int height) : width_(width), height_(height) {}
  int width() const { return width_; }
  int height() const { return height_; }

 private:
  int width_;
  int height_;
}

Sekarang sudah jelas bahwa saya telah merangkum lebar dan tinggi (akses entah bagaimana dibatasi), tapi saya belum mengabstraksikan apa pun (oke, mungkin saya telah mengabaikan di mana persegi panjang terletak di ruang koordinat, tapi ini adalah cacat dari contoh).

Abstraksi yang baik biasanya menyiratkan enkapsulasi yang baik.

Contoh abstraksi yang baik adalah kelas koneksi basis data generik. Antarmuka publiknya adalah database-agnostik, dan sangat sederhana, namun memungkinkan saya untuk melakukan apa yang saya inginkan dengan koneksi. Dan kamu lihat? Ada juga enkapsulasi di sana, karena kelas harus memiliki semua pegangan dan panggilan tingkat rendah di dalam.

Abstractiondan Encapsulationdengan menggunakan satu contoh umum

-------------------------------------------------- -------------------------------------------------- --------------------------------

Kita semua menggunakan kalkulator untuk perhitungan masalah kompleks!

Suatu mekanisme yang mencegah data dari objek tertentu yang aman dari penyalahgunaan yang disengaja atau tidak disengaja oleh fungsi eksternal disebut " enkapsulasi data"

Tindakan mewakili fitur-fitur penting tanpa menyertakan detail atau penjelasan latar belakang dikenal sebagai abstraksi

Abstraksi: Abstraksi berarti menunjukkanWhat bagian dari fungsionalitas.

Enkapsulasi: Enkapsulasi berarti menyembunyikanHow bagian dari fungsionalitas.

Mari kita ambil contoh yang sangat sederhana

/// <summary>
/// We have an Employee class having two properties EmployeeName and EmployeeCode
/// </summary>
public class Employee
{
    public string EmplpyeeName { get; set; }
    public string EmployeeCode { get; set; }

    // Add new employee to DB is the main functionality, so are making it public so that we can expose it to external environment
    // This is ABSTRACTION
    public void AddEmployee(Employee obj)
    {
        // "Creation of DB connection" and "To check if employee exists" are internal details which we have hide from external environment
        // You can see that these methods are private, external environment just need "What" part only
        CreateDBConnection();
        CheckIfEmployeeExists();
    }


    // ENCAPLUSATION using private keyword
    private bool CheckIfEmployeeExists()
    {
        // Here we can validate if the employee already exists
        return true;
    }

    // ENCAPLUSATION using private keyword
    private void CreateDBConnection()
    {
        // Create DB connection code
    }
}

Kelas program Aplikasi Konsol

class Program
{
    static void Main(string[] args)
    {
        Employee obj = new Employee();
        obj.EmplpyeeName = "001";
        obj.EmployeeCode = "Raj";

        // We have exposed only what part of the functionality
        obj.AddEmployee(obj);
    }
}

Mari kita ambil contoh tumpukan. Ini bisa diimplementasikan menggunakan array atau daftar tertaut. Tetapi operasi yang didukungnya adalah push dan pop.

Sekarang abstraksi hanya menampilkan antarmuka push dan pop. Representasi yang mendasarinya disembunyikan (apakah array atau daftar yang ditautkan?) Dan antarmuka yang jelas disediakan. Sekarang bagaimana Anda memastikan bahwa tidak ada akses tidak disengaja yang dibuat untuk data yang diabstraksi? Di situlah enkapsulasi masuk. Misalnya, kelas di C ++ menggunakan penentu akses yang memastikan bahwa akses dan modifikasi yang tidak sengaja dapat dicegah. Dan juga, dengan membuat antarmuka yang disebutkan di atas sebagai publik, itu memastikan bahwa satu-satunya cara untuk memanipulasi tumpukan adalah melalui antarmuka yang didefinisikan dengan baik. Dalam prosesnya, telah digabungkan data dan kode yang dapat memanipulasinya (jangan melibatkan fungsi teman di sini). Artinya, kode dan data terikat bersama atau diikat atau dienkapsulasi.

Enkapsulasi adalah membungkus kompleksitas dalam satu kapsul yaitu kelas & karenanya Enkapsulasi ... Sementara abstraksi adalah karakteristik dari suatu objek yang membedakan dari objek lain ...

Abstraksi dapat dicapai dengan membuat abstrak kelas memiliki satu atau lebih metode abstrak. Yang tidak lain adalah karakteristik yang harus diimplementasikan oleh kelas yang memperluasnya. mis. ketika Anda menciptakan / mendesain mobil Anda mendefinisikan karakteristik seperti mobil harus memiliki 4 pintu, istirahat, setir dll ... jadi siapa pun yang menggunakan desain ini harus memasukkan karakteristik ini. Implementasi bukanlah kepala masing-masing abstraksi. Itu hanya akan mendefinisikan karakteristik yang harus dimasukkan.

Enkapsulasi dicapai menjaga data dan perilaku dalam satu kapsul yang berkelas & dengan memanfaatkan pengubah akses seperti publik, pribadi, dilindungi bersama dengan warisan, agregasi atau komposisi. Jadi Anda hanya menunjukkan hal-hal yang diperlukan saja, itu juga, hanya sejauh yang ingin Anda tunjukkan. yaitu ka funda publik, dilindungi, ramah & pribadi …… misalnya GM memutuskan untuk menggunakan desain mobil abstrak di atas. Tetapi mereka memiliki berbagai produk yang memiliki karakteristik yang sama & melakukan fungsi yang hampir sama. Jadi mereka menulis kelas yang memperluas kelas abstrak di atas. Dikatakan bagaimana gear box harus bekerja, bagaimana break seharusnya bekerja, bagaimana kemudi harus bekerja. Maka semua produk hanya menggunakan fungsi umum ini. Mereka tidak perlu tahu bagaimana gear box bekerja atau merusak, atau mengemudikan wheal.

Keduanya kuat; tetapi menggunakan abstraksi membutuhkan lebih banyak keterampilan daripada enkapsulasi dan aplikasi / produk yang lebih besar tidak dapat bertahan tanpa abstraksi.

Abstraksi --- Menyembunyikan Implementasi - pada Desain --- Menggunakan Antarmuka / abstrak calsses

Enkapsulasi - Menyembunyikan Data --Pada Pengembangan --- Menggunakan pengubah akses (publik / pribadi)

Dari sini

Perbedaan antara Enkapsulasi dan Abstraksi dalam OOPS

Abstraksi dan Enkapsulasi adalah dua konsep Pemrograman Berorientasi Objek (OOPS) yang penting. Enkapsulasi dan Abstraksi keduanya adalah istilah yang saling terkait.

Perbedaan Kehidupan Nyata Antara Enkapsulasi dan Abstraksi

Enkapsulasi artinya bersembunyi. Enkapsulasi juga disebut penyembunyian data. Anda dapat berpikir Enkapsulasi seperti kapsul (tablet obat) yang menyembunyikan obat di dalamnya. Enkapsulasi adalah pembungkus, hanya menyembunyikan properti dan metode. Enkapsulasi digunakan untuk menyembunyikan kode dan data dalam satu unit untuk melindungi data dari dunia luar. Kelas adalah contoh terbaik enkapsulasi.

Abstraksi mengacu hanya menunjukkan rincian yang diperlukan untuk pengguna yang dituju. Seperti namanya, abstraksi adalah "bentuk abstrak dari segala sesuatu". Kami menggunakan abstraksi dalam bahasa pemrograman untuk membuat kelas abstrak. Kelas abstrak merupakan tampilan abstrak dari metode dan properti kelas.

Perbedaan Implementasi Antara Enkapsulasi dan Abstraksi

1. Abstraksi diimplementasikan menggunakan antarmuka dan kelas abstrak sementara Enkapsulasi diimplementasikan menggunakan pengubah akses pribadi dan dilindungi.

2. OOPS menggunakan enkapsulasi untuk menegakkan integritas suatu tipe (yaitu untuk memastikan data digunakan dengan cara yang tepat) dengan mencegah programmer mengakses data dengan cara yang tidak dimaksudkan. Melalui enkapsulasi, hanya sekelompok fungsi yang telah ditentukan yang dapat mengakses data. Istilah kolektif untuk tipe data dan operasi (metode) yang digabungkan bersama dengan pembatasan akses (publik / pribadi, dll.) Adalah kelas.

Saya akan mencoba untuk menunjukkan Enkapsulasi dengan cara yang sederhana .. Mari kita lihat ..

• Pembungkus data dan fungsi ke dalam satu unit (disebut kelas) dikenal sebagai enkapsulasi. Enkapsulasi yang berisi dan menyembunyikan informasi tentang suatu objek, seperti struktur data internal dan kode.

Enkapsulasi adalah -

• Menyembunyikan Kompleksitas,
• Mengikat Data dan Fungsi bersama,
• Menjadikan Metode Komplikasi sebagai Privat,
• Membuat Instance Variable's Private,
• Menyembunyikan Data dan Fungsi yang Tidak Perlu dari Pengguna Akhir.

Enkapsulasi mengimplementasikan Abstraksi.

Dan Abstraksi adalah -

• Menampilkan Whats Diperlukan,
• Data perlu disarikan dari Pengguna Akhir,

Mari kita lihat contoh-

Gambar di bawah ini menunjukkan GUI "Detail Pelanggan yang akan ADD-ed ke dalam Database".

Dengan melihat Gambar kita dapat mengatakan bahwa kita membutuhkan Kelas Pelanggan.

Langkah - 1: Apa yang dibutuhkan oleh Kelas Pelanggan saya?

yaitu

• 2 variabel untuk menyimpan Kode Pelanggan dan Nama Pelanggan.

• 1 Berfungsi untuk Menambahkan Kode Pelanggan dan Nama Pelanggan ke dalam Database.

  namespace CustomerContent {pelanggan kelas publik {public string CustomerCode = ""; string publik CustomerName = ""; public void ADD () {// kode DB saya akan ada di sini}

Sekarang hanya metode ADD tidak akan bekerja di sini sendirian.

Langkah -2: Bagaimana validasi akan berfungsi, Fungsi ADD bertindak?

Kami akan membutuhkan kode Koneksi Database dan Kode Validasi (Metode Ekstra).

public bool Validate()
{
    //Granular Customer Code and Name
    return true;
}

public bool CreateDBObject()
{
    //DB Connection Code
    return true;
}


class Program
{
static void main(String[] args)
{
CustomerComponent.Customer obj = new CustomerComponent.Customer;

obj.CustomerCode = "s001";
obj.CustomerName = "Mac";

obj.Validate();
obj.CreateDBObject();

obj.ADD();
}
}

Sekarang tidak perlu menampilkan Metode Ekstra (Validasi (); CreateDBObject () [Metode rumit dan Ekstra]) kepada Pengguna Akhir. Pengguna hanya perlu melihat dan mengetahui tentang Kode Pelanggan, Nama Pelanggan dan tombol ADD yang akan ADD. catatan .. Pengguna Akhir tidak peduli BAGAIMANA itu akan MENAMBAHKAN Data ke Database ?.

Langkah -3: Pribadi metode tambahan dan rumit yang tidak melibatkan Interaksi Pengguna Akhir.

Jadi menjadikan metode rumit dan Ekstra itu sebagai Pribadi alih-alih Publik (mis. Menyembunyikan metode itu) dan menghapus objek.Validate (); obj.CreateDBObject (); dari utama di Program kelas kami mencapai Enkapsulasi.

Dengan kata lain Penyederhanaan Antarmuka untuk Pengguna Akhir adalah Enkapsulasi.

Jadi sekarang kodenya seperti di bawah ini -

namespace CustomerContent
{
public class Customer
{
public string CustomerCode = "";
public string CustomerName = "";
public void ADD()
{
   //my DB code will go here
}

private bool Validate()
{
    //Granular Customer Code and Name
    return true;
}

private bool CreateDBObject()
{
    //DB Connection Code
    return true;
}


class Program
{
static void main(String[] args)
{
CustomerComponent.Customer obj = new CustomerComponent.Customer;

obj.CustomerCode = "s001";

obj.CustomerName = "Mac";

obj.ADD();
}
}

Ringkasan:

Langkah -1: Apa yang dibutuhkan oleh Kelas Pelanggan saya? adalah Abstraksi.

Langkah -3: Langkah -3: Pribadi metode tambahan dan rumit yang tidak melibatkan Interaksi Pengguna Akhir adalah Enkapsulasi.

PS - Kode di atas sulit dan cepat.

Paragraf di bawah ini membantu saya memahami bagaimana mereka berbeda satu sama lain:

Enkapsulasi data adalah mekanisme bundling data, dan fungsi yang menggunakannya dan abstraksi data adalah mekanisme untuk hanya mengekspos antarmuka dan menyembunyikan detail implementasi dari pengguna.

Anda dapat membaca lebih lanjut di sini .

Penyembunyian informasi tidak sepenuhnya diperlukan untuk abstraksi atau enkapsulasi. Informasi mungkin diabaikan, tetapi tidak harus disembunyikan.

Enkapsulasi adalah kemampuan untuk memperlakukan sesuatu sebagai satu hal, meskipun itu dapat terdiri dari banyak bagian atau ide yang kompleks. Sebagai contoh, saya dapat mengatakan bahwa saya duduk di "kursi" daripada merujuk ke berbagai bagian kursi yang masing-masing dengan desain dan fungsi tertentu, semuanya pas bersama-sama untuk tujuan memegang pantat saya dengan nyaman beberapa kaki jauh dari lantai.

Abstraksi diaktifkan dengan enkapsulasi. Karena kita merangkum objek, kita dapat menganggapnya sebagai hal-hal yang berhubungan satu sama lain dalam beberapa cara daripada terjebak dalam detail halus dari struktur objek internal. Abstraksi adalah kemampuan untuk mempertimbangkan gambaran yang lebih besar, dihilangkan dari keprihatinan atas detail kecil. Akar kata adalah abstrak seperti pada ringkasan yang muncul di bagian atas makalah ilmiah, bukan abstrak seperti dalam kelas yang hanya dapat dipakai sebagai subkelas turunan.

Saya bisa dengan jujur ​​mengatakan bahwa ketika saya meletakkan pantat saya di kursi saya, saya tidak pernah memikirkan bagaimana struktur kursi itu akan menangkap dan menahan berat badan saya. Itu kursi yang cukup layak sehingga saya tidak perlu khawatir tentang detail itu. Jadi saya bisa mengalihkan perhatian saya ke komputer saya. Dan lagi, saya tidak memikirkan komponen komponen komputer saya. Saya hanya melihat bagian dari halaman web yang mewakili area teks yang dapat saya ketik, dan saya berkomunikasi dalam kata-kata, bahkan tidak memikirkan bagaimana jari-jari saya selalu menemukan huruf yang tepat dengan cepat pada keyboard, dan bagaimana koneksi akhirnya dibuat antara mengetuk tombol-tombol ini dan memposting ke forum ini. Inilah kekuatan abstraksi yang luar biasa. Karena level yang lebih rendah dari sistem dapat dipercaya untuk bekerja dengan konsistensi dan presisi, kami memiliki perhatian pada cadangan untuk pekerjaan yang lebih besar.

class Aeroplane : IFlyable, IFuelable, IMachine
{ // Aeroplane's Design says:
  // Aeroplane is a flying object
  // Aeroplane can be fueled
  // Aeroplane is a Machine
}
// But the code related to Pilot, or Driver of Aeroplane is not bothered 
// about Machine or Fuel. Hence,
// pilot code:
IFlyable flyingObj = new Aeroplane();
flyingObj.Fly();
// fighter Pilot related code
IFlyable flyingObj2 = new FighterAeroplane();
flyingObj2.Fly();
// UFO related code 
IFlyable ufoObj = new UFO();
ufoObj.Fly();
// **All the 3 Above codes are genaralized using IFlyable,
// Interface Abstraction**
// Fly related code knows how to fly, irrespective of the type of 
// flying object they are.

// Similarly, Fuel related code:
// Fueling an Aeroplane
IFuelable fuelableObj = new Aeroplane();
fuelableObj.FillFuel();
// Fueling a Car
IFuelable fuelableObj2 = new Car(); // class Car : IFuelable { }
fuelableObj2.FillFuel();

// ** Fueling code does not need know what kind of vehicle it is, so far 
// as it can Fill Fuel**

abstraksi menyembunyikan data yang tidak berguna dari pengguna dan enkapsulasi mengikat data menjadi kapsul (kelas). Saya pikir enkapsulasi adalah cara kita mencapai abstraksi.

Proses Abstraksi dan Enkapsulasi keduanya menghasilkan antarmuka.

Antarmuka yang dihasilkan melalui enkapsulasi menyembunyikan detail implementasi.

Antarmuka yang dihasilkan melalui abstraksi menjadi berlaku untuk lebih banyak tipe data, dibandingkan dengan sebelum abstraksi.

Abstractionadalah kontrak untuk implementasi yang akan kita lakukan. Implementasi dapat berubah selama periode waktu tertentu. Berbagai implementasi sendiri mungkin atau mungkin tidak disembunyikan tetapi Masked belakang Abstraksi.

Misalkan kita mendefinisikan semua APIskelas di interfacekemudian meminta pengguna kode kita untuk bergantung pada definisi APIsdari interface. Kami bebas untuk meningkatkan atau memodifikasi implementasi hanya kami harus mengikuti kontrak yang ditetapkan. Pengguna tidak ditambah dengan implementasi kami.

Kami MENGUNGKAPKAN semua aturan yang diperlukan (metode) dalam abstraksi , implementasi aturan dibiarkan untuk entitas implementor, juga implementasi bukan bagian dari abstraksi. Hanya tanda tangan dan pernyataan yang membuat abstraksi.

Encapsulationhanyalah menyembunyikan detail internal dengan mengurangi akses negara dan perilaku. Kelas enkapsulasi mungkin atau mungkin tidak didefinisikan dengan baik Abstraction.

java.util.Listadalah abstraksi untuk java.util.ArrayList. Status internal java.util.ArrayListyang ditandai dengan non publicpengubah akses adalah enkapsulasi.

Mengedit Misalkan kelas Container.nava implements IContainer, IContainerdapat menyatakan metode seperti addElement, removeElements, contains, dll Berikut IContainermerupakan abstraksi untuk kelas pelaksanaannya. Abstraksi mendeklarasikan API kelas atau modul atau sistem ke dunia luar. API ini menjadi contract. Sistem itu mungkin atau mungkin belum dikembangkan. Pengguna sistem sekarang dapat bergantung pada API yang diumumkan dan yakin bahwa sistem yang menerapkan kontrak semacam itu akan selalu mematuhi API yang dinyatakan, mereka akan selalu menyediakan implementasi untuk API tersebut. Setelah kami menulis beberapa entitas konkret kemudian memutuskan untuk menyembunyikan keadaan internal kami adalah enkapsulasi

I Think Encapsulation adalah cara untuk mengimplementasikan abstraksi. Lihatlah tautan berikut.

Abstraksi dan Enkapsulasi

Pendeknya

Penggunaan abstraksi -> Enkapsulasi & Penggunaan enkapsulasi -> menyembunyikan data

ATAU

menyembunyikan data adalah bagian dari Enkapsulasi dan Enkapsulasi adalah bagian dari Abstraksi

Referensi: http://www.tonymarston.co.uk/php-mysql/abstraction.txt