Kapsülleme ve soyutlama arasındaki kesin fark nedir?

Buradaki cevapların çoğu OOP'ye odaklanıyor, ancak kapsülleme çok daha erken başlıyor:

• Her fonksiyon bir kapsüllemedir ; sözde kod:

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

  Burada, distancebir düzlemdeki iki nokta arasındaki (Öklid) mesafenin hesaplanmasını içerir: uygulama ayrıntılarını gizler. Bu kapsülleme, saf ve basit.

• Soyutlama genelleme sürecidir : somut bir uygulama yapmak ve onu biraz ilişkili olsa da farklı veri türlerine uygulanabilir kılmak. Soyutlamanın klasik örneği C'ninqsortverileri sıralama işlevidir:

  Mesele qsortşu ki, sıraladığı verileri umursamıyor - aslında hangi verileri sıraladığını bilmiyor . Bunun yerine, girdi türü, void*yalnızca C'nin “Veri türünü umursamıyorum” demenin tipik bir işaretçisidir ( ). Önemli olan nokta, qsortveri türüne bakılmaksızın her zaman uygulanmasının aynı kalmasıdır. Tek şey olan değişime farklıdır veri tipinden veri türüne karşılaştırma fonksiyonudur. qsortbu nedenle kullanıcının bahsedilen karşılaştırma işlevini bir işlev bağımsız değişkeni olarak sunmasını bekler.

Kapsülleme ve soyutlama o kadar çok el ele gider ki, gerçekten ayrılmaz olduklarına dikkat çekebilirsiniz. Pratik amaçlar için, bu muhtemelen doğrudur; dedi ki, işte çok soyutlama olmayan bir kapsülleme:

class point {
    numeric x
    numeric y
}

Noktanın koordinatını kapsülliyoruz, ancak mantıklı olarak gruplandırmanın ötesinde onları maddi olarak soyutlamıyoruz.

Ve burada kapsülleme olmayan bir soyutlama örneği:

T pi<T> = 3.1415926535

Bu, belirli bir değere (π) sahip genel bir değişkendir pi ve bildirim, değişkenin tam türünü umursamaz. Kuşkusuz, gerçek kodda böyle bir şey bulmak zor olurdu: soyutlama neredeyse her zaman kapsülleme kullanır. Bununla birlikte, yukarıda etmez aslında ile, C ++ (14) 'de bulunan değişken şablon (= değişkenler için genel şablonlar); biraz daha karmaşık bir sözdizimi ile, örneğin:

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

Kapsülleme , genel veya özel davranış (lar) için olabilecek veya olmayabilecek uygulama ayrıntılarını gizliyor.

Soyutlama bir genelleme sağlar (örneğin, bir dizi davranış üzerinde).

İşte iyi bir okuma: Nesne Ajansı'ndan Edward V. Berard tarafından Soyutlama, Kapsülleme ve Bilgi Gizleme .

Birçok cevap ve örnekleri yanıltıcıdır.

Kapsülleme , bu veriler üzerinde çalışan verilerin ve işlevlerin tek bir bileşene paketlenmesi ve nesnenin bazı bileşenlerine erişimi kısıtlamasıdır.
Kapsülleme, bir nesnenin dahili gösteriminin genellikle nesnenin tanımının dışındaki görünümden gizlendiği anlamına gelir.

Soyutlama , uygulama ayrıntılarını içermeden temel özellikleri temsil eden bir mekanizmadır.

Kapsülleme: - Bilgi gizleme .
Soyutlama: - Uygulama gizleme .

Misal:

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

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

fooSınıftaki herhangi bir nesnenin iç temsili sınıf dışında gizlidir. -> Kapsülleme.
Nesnesinin erişilebilir herhangi bir üyesi (veri / işlevi) fookısıtlanmıştır ve yalnızca o nesne tarafından erişilebilir.

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

Yöntemin adduygulanması gizlidir. -> Soyutlama.

kapsülleme bazı şeyleri bir kutuya koyar ve size bir gözetleme deliği verir; bu sizi dişlilerle boğuşturamaz.

soyutlama düzlüğü, şeylerin dişlileri, cırcırları, volanları veya nükleer çekirdekleri olup olmadığı gibi önemli olmayan ayrıntıları göz ardı eder; sadece "giderler"

kapsülleme örnekleri:

• külot
• araç kutusu
• cüzdan
• el çantası
• kapsül
• donmuş karbonit
• üzerinde bir düğme olan veya olmayan bir kutu
• bir börek (teknik olarak, börek çevresindeki tortilla)

soyutlama örnekleri:

• "şey grupları" bir soyutlamadır (buna toplanma diyoruz)
• "başka şeyler içeren şeyler" bir soyutlamadır (buna kompozisyon deriz)
• "konteyner" başka bir tür "başka şeyler içeren şeyler" soyutlamasıdır; tüm kapsülleme örneklerinin kap türleri olduğuna dikkat edin, ancak tüm kaplar kapsülleme sergilemez / sağlamaz. Örneğin bir sepet, içeriğini kapsüllemeyen bir kaptır.

Kapsülleme , alıcı ve ayarlayıcı gibi verileri gizlemek anlamına gelir.

Soyutlama , soyut sınıf ve arayüzler vb. Kullanarak uygulamanın gizlenmesi anlamına gelir.

Soyutlama genel bir terimdir. Kapsülleme, Soyutlamanın alt kümesidir.

• Örnek 2: çözüm mimarı üst düzey oluşturur kişidir soyut tüm çözümün teknik tasarım ve bu tasarımın ardından teslim edilir geliştirme ekibi için uygulanması .
  

  Burada, çözüm mimarı bir soyut olarak hareket eder ve geliştirme ekibi bir kapsülleme görevi görür.

• Örnek 3: Kullanıcı verilerinin kapsüllenmesi (ağ bağlantısı)

Nezaket

Soyutlama (veya modülerlik) - Türler, programcıların düşük düzeyli uygulama ile uğraşmadan bit veya bayttan daha yüksek bir seviyede düşünmelerini sağlar. Örneğin, programcılar bir dizeyi yalnızca bir bayt dizisi yerine bir karakter değerleri kümesi olarak düşünmeye başlayabilir. Daha da yüksek olan türler, programcıların herhangi bir büyüklükteki alt sistem arasında iki arabirim hakkında düşünmelerini ve ara yüzleri ifade etmelerini sağlar. Bu, alt sistemlerin birlikte çalışabilirliği için gereken tanımların, bu iki alt sistem iletişim kurduğunda tutarlı kalması için daha fazla yerelleştirme düzeyi sağlar. Kaynak

Yukarıda bir çok iyi yanıt verilmiştir ancak (Java) bakış açımı burada sunacağım.

Veri Kapsülleme, basitçe bir sınıftaki mantıksal olarak gruplandırılmış verilere erişimin kaydırılması ve kontrol edilmesi anlamına gelir. Genellikle başka bir anahtar kelimeyle ilişkilendirilir - Veri Gizleme . Bu, Java'da erişim değiştiricileri kullanılarak gerçekleştirilir .

Basit bir örnek, özel bir değişkeni tanımlamak ve getter ve setter yöntemlerini kullanarak bu değişkene erişim vermek veya tek bir yöntemi sınıfta kullanmak olduğu için özel yapmak olabilir. Kullanıcının bu yöntemleri ve değişkenleri bilmesine gerek yoktur.

Not : Kapsüllemenin yalnızca verilerin gizlenmesi ile ilgili olduğu yanlış anlaşılmamalıdır. Kapsülleme dediğimizde, ilgili verilerin ve davranışların birlikte gruplandırılması veya paketlenmesi veya paketlenmesi üzerinde durulmalıdır.

Diğer yandan Veri Soyutlama , genelleştirme kavramıdır, böylece karmaşık mantığın altında kullanıcıya maruz kalmaz. Java'da bu, arayüzler ve soyut sınıflar kullanılarak elde edilir .

Misal -

Hayvan bir arayüzümüz olduğunu ve makeSound () fonksiyonuna sahip olduğunu varsayalım . Bu arayüzü uygulayan iki somut köpek ve kedi sınıfı vardır . Bu somut sınıfların makeSound () işlevinin ayrı uygulamaları vardır. Şimdi bir hayvanımız olduğunu varsayalım (Bunu bazı harici modüllerden alıyoruz). Tüm kullanıcıların bildiği, aldığı nesnenin bir hayvansal olduğunu ve hayvan sesini basmanın kullanıcının sorumluluğunda olduğudur. Bir kaba kuvvet yolu ile alınan nesneyi kontrol etmektir tespit sonra, 's türünü kalıplaştığı o Hayvan türüne bunun ardından çağrı üzerine () makeSound. Ancak daha temiz bir yol, şeyden soyutlamaktır . Hayvanı birpolimorfik referans ve üzerinde makeSound () çağrısı yapın. Çalışma zamanında gerçek Nesne türünün ne olduğuna bağlı olarak uygun işlev çağrılır.

Daha fazla ayrıntı burada .

Karmaşık mantık, bir dokunmatik yüzeyde kapsüllenmiş olan devre kartındadır ve kullanıcıya soyutlamak için güzel bir arayüz (düğmeler) sağlanır.

Not: Yukarıdaki bağlantılar kişisel bloguma aittir.

• Soyutlama, nesnenin nasıl yaptığı yerine ne yaptığına odaklanmanızı sağlar
• Kapsülleme, bir nesnenin bir şeyi nasıl yaptığının iç detaylarını veya mekaniğini gizlemek anlamına gelir.

Bir araba kullanırken olduğu gibi, gaz pedalının ne yaptığını biliyorsunuz, ancak arkasındaki işlemi bilmiyor olabilirsiniz çünkü kapsüllenmiş.

C # 'da bir örnek vereyim. Bir tamsayı olduğunu varsayalım:

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

5 sayısının karakter temsilini döndüren ve bunu bir dize nesnesinde saklayan Number.ToString () gibi bir yöntem kullanabilirsiniz. Yöntem, nasıl yaptığını yerine ne yaptığını size söyler.

Bunlar Bilgisayar Bilimi ve programlamaya özgü olmayan biraz bulanık kavramlardır. Başkalarının bu önemli kavramları anlamalarına yardımcı olabilecek bazı ek düşünceler sunmak istiyorum.

Kısa cevap

Kapsülleme - Gerekli arabirimleri ortaya koyarken bir sistemin belirli bölümlerine erişimi gizlemek ve / veya kısıtlamak.

Soyutlama - Somut gerçekliklerden, belirli nesnelerden veya gerçek örneklerden ayrı olarak belirli özellikleri kaldırılmış bir şeyi göz önüne alarak karmaşıklığı azaltır.

Temel benzerlik , bu tekniklerin kavrayışı ve faydayı geliştirmeyi amaçlamasıdır.

Temel fark , soyutlamanın, şeyleri daha basit bir şekilde temsil etmenin bir aracı olmasıdır (genellikle temsili daha yaygın olarak uygulanabilir hale getirmek için), ancak kapsülleme, diğer şeylerin bir şeyle etkileşme şeklini değiştirme yöntemidir.

Uzun cevap

kapsülleme

İşte umarım işleri daha net hale getiren bir kapsülleme örneği:

Burada bir Arduino var Uno ve bir muhafaza içinde bir Arduino Uno var. Bir muhafaza, kapsüllemenin neyle ilgili olduğunun mükemmel bir temsilidir.

Kapsülleme, belirli bileşenleri dış etkilerden ve bilgiden korumayı ve diğer şeylerin arayüzleşmesi gereken bileşenleri ortaya çıkarmayı amaçlamaktadır. Programlama açısından, bu kapsar bilgi saklanarak olsa erişim değiştiricileri bazı değişkenlerin ve / veya özellikleri okuyup yazılabilir ne ölçüde değiştirebilir.

Ancak bunun ötesinde, kapsülleme, bu dış arayüzleri çok daha etkili bir şekilde sağlamayı da amaçlamaktadır. Arduino örneğimizde, kullanıcının cihazla etkileşimini daha basit hale getiren güzel düğmeler ve ekran olabilir. Kullanıcıya cihazın davranışını etkilemek için basit yollar sağlarlar ve çalışması hakkında çok daha zor olan yararlı bilgiler elde ederler.

Programlamada, bu tür bir şekilde, ayrılabilir bir yapının içine çeşitli bileşenler gruplandırılmasını içerir function, classya da object. Ayrıca, bu yapılarla etkileşim araçlarının yanı sıra, bunlar hakkında yararlı bilgi edinme yöntemlerinin sağlanmasını da içerir.

Kapsülleme, programcıların pek çok ek yolla yardımcı olur, en azı kod geliştirme ve test edilebilirliği geliştirir.

Soyutlama

Buradaki diğer birçok cevap soyutlamayı genelleme olarak tanımlasa da, kişisel olarak tanımın yanlış yönlendirildiğini düşünüyorum. Genellemenin aslında başka türlü değil, belirli bir soyutlama türü olduğunu söyleyebilirim . Diğer bir deyişle, tüm genellemeler soyutlamalardır, ancak tüm soyutlamalar mutlaka genelleme değildir .

Ben soyutlama nasıl düşünmek istiyorum:

Resmin bir ağaç olduğunu söyler misiniz? Şansınız var. Ama bu gerçekten bir ağaç mı? Tabii ki hayır! Bir ağaç diyebileceğimiz bir şeye benzemek için yapılmış bir grup piksel. Gerçek bir ağacın soyutlanmasını temsil ettiğini söyleyebiliriz. Ağacın birkaç görsel detayının atlandığına dikkat edin. Ayrıca, büyümez, su tüketmez veya oksijen üretmez. Nasıl olabilir? bilgisayar belleğindeki baytlarla temsil edilen bir ekranda sadece bir grup renk.

Ve işte soyutlamanın özü. Bu şeyleri basitleştirmenin bir yolu, böylece anlaşılması daha kolay. Kafanızdan geçen her fikir gerçekliğin bir soyutlamasıdır. Bir ağacın zihinsel imajınız bu jpeg'den daha gerçek bir ağaç değildir.

Programlamada, Treesimüle edilmiş büyüme, su tüketimi ve oksijen üretimi için yöntemler içeren bir sınıf oluşturarak bunu kendi yararımıza kullanabiliriz . Yaratılışımız, gerçek ağaç deneyimlerimizi temsil eden bir şey olurdu ve sadece özel simülasyonumuz için gerçekten önemsediğimiz unsurları içerir. Soyutlamayı bayt ve matematik ile ilgili bir şey deneyimimizi temsil etmenin bir yolu olarak kullanıyoruz.

Soyut Sınıflar

Programlamadaki soyutlama, birkaç "somut" nesne türü (gerçekte var olan türler) arasındaki ortaklıkları göz önünde bulundurmamıza ve bu ortak özellikleri benzersiz bir varlık içinde tanımlamamıza olanak tanır. Örneğin, Treesınıfımız, abstract class Plantbitki benzeri tüm sınıflarımız için geçerli olan çeşitli özelliklere ve yöntemlere sahip olan, ancak her bitki türüne özgü olanları kaldıran bir andan miras alabilir . Bu, kodun kopyalanmasını önemli ölçüde azaltabilir ve sürdürülebilirliği geliştirebilir.

Bir abstract classve düzün pratik farkı, classkavramsal olarak "gerçek" örneklerinin olmamasıdır abstract class. Bir Plantnesneyi inşa etmek mantıklı olmaz çünkü yeterince spesifik değil. Her "gerçek" Plantaynı zamanda daha spesifik bir türdür Plant.

Ayrıca, programımızın daha gerçekçi olmasını istiyorsak, Treesınıfımızın çok soyut olabileceğini düşünmek isteyebiliriz. Gerçekte, her Treebir daha spesifik bir türüdür Treebiz gibi türlerinde sınıfları yol açacağını, Birch, Maplevb bizim, belki bundan hangi devralır abstract, Treesınıfta.

JVM

Soyutlamanın bir başka iyi örneği, Java kodunun çalışması için sanal veya soyut bir bilgisayar sağlayan Java Sanal Makinesi'dir (JVM) . Esasen bir sistemin platforma özgü tüm bileşenlerini alır ve özellikle herhangi bir sisteme bakmadan soyut bir "bilgisayar" arabirimi sağlar.

Fark

Kapsülleme, bir şeyin 'gerçek' veya 'doğru' olduğu ile hiçbir ilgisi olmadığı için soyutlamadan farklıdır. Daha basit veya daha yaygın olarak uygulanabilir hale getirmek için bir şeyin bileşenlerini kaldırmaz . Daha ziyade , benzer bir amaca ulaşmak için belirli bileşenleri gizleyebilir .

Kapsülleme : Nesnenin gerçek kullanıcılarından istenmeyen / beklenmeyen / uygun uygulama ayrıntılarını gizliyor. Örneğin

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. */

Soyutlama : Genelleştirmeyi sağlamanın ve dolayısıyla çok çeşitli çeşitlilikteki nesnelerle çalışmanın ortak bir yoludur. Örneğin

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**

Soyutlama ve Kapsülleme Arasındaki Fark.

Soyutlama: Bir şeyi basitleştirilmiş / farklı bir şekilde sunma fikri, ya anlaşılması ve kullanılması daha kolay veya durumla daha ilgili.

Bir e-posta gönderen bir sınıfı düşünün ... kendini bir tür messenger çocuğu olarak göstermek için soyutlama kullanır, böylece emailSender.send'i (mail, alıcı) arayabilirsiniz. Aslında ne yapar - POP3 / SMTP'yi seçer, sunucuları çağırır, MIME çevirisi, vb. Soyutlar. Sadece haberci oğlunu görüyorsun.

Kapsülleme: Bir nesneye özel verileri ve yöntemleri koruma ve gizleme fikri. Bağımsız ve kusursuz bir şey yapmakla daha çok ilgilenir.

Mesela beni al. Kalp atış hızımı dünyanın geri kalanından kapsarım. Çünkü kimsenin bu değişkeni değiştirmesini istemiyorum ve çalışabilmek için kimsenin onu ayarlamasına ihtiyacım yok. Bu benim için hayati önem taşıyor, ama bunun ne olduğunu bilmene gerek yok ve muhtemelen umrunda bile değil.

Etrafınıza bakın, dokunduğunuz hemen hemen her şeyin hem soyutlama hem de kapsülleme örneği olduğunu göreceksiniz. Örneğin, telefonunuz size söylediklerinizi alıp bir başkasına söyleyebilmenin soyutluğunu sunar - GSM, işlemci mimarisi, radyo frekansları ve anlamadığınız veya umursamadığınız bir milyon şeyi daha kapsayan. Ayrıca, sizden seri numaraları, kimlik numaraları, frekanslar vb. Gibi belirli verileri de içerir.

Her şey dünyayı yaşanacak daha güzel bir yer yapar: D

Soyutlama: Yalnızca gerekli bilgiler gösterilir. Bilgisayarı açma örneğine odaklanalım. Kullanıcının sistem yüklenirken neler olduğunu bilmesine gerek yoktur (bu bilgiler kullanıcıdan gizlenir).

ATM'den başka bir örnek daha alalım. Müşterinin makinenin PIN'i nasıl okuduğunu ve işlemi nasıl işlediğini bilmesine gerek yoktur, tek yapması gereken PIN'i girmek, parayı almak ve ayrılmaktır.

Kapsülleme: Bir sınıfın hassas verilerini gizleyerek, böylece bir bölümünü özelleştirir. Dışarıdan erişime izin vermeyerek bazı bilgileri müşterilerine özel tutmanın bir yoludur.

Başka bir örnek:

Diyelim ki böyle bir değişmez Dikdörtgen sınıfı yarattım:

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_;
}

Şimdi genişlik ve yüksekliği kapsadığım açıktır (erişim bir şekilde kısıtlanmıştır), ancak hiçbir şeyi soyutlamadım (tamam, belki de dikdörtgenin koordinat alanında bulunduğu yeri göz ardı ettim, ancak bu bir kusur misal).

İyi soyutlama genellikle iyi kapsülleme anlamına gelir.

İyi soyutlamaya bir örnek, genel bir veritabanı bağlantı sınıfıdır. Genel arayüzü veritabanı agnostik ve çok basit, ancak bağlantı ile istediğimi yapmama izin veriyor. Ve gördün mü? Orada da kapsülleme var, çünkü sınıfın tüm düşük seviyeli tutamaçlara ve çağrılara sahip olması gerekiyor.

Abstractionve Encapsulationtek bir genelleştirilmiş örnek kullanarak

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

Hepimiz karmaşık sorunların hesaplanması için hesap makinesi kullanıyoruz!

Harici fonksiyonlar tarafından kasıtlı veya kazayla kötüye kullanılmasını önleyen belirli bir nesnenin verilerini " veri kapsülleme"

Arka plan detaylarını veya açıklamalarını içermeden temel özellikleri temsil etme eylemi soyutlama olarak bilinir

Soyutlama: Soyutlama Whatişlevselliğin bir bölümünü göstermek anlamına gelir .

Kapsülleme: Kapsülleme How, işlevsellik kısmını gizlemek anlamına gelir .

Çok basit bir örnek verelim

/// <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
    }
}

Konsol Uygulaması program sınıfı

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);
    }
}

Bir yığın örneğini ele alalım. Bir dizi veya bağlantılı bir liste kullanılarak uygulanabilir. Ancak desteklediği işlemler itme ve pop.

Şimdi soyutlama sadece push ve pop arayüzlerini açığa çıkarıyor. Temel temsil gizlidir (bir dizi mi yoksa bağlantılı bir liste mi?) Ve iyi tanımlanmış bir arayüz sağlanır. Şimdi, soyutlanmış verilere yanlışlıkla erişim yapılmamasını nasıl sağlıyorsunuz? Kapsülleme burada devreye girer. Örneğin, C ++ sınıfları, yanlışlıkla erişim ve değişikliğin önlenmesini sağlayan erişim belirteçlerini kullanır. Ayrıca, yukarıda belirtilen arayüzleri herkese açık hale getirerek, yığını manipüle etmenin tek yolunun iyi tanımlanmış arayüzden geçmesini sağlar. Bu süreçte, verileri ve manipüle edebilecek kodu birleştirdi (arkadaş işlevlerini burada bulamayalım). Yani, kod ve veriler birbirine bağlanır veya bağlanır veya kapsüllenir.

Kapsülleme, karmaşıklığı sınıf ve dolayısıyla Kapsülleme olan bir kapsüle sarıyor… Soyutlama, diğer nesneden farklı bir nesnenin özellikleri iken ...

Soyutlama, bir veya daha fazla yönteme soyut olan sınıf özeti yapılarak elde edilebilir. Bu, onu genişleten sınıf tarafından uygulanması gereken özellikten başka bir şey değildir. Örneğin, bir araba icat ederken / tasarlarken, arabanın 4 kapısı, molası, direksiyon simidi vb. olması gerekir. Uygulama, soyutlamanın başı değildir. Sadece dahil edilmesi gereken özellikleri tanımlayacaktır.

Kapsülleme, verileri ve davranışı sınıfta olan bir kapsülde tutarak ve kamusal, özel, miras, toplama veya kompozisyonla birlikte korunan erişim değiştiricilerinden yararlanılarak elde edilir. Böylece sadece gerekli şeyleri, yalnızca göstermek istediğiniz ölçüde gösterirsiniz. örneğin, kamu, korumalı, arkadaş canlısı ve özel ka funda …… ör. GM yukarıdaki soyutlanmış araba tasarımını kullanmaya karar verir. Ama aynı özelliklere sahip ve neredeyse aynı işlevselliği yapan çeşitli ürünleri var. Böylece yukarıdaki soyut sınıfı genişleten bir sınıf yazarlar. Vites kutusunun nasıl çalışması, mola nasıl çalışması, direksiyon simidinin nasıl çalışması gerektiği yazıyor. Sonra tüm ürünler bu ortak işlevselliği kullanır. Vites kutusunun nasıl çalıştığını veya mola çalışmalarını veya direksiyon suyunun çalıştığını bilmelerine gerek yoktur.

İkisi de güçlü; ancak soyutlamayı kullanmak, kapsüllemeden daha fazla beceri gerektirir ve daha büyük uygulamalar / ürünler soyutlama ile hayatta kalamaz.

Soyutlama - Uygulamayı Gizleme - Tasarımda --- Arabirim / Soyut kalsses kullanma

Kapsülleme - Verileri Gizleme - Geliştirmede --- Erişim değiştiricileri kullanma (genel / özel)

Gönderen bu

OOPS'de Kapsülleme ve Soyutlama Arasındaki Fark

Soyutlama ve Kapsülleme iki önemli Nesne Tabanlı Programlama (OOPS) kavramlarıdır. Kapsülleme ve Soyutlama birbiriyle ilişkili terimlerdir.

Kapsülleme ve Soyutlama Arasındaki Gerçek Hayat Farkı

Encapsulate gizlemek demektir. Enkapsülasyona veri gizleme de denir. Kapsüllemeyi, içindeki ilacı gizleyen bir kapsül (ilaç tableti) gibi düşünebilirsiniz. Kapsülleme, sadece özellikleri ve yöntemleri gizlemektedir. Kapsülleme, verileri dünyanın dışından korumak için kodu ve verileri tek bir birimde gizlemek için kullanılır. Sınıf en iyi kapsülleme örneğidir.

Soyutlama, hedeflenen kullanıcıya sadece gerekli ayrıntıların gösterilmesini ifade eder. Adından da anlaşılacağı gibi, soyutlama "her şeyin soyut biçimidir". Soyut sınıf yapmak için programlama dillerinde soyutlamayı kullanıyoruz. Soyut sınıf, sınıfın yöntem ve özelliklerinin soyut görünümünü temsil eder.

Kapsülleme ve Soyutlama Arasındaki Uygulama Farkı

1. Kapsülleme özel ve korumalı erişim değiştirici kullanılarak uygulanırken, soyutlama arabirim ve soyut sınıf kullanılarak uygulanır.

2. OOPS, programcıların verilere amaçlanmayan bir şekilde erişmesini engelleyerek bir türün bütünlüğünü (yani verilerin uygun bir şekilde kullanıldığından emin olmak için) kapsüllemeyi kullanır. Kapsülleme yoluyla verilere yalnızca önceden belirlenmiş bir işlev grubu erişebilir. Erişim kısıtlamaları (kamu / özel, vb.) İle birlikte paketlenmiş veri türleri ve işlemler (yöntemler) için toplu terim bir sınıftır.

Enkapsülasyonu basit bir şekilde göstermeye çalışacağım .. Bakalım ..

• Verilerin ve fonksiyonların tek bir birime (sınıf adı verilir) sarılması kapsülleme olarak bilinir. Dahili veri yapıları ve kod gibi bir nesne hakkında bilgi içeren ve gizleyen kapsülleme.

Kapsülleme -

• Gizleme Karmaşıklığı,
• Veri ve İşlevi Bir Araya Bağlama,
• Karmaşık Yöntemin Özel Yapılması,
• Örneği Değişken Özel Yapmak,
• Son Kullanıcıdan Gereksiz Verileri ve İşlevleri Gizleme.

Kapsülleme, Soyutlamayı uygular.

Ve Soyutlama -

• Neyin Gerekli Olduğunu Göstermek,
• Verilerin Son Kullanıcıdan özetlenmesi gerekir,

Bir örnek görelim-

Aşağıdaki Resimde "Veritabanına Eklenecek Müşteri Ayrıntıları" GUI'si gösterilmektedir.

Resme bakarak bir Müşteri Sınıfına ihtiyacımız olduğunu söyleyebiliriz.

Adım - 1: Müşteri Sınıfımın neye ihtiyacı var?

yani

• Müşteri Kodu ve Müşteri Adını saklamak için 2 değişken.

• 1 Müşteri Kodunu ve Müşteri Adını Veritabanına Ekleme İşlevi.

  namespace CustomerContent {genel sınıf Müşteri {genel dize CustomerCode = ""; public string CustomerName = ""; public void ADD () {// DB kodum buraya gelecek}

Şimdi sadece ADD yöntemi burada tek başına çalışmaz.

Adım -2: Doğrulama nasıl çalışır, EKLE Fonksiyonu nasıl çalışır?

Veritabanı Bağlantı koduna ve Doğrulama Koduna (Ek Yöntemler) ihtiyacımız olacak.

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();
}
}

Artık Son Kullanıcıya Ekstra Yöntemlerin (Validate (); CreateDBObject () [Karmaşık ve Ekstra yöntem]) gösterilmesine gerek yoktur.Kullanıcının yalnızca Müşteri Kodu, Müşteri Adı ve EKLE düğmesini ekleyecek Son Kullanıcı Verileri Veritabanına NASIL EKLEYECEK?

Adım -3: Son Kullanıcının Etkileşimini içermeyen ekstra ve karmaşık yöntemleri gizleyin.

Bu nedenle bu Karmaşık ve Ekstra yöntemi Özel yerine Herkese Açık yapmak (yani bu yöntemleri gizlemek) ve obj.Validate () öğesini silmek; obj.CreateDBObject (); sınıfta ana Programdan Kapsülleme elde ediyoruz.

Başka bir deyişle, Son Kullanıcıya Arabirimi Basitleştirmek Kapsülleme'dir.

Şimdi kod aşağıdaki gibi görünüyor -

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();
}
}

Özet:

Adım -1: Müşteri Sınıfımın neye ihtiyacı var? soyutlamadır.

Adım -3: Adım -3: Özel Son Kullanıcı Etkileşimi içermeyen ekstra ve karmaşık yöntemler Kapsülleme'dir.

PS - Yukarıdaki kod zor ve hızlı.

Aşağıdaki paragraf birbirlerinden nasıl farklı olduklarını anlamama yardımcı oldu:

Veri kapsülleme, verileri bir araya getirme mekanizmasıdır ve bunları kullanan işlevler ve veri soyutlama, yalnızca arabirimleri ortaya çıkarma ve uygulama ayrıntılarını kullanıcıdan gizleme mekanizmasıdır.

Daha fazlasını buradan okuyabilirsiniz .

Soyutlama veya kapsülleme için bilgi gizleme kesinlikle gerekli değildir. Bilgiler dikkate alınmayabilir, ancak gizlenmesi gerekmez.

Kapsülleme , birçok karmaşık parça veya fikirden oluşabilse de, bir şeyi tek bir şey olarak ele alma yeteneğidir. Örneğin, her biri belirli bir tasarım ve fonksiyona sahip birçok sandalyeye atıfta bulunmak yerine bir "sandalyede" oturduğumu söyleyebilirim, hepsi de kıçımı birkaç metre rahatça tutmak amacıyla birbirine uyuyor yerden uzağa.

Soyutlama kapsülleme ile etkinleştirilir. Nesneleri kapsüllediğimizden, onları iç nesne yapısının ince ayrıntılarında bataklığa düşmek yerine birbirleriyle ilişkili şeyler olarak düşünebiliriz. Soyutlama, küçük detaylardan endişe duyulan daha büyük resmi düşünme yeteneğidir.Kelimenin kökü, bilimsel bir makalenin üstünde görünen özette olduğu gibi soyuttur, sadece türetilmiş bir alt sınıf olarak örneklenebilen bir sınıfta olduğu gibi soyut değildir.

Dürüstçe söyleyebilirim ki, popomu sandalyeme koyduğumda, o sandalyenin yapısının kiloumu nasıl yakalayıp tutacağını asla düşünmem. Bu ayrıntılar için endişelenmem gerekecek kadar iyi bir sandalye. Böylece dikkatimi bilgisayarıma çevirebilirim. Ve yine, bilgisayarımın bileşen kısımlarını düşünmüyorum. Bir web sayfasının yazabileceğim bir metin alanını temsil eden bir bölümüne bakıyorum ve kelimelerle iletişim kuruyorum, hatta parmaklarımın her zaman doğru harfleri klavyede nasıl bu kadar hızlı bulduğunu ve nasıl sonuçta bu tuşlara dokunmak ve bu foruma mesaj göndermek arasında bağlantı kurulur. Bu soyutlamanın büyük gücüdür. Sistemin düşük seviyelerinin tutarlılık ve hassasiyetle çalışabileceğine güvenilebildiğinden, daha fazla iş için yedeklemeye dikkat ediyoruz.

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**

soyutlama, kullanıcılardan yararlı olmayan verileri saklıyor ve kapsülleme, verileri bir kapsüle (bir sınıfa) bağlıyor. Bence kapsülleme soyutlamaya ulaşmanın bir yolu.

Soyutlama ve Kapsülleme işlemi, her iki arabirimi de oluşturur.

Kapsülleme yoluyla oluşturulan bir arabirim uygulama ayrıntılarını gizler.

Soyutlama yoluyla oluşturulan bir arayüz, soyutlamadan önce daha fazla veri tipine uygulanabilir hale gelir.

Abstractionyapacağımız uygulama için bir sözleşmedir . Uygulama zaman içinde değişebilir. Çeşitli uygulamalar kendileri gizli olabilir veya olmayabilir ya da ancak Maskeli Soyutlama arkasında.

Hepimizin tanımlamak varsayalım APIsbir bir sınıfın interfacetanımlı üzerine depened sonra bizim kod kullanıcıları sormak APIsait interface. Uygulamayı iyileştirmek veya değiştirmekte özgürüz, sadece belirlenen sözleşmeyi takip etmeliyiz. Kullanıcılar uygulamamızla birleştirilmez .

Soyutlamadaki tüm GEREKLİ Kuralları (yöntemleri) BEKLİYORUZ , kuralların uygulanması uygulayıcı kurumlar için bırakılmıştır, ayrıca uygulama soyutlamanın bir parçası değildir. Bu soyutlama yapan sadece imzası ve beyanıdır .

Encapsulationbasitçe edilir HIDING devletler ve davranışların acess azaltarak iç ayrıntıları. Kapsüllenmiş bir sınıf iyi tanımlanmış olabilir veya olmayabilir Abstraction.

java.util.Listiçin bir soyutlamadır java.util.ArrayList. Erişim değiştiricilerle java.util.ArrayListişaretlenmenin dahili durumları non publickapsülleme şeklindedir.

Düzen bir sınıf varsayalım Container.nava implements IContainer, IContaineryöntemler gibi ilan edebilir addElement, removeElements, containsBurada, vb IContaineronun uygulanması sınıf için soyutlama temsil eder. Soyutlama, sınıfın veya bir modülün veya bir sistemin API'lerini dış dünyaya bildirmektir. Bu API'lar contract. Bu sistem henüz geliştirilebilir veya geliştirilmeyebilir. Sistemin kullanıcıları artık beyan edilen API'lara güvenebilir ve böyle bir sözleşmeyi uygulayan herhangi bir sistemin beyan edilen API'lere her zaman bağlı kalacağından emin olurlar, bu API'lar için her zaman tge uygulaması sağlarlar. Somut bir varlık yazdığımızda, iç durumlarımızı gizlemeye karar vermek kapsülleme

Bence Kapsülleme soyutlamanın bir yoludur. Aşağıdaki bağlantıya bir göz atın.

Soyutlama ve Kapsülleme

Kısacası

Soyutlama kullanımı -> Kapsülleme ve Kapsülleme kullanımı -> veri gizleme

VEYA

veri gizleme, Kapsülleme alt kümesidir ve Kapsülleme, Soyutlamanın bir alt kümesidir

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