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

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

• Toda função é um encapsulamento ; no pseudocódigo:

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

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

• Abstração é o processo de generalização : adotando uma implementação concreta e tornando-a aplicável a diferentes tipos de dados, embora um pouco relacionados. O exemplo clássico de abstração é aqsortfunçãode Cpara classificar dados:

  O fato qsorté que ele não se importa com os dados que classifica - na verdade, não sabe quais dados ele classifica. Em vez disso, seu tipo de entrada é um ponteiro sem tipo ( void*), que é apenas a maneira de C dizer “não me importo com o tipo de dados” (isso também é chamado de apagamento de tipo). O ponto importante é que a implementação de qsortsempre permanece a mesma, independentemente do tipo de dados. A única coisa que precisa ser alterada é a função de comparação, que difere de um tipo para outro. qsortportanto, espera que o usuário forneça a referida função de comparação como um argumento de função.

Encapsulamento e abstração andam de mãos dadas tanto que você pode dizer que eles são realmente inseparáveis. Para fins práticos, isso provavelmente é verdade; Dito isto, aqui está um encapsulamento que não é uma abstração:

class point {
    numeric x
    numeric y
}

Encapsulamos as coordenadas do ponto, mas não as abstraímos materialmente, além de agrupá-las logicamente.

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

T pi<T> = 3.1415926535

Essa é 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. É certo que seria difícil encontrar algo assim no código real: a abstração quase sempre usa encapsulamento. No entanto, o acima não existe realmente em C ++ (14), através de modelos de variáveis (= modelos genéricos para as variáveis); com uma sintaxe um pouco mais complexa, por exemplo:

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

O encapsulamento está ocultando os detalhes da implementação que podem ou não ser relativos a comportamentos genéricos ou especializados.

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

Aqui está uma boa leitura: Abstração, encapsulamento e ocultação de informações por Edward V. Berard, da Agência de Objetos.

Muitas respostas e seus exemplos são enganosos.

Encapsulamento é o empacotamento de dados e funções que operam nesses dados em um único componente e restringem o acesso a alguns dos componentes do objeto.
Encapsulamento significa que a representação interna de um objeto geralmente está oculta fora da definição do objeto.

Abstração é um mecanismo que representa os recursos essenciais sem incluir detalhes de implementação.

Encapsulamento: - Esconder informações .
Abstração: - Implementação oculta .

Exemplo:

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

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

A representação interna de qualquer objeto da fooclasse está oculta fora da classe. -> Encapsulamento.
Qualquer membro acessível (dados / função) de um objeto de fooé restrito e só pode ser acessado por esse objeto.

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

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

o encapsulamento coloca algumas coisas em uma caixa e oferece um olho mágico; isso evita que você estrague as engrenagens.

a abstração direta ignora os detalhes que não importam, como se as coisas têm engrenagens, catracas, volantes ou núcleos nucleares; eles apenas "vão"

exemplos de encapsulamento:

• cuecas
• Caixa de ferramentas
• carteira
• Bolsa
• cápsula
• carbonita congelada
• uma caixa, com ou sem um botão nela
• um burrito (tecnicamente, a tortilha ao redor 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)
• "container" é outro tipo de abstração de "coisas que contêm outras coisas"; observe 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.

Encapsulamento significa ocultar dados, como usar getter e setter etc.

Abstração significa ocultar a implementação usando classe abstrata e interfaces etc.

Abstração é um termo generalizado. ie Encapsulamento é um subconjunto de Abstração.

• Exemplo 2:
  O arquiteto da solução é a pessoa que cria o design técnico abstrato de alto nível de toda a solução, e esse design é entregue à equipe de desenvolvimento para implementação .

  Aqui, o arquiteto de soluções atua como uma equipe abstrata e de desenvolvimento como um encapsulamento.

• Exemplo 3: Encapsulamento (rede) de dados do usuário

Cortesia

Abstração (ou modularidade) - Os tipos permitem que os programadores pensem em um nível superior ao bit ou byte, sem se preocupar com a implementação de baixo nível. Por exemplo, os programadores podem começar a pensar em uma string como um conjunto de valores de caracteres em vez de como uma mera matriz de bytes. Mais alto ainda, os tipos permitem que os programadores pensem e expressem interfaces entre dois dos subsistemas de qualquer tamanho. Isso permite mais níveis de localização, para que as definições necessárias para a interoperabilidade dos subsistemas permaneçam consistentes quando esses dois subsistemas se comunicarem. Fonte

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

Encapsulamento de dados significa simplesmente agrupar e controlar o acesso de dados agrupados logicamente em uma classe. Geralmente é associado a outra palavra-chave - Data Hiding . Isso é alcançado em Java usando modificadores de acesso .

Um exemplo simples seria definir uma variável privada e dar acesso a ela usando os métodos getter e setter ou tornar um método privado, pois seu uso é apenas na classe. Não é necessário que o usuário saiba sobre esses métodos e variáveis.

Nota : Não deve ser mal entendido que o encapsulamento se refere apenas à ocultação de dados. Quando dizemos encapsulamento, a ênfase deve estar no agrupamento ou empacotamento ou agregação de dados e comportamentos relacionados.

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

Exemplo -

Digamos que temos uma interface Animal e uma função makeSound () . Existem duas classes concretas Dog e Cat que implementam essa interface. Essas classes concretas têm implementações separadas da função makeSound (). Agora vamos dizer que temos um animal (obtemos isso de algum módulo externo). Tudo que o usuário sabe é que o objeto que está recebendo é algum Animal e é responsabilidade do usuário imprimir o som do animal. Uma maneira de força bruta é verificar o objeto recebido para identificar seu tipo, depois convertê- lo para esse tipo de animal e chamar makeSound () nele. Mas uma maneira mais pura é abstrair as coisas . Use Animal como um referência polimórficae chame makeSound () nele. Em tempo de execução dependendo do que o tipo de objeto real é a função adequada, será chamado.

Mais detalhes aqui .

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

PS: Os links acima são para o meu blog pessoal.

• Abstração permite que você se concentre no que o objeto faz, e não como ele faz
• Encapsulamento significa ocultar os detalhes internos ou a mecânica de como um objeto faz alguma coisa.

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

Deixe-me dar um exemplo em c #. Suponha que você tenha um número 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 a armazena em um objeto de string. O método informa o que faz, em vez de como faz.

Estes são conceitos um tanto confusos que não são exclusivos da Ciência da Computação e da programação. Gostaria de apresentar algumas idéias adicionais que podem ajudar outras pessoas a entender esses conceitos importantes.

Resposta curta

Encapsulamento - Ocultando e / ou restringindo o acesso a certas partes de um sistema, enquanto expõe as interfaces necessárias.

Abstração - considerando algo com certas características removidas, além de realidades concretas, objetos 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 alguma coisa.

Resposta longa

Encapsulamento

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

Aqui temos um Arduino Uno e um Arduino Uno dentro de um gabinete. Um gabinete é uma ótima representação do significado do 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 ocultar informações através de modificadores de acesso , que alteram a extensão em que determinadas variáveis ​​e / ou propriedades podem ser lidas e gravadas.

Além disso, o encapsulamento também visa fornecer essas interfaces externas com muito mais eficiência. No nosso exemplo do Arduino, isso pode incluir os botões e a tela agradáveis, o que torna 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, isto envolve o agrupamento de vários componentes em um construto separável, tal como um function, classou object. Também inclui fornecer os meios de interação com essas construções, bem como métodos para obter informações úteis sobre elas.

O encapsulamento ajuda os programadores de várias maneiras adicionais, entre as quais a manutenção e o código aprimorados da capacidade de teste.

Abstração

Embora muitas outras respostas aqui definam abstração como generalização, pessoalmente acho que essa definição é equivocada. Eu diria que a generalização é realmente 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:

Você diria que a imagem existe uma árvore? Provavelmente, você faria. Mas é realmente uma árvore? Bem, claro que não! É um monte de pixels feitos para parecer algo que poderíamos chamar de árvore. Poderíamos dizer que representa uma abstração de uma árvore real. Observe que vários detalhes visuais da árvore são omitidos. Além disso, ele não cresce, consome água ou produz oxigênio. Como pôde isso? são apenas várias cores na tela, representadas por bytes na memória do 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 árvore não é mais uma árvore real do que esse jpeg.

Na programação, podemos usar isso para nossa vantagem, criando uma Treeclasse com métodos para cultivo simulado, consumo de água e produção de oxigênio. Nossa criação seria algo que representa nossa experiência com árvores reais e inclui apenas os elementos com os quais realmente nos importamos para nossa simulação em particular. Usamos a abstração como uma maneira 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 em comum entre vários tipos de objetos "concretos" (tipos que realmente existem) e definir esses pontos comuns em uma entidade única. Por exemplo, nossa Treeclasse pode herdar de um abstract class Plant, que possui várias propriedades e métodos aplicáveis ​​a todas as classes de 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 melhorar a capacidade de manutenção.

A diferença prática de um abstract classe simples classé que, conceitualmente, não há instâncias "reais" do abstract class. Não faria sentido construir um Plantobjeto porque isso não é específico o suficiente. Todo "real" Planttambém é um tipo mais específico de Plant.

Além disso, se queremos que nosso programa seja mais realista, podemos considerar o fato de que nossa Treeclasse pode ser abstrata demais. Na realidade, cada Treeé um tipo mais específico de Tree, para que pudéssemos criar classes para esses tipos, tais como Birch, Maple, etc., que herdamos de nossos, talvez agora abstract, Treede classe.

JVM

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

A diferença

O encapsulamento difere da abstração, pois não tem nada a ver com o quão 'real' ou 'precisa' é algo. Não remove componentes de algo para torná-lo mais simples ou mais amplamente aplicável. Em vez disso, pode ocultar certos componentes para atingir um objetivo semelhante.

Encapsulamento : está ocultando detalhes de implementação indesejados / não esperados / propriedade dos usuários reais do objeto. por exemplo

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

Abstração : É uma maneira de fornecer generalização e, portanto, uma maneira comum de trabalhar com objetos 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**

Diferença entre abstração e encapsulamento.

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

Considere uma classe que envia um email ... ela usa a abstração para se mostrar como algum tipo de mensageiro, para que você possa chamar emailSender.send (email, destinatário). O que ele realmente faz - escolhe POP3 / SMTP, chamando servidores, tradução MIME, etc., é abstraído. Você só vê seu mensageiro.

Encapsulamento: a idéia de proteger e ocultar dados e métodos que são particulares a um objeto. Ele trata mais de fazer algo independente e infalível.

Leve-me, por exemplo. Eu encapsulo minha freqüência cardíaca do resto do mundo. Porque não quero que mais ninguém altere essa variável e não preciso que mais ninguém a defina 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 o que toca é um exemplo de abstração e encapsulamento. Seu telefone, por exemplo, apresenta a você a abstração de poder levar o que você diz e diz para outra pessoa - cobrindo GSM, arquitetura de processador, frequências de rádio e um milhão de outras coisas que você não entende ou não gosta. Ele também encapsula certos dados de você, como números de série, números de identificação, frequências etc.

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

Abstração: Somente 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 (essas informações estão ocultas do usuário).

Vamos dar outro exemplo, o do caixa eletrônico. O cliente não precisa saber como a máquina lê o PIN e processa a transação, tudo o que ele precisa fazer é inserir o PIN, pegar o dinheiro e sair.

Encapsulamento: trata de ocultar os dados confidenciais de um clas, privatizando parte dele. É uma maneira de manter algumas informações privadas para seus clientes, não permitindo acesso externo a elas.

Outro exemplo:

Suponha que eu criei uma classe Rectangle imutável como esta:

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 encapsulei a largura e a altura (o acesso é de alguma forma restrito), mas não abstraí nada (ok, talvez eu tenha ignorado onde o retângulo está localizado no espaço das coordenadas, mas essa é uma falha do exemplo).

Uma boa abstração geralmente implica um bom encapsulamento.

Um exemplo de boa abstração é uma classe de conexão de banco de dados genérica. Sua interface pública é independente de banco de dados e é muito simples, mas me permite fazer o que quero com a conexão. E você vê? Também há encapsulamento, porque a classe deve ter todos os identificadores e chamadas de baixo nível dentro.

Abstractione Encapsulationusando um único exemplo generalizado

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

Todos nós usamos a calculadora para calcular problemas complexos!

Um mecanismo que impede que os dados de um determinado objeto estejam protegidos contra uso indevido intencional ou acidental por funções externas é chamado " encapsulamento de dados"

O ato de representar recursos essenciais sem incluir os detalhes ou explicações do plano de fundo é conhecido como abstração

Abstração: Abstração significa mostrar Whatparte da funcionalidade.

Encapsulamento: encapsulamento significa ocultar a Howparte da funcionalidade.

Vamos dar um exemplo muito simples

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

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

Vamos pegar o exemplo de uma pilha. Pode ser implementado usando uma matriz ou uma lista vinculada. Mas as operações suportadas são push e pop.

Agora, a abstração está expondo apenas as interfaces push e pop. A representação subjacente está oculta (é uma matriz ou uma lista vinculada?) E uma interface bem definida é fornecida. Agora, como você garante que nenhum acesso acidental seja feito aos dados abstraídos? É aí que entra o encapsulamento . Por exemplo, as classes em C ++ usam os especificadores de acesso que garantem que o acesso e a modificação acidental sejam impedidos. E também, ao tornar públicas as interfaces mencionadas acima, garante que a única maneira de manipular a pilha é através da interface bem definida. No processo, ele acoplou os dados e o código que pode manipulá-los (não vamos envolver as funções de amigo aqui). Ou seja, o código e os dados são vinculados ou vinculados ou encapsulados.

O encapsulamento está encerrando a complexidade em uma cápsula que é de classe e, portanto, o encapsulamento ... Embora a abstração seja as características de um objeto que se diferencia de outro objeto ...

A abstração pode ser alcançada tornando a classe abstrata com um ou mais métodos abstratos. Que nada mais é do que a característica que deve ser implementada pela classe que a estende. por exemplo, ao inventar / projetar um carro, você define características como o carro deve ter 4 portas, freio, volante etc.… para que qualquer pessoa que use esse design inclua essas características. A implementação não é a cabeça de abstração. Apenas definirá as características que devem ser incluídas.

O encapsulamento é conseguido mantendo os dados e o comportamento em uma cápsula de classe e usando modificadores de acesso como público, privado, protegido, juntamente com herança, agregação ou composição. Então, você só mostra apenas as coisas necessárias, também, na medida em que deseja mostrar. ou seja, público, protegido, amigável e privado ………………. GM decide usar o design 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 classe que estende a classe abstrata acima. Ele diz como a caixa de velocidades deve funcionar, como a quebra deve funcionar, como o volante deve funcionar. Todos os produtos usam apenas essa funcionalidade comum. Eles não precisam saber como a caixa de marchas funciona, a quebra ou o funcionamento da direção.

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

Abstração --- Ocultando Implementação - no Design --- Usando Interface / Resumo calsses

Encapsulamento - Ocultando dados --Em desenvolvimento --- Usando modificadores de acesso (público / privado)

A partir disso

Diferença entre encapsulamento e abstração no OOPS

Abstração e encapsulamento são dois importantes conceitos de Programação Orientada a Objetos (OOPS). Encapsulamento e Abstração são termos inter-relacionados.

Diferença na vida real entre encapsulamento e abstração

Encapsular significa se esconder. O encapsulamento também é chamado de ocultação de dados. Você pode pensar em encapsulamento como uma cápsula (comprimido para medicina) que esconde remédios dentro dela. Encapsulamento é encapsulamento, apenas ocultando propriedades e métodos. O encapsulamento é usado para ocultar o código e os dados em uma única unidade para proteger os dados do exterior. Class é o melhor exemplo de encapsulamento.

Abstração refere-se a mostrar apenas os detalhes necessários para o usuário pretendido. Como o nome sugere, a abstração é a "forma abstrata de qualquer coisa". Usamos abstração em linguagens de programação para criar classe abstrata. A classe abstrata representa uma visão abstrata dos métodos e propriedades da classe.

Diferença de implementação entre encapsulamento e abstração

1. A abstração é implementada usando a interface e a classe abstrata, enquanto o Encapsulation é implementado usando o modificador de acesso privado e protegido.

2. O OOPS utiliza encapsulamento para reforçar a integridade de um tipo (ou seja, para garantir que os dados sejam usados ​​de maneira adequada), impedindo que os programadores acessem os dados de maneira não intencional. Através do encapsulamento, apenas um grupo predeterminado de funções pode acessar os dados. O termo coletivo para tipos de dados e operações (métodos) agrupados com restrições de acesso (público / privado, etc.) é uma classe.

Vou tentar demonstrar o encapsulamento de uma maneira simples. Vamos ver ..

• O agrupamento de dados e funções em uma única unidade (chamada classe) é conhecido como encapsulamento. Encapsulamento que contém e oculta informações sobre um objeto, como estruturas e código de dados internos.

Encapsulamento é -

• Escondendo Complexidade,
• Vinculando Dados e Função,
• Tornando o método complicado privado,
• Tornando a variável da instância privada,
• Ocultando dados e funções desnecessários do usuário final.

Encapsulamento implementa abstração.

E abstração é -

• Mostrando o que é necessário,
• Os dados precisam abstrair do Usuário final,

Vamos ver um exemplo

A imagem abaixo mostra uma GUI de "Detalhes do cliente a serem adicionados em um banco de dados".

Observando a imagem, podemos dizer que precisamos de uma classe de cliente.

Etapa 1: O que minha classe de clientes precisa?

ie

• 2 variáveis ​​para armazenar o Código do Cliente e o Nome do Cliente.

• 1 Função para adicionar o código e o nome do cliente ao banco de dados.

  espaço para nome CustomerContent {public class Customer {public string CustomerCode = ""; public string CustomerName = ""; public void ADD () {// meu código de banco de dados será aqui}

Agora, apenas o método ADD não funcionará aqui sozinho.

Etapa -2: Como funcionará a validação, a função ADD Function?

Vamos precisar do código de conexão com o banco de dados e do código de validação (métodos extras).

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

Agora não há necessidade de mostrar os Métodos Extra (Validate (); CreateDBObject () [Método Complicado e Extra]) para o Usuário Final. O usuário final precisa apenas ver e saber sobre o Código do Cliente, Nome do Cliente e o botão ADICIONAR, o qual ADD o registro .. O Usuário Final não se importa com COMO ADICIONARÁ os Dados no Banco de Dados ?.

Etapa -3: Participe dos métodos extras e complicados que não envolvem a interação do usuário final.

Tornando o método Complicado e Extra como Privado, em vez de Público (ou seja, Ocultando esses métodos) e excluindo o obj.Validate (); obj.CreateDBObject (); do programa principal da classe, alcançamos o encapsulamento.

Em outras palavras, simplificar a interface para o usuário final é encapsulamento.

Então agora o código se parece com abaixo -

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

Resumo:

Etapa -1: O que minha classe de clientes precisa? é abstração.

Etapa -3: Etapa -3: Privado os métodos extras e complicados que não envolvem a interação do usuário final são o encapsulamento.

PS - O código acima é difícil e rápido.

O parágrafo abaixo me ajudou a entender como eles diferem um do outro:

O encapsulamento de dados é um mecanismo de agrupar os dados, e as funções que os utilizam e a abstração de dados são um mecanismo de expor apenas as interfaces e ocultar os detalhes da implementação do usuário.

Você pode ler mais aqui .

A ocultação de informações não é estritamente necessária para abstração ou encapsulamento. As informações podem ser ignoradas, mas não precisam ser ocultadas.

Encapsulamento é a capacidade de tratar algo como uma única coisa, mesmo que possa ser composto de muitas partes ou idéias complexas. Por exemplo, posso dizer que estou sentado em uma "cadeira", em vez de me referir às várias partes da cadeira, cada uma com um design e função específicos, todas encaixadas exatamente com o objetivo de segurar confortavelmente minha bunda a alguns metros longe do chão.

A abstração é ativada pelo encapsulamento. Como encapsulamos objetos, podemos pensar neles como coisas que se relacionam de alguma maneira, em vez de se atolar nos detalhes sutis da estrutura interna de objetos. Abstração é a capacidade de considerar a imagem maior, removida da preocupação com pequenos detalhes. A raiz da palavra é abstrata como no resumo que aparece no topo de um artigo acadêmico, não abstrata como em uma classe que só pode ser instanciada como uma subclasse derivada.

Posso dizer honestamente que, quando coloco minha bunda na minha cadeira, nunca penso em como a estrutura dessa cadeira vai pegar e segurar meu peso. É uma cadeira decente o suficiente para que eu não precise me preocupar com esses detalhes. Para que eu possa voltar minha atenção para o meu computador. E, novamente, não penso nas partes componentes do meu computador. Estou apenas olhando para uma parte de uma página da web que representa uma área de texto que posso digitar e estou me comunicando com palavras, mal pensando em como meus dedos sempre encontram as letras certas tão rapidamente no teclado e como a conexão é finalmente estabelecida entre tocar nessas teclas e postar neste fórum. Este é o grande poder da abstração. Como os níveis mais baixos do sistema podem ser confiáveis ​​para trabalhar com consistência e precisão, temos atenção para poupar mais trabalho.

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

a abstração está ocultando dados não úteis dos usuários e o encapsulamento liga os dados a uma cápsula (uma classe). Eu acho que o encapsulamento é o caminho para alcançarmos a abstração.

O processo de abstração e encapsulamento gera interfaces.

Uma interface gerada via encapsulamento oculta os detalhes da implementação.

Uma interface gerada por abstração se torna aplicável a mais tipos de dados, em comparação com a abstração anterior.

Abstractioné um contrato para a implementação que vamos fazer. A implementação pode sofrer alterações ao longo do período. As várias implementações em si podem ou não estar ocultas, mas estão mascaradas por trás da abstração.

Suponha que definamos tudo APIsde uma classe e interfacedepois solicitamos que os usuários do nosso código dependam do definido APIsdo interface. Somos livres para melhorar ou modificar a implementação, apenas devemos seguir o contrato definido. Os usuários não estão associados à nossa implementação.

EXPOSTAMOS todas as Regras NECESSÁRIAS (métodos) na abstração , a implementação das regras é deixada para as entidades implementadoras, também a implementação não faz parte da abstração. É apenas a assinatura e a declaração que fazem a abstração.

Encapsulationé simplesmente ocultar os detalhes internos, reduzindo o acesso dos estados e comportamentos. Uma classe encapsulada pode ou não ter sido bem definida Abstraction.

java.util.Listé uma abstração para java.util.ArrayList. O estado interno de java.util.ArrayListser marcado com non publicmodificadores de acesso é o encapsulamento.

Editar Suponha que uma classe Container.nava implements IContainer, IContainerpode declarar métodos como addElement, removeElements, contains, etc. Aqui IContainerrepresenta a abstração para sua classe de execução. A abstração está declarando as APIs da classe ou um módulo ou sistema para o mundo externo. Essas APIs se tornam as contract. Esse sistema pode ou não pode ser desenvolvido ainda. Os usuários do sistema agora podem depender das APIs declaradas e têm certeza de que qualquer sistema que implemente esse contrato sempre adira às APIs declaradas, sempre fornecerão uma implementação de tge para essas APIs. Uma vez que estamos escrevendo alguma entidade concreta, a decisão de ocultar nossos estados internos é um encapsulamento

Eu acho que o encapsulamento é uma maneira de implementar a abstração. Dê uma olhada no seguinte link.

Abstração e Encapsulamento

Em resumo

Uso de abstração -> Encapsulamento e uso de encapsulamento -> ocultação de dados

OU

ocultar dados é um subconjunto de Encapsulamento e Encapsulamento é um subconjunto de Abstração

Referência: http://www.tonymarston.co.uk/php-mysql/abstraction.txt