diferença entre abstração e encapsulamento?

Qual é a diferença precisa entre encapsulamento e abstração?

A maioria das respostas aqui se concentra na POO, mas o encapsulamento começa muito antes:

  • Toda function é um encapsulamento ; no pseudocódigo:

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

    Aqui, a distance encapsula o cálculo da distância (euclidiana) entre dois pontos em um plano: ela oculta detalhes de implementação. Isso é encapsulamento, puro e simples.

  • A abstração é o processo de generalização : tomar uma implementação concreta e torná-la aplicável a diferentes tipos de dados, embora um tanto relacionados. O exemplo clássico de abstração é a function qsort de C para ordenar dados:

    A coisa sobre o qsort é que ele não se importa com os dados que ele classifica – na verdade, ele não sabe quais dados são classificados. Em vez disso, seu tipo de input é um ponteiro void* ( void* ), que é apenas a maneira de C dizer “não me importo com o tipo de dado” (isso também é chamado de eliminação de tipo). O ponto importante é que a implementação do qsort permanece sempre a mesma, independentemente do tipo de dados. A única coisa que tem que mudar é a function de comparação, que difere do tipo de dados para o tipo de dados. Portanto, o qsort espera que o usuário forneça a referida function de comparação como um argumento de function.

O encapsulamento e a abstração andam de mãos dadas, tanto que você poderia afirmar que eles são verdadeiramente inseparáveis. Para fins práticos, isso é provavelmente verdade; Dito isso, aqui está um encapsulamento que não é muito de uma abstração:

 class point { numeric x numeric y } 

Nós encapsulamos a coordenada do ponto, mas não os abstraímos materialmente, além de agrupá-los logicamente.

E aqui está um exemplo de abstração que não é encapsulamento:

 T pi = 3.1415926535 

Esta é uma variável genérica pi com um determinado valor (π), e a declaração não se importa com o tipo exato da variável. Evidentemente, seria difícil encontrar algo assim em código real: a abstração praticamente sempre usa o encapsulamento. No entanto, o acima , na verdade, existe em C ++ (14), através de modelos variables (= modelos genéricos para variables); com uma syntax um pouco mais complexa, por exemplo:

 template  constexpr T pi = T{3.1415926535}; 

O encapsulamento está ocultando os detalhes da implementação, que podem ou não ser para comportamento (s) genérico (s) ou especializado (s).

A abstração está fornecendo uma generalização (digamos, sobre um conjunto de comportamentos).

Aqui está uma boa leitura: Abstração, Encapsulamento e Informação Escondida por Edward V. Berard da Agência de Objetos.

o encapsulamento coloca algumas coisas em uma checkbox e lhe dá um olho mágico; isso evita que você muck com as engrenagens.

abstração plana ignora os detalhes que não importam, como se as coisas tivessem engrenagens, catracas, volantes ou núcleos nucleares; eles simplesmente “vão”

exemplos de encapsulamento:

  • cuecas
  • Caixa de ferramentas
  • carteira
  • Bolsa
  • cápsula
  • carbonite congelado
  • uma checkbox, com ou sem botão
  • um burrito (tecnicamente, a tortilla em volta do burrito)

exemplos de abstração:

  • “grupos de coisas” é uma abstração (que chamamos de agregação)
  • “coisas que contém outras coisas” é uma abstração (que chamamos de composição)
  • “contêiner” é outro tipo de abstração “coisas que contêm outras coisas”; note que todos os exemplos de encapsulamento são tipos de contêineres, mas nem todos os contêineres exibem / fornecem encapsulamento. Uma cesta, por exemplo, é um contêiner que não encapsula seu conteúdo.

Muitas respostas e seus exemplos são enganosos.

O encapsulamento é o empacotamento de dados e funções que operam nesses dados em um único componente e restringe o access a alguns dos componentes do object.
Encapsulamento significa que a representação interna de um object é geralmente ocultada da visão fora da definição do object.

A abstração é um mecanismo que representa os resources essenciais sem include detalhes de implementação.

Encapsulamento:Esconder informação .
Abstração:Escondimento da implementação .

Exemplo:

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

A representação interna de qualquer object da class foo está oculta fora da class. -> encapsulamento.
Qualquer membro acessível (dados / function) de um object de foo é restrito e só pode ser acessado por esse object apenas.

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

A implementação do método add está oculta. -> Abstração.

Encapsulamento significa esconder dados como getter e setter etc.

Abstração significa esconder a implementação usando classs e interfaces abstratas, etc.

Abstração é um termo generalizado. ou seja, o encapsulamento é subconjunto da abstração.

insira a descrição da imagem aqui

Cortesia

  • A abstração permite que você se concentre no que o object faz em vez de como ele faz isso
  • Encapsulamento significa esconder os detalhes internos ou a mecânica de como um object faz alguma coisa.

Como quando você dirige um carro, você sabe o que o acelerador faz, mas você pode não conhecer o processo por trás dele, porque ele é encapsulado.

Deixe-me dar um exemplo em c #. Suponha que você tenha um inteiro:

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

você pode usar um método como Number.ToString () que retorna a representação de caracteres do número 5 e armazena isso em um object de string. O método diz o que ele faz em vez de como ele faz isso.

Muitas boas respostas são fornecidas acima, mas vou apresentar meu ponto de vista (Java) aqui.

Encapsulamento de Dados significa simplesmente agrupar e controlar o access de dados agrupados logicamente em uma class. Geralmente está associado a outra palavra-chave – ocultação de dados . Isto é conseguido em Java usando modificadores de access .

Um exemplo simples seria definir uma variável privada e dar access a ela usando methods getter e setter ou tornar um método privado, já que seu uso é apenas na class. Não há necessidade de o usuário saber sobre esses methods e variables.

Nota : Não deve ser mal compreendido que o encapsulamento é apenas sobre a ocultação de dados. Quando dizemos encapsulamento, a ênfase deve ser no agrupamento ou empacotamento ou agrupamento de dados e comportamentos relacionados.

A Abstração de Dados, por outro lado, é um conceito de generalização, de forma que a lógica complexa subjacente não seja exposta ao usuário. Em Java, isso é obtido usando interfaces e classs abstratas .

Exemplo –

Vamos dizer que temos uma interface Animal e tem uma function makeSound () . Existem duas classs concretas Dog e Cat que implementam essa interface. Essas classs concretas têm implementações separadas da function makeSound (). Agora vamos dizer que temos um animal (nós obtemos isso de algum módulo externo). Todo usuário sabe que o object que está recebendo é algum animal e é de responsabilidade do usuário imprimir o som do animal. Uma forma de força bruta é verificar o object recebido para identificá- lo, então fazer a typecast para esse tipo de Animal e então chamar makeSound () nele. Mas uma maneira mais agradável é abstrair a coisa . Use Animal como uma referência polimórfica e chame makeSound () nela. No tempo de execução, dependendo do tipo de object real, a function apropriada será chamada.

Mais detalhes aqui .

insira a descrição da imagem aqui

A lógica complexa está na placa de circuito que é encapsulada em um touchpad e uma interface agradável (botões) é fornecida para abstrair o usuário.

Esses são conceitos um tanto difusos que não são exclusivos da Ciência da Computação e da programação. Eu gostaria de oferecer alguns pensamentos adicionais que podem ajudar os outros a entender esses conceitos importantes.


Resposta curta

Encapsulamento – Escondendo e / ou restringindo o access a certas partes de um sistema, enquanto expõe as interfaces necessárias.

Abstração – Considerar algo com certas características removidas, além de realidades concretas, objects específicos ou instâncias reais, reduzindo assim a complexidade.

A principal semelhança é que essas técnicas visam melhorar a compreensão e a utilidade.

A principal diferença é que a abstração é um meio de representar as coisas de maneira mais simples (geralmente para tornar a representação mais amplamente aplicável), enquanto o encapsulamento é um método de mudar a maneira como outras coisas interagem com algo.


Resposta longa

Encapsulamento

Aqui está um exemplo de encapsulamento que, esperamos, torna as coisas mais claras:

Encapsulamento Arduino

Aqui temos um Arduino Uno e um Arduino Uno dentro de um gabinete. Um gabinete é uma ótima representação do que é o encapsulamento.

O encapsulamento visa proteger certos componentes de influências e conhecimentos externos, bem como expor componentes com os quais outras coisas devem interagir. Em termos de programação, isso envolve a ocultação de informações através de modificadores de access , o que altera a extensão em que certas variables ​​e / ou propriedades podem ser lidas e escritas.

Mas além disso, o encapsulamento também visa fornecer essas interfaces externas com muito mais eficiência. Com nosso exemplo do Arduino, isso poderia include os botões e a canvas agradáveis ​​que tornam a interação do usuário com o dispositivo muito mais simples. Eles fornecem ao usuário maneiras simples de afetar o comportamento do dispositivo e obter informações úteis sobre sua operação, que de outra forma seriam muito mais difíceis.

Na programação, isso envolve o agrupamento de vários componentes em uma construção separável, como uma function , class ou object . Também inclui fornecer os meios de interagir com essas construções, bem como methods para obter informações úteis sobre eles.

O encapsulamento ajuda os programadores de muitas outras maneiras, incluindo a melhor manutenibilidade e testabilidade do código.

Abstração

Embora muitas outras respostas aqui tenham definido a abstração como generalização, eu pessoalmente acho que essa definição é equivocada. Eu diria que a generalização é na verdade um tipo específico de abstração, e não o contrário. Em outras palavras, todas as generalizações são abstrações, mas todas as abstrações não são necessariamente generalizações.

Aqui está como eu gosto de pensar em abstração:

Árvore de Pixel

Você diria que a imagem é uma tree? As chances são de que você faria. Mas é mesmo uma tree? Bem, claro que não! É um monte de pixels feitos para parecer algo que podemos chamar de tree. Poderíamos dizer que é uma abstração de uma tree real. Observe que vários detalhes visuais da tree são omitidos. Além disso, não cresce, consome água ou produz oxigênio. Como poderia? É apenas um monte de colors em uma canvas, representada por bytes na memory do seu computador.

E aqui está a essência da abstração. É uma maneira de simplificar as coisas para que elas sejam mais fáceis de entender. Toda idéia que passa pela sua cabeça é uma abstração da realidade. Sua imagem mental de uma tree não é mais uma tree real do que esta jpeg é.

Na programação, podemos usar isso a nosso favor criando uma class Tree com methods para crescimento simulado, consumo de água e produção de oxigênio. Nossa criação seria algo que representa nossa experiência de trees reais, e inclui apenas aqueles elementos que realmente nos interessam em nossa simulação particular. Usamos a abstração como uma forma de representar nossa experiência de algo com bytes e matemática.

Classes Abstratas

A abstração na programação também nos permite considerar pontos comuns entre vários tipos de objects “concretos” (tipos que realmente existem) e definir esses pontos comuns dentro de uma entidade única. Por exemplo, nossa class Tree pode herdar de uma abstract class Plant , que possui várias propriedades e methods que são aplicáveis ​​a todas as nossas classs semelhantes a plantas, mas remove aquelas que são específicas para cada tipo de planta. Isso pode reduzir significativamente a duplicação de código e melhora a capacidade de manutenção.

A diferença prática de uma abstract class e abstract class simples é que, conceitualmente, não há exemplos “reais” da abstract class . Não faria sentido construir um object Plant porque isso não é específico o suficiente. Toda Plant “real” é também um tipo mais específico de Plant .

Além disso, se quisermos que nosso programa seja mais realista, podemos considerar o fato de que nossa class Tree pode ser abstrata demais. Na realidade, cada Tree é um tipo mais específico de Tree , então poderíamos criar classs para tipos como Birch , Maple , etc., que herdam da nossa, talvez agora abstract , class Tree .

JVM

Outro bom exemplo de abstração é a Java Virtual Machine (JVM) , que fornece um computador virtual ou abstrato para o código Java ser executado. Essencialmente, ele tira todos os componentes específicos da plataforma de um sistema e fornece uma interface abstrata de “computador” sem levar em conta qualquer sistema em particular.

A diferença

O encapsulamento difere da abstração porque não tem nada a ver com o quão ‘real’ ou ‘preciso’ é. Não remove componentes de algo para torná-lo mais simples ou mais amplamente aplicável. Pelo contrário, pode ocultar certos componentes para alcançar um propósito similar.

Encapsulamento : Está ocultando detalhes de implementação indesejados / inesperados / proprietários dos usuários reais do object. por exemplo

 List list = new List(); 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. */ 

Abstração : É uma maneira de fornecer generalização e, portanto, uma maneira comum de trabalhar com objects de grande diversidade. por exemplo

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

Abstração: A ideia de apresentar algo de uma maneira simplificada / diferente, que seja mais fácil de entender e usar ou mais pertinente à situação.

Considere uma class que envia um email … ele usa abstração para mostrar-se a você como algum tipo de mensageiro, então você pode chamar o emailSender.send (mail, recipient). O que ele realmente faz – escolhe POP3 / SMTP, servidores de chamada, tradução de MIME, etc, é abstraído. Você só vê o seu mensageiro.

Encapsulamento: A ideia de proteger e ocultar dados e methods que são particulares para um object. Ele lida mais com algo independente e infalível.

Me leve, por exemplo. Eu encapsulo meu ritmo cardíaco do resto do mundo. Porque não quero mais ninguém mudando essa variável, e não preciso de mais ninguém para configurá-la para que eu funcione. É de vital importância para mim, mas você não precisa saber o que é e provavelmente não se importa.

Olhe em volta e verá que quase tudo que você toca é um exemplo de abstração e encapsulamento. Seu telefone, por exemplo, apresenta a você a abstração de poder pegar o que você diz e dizê-lo para outra pessoa – encobrir o GSM, a arquitetura do processador, as freqüências de rádio e um milhão de outras coisas que você não entende ou não se importa. Também encapsula certos dados seus, como números de série, números de identificação, frequências, etc.

Tudo isso faz do mundo um lugar melhor para se morar: D

Diferença entre abstração e encapsulamento.

Diferença entre abstração e encapsulamento

Abstração: Apenas as informações necessárias são mostradas. Vamos nos concentrar no exemplo de ligar um computador. O usuário não precisa saber o que acontece enquanto o sistema ainda está carregando (essa informação é ocultada do usuário).

Vamos dar outro exemplo, o do ATM. O cliente não precisa saber como a máquina lê o PIN e processa a transação. Tudo o que ele precisa fazer é digitar o PIN, pegar o dinheiro e sair.

Encapsulamento: Trata-se de ocultar os dados confidenciais de uma class, portanto privatizando parte dela. É uma maneira de manter algumas informações privadas para seus clientes, não permitindo access a elas de fora.

Outro exemplo:

Suponha que eu criei uma class Rectangle imutável assim:

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

Agora é óbvio que eu encapsulei largura e altura (o access é de alguma forma restrito), mas eu não abstranciei nada (ok, talvez eu tenha ignorado onde o retângulo está localizado no espaço de coordenadas, mas isso é uma falha do exemplo).

Boa abstração geralmente implica um bom encapsulamento.

Um exemplo de boa abstração é uma class de conexão de database genérica. Sua interface pública é independente de database e é muito simples, mas permite que eu faça o que eu quero com a conexão. E você vê Também há encapsulamento, porque a class deve ter todas as alças e chamadas de baixo nível dentro dela.

Abstraction e Encapsulation usando um único exemplo generalizado

————————————————– ————————————————– ——————————–

Todos usamos calculadora para calcular problemas complexos!

imagem

Um mecanismo que impede que os dados de um determinado object sejam protegidos contra uso intencional ou acidental por funções externas é chamado de ” encapsulamento de dados”.

O ato de representar características essenciais sem include os detalhes de fundo ou explicações é conhecido como abstração

Abstração: Abstração significa mostrar What parte da funcionalidade.

Encapsulamento: Encapsulamento significa ocultar a parte How da funcionalidade.

Vamos dar um exemplo muito simples

 ///  /// We have an Employee class having two properties EmployeeName and EmployeeCode ///  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 } } 

Classe de programa do aplicativo de 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); } } 

Encapsulamento está encapsulando complexidade em uma cápsula que é class e, portanto, encapsulamento … Enquanto abstração são as características de um object que se diferencia de outro object …

A abstração pode ser obtida fazendo abstração de class tendo um ou mais methods abstratos. Que nada mais é que a característica que deve ser implementada pela class que a estende. Por exemplo, quando você inventa / projeta um carro, você define as características como o carro deve ter 4 portas, quebra, volante, etc … para que qualquer pessoa use este projeto deve include essas características. Implementação não é a cabeça de cada abstração. Apenas definirá características que devem ser incluídas.

O encapsulamento é alcançado mantendo os dados e o comportamento em uma cápsula que é de class e fazendo uso de modificadores de access como público, privado, protegido juntamente com inheritance, agregação ou composição. Então você só mostra apenas as coisas necessárias, isso também, apenas na medida em que você quer mostrar. ou seja, público, protegido, amigável e privado ka funda ……, por exemplo, a GM decide usar o desenho abstraído do carro acima. Mas eles têm vários produtos com as mesmas características e fazendo quase a mesma funcionalidade. Então eles escrevem uma class que estende a class abstrata acima. Ele diz como a checkbox de engrenagens deve funcionar, como a folga deve funcionar, como o volante deve funcionar. Então todos os produtos usam essa funcionalidade comum. Eles não precisam saber como a checkbox de engrenagens funciona ou quebras ou obras de direção. Produto individual pode certamente ter mais resources como a / c ou bloqueio automático etc … ..

Ambos são poderosos; mas usar abstração requer mais habilidades do que encapsulamento e aplicativos / produtos maiores não podem sobreviver sem a abstração.

Abstração — Ocultando Implementação – no Design — Usando Interface / Abstract calsses

Encapsulamento – Escondendo dados –Desenvolvimento – Usando modificadores de access (público / privado)

Vamos pegar o exemplo de uma pilha. Pode ser implementado usando uma matriz ou uma linked list. Mas as operações que ele suporta são push e pop. Agora a abstração está expondo apenas as interfaces push e pop. A representação subjacente é oculta (é uma matriz ou é uma linked list?) E uma interface bem definida é fornecida. Now how do you ensure that no accidental access is made to the abstracted data? That is where the Encapsulation comes in. For eg classs in C++ use the access specifiers which ensure that accidental access and modification is prevented. And also by making the above mentioned interfaces as public, it ensures that the only way to manipulate the stack is through the well defined interface. In the process, it has coupled the data and the code that can manipulate it. ( Lets not get the friend functions involved here.). That is the code and data are bonded together or tied or encapsulated

From this

Difference between Encapsulation and Abstraction in OOPS

Abstraction and Encapsulation are two important Object Oriented Programming (OOPS) concepts. Encapsulation and Abstraction both are interrelated terms.

Real Life Difference Between Encapsulation and Abstraction

Encapsulate means to hide. Encapsulation is also called data hiding.You can think Encapsulation like a capsule (medicine tablet) which hides medicine inside it. Encapsulation is wrapping, just hiding properties and methods. Encapsulation is used for hide the code and data in a single unit to protect the data from the outside the world. Class is the best example of encapsulation.

Abstraction refers to showing only the necessary details to the intended user. As the name suggests, abstraction is the “abstract form of anything”. We use abstraction in programming languages to make abstract class. Abstract class represents abstract view of methods and properties of class.

Implementation Difference Between Encapsulation and Abstraction

  1. Abstraction is implemented using interface and abstract class while Encapsulation is implemented using private and protected access modifier.

  2. OOPS makes use of encapsulation to enforce the integrity of a type (ie to make sure data is used in an appropriate manner) by preventing programmers from accessing data in a non-intended manner. Through encapsulation, only a predetermined group of functions can access the data. The collective term for datatypes and operations (methods) bundled together with access restrictions (public/private, etc.) is a class.

I will try to demonstrate Encapsulation in a simple way.. Lets see..

  • The wrapping up of data and functions into a single unit (called class) is known as encapsulation. Encapsulation containing and hiding information about an object, such as internal data structures and code.

Encapsulation is –

  • Hiding Complexity,
  • Binding Data and Function together,
  • Making Complicated Method’s Private,
  • Making Instance Variable’s Private,
  • Hiding Unnecessary Data and Functions from End User.

Encapsulation implements Abstraction.

And Abstraction is –

  • Showing Whats Necessary,
  • Data needs to abstract from End User,

Lets see an example-

The below Image shows a GUI of “Customer Details to be ADD-ed into a Database”.

Customer Screen GUI

By looking at the Image we can say that we need a Customer Class.

Step – 1: What does my Customer Class needs?

ou seja

  • 2 variables to store Customer Code and Customer Name.
  • 1 Function to Add the Customer Code and Customer Name into Database.

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

Now only ADD method wont work here alone.

Step -2: How will the validation work, ADD Function act?

We will need Database Connection code and Validation Code (Extra Methods).

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

Now there is no need of showing the Extra Methods(Validate(); CreateDBObject() [Complicated and Extra method] ) to the End User.End user only needs to see and know about Customer Code, Customer Name and ADD button which will ADD the record.. End User doesn’t care about HOW it will ADD the Data to Database?.

Step -3: Private the extra and complicated methods which doesn’t involves End User’s Interaction.

So making those Complicated and Extra method as Private instead Public(ie Hiding those methods) and deleting the obj.Validate(); obj.CreateDBObject(); from main in class Program we achieve Encapsulation.

In other words Simplifying Interface to End User is Encapsulation.

So now the code looks like as below –

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

Summary :

Step -1: What does my Customer Class needs? is Abstraction.

Step -3: Step -3: Private the extra and complicated methods which doesn’t involves End User’s Interaction is Encapsulation.

PS – The code above is hard and fast.

The below paragraph helped me to understand how they differ from each other:

Data encapsulation is a mechanism of bundling the data, and the functions that use them and data abstraction is a mechanism of exposing only the interfaces and hiding the implementation details from the user.

Você pode ler mais aqui .

Information hiding is not strictly required for abstraction or encapsulation. Information might be ignored, but does not have to be hidden.

Encapsulation is the ability to treat something as a single thing, even though it may be composed of many complex parts or ideas. For example, I can say that I’m sitting in a “chair” rather than referring to the many various parts of that chair each with a specific design and function, all fitting together precisely for the purpose of comfortably holding my butt a few feet away from the floor.

Abstraction is enabled by encapsulation. Because we encapsulate objects, we can think about them as things which relate to each other in some way rather than getting bogged down in the subtle details of internal object structure. Abstraction is the ability to consider the bigger picture, removed from concern over little details. The root of the word is abstract as in the summary that appears at the top of a scholarly paper, not abstract as in a class which can only be instantiated as a derived subclass.

I can honestly say that when I plop my butt down in my chair, I never think about how the structure of that chair will catch and hold my weight. It’s a decent enough chair that I don’t have to worry about those details. So I can turn my attention toward my computer. And again, I don’t think about the component parts of my computer. I’m just looking at a part of a webpage that represents a text area that I can type in, and I’m communicating in words, barely even thinking about how my fingers always find the right letters so quickly on the keyboard, and how the connection is ultimately made between tapping these keys and posting to this forum. This is the great power of abstraction. Because the lower levels of the system can be trusted to work with consistency and precision, we have attention to spare for greater work.

Encapsulation (Binding data and Code)

  • Encapsulation is the mechanism that binds together code and the data it manipulates, and keeps both safe from outside interference and misuse.

  • In an object-oriented language, code and data may be combined in such a way that a self-contained “black box” is created. When code and data are linked together in this fashion, an object is created. In other words, an object is the device that supports encapsulation.

  • Encapsulation leads to the concept of data hiding, but the concept of encapsulation must not be restricted to information hiding.

  • Encapsulation clearly represents the ability to bundle related data and functionality within a single, autonomous entity called a class.

Abstraction (Hiding how data stored and Hiding how function is implemented)

  • Data abstraction is a process of representing the essential features without including implementation details.

  • Abstraction is one of the most powerful and vital features provided by object-oriented programming.

  • The main idea behind data abstraction is to give a clear separation between properties of data type and the associated implementation details. This separation is achieved in order that the properties of the abstract data type are visible to the user interface and the implementation details are hidden.

  • Abstraction is separating the logical properties from implementation details. For example driving the car is a logical property and design of the engine is the implementation detail.

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

abstraction is hiding non useful data from users and encapsulation is bind together data into a capsule (a class). I think encapsulation is way that we achieve abstraction.

The process of Abstraction and Encapsulation both generate interfaces.

An interface generated via encapsulation hides implementation details.

An interface generated via abstraction becomes applicable to more data types, compared to before abstraction.

Abstraction is a contract for the implementation we are going to do. Implementation may get changed over period of time. The various implementations themselves may or may not be hidden but are Masked behind the Abstraction.

Suppose we define all the APIs of a class in an interface then ask the users of our code to depened upon the defined APIs of the interface . We are free to improve or modify the implementation only we must follow the set contract. The users are not coupled with our implementation.

We EXPOSE all the NECESSARY Rules (methods) in abstraction , the implementation of the rules are left for the implementor entities, also the implemention is not part of the abstraction. Its just the signature and declaration what makes the abstraction.

Encapsulation is simply HIDING the internal details by reducing the acess of the states and behaviors. An encapsulated class may or may not have well defined Abstraction .

java.util.List is an abstraction for java.util.ArrayList . The internal states of java.util.ArrayList being marked with non public access modifiers is encapsulation.

Edit Suppose a class Container.nava implements IContainer , IContainer may declare methods like addElement , removeElements , contains , etc. Here IContainer represents the abstraction for its implementing class. Abstraction is declaring the APIs of the class or a module or a system to the outer world. These APIs become the contract . That system may be or may not be developed yet. The users of the system now can depend on the declared APIs and are sure any system implementing such a contract will always adhere to the APIs declared, they will always provide tge implementation for those APIs. Once we are writing some concrete entity then deciding to hide our internal states is encapsulation

One could argue that abstraction is a technique that helps us identify which specific information should be visible, and which information should be hidden. Encapsulation is then the technique for packaging the information in such a way as to hide what should be hidden, and make visible what is intended to be visible.