Sự khác biệt chính xác giữa đóng gói và trừu tượng là gì?

Hầu hết các câu trả lời ở đây tập trung vào OOP nhưng đóng gói bắt đầu sớm hơn nhiều:

• Mỗi chức năng là một đóng gói ; trong mã giả:

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

  Ở đây, distancegói gọn việc tính toán khoảng cách (Euclide) giữa hai điểm trong một mặt phẳng: nó ẩn chi tiết thực hiện. Đây là đóng gói, tinh khiết và đơn giản.

• Trừu tượng hóa là quá trình khái quát hóa : thực hiện cụ thể và áp dụng nó cho các loại dữ liệu khác nhau, mặc dù có liên quan. Ví dụ cổ điển về sự trừu tượng làqsortchức năngcủa Cđể sắp xếp dữ liệu:

  Vấn đề qsortlà nó không quan tâm đến dữ liệu mà nó sắp xếp - thực tế, nó không biết nó sắp xếp dữ liệu gì. Thay vào đó, kiểu đầu vào của nó là một con trỏ không chữ ( void*) chỉ là cách nói của C, tôi không quan tâm đến kiểu dữ liệu (đây còn được gọi là kiểu xóa). Điểm quan trọng là việc thực hiện qsortluôn luôn giữ nguyên, bất kể loại dữ liệu. Điều duy nhất mà có sự thay đổi là chức năng so sánh, mà khác với kiểu dữ liệu để kiểu dữ liệu. qsortdo đó mong muốn người dùng cung cấp chức năng so sánh đã nói như một đối số chức năng.

Đóng gói và trừu tượng đi đôi với nhau đến mức bạn có thể đưa ra quan điểm rằng chúng thực sự không thể tách rời. Đối với mục đích thực tế, điều này có lẽ đúng; điều đó nói rằng, đây là một đóng gói không nhiều trừu tượng:

class point {
    numeric x
    numeric y
}

Chúng tôi gói gọn tọa độ của điểm, nhưng chúng tôi không trừu tượng hóa chúng đi, ngoài việc nhóm chúng một cách hợp lý.

Và đây là một ví dụ về sự trừu tượng không đóng gói:

T pi<T> = 3.1415926535

Đây là một biến chung pi có giá trị cho trước (π) và khai báo không quan tâm đến loại chính xác của biến. Phải thừa nhận rằng, tôi rất khó để tìm thấy một cái gì đó như thế này trong mã thực: sự trừu tượng hầu như luôn sử dụng đóng gói. Tuy nhiên, trên không thực sự tồn tại trong C ++ (14), thông qua mẫu biến (= mẫu chung cho biến); với cú pháp phức tạp hơn một chút, vd:

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

Đóng gói là ẩn các chi tiết thực hiện có thể có hoặc không dành cho (các) hành vi chung hoặc chuyên biệt.

Trừu tượng là cung cấp một khái quát (nói, qua một tập hợp các hành vi).

Đây là một bài đọc tốt: Trừu tượng, Đóng gói và Ẩn thông tin của Edward V. Berard thuộc Cơ quan đối tượng.

Nhiều câu trả lời và ví dụ của họ là sai lệch.

Đóng gói là việc đóng gói dữ liệu và các chức năng hoạt động trên dữ liệu đó thành một thành phần duy nhất và hạn chế quyền truy cập vào một số thành phần của đối tượng.
Đóng gói có nghĩa là biểu diễn bên trong của một đối tượng thường bị ẩn khỏi chế độ xem bên ngoài định nghĩa của đối tượng.

Trừu tượng là một cơ chế đại diện cho các tính năng thiết yếu mà không bao gồm các chi tiết thực hiện.

Đóng gói: - Ẩn thông tin .
Trừu tượng: - Thực hiện ẩn .

Thí dụ:

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

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

Đại diện bên trong của bất kỳ đối tượng của foolớp được ẩn bên ngoài lớp. -> Đóng gói.
Bất kỳ thành viên nào có thể truy cập (dữ liệu / chức năng) của một đối tượng foođều bị hạn chế và chỉ có thể được truy cập bởi đối tượng đó.

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

Thực hiện phương pháp addlà ẩn. -> Trừu tượng.

đóng gói đặt một số thứ trong một hộp và cung cấp cho bạn một lỗ nhìn trộm; điều này giữ cho bạn khỏi mucking với các bánh răng.

sự trừu tượng hóa phẳng bỏ qua các chi tiết không quan trọng, như liệu mọi thứ có bánh răng, bánh răng, bánh đà hay lõi hạt nhân; họ chỉ "đi"

ví dụ về đóng gói:

• quần lót
• hộp công cụ
• ví tiền
• túi xách tay
• viên con nhộng
• carbonite đông lạnh
• một hộp, có hoặc không có nút trên đó
• một burrito (về mặt kỹ thuật, tortilla xung quanh burrito)

ví dụ về sự trừu tượng:

• "Các nhóm sự vật" là một sự trừu tượng (mà chúng ta gọi là tổng hợp)
• "Những thứ có chứa những thứ khác" là một sự trừu tượng (mà chúng ta gọi là thành phần)
• "Container" là một loại "trừu tượng chứa những thứ khác" trừu tượng; lưu ý rằng tất cả các ví dụ đóng gói là các loại container, nhưng không phải tất cả các container đều trưng bày / cung cấp đóng gói. Một giỏ, ví dụ, là một container không gói gọn nội dung của nó.

Đóng gói có nghĩa là ẩn dữ liệu như sử dụng getter và setter, v.v.

Trừu tượng có nghĩa là - ẩn thực hiện bằng cách sử dụng lớp trừu tượng và giao diện, v.v.

Trừu tượng là thuật ngữ tổng quát. tức là Đóng gói là tập hợp con của Trừu tượng.

• Ví dụ 2:
  Các kiến trúc sư giải pháp là người tạo ra sự cấp cao trừu tượng thiết kế kỹ thuật của toàn bộ giải pháp, và sau đó thiết kế này được bàn giao cho các nhóm phát triển cho thực hiện .

  Ở đây, kiến ​​trúc sư giải pháp hoạt động như một nhóm trừu tượng và phát triển hoạt động như một Đóng gói.

• Ví dụ 3: Đóng gói (kết nối mạng) dữ liệu người dùng

Phép lịch sự

Trừu tượng hóa (hoặc mô đun hóa) - Các loại cho phép các lập trình viên suy nghĩ ở mức cao hơn bit hoặc byte, không bận tâm đến việc thực hiện ở mức độ thấp. Ví dụ, các lập trình viên có thể bắt đầu nghĩ về một chuỗi như một tập hợp các giá trị ký tự thay vì chỉ là một mảng byte. Cao hơn, các loại cho phép các lập trình viên suy nghĩ và thể hiện giao diện giữa hai trong số các hệ thống con có kích thước bất kỳ. Điều này cho phép nhiều mức độ nội địa hóa hơn để các định nghĩa cần thiết cho khả năng tương tác của các hệ thống con vẫn nhất quán khi hai hệ thống con đó giao tiếp với nhau. Nguồn

Rất nhiều câu trả lời hay được cung cấp ở trên nhưng tôi sẽ trình bày quan điểm (Java) của mình ở đây.

Đóng gói dữ liệu đơn giản có nghĩa là gói và kiểm soát truy cập dữ liệu được nhóm hợp lý trong một lớp. Nó thường được liên kết với một từ khóa khác - Ẩn dữ liệu . Điều này đạt được trong Java bằng cách sử dụng các sửa đổi truy cập .

Một ví dụ đơn giản sẽ là xác định một biến riêng tư và cấp quyền truy cập cho nó bằng các phương thức getter và setter hoặc đặt một phương thức riêng tư vì nó chỉ sử dụng là làm khô lớp. Không cần người dùng biết về các phương thức và biến này.

Lưu ý : Không nên hiểu nhầm rằng đóng gói chỉ là về việc ẩn dữ liệu. Khi chúng ta nói đóng gói, cần nhấn mạnh vào việc nhóm hoặc đóng gói hoặc kết hợp các dữ liệu và hành vi liên quan với nhau.

Mặt khác, trừu tượng hóa dữ liệu là khái niệm khái quát hóa để logic bên dưới không bị lộ ra cho người dùng. Trong Java, điều này đạt được bằng cách sử dụng các giao diện và các lớp trừu tượng .

Thí dụ -

Hãy nói rằng chúng ta có một giao diện Animal và nó có chức năng makeSound () . Có hai lớp cụ thể Dog và Cat thực hiện giao diện này. Các lớp cụ thể này có các cài đặt riêng của hàm makeSound (). Bây giờ hãy nói rằng chúng ta có một con vật (Chúng ta có được điều này từ một số mô-đun bên ngoài). Tất cả người dùng đều biết rằng đối tượng mà nó nhận được là một số Động vật và người dùng có trách nhiệm in âm thanh động vật. Một cách mạnh mẽ là kiểm tra đối tượng nhận được để xác định loại của nó, sau đó đánh máy nó thành loại Động vật đó và sau đó gọi makeSound () trên đó. Nhưng một cách gọn gàng hơn là trừu tượng hóa mọi thứ . Sử dụng động vật như mộttham chiếu đa hình và gọi makeSound () trên đó. Trong thời gian chạy tùy thuộc vào loại đối tượng thực sự là chức năng phù hợp sẽ được gọi.

Thêm chi tiết tại đây .

Logic phức tạp nằm trong bảng mạch được gói gọn trong bàn di chuột và một giao diện (nút) đẹp mắt được cung cấp để trừu tượng hóa nó ra cho người dùng.

PS: Liên kết trên là vào blog cá nhân của tôi.

• Trừu tượng cho phép bạn tập trung vào những gì đối tượng làm thay vì cách nó thực hiện
• Đóng gói có nghĩa là ẩn các chi tiết bên trong hoặc cơ học về cách một đối tượng làm một cái gì đó.

Giống như khi bạn lái xe, bạn biết bàn đạp ga làm gì nhưng bạn có thể không biết quá trình đằng sau nó vì nó được gói gọn.

Hãy để tôi đưa ra một ví dụ trong C #. Giả sử bạn có một số nguyên:

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

bạn có thể sử dụng một phương thức như Number.ToString () để trả về cho bạn các ký tự đại diện cho số 5 và lưu trữ nó trong một đối tượng chuỗi. Phương pháp cho bạn biết những gì nó làm thay vì làm như thế nào.

Đây là những khái niệm hơi mờ không phải là duy nhất cho Khoa học Máy tính và lập trình. Tôi muốn đưa ra một số suy nghĩ bổ sung có thể giúp người khác hiểu những khái niệm quan trọng này.

Câu trả lời ngắn

Đóng gói - Ẩn và / hoặc hạn chế quyền truy cập vào một số phần nhất định của hệ thống, đồng thời hiển thị các giao diện cần thiết.

Trừu tượng - Xem xét một cái gì đó với các đặc điểm nhất định được loại bỏ, ngoài thực tế cụ thể, các đối tượng cụ thể hoặc các trường hợp thực tế, do đó làm giảm sự phức tạp.

Điểm tương đồng chính là các kỹ thuật này nhằm cải thiện sự hiểu biết và tiện ích.

Sự khác biệt chính là sự trừu tượng là một phương tiện để thể hiện mọi thứ đơn giản hơn (thường là làm cho biểu diễn được áp dụng rộng rãi hơn), trong khi đóng gói là một phương pháp thay đổi cách những thứ khác tương tác với một thứ gì đó.

Câu trả lời dài

Đóng gói

Đây là một ví dụ về đóng gói mà hy vọng làm cho mọi thứ rõ ràng hơn:

Ở đây chúng tôi có Arduino Uno và Arduino Uno trong một bao vây. Một bao vây là một đại diện tuyệt vời của những gì đóng gói là tất cả về.

Đóng gói nhằm bảo vệ các thành phần nhất định khỏi những ảnh hưởng và kiến ​​thức bên ngoài cũng như phơi bày các thành phần mà những thứ khác nên giao tiếp. Trong thuật ngữ lập trình, điều này liên quan đến việc ẩn thông tin mặc dù các công cụ sửa đổi truy cập , thay đổi mức độ mà các biến và / hoặc thuộc tính nhất định có thể được đọc và ghi.

Nhưng ngoài ra, đóng gói cũng nhằm mục đích cung cấp các giao diện bên ngoài hiệu quả hơn nhiều. Với ví dụ về Arduino của chúng tôi, điều này có thể bao gồm các nút và màn hình đẹp giúp cho việc tương tác của người dùng với thiết bị đơn giản hơn nhiều. Họ cung cấp cho người dùng những cách đơn giản để tác động đến hành vi của thiết bị và có được thông tin hữu ích về hoạt động của thiết bị, điều này sẽ khó khăn hơn nhiều.

Trong lập trình, điều này liên quan đến việc nhóm của các thành phần khác nhau vào một cấu trúc phân chia, như một function, classhoặc object. Nó cũng bao gồm việc cung cấp các phương tiện tương tác với các cấu trúc đó, cũng như các phương thức để có được thông tin hữu ích về chúng.

Đóng gói giúp các lập trình viên theo nhiều cách bổ sung, trong đó ít nhất là cải thiện khả năng duy trì và kiểm tra mã.

Trừu tượng

Mặc dù nhiều câu trả lời khác ở đây định nghĩa trừu tượng là khái quát hóa, cá nhân tôi nghĩ rằng định nghĩa đó là sai lầm. Tôi muốn nói rằng khái quát hóa thực sự là một loại trừu tượng cụ thể , không phải là cách khác. Nói cách khác, tất cả các khái quát là trừu tượng hóa, nhưng tất cả các khái niệm trừu tượng không nhất thiết là khái quát.

Đây là cách tôi muốn nghĩ về sự trừu tượng:

Bạn có thể nói hình ảnh có một cái cây? Rất có thể bạn sẽ. Nhưng nó là thực sự là một cái cây? Vâng, tất nhiên là không! Đó là một loạt các pixel được tạo ra trông giống như một cái gì đó mà chúng ta có thể gọi là một cái cây. Chúng ta có thể nói rằng nó đại diện cho một sự trừu tượng của một cây thật. Lưu ý rằng một số chi tiết trực quan của cây bị bỏ qua. Ngoài ra, nó không phát triển, tiêu thụ nước hoặc sản xuất oxy. Làm thế nào nó có thể? nó chỉ là một loạt các màu trên màn hình, được biểu thị bằng byte trong bộ nhớ máy tính của bạn.

Và đây là bản chất của sự trừu tượng. Đó là một cách đơn giản hóa mọi thứ để chúng dễ hiểu hơn. Mỗi ý tưởng đi qua đầu bạn là một sự trừu tượng của thực tế. Hình ảnh tinh thần của bạn về một cái cây không còn là một cây thực tế hơn jpeg này.

Trong lập trình, chúng ta có thể sử dụng điều này cho lợi thế của mình bằng cách tạo ra một Tree lớp với các phương pháp mô phỏng phát triển, tiêu thụ nước và sản xuất oxy. Sáng tạo của chúng tôi sẽ là thứ đại diện cho trải nghiệm của chúng tôi về cây thực tế và chỉ bao gồm những yếu tố mà chúng tôi thực sự quan tâm cho mô phỏng cụ thể của chúng tôi. Chúng tôi sử dụng sự trừu tượng như một cách thể hiện trải nghiệm của chúng tôi về một cái gì đó với byte và toán học.

Lớp học trừu tượng

Sự trừu tượng trong lập trình cũng cho phép chúng ta xem xét các điểm tương đồng giữa một số loại đối tượng "cụ thể" (các loại thực sự tồn tại) và xác định các điểm tương đồng đó trong một thực thể duy nhất. Ví dụ, Treelớp của chúng tôi có thể kế thừa từ một abstract class Plant, có một số thuộc tính và phương thức áp dụng cho tất cả các lớp giống như thực vật của chúng tôi, nhưng loại bỏ những thứ đặc trưng cho từng loại cây. Điều này có thể làm giảm đáng kể sự trùng lặp mã và cải thiện khả năng bảo trì.

Sự khác biệt thực tế của một abstract classvà đơn giản classlà về mặt khái niệm không có trường hợp "thực" nào abstract class. Sẽ không có ý nghĩa khi xây dựng một Plantđối tượng bởi vì điều đó không đủ cụ thể. Mỗi "thực" Plantcũng là một loại cụ thể hơn Plant.

Ngoài ra, nếu chúng ta muốn chương trình của chúng ta thực tế hơn, chúng ta có thể muốn xem xét thực tế rằng Treelớp học của chúng ta có thể quá trừu tượng. Trên thực tế, mỗi Treemột loại hình cụ thể hơn Tree, vì vậy chúng tôi có thể tạo ra các lớp học dành cho những loại như Birch, Maplevv mà kế thừa từ của chúng tôi, có lẽ bây giờ abstract, Treelớp.

JVM

Một ví dụ điển hình khác về sự trừu tượng là Máy ảo Java (JVM) , cung cấp một máy tính ảo hoặc trừu tượng để mã Java chạy. Về cơ bản, nó lấy đi tất cả các thành phần cụ thể của nền tảng của một hệ thống và cung cấp một giao diện trừu tượng của "máy tính" mà không liên quan đến bất kỳ hệ thống nào nói riêng.

Sự khác biệt

Đóng gói khác với sự trừu tượng ở chỗ nó không liên quan gì đến việc một cái gì đó 'thực sự' hay 'chính xác'. Nó không loại bỏ các thành phần của một cái gì đó để làm cho nó đơn giản hơn hoặc áp dụng rộng rãi hơn. Thay vào đó, nó có thể ẩn các thành phần nhất định để đạt được một mục đích tương tự.

Đóng gói : Đang ẩn chi tiết triển khai không mong muốn / không mong đợi / sở hữu từ người dùng thực tế của đối tượng. ví dụ

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

Trừu tượng : Là một cách cung cấp khái quát hóa và do đó là một cách phổ biến để làm việc với các đối tượng có sự đa dạng rộng lớn. ví dụ

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

Sự khác biệt giữa Trừu tượng và Đóng gói.

Trừu tượng: Ý tưởng trình bày một cái gì đó theo cách đơn giản / khác nhau, dễ hiểu và dễ sử dụng hơn hoặc phù hợp hơn với tình huống.

Hãy xem xét một lớp gửi email ... nó sử dụng sự trừu tượng để hiển thị cho bạn như một loại người đưa tin, vì vậy bạn có thể gọi emailSender.send (thư, người nhận). Những gì nó thực sự làm - chọn POP3 / SMTP, gọi máy chủ, dịch MIME, v.v., được trừu tượng hóa. Bạn chỉ nhìn thấy cậu bé nhắn tin của bạn.

Đóng gói: Ý tưởng bảo mật và ẩn dữ liệu và phương thức riêng tư với một đối tượng. Nó liên quan nhiều hơn đến việc làm cho một cái gì đó độc lập và hoàn hảo.

Lấy tôi làm ví dụ. Tôi gói gọn nhịp tim của mình từ phần còn lại của thế giới. Bởi vì tôi không muốn ai khác thay đổi biến đó và tôi không cần ai khác thiết lập nó để tôi hoạt động. Nó cực kỳ quan trọng đối với tôi, nhưng bạn không cần biết nó là gì và có lẽ bạn không quan tâm.

Nhìn xung quanh bạn sẽ thấy rằng hầu hết mọi thứ bạn chạm vào là một ví dụ về cả sự trừu tượng và đóng gói. Chẳng hạn, điện thoại của bạn trình bày cho bạn sự trừu tượng để có thể nói những gì bạn nói và nói với người khác - che đậy GSM, kiến ​​trúc bộ xử lý, tần số radio và hàng triệu thứ khác mà bạn không hiểu hoặc không quan tâm. Nó cũng đóng gói một số dữ liệu từ bạn, như số sê-ri, số ID, tần số, v.v.

Tất cả làm cho thế giới trở thành một nơi tốt đẹp hơn để sống: D

Trừu tượng: Chỉ thông tin cần thiết được hiển thị. Hãy tập trung vào ví dụ về chuyển đổi trên máy tính. Người dùng không cần phải biết những gì đang diễn ra trong khi hệ thống vẫn đang tải (thông tin đó bị ẩn khỏi người dùng).

Hãy lấy một ví dụ khác, đó là ATM. Khách hàng không cần biết máy đọc mã PIN và xử lý giao dịch như thế nào, tất cả những gì anh ta cần làm là nhập mã PIN, lấy tiền mặt và rời đi.

Đóng gói: Thỏa thuận với việc ẩn dữ liệu nhạy cảm của một clas do đó tư nhân hóa một phần của nó. Đó là một cách giữ một số thông tin riêng tư cho khách hàng của mình bằng cách cho phép không có quyền truy cập từ bên ngoài.

Một vi dụ khac:

Giả sử tôi đã tạo một lớp Hình chữ nhật bất biến như thế này:

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

Bây giờ rõ ràng là tôi đã đóng gói chiều rộng và chiều cao (quyền truy cập bị hạn chế theo cách nào đó), nhưng tôi đã không trừu tượng hóa bất cứ điều gì (được rồi, có lẽ tôi đã bỏ qua nơi hình chữ nhật nằm trong không gian tọa độ, nhưng đây là một lỗ hổng của thí dụ).

Trừu tượng tốt thường ngụ ý đóng gói tốt.

Một ví dụ về sự trừu tượng tốt là một lớp kết nối cơ sở dữ liệu chung. Giao diện công cộng của nó là cơ sở dữ liệu bất khả tri, và rất đơn giản, nhưng cho phép tôi làm những gì tôi muốn với kết nối. Và bạn thấy sao? Cũng có đóng gói ở đó, bởi vì lớp phải có tất cả các tay cầm và cuộc gọi cấp thấp bên trong.

Abstractionvà Encapsulationbằng cách sử dụng một ví dụ tổng quát duy nhất

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

Tất cả chúng ta đều sử dụng máy tính để tính toán các vấn đề phức tạp!

Một cơ chế ngăn chặn dữ liệu của một đối tượng cụ thể an toàn khỏi việc lạm dụng có chủ ý hoặc vô tình bởi các chức năng bên ngoài được gọi là " Đóng gói dữ liệu"

Hành động thể hiện các tính năng thiết yếu mà không bao gồm các chi tiết hoặc giải thích nền được gọi là trừu tượng hóa

Trừu tượng: Trừu tượng có nghĩa là hiển thị Whatmột phần chức năng.

Encapsulation: Encapsulation có nghĩa là ẩn Howphần chức năng.

Hãy lấy một ví dụ rất đơn giản

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

Lớp chương trình của Ứng dụng Console

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

Hãy lấy ví dụ về một ngăn xếp. Nó có thể được thực hiện bằng cách sử dụng một mảng hoặc một danh sách liên kết. Nhưng các hoạt động mà nó hỗ trợ là đẩy và bật.

Bây giờ sự trừu tượng chỉ lộ ra các giao diện đẩy và bật. Các đại diện cơ bản bị ẩn (nó là một mảng hoặc một danh sách được liên kết?) Và một giao diện được xác định rõ được cung cấp. Bây giờ làm thế nào để bạn đảm bảo rằng không có truy cập ngẫu nhiên được thực hiện cho dữ liệu trừu tượng? Đó là nơi đóng gói . Ví dụ, các lớp trong C ++ sử dụng các chỉ định truy cập để đảm bảo rằng việc truy cập và sửa đổi ngẫu nhiên bị ngăn chặn. Ngoài ra, bằng cách đặt các giao diện được đề cập ở trên thành công khai, nó đảm bảo rằng cách duy nhất để thao tác ngăn xếp là thông qua giao diện được xác định rõ. Trong quá trình này, nó đã kết hợp dữ liệu và mã có thể thao tác với nó (chúng ta đừng để các hàm bạn bè tham gia ở đây). Đó là, mã và dữ liệu được liên kết với nhau hoặc gắn hoặc đóng gói.

Encapsulation đang gói ghém sự phức tạp trong một viên nang là lớp và do đó Encapsulation, Trong khi trừu tượng hóa là đặc điểm của một đối tượng khác biệt với đối tượng khác ...

Trừu tượng hóa có thể đạt được bằng cách làm cho lớp trừu tượng có một hoặc nhiều phương thức trừu tượng. Không có gì ngoài đặc điểm cần được thực hiện bởi lớp mở rộng nó. ví dụ: khi bạn phát minh / thiết kế một chiếc xe bạn xác định một đặc điểm như xe hơi nên có 4 cửa, phá, vô lăng, vv. Vì vậy, bất cứ ai sử dụng thiết kế này nên bao gồm các đặc điểm này. Thực hiện không phải là đầu mỗi trừu tượng. Nó sẽ chỉ xác định các đặc điểm cần được bao gồm.

Đóng gói được thực hiện để giữ dữ liệu và hành vi trong một viên nang là lớp & bằng cách sử dụng các công cụ sửa đổi truy cập như công khai, riêng tư, được bảo vệ cùng với kế thừa, tổng hợp hoặc thành phần. Vì vậy, bạn chỉ hiển thị những thứ bắt buộc, điều đó cũng vậy, chỉ trong phạm vi bạn muốn hiển thị. tức là công khai, được bảo vệ, thân thiện và riêng tư ka funda, ví dụ GM quyết định sử dụng thiết kế trừu tượng của chiếc xe ở trên. Nhưng họ có nhiều sản phẩm khác nhau có cùng đặc điểm & thực hiện chức năng gần như giống nhau. Vì vậy, họ viết một lớp mở rộng lớp trừu tượng ở trên. Nó cho biết hộp số nên hoạt động như thế nào, làm thế nào để phá vỡ hoạt động, làm thế nào tay lái nên làm việc. Sau đó, tất cả các sản phẩm chỉ sử dụng chức năng phổ biến này. Họ không cần biết làm thế nào hộp số hoạt động hoặc phá vỡ hoạt động hoặc chỉ đạo hoạt động wheal.

Cả hai đều mạnh mẽ; nhưng sử dụng trừu tượng hóa đòi hỏi nhiều kỹ năng hơn đóng gói và các ứng dụng / sản phẩm lớn hơn không thể tồn tại với sự trừu tượng hóa.

Trừu tượng --- Ẩn thực hiện - tại Thiết kế --- Sử dụng Giao diện / Tóm tắt

Đóng gói - Ẩn dữ liệu - Phát triển --- Sử dụng công cụ sửa đổi truy cập (công khai / riêng tư)

Từ đây

Sự khác biệt giữa Đóng gói và Trừu tượng trong OOPS

Trừu tượng hóa và Đóng gói là hai khái niệm quan trọng về lập trình hướng đối tượng (OOPS). Đóng gói và Trừu tượng cả hai đều là các thuật ngữ liên quan đến nhau.

Sự khác biệt trong cuộc sống thực giữa sự đóng gói và trừu tượng

Đóng gói có nghĩa là để ẩn. Đóng gói còn được gọi là ẩn dữ liệu. Bạn có thể nghĩ Đóng gói giống như một viên nang (viên thuốc) che giấu thuốc bên trong nó. Đóng gói là gói, chỉ ẩn các thuộc tính và phương thức. Đóng gói được sử dụng để ẩn mã và dữ liệu trong một đơn vị để bảo vệ dữ liệu từ bên ngoài thế giới. Lớp học là ví dụ tốt nhất về đóng gói.

Trừu tượng đề cập đến chỉ hiển thị các chi tiết cần thiết cho người dùng dự định. Như tên cho thấy, trừu tượng là "hình thức trừu tượng của bất cứ điều gì". Chúng tôi sử dụng sự trừu tượng trong các ngôn ngữ lập trình để tạo ra lớp trừu tượng. Lớp trừu tượng đại diện cho cái nhìn trừu tượng về các phương thức và thuộc tính của lớp.

Sự khác biệt thực hiện giữa đóng gói và trừu tượng

1. Trừu tượng được thực hiện bằng giao diện và lớp trừu tượng trong khi Encapsulation được thực hiện bằng cách sử dụng công cụ sửa đổi truy cập riêng tư và được bảo vệ.

2. OOPS sử dụng đóng gói để thực thi tính toàn vẹn của một loại (nghĩa là đảm bảo dữ liệu được sử dụng theo cách phù hợp) bằng cách ngăn các lập trình viên truy cập dữ liệu theo cách không có chủ đích. Thông qua việc đóng gói, chỉ một nhóm chức năng được xác định trước có thể truy cập dữ liệu. Thuật ngữ tập thể cho kiểu dữ liệu và hoạt động (phương thức) được gói cùng với các hạn chế truy cập (công khai / riêng tư, v.v.) là một lớp.

Tôi sẽ cố gắng chứng minh Encapsulation một cách đơn giản .. Hãy xem ..

• Việc gói dữ liệu và các hàm thành một đơn vị (được gọi là lớp) được gọi là đóng gói. Đóng gói chứa và ẩn thông tin về một đối tượng, chẳng hạn như cấu trúc dữ liệu nội bộ và mã.

Đóng gói là -

• Ẩn phức tạp,
• Liên kết dữ liệu và chức năng với nhau,
• Làm cho phương thức phức tạp là riêng tư,
• Biến tư nhân ngay lập tức,
• Ẩn dữ liệu và chức năng không cần thiết từ người dùng cuối.

Đóng gói thực hiện Trừu tượng hóa.

Và Trừu tượng là -

• Hiển thị những gì cần thiết,
• Dữ liệu cần trừu tượng hóa từ Người dùng cuối,

Hãy xem một ví dụ-

Hình ảnh bên dưới hiển thị GUI "Chi tiết khách hàng sẽ được thêm vào cơ sở dữ liệu".

Bằng cách nhìn vào Hình ảnh, chúng tôi có thể nói rằng chúng tôi cần một Lớp khách hàng.

Bước - 1: Lớp khách hàng của tôi cần gì?

I E

• 2 biến để lưu Mã khách hàng và Tên khách hàng.

• 1 Chức năng để thêm mã khách hàng và tên khách hàng vào cơ sở dữ liệu.

  không gian tên CustomerContent {lớp công khai Khách hàng {chuỗi công khai CustomerCode = ""; chuỗi công khai CustomerName = ""; công khai void ADD () {// mã DB của tôi sẽ xuất hiện ở đây}

Bây giờ chỉ có phương pháp THÊM sẽ không làm việc ở đây một mình.

Bước -2: Quá trình xác nhận sẽ hoạt động như thế nào, hàm ADD hoạt động như thế nào?

Chúng ta sẽ cần mã kết nối cơ sở dữ liệu và mã xác nhận (Phương thức bổ sung).

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

Bây giờ không cần hiển thị các Phương thức bổ sung (Xác thực (); TạoDBObject () [Phương thức phức tạp và bổ sung]) cho Người dùng cuối. Người dùng chỉ cần xem và biết về Mã khách hàng, Tên khách hàng và nút THÊM bản ghi .. Người dùng cuối không quan tâm đến việc nó sẽ THÊM dữ liệu vào cơ sở dữ liệu như thế nào?.

Bước -3: Riêng tư các phương thức bổ sung và phức tạp không liên quan đến Tương tác của Người dùng Cuối.

Vì vậy, làm cho các phương thức Complicated và Extra thành Private thay vì Public (tức là Ẩn các phương thức đó) và xóa obj.Validate (); obj.CreateDBObject (); từ chương trình chính trong lớp, chúng tôi đạt được Đóng gói.

Nói cách khác, đơn giản hóa giao diện cho người dùng cuối là đóng gói.

Vì vậy, bây giờ mã trông như dưới đây -

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

Tóm lược :

Bước -1: Lớp khách hàng của tôi cần gì? là trừu tượng.

Bước -3: Bước -3: Riêng tư các phương thức bổ sung và phức tạp không liên quan đến Tương tác của người dùng cuối là Đóng gói.

PS - Đoạn mã trên cứng và nhanh.

Đoạn văn dưới đây đã giúp tôi hiểu họ khác nhau như thế nào:

Đóng gói dữ liệu là một cơ chế đóng gói dữ liệu và các chức năng sử dụng chúng và trừu tượng hóa dữ liệu là một cơ chế chỉ hiển thị các giao diện và ẩn chi tiết triển khai khỏi người dùng.

Bạn có thể đọc thêm ở đây .

Việc che giấu thông tin không được yêu cầu nghiêm ngặt cho sự trừu tượng hóa hay đóng gói. Thông tin có thể bị bỏ qua, nhưng không phải ẩn đi.

Đóng gói là khả năng coi một cái gì đó là một thứ duy nhất, mặc dù nó có thể bao gồm nhiều phần hoặc ý tưởng phức tạp. Ví dụ, tôi có thể nói rằng tôi đang ngồi trên "chiếc ghế" thay vì đề cập đến nhiều bộ phận khác nhau của chiếc ghế đó với một thiết kế và chức năng cụ thể, tất cả đều khớp với nhau một cách chính xác với mục đích thoải mái giữ mông tôi vài feet cách xa sàn nhà

Trừu tượng được kích hoạt bằng cách đóng gói. Bởi vì chúng tôi gói gọn các đối tượng, chúng tôi có thể nghĩ về chúng như những thứ liên quan đến nhau theo một cách nào đó thay vì bị sa lầy vào các chi tiết tinh tế của cấu trúc đối tượng bên trong. Trừu tượng là khả năng xem xét bức tranh lớn hơn, loại bỏ khỏi mối quan tâm qua các chi tiết nhỏ. Từ gốc của từ này là trừu tượng như trong bản tóm tắt xuất hiện ở đầu một bài báo học thuật, không trừu tượng như trong một lớp chỉ có thể được khởi tạo như một lớp con dẫn xuất.

Tôi có thể thành thật nói rằng khi tôi ngồi phịch xuống ghế, tôi không bao giờ nghĩ về cấu trúc của chiếc ghế đó sẽ bắt và giữ trọng lượng của tôi như thế nào. Đó là một chiếc ghế đủ tốt mà tôi không phải lo lắng về những chi tiết đó. Vì vậy, tôi có thể chuyển sự chú ý của tôi về phía máy tính của tôi. Và một lần nữa, tôi không nghĩ về các bộ phận cấu thành của máy tính. Tôi chỉ nhìn vào một phần của trang web đại diện cho một vùng văn bản mà tôi có thể nhập và tôi đang giao tiếp bằng lời, thậm chí không nghĩ đến việc ngón tay của tôi luôn tìm thấy các chữ cái nhanh như thế nào trên bàn phím và làm thế nào kết nối cuối cùng được thực hiện giữa việc nhấn các phím này và đăng lên diễn đàn này. Đây là sức mạnh tuyệt vời của sự trừu tượng. Bởi vì các cấp thấp hơn của hệ thống có thể được tin cậy để làm việc với tính nhất quán và chính xác, chúng tôi có sự chú ý để dự phòng cho công việc lớn hơn.

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

sự trừu tượng hóa đang ẩn dữ liệu không hữu ích từ người dùng và đóng gói được liên kết dữ liệu với nhau thành một viên nang (một lớp). Tôi nghĩ đóng gói là cách mà chúng ta đạt được sự trừu tượng.

Cả quá trình Trừu tượng hóa và Đóng gói đều tạo ra các giao diện.

Một giao diện được tạo thông qua đóng gói ẩn chi tiết thực hiện.

Một giao diện được tạo thông qua trừu tượng hóa trở nên áp dụng cho nhiều loại dữ liệu hơn so với trước khi trừu tượng hóa.

Abstractionlà một hợp đồng cho việc thực hiện chúng ta sẽ làm. Việc thực hiện có thể được thay đổi theo thời gian. Việc triển khai khác nhau mình có thể hoặc không thể được ẩn nhưng Masked đằng sau những trừu tượng.

Giả sử chúng ta định nghĩa tất cả các APIslớp trong một interfacesau đó yêu cầu người dùng mã của chúng ta phụ thuộc vào định nghĩa APIscủa interface. Chúng tôi được tự do cải thiện hoặc sửa đổi việc thực hiện chỉ khi chúng tôi phải tuân theo hợp đồng đã đặt. Người dùng không được kết hợp với việc thực hiện của chúng tôi.

Chúng tôi TIẾP TỤC tất cả các Quy tắc (phương pháp) CẦN THIẾT trong trừu tượng hóa , việc thực hiện các quy tắc được dành cho các thực thể triển khai, và việc triển khai không phải là một phần của trừu tượng hóa. Nó chỉ là chữ ký và tuyên bố những gì làm cho trừu tượng.

Encapsulationchỉ đơn giản là NÓI các chi tiết nội bộ bằng cách giảm sự nhạy bén của các trạng thái và hành vi. Một lớp được đóng gói có thể có hoặc không được xác định rõ Abstraction.

java.util.Listlà một sự trừu tượng cho java.util.ArrayList. Các trạng thái nội bộ của java.util.ArrayListviệc được đánh dấu bằng các non publicsửa đổi truy cập là đóng gói.

Sửa Giả sử một lớp Container.nava implements IContainer, IContainercó thể tuyên bố phương pháp thích addElement, removeElements, contains, vv Ở đây IContainerđại diện cho trừu tượng cho các lớp học hướng dẫn thi hành. Trừu tượng hóa là khai báo các API của lớp hoặc một mô-đun hoặc một hệ thống ra thế giới bên ngoài. Các API này trở thành contract. Hệ thống đó có thể hoặc chưa được phát triển. Người dùng hệ thống hiện có thể phụ thuộc vào các API được khai báo và chắc chắn rằng bất kỳ hệ thống nào thực hiện hợp đồng như vậy sẽ luôn tuân thủ các API được khai báo, họ sẽ luôn cung cấp triển khai cho các API đó. Một khi chúng ta đang viết một số thực thể cụ thể thì quyết định che giấu các trạng thái nội bộ của chúng ta là đóng gói

Tôi nghĩ Encapsulation là một cách để thực hiện trừu tượng hóa. Có một cái nhìn vào liên kết sau đây.

Trừu tượng và đóng gói

Nói ngắn gọn

Sử dụng trừu tượng -> Sử dụng đóng gói & Đóng gói -> ẩn dữ liệu

HOẶC LÀ

ẩn dữ liệu là một tập hợp con của Encapsulation và Encapsulation là một tập hợp con của Trừu tượng hóa

Tham khảo: http://www.tonymarston.co.uk/php-mysql/abstraction.txt