Para resumir o conteúdo anterior, objeto refere-se a uma determinada coisa e classe refere-se ao tipo de objeto. Os objetos podem ter estados e ações, ou seja, membros de dados e métodos.
Até agora, os membros e métodos de dados estavam abertos a usuários internos e externos. Dentro do objeto, usamos this para chamar os membros de dados e métodos do objeto. Fora do objeto, por exemplo, quando chamamos o objeto em outra classe, podemos usar membros object.data e object.method() para chamar os membros de dados e métodos do objeto.
Vamos encapsular os membros do objeto (os membros incluem membros de dados e métodos), permitindo assim que apenas alguns membros sejam chamados de fora. Usando o encapsulamento, podemos melhorar a facilidade de uso e a segurança dos objetos.
Encapsulamento e interface
Encapsulamento é um termo comum para computadores, o que significa manter uma interface externa limitada e ocultar detalhes específicos de implementação. Por exemplo, na arquitetura Linux, você pode ver que o sistema operacional Linux encapsula os detalhes específicos do hardware subjacente, mantendo apenas a interface de chamada do sistema. O usuário está fora do pacote e só pode realizar as operações necessárias por meio da interface.
O encapsulamento é muito comum na vida. Por exemplo, aqui está uma lanterna recarregável:
Mesmo sem ler o manual, o usuário pode adivinhar o funcionamento desta lanterna: troca e carregamento. Essa lanterna utiliza um invólucro de plástico para ocultar os detalhes internos que o usuário não precisa tocar, restando apenas duas interfaces, o interruptor e o plugue elétrico. Usando essas duas interfaces, basta que os usuários utilizem as funções que o produto foi projetado para alcançar. Se todos os detalhes forem expostos ao usuário ao mesmo tempo, o usuário se sentirá sobrecarregado pelo produto (como o controle remoto sem casca abaixo). Portanto, o encapsulamento melhora a facilidade de uso do produto.
Se o produto não estiver embalado, muitos detalhes da lanterna ou controle remoto ficarão expostos ao usuário: bateria, circuito, borracha selada, etc. Embora isso permita aos usuários operar o produto com mais liberdade, como descarregar diretamente a bateria, retirar uma luz LED, etc. No entanto, os utilizadores correm frequentemente um risco maior de danificar o produto. Portanto, o encapsulamento melhora a segurança do produto.
Um produto de software Java é igual a um produto de uso diário. Um objeto pode ter muitos membros (membros de dados e métodos) dentro dele. Alguns membros de dados e métodos são usados apenas internamente. Neste momento, esperamos ter um mecanismo para "empacotar" o objeto e encapsular o objeto. Dessa forma, os usuários podem aprender e usar interfaces externas com mais facilidade, sem precisar entrar em contato com membros internos.
Encapsulamento de membros de objeto
Java usa três palavras-chave para controlar a visibilidade externa dos membros de um objeto: público, privado, protegido.
1.public: O membro é visível externamente, ou seja, o membro faz parte da interface
2.privado: Este membro não é visível externamente e só pode ser usado internamente e não pode ser acessado externamente.
(protegido envolve o conceito de herança, que será discutido mais adiante)
Vamos primeiro encapsular a classe Human definida anteriormente:
Copie o código do código da seguinte forma:
Teste de classe pública
{
público estático void principal(String[] args)
{
Humano aPerson = novo Humano(160);
System.out.println(aPerson.getHeight());
aPerson.growHeight(170);
System.out.println(aPerson.getHeight());
aPerson.repeatBreath(100);
}
}
classeHumano
{
/**
* construtor
*/
humano público (int h)
{
esta.altura = h;
System.out.println("Eu nasci");
}
/**
*acessador
*/
público int getHeight()
{
retorne esta altura;
}
/**
* mutador
*/
public void growHeight(int h)
{
esta.altura = esta.altura + h;
}
/**
* encapsulado, para uso interno
*/
respiração vazia privada()
{
System.out.println("hu...hu...");
}
/**
*chame respiração()
*/
public void repetirBreath(int rep)
{
int eu;
for(i = 0; i < rep; i++) {
this.respiração();
}
}
private int height; // encapsulado, para uso interno
}
Os métodos internos não são afetados pelo encapsulamento. Os métodos internos do ser humano podem chamar qualquer membro, até mesmo altura e respiração() definidas como privadas
Os métodos externos só podem chamar membros públicos. Quando estamos fora de Human, como em Test, só podemos chamar membros especificados como públicos em Human, mas não membros especificados como privados.
Através do encapsulamento, a classe Human retém apenas os seguintes métodos como interfaces:
1.getAltura()
2. crescerAltura()
3.repBreath()
Podemos representar a classe Human e sua interface da seguinte forma:
"Controle remoto com estojo"
Se forçarmos a altura da chamada do principal:
Copie o código do código da seguinte forma:
System.out.println(aPerson.height);
Haverá a seguinte mensagem de erro:
Copie o código do código da seguinte forma:
Test.java:6: height tem acesso privado em Humano
System.out.println(aPerson.height);
^
1 erro
Bip, você levou um choque elétrico! Um membro declarado como privado não pode ser chamado externamente.
Na especificação usual do Java, os membros de dados que expressam estado (como altura) são definidos como privados. As modificações nos membros dos dados devem ser realizadas por meio dos métodos fornecidos pela interface (como getHeight() e growHeight()). Esta especificação desempenha um papel na proteção de dados. Os usuários não podem modificar dados diretamente e devem usar métodos correspondentes para ler e gravar dados. Os designers de classe podem adicionar especificações de uso de dados aos métodos de interface.
encapsulamento de classe
Em um arquivo .java, existe e só pode haver uma classe com a palavra-chave public, como a classe Test acima. Então, de qualquer outra classe, podemos chamar essa classe diretamente. A classe humana não tem palavra-chave. Anteriormente, os membros de nossos objetos não tinham palavras-chave. Essa falta de palavras-chave também representa uma espécie de visibilidade, que irei aprofundar ao explicar os pacotes.
Pratique encapsular uma classe Torch para representar uma lanterna. A interface possui comutação e carregamento. Os membros internos têm poder.
Resumir
encapsulamento, interface
privado, público