Recentemente, um amigo disse que queria dizer que estava aprendendo Java recentemente. Ele ainda não entendia linguagens de programação orientadas a objetos. Para ajudá -lo a "transformar" mais rápido, escrevi este artigo. Porque do nível de superestrutura. As idéias de todas as linguagens de programação orientadas a objetos são semelhantes, e essas três características são os pilares no pensamento. Em seguida, vou me concentrar em explicar as três principais características do Java.
Uma linguagem de programação orientada a objetos tem três recursos principais: "encapsulamento", "herança" e "polimorfismo".
Pacote
Na programação orientada a objetos, o encapsulamento (encapsulamento) é literalmente o significado da embalagem, o que significa usar tipos de dados abstratos para encapsular dados e operações baseadas em dados, tornando-as uma entidade independente inseparável. De fato, é para encapsular os métodos e dados necessários para que o objeto seja executado no programa para publicar sua interface. Os dados são protegidos dentro do tipo de dados abstratos, ocultando detalhes internos o máximo possível e retendo apenas algumas interfaces externas para fazê -lo entrar em contato com o exterior. Em outras palavras, o usuário não precisa conhecer os detalhes dentro do objeto (é claro, não há como conhecê -lo), mas o objeto pode ser acessado através da interface fornecida pelo objeto para o exterior. Nos termos do leigo, outros objetos anexados a essas interfaces não precisam se preocupar com a implementação do objeto para usar esse objeto. O conceito é "não me diga como você fez isso, apenas faça isso".
Portanto, o encapsulamento privatiza as propriedades de um objeto e fornece alguns métodos de atributos que podem ser acessados pelo mundo exterior. Se não queremos ser acessados pelo mundo exterior, não precisamos fornecer métodos para acessar pelo mundo exterior. Mas se uma classe não fornece métodos para o mundo exterior para acessar, essa classe não tem significado.
Por exemplo, consideramos um objeto como uma casa, e os belos papéis de parede internos, como sofás, TVs, ar condicionados etc., são todos atributos privados da casa, mas se não houver cobertura de parede, não há privacidade! É por causa da parede de bloqueio que não podemos apenas ter nossa própria privacidade, mas também alterar as decorações de interiores à vontade sem afetar os outros. Mas se não houver portas e janelas, qual é o significado de uma caixa preta bem embrulhada? Portanto, outros também podem ver o cenário dentro das portas e janelas. Portanto, portas e janelas são as interfaces deixadas pelo objeto da casa para o mundo exterior acessar.
Geralmente, o modificador privado deve ser adicionado antes do atributo na classe. Em seguida, defina os métodos Getter e Setter. Em seguida, os objetos em nossa função principal não podem mais chamar as propriedades diretamente e só podem ser chamados através dos métodos Getter e Setter.
Três benefícios da embalagem
1. Um bom pacote pode reduzir o acoplamento.
2. A estrutura dentro da classe pode ser modificada livremente.
3. Controle mais preciso dos membros pode ser fornecido.
4. Ocultar informações e implementar detalhes.
Modificador
Primeiro de tudo, você precisa entender o que é um modificador. Modificadores de acesso podem ser usados para modificar o escopo de acesso de atributos e métodos.
No processo orientado a objetos, usamos o controle de permissão para adicionar permissões à classe encapsulada para restringir a manipulação da classe por pessoas de fora, para garantir a segurança dos dados e métodos na classe. Pode -se dizer que uma classe é uma entidade lógica que encapsula atributos e métodos relacionados. Para certas propriedades ou métodos em um objeto, eles podem ser privados e não podem ser acessados pelo mundo exterior. Também pode ser compartilhado e pode ser acessado por qualquer estranho. Dessa maneira, os objetos fornecem diferentes níveis de proteção para dados internos para impedir que partes não relacionadas do programa mudem ou usam acidentalmente partes privadas do objeto incorretamente, fazendo com que erros desnecessários ocorram no programa.
Os modificadores em Java são públicos, protegidos, inadimplentes e privados. Isso mostra o encapsulamento orientado a objetos e devemos tentar o possível para minimizar as permissões, para melhorar a segurança.
Conforme mostrado na figura, representa o escopo de acesso de diferentes modificadores de acesso, como as propriedades ou métodos modificados por privado, que só podem ser acessados ou usados nesta classe. Se nenhum modificador for adicionado, o padrão será padrão e poderá ser acessado e usado por padrão na classe atual e no mesmo pacote.
Acesso a classe de permissões Subclasse outros pacotes
público ∨ ∨ ∨ ∨
proteger ∨ ∨ ∨ ×
padrão ∨ ∨ × ×
Privado ∨ × × ×
Se nenhum modificador for adicionado antes do atributo, a permissão padrão será padrão. Podemos modificar diretamente o valor do atributo criando um objeto e as características de encapsulamento não são refletidas. Isso não é seguro na programação; portanto, precisamos usar o encapsulamento para melhorar nosso código.
Exemplo de modificadores
Primeiro, definimos quatro aulas, pai, professora, aluno e comparamos as diferenças entre outros pacotes, subclasses, pacotes e esta aula. O diagrama de localização de cada classe é mostrado.
pacote com.java.test; public class Pessoa {public string name = "zhang san"; public void IntroduCemySelf () {System.out.println (nome); }}O nome é público. Se não houver erro na compilação, isso significa que a variável pública tem acesso a esta classe.
pacote com.java.test; public class Student {Pessoa P = new Person (); public void test () {System.out.println (p.Uname); }}Estudante e pessoa estão no mesmo pacote. Se não houver erro na compilação, isso significa que a variável possui direitos de acesso no mesmo pacote.
pacote com.java.test1; importar com.java.test.person; professor de classe pública estende a pessoa {public int Age; Pessoa p = nova pessoa (); public void test1 () {System.out.println (p.Uname); }}Estudante e pessoa não estão no mesmo pacote, mas o professor herda a aula de pessoa. Se não houver erro na compilação, isso significa que a variável possui direitos de acesso na subpackagem.
pacote com.java.test1; import com.java.test.person; public class Pais {public string uname = "haha"; Pessoa p = nova pessoa (); public void test2 () {System.out.println (p.Uname); }}Pai e pessoa não estão no mesmo pacote. Se não houver erro na compilação, isso significa que a variável não possui permissões de acesso.
Após o teste acima, se todos eles puderem ser compilados e passados, isso significa que as classes modificadas com o público podem se acessar nesta classe, na mesma embalagem, subclasse e outros pacotes.
Também começamos a testar o problema de permissão protegido. Se a pessoa, o professor e o aluno puderem compilar e passar, isso significa que as aulas modificadas com protegidas podem se acessar nesta classe, na mesma embalagem e subclasses. Se os pais não compilarem e não passarem, significa que protegidos não podem se acessar em classes sem relacionamentos de herança fora do pacote.
Comece também a testar o problema de permissão padrão. Se a pessoa e o aluno puderem compilar e passar, isso significa que as classes modificadas com o padrão podem acessar uns aos outros nesta classe, no mesmo pacote e subclasses. Os pais e os professores compilam sem passar a aula de pais e professores não podem se acessar, independentemente de haver um relacionamento de herança.
Também começamos a testar o problema de permissão privada. Se a pessoa puder ser compilada e passada, isso significa que as classes modificadas com privado podem acessar uns aos outros nesta classe, no mesmo pacote e subclasses. Pai, professor e aluno não podem compilar sem passar o privado para indicar que as aulas modificadas com privado só podem ser acessadas nesta classe.
Geralmente, modificadores privados devem ser adicionados antes dos atributos da classe. Em seguida, defina os métodos Getter e Setter. Em seguida, os objetos em nossa função principal não podem mais chamar as propriedades diretamente e só podem ser chamados através dos métodos Getter e Setter.
Bolsa
Deixe -me dizer a função da bolsa
Às vezes, quando você encontra o nome da classe do programa pode ser duplicado, podemos usar o conceito de pacote para resolver nosso problema. O objetivo do pacote é gerenciar arquivos Java e resolver conflitos de arquivos com o mesmo nome. Isso é semelhante a um guarda -roupa. Temos partições e gavetas diferentes no guarda -roupa? Colocamos as roupas separadamente em diferentes categorias, o que é mais propício à nossa administração.
Para definir um pacote, usamos a palavra -chave do pacote, além do nome do nosso pacote.
pacote com.java.test; // Nota: Ele deve ser colocado na primeira linha do programa de origem, e o nome do pacote pode ser separado pelo "." sinal. A especificação de nomenclatura do pacote é escrita com todas as letras minúsculas.
Pacotes comumente usados no sistema Java
Java. (Função). (Classe) Java.lang. (Classe) contém o básico da linguagem java java.util. (Classe) contém várias classes de ferramentas no idioma java.io (classe) contém classes de entrada e saída
Para usar a classe em outro arquivo em pacotes diferentes, você precisa usar a palavra -chave import. Por exemplo, importar com.java.test1.test.java. Ao mesmo tempo, se importar com.java.test1*, importe todos os arquivos no pacote.
essa palavra -chave
1. Existem três aplicações principais dessa palavra -chave:
(1) Isso chama os atributos nesta classe, ou seja, as variáveis de membro da classe;
(2) isso chama outros métodos nesta classe;
(3) Isso chama outros construtores nesta classe e deve ser colocado na primeira linha do construtor ao ligar.
Public class Student {public student (nome da string) {// Defina um construtor com parâmetros formais} public student () {// define um método, o nome é o mesmo que a classe, por isso é o construtor que ("olá!"); } Nome da string; // Defina um nome de variável de membro private void setName (nome da string) {// define um parâmetro (variável local) nome this.name = name; // Passe o valor da variável local para a variável de membro}}Como no código acima, há um nome de variável de membro e há um parâmetro formal no método, e o nome também é o nome. Em seguida, o valor do nome do parâmetro formal é passado para o nome da variável do membro no método.
A palavra -chave Isso representa variáveis ou métodos de membro no objeto. Ou seja, se uma variável for adicionada com essa palavra -chave, ela se refere à variável ou método do objeto, em vez dos parâmetros formais ou variáveis locais do método do membro. Por esse motivo, no código acima, este.name representa a variável de membro no objeto, também conhecida como propriedades do objeto, e o nome seguido é o parâmetro formal do método. O código this.name = nome é passar o valor do parâmetro formal para a variável do membro.
Se houver vários construtores em uma classe porque seus nomes são iguais e iguais ao nome da classe, qual construtor isso é chamado? De fato, é o mesmo que usar outros métodos para se referir aos construtores e eles são chamados por meio de parâmetros formais. Como no exemplo acima, se um parâmetro for adicionado após essa palavra -chave, isso significa que ela se refere a um construtor com parâmetros. Se agora houver três métodos de construção, ou seja, sem parâmetros, um parâmetro e dois parâmetros. Em seguida, o compilador Java determinará qual construtor chama com base no número de parâmetros passados. Como pode ser visto no exemplo acima, essa palavra -chave pode ser usada não apenas para fazer referência a variáveis de membros, mas também para referenciar construtores.
Classe interna
A classe interna é muito fácil de entender do lado de fora. Classe interna é colocar a definição de uma classe dentro da definição de outra classe. Obviamente, correspondendo a isso, uma classe que contém uma classe interna é chamada de classe externa.
Muitos iniciantes definitivamente perguntarão por que uma aula deve ser definida em outra classe?
Às vezes, existem alguns problemas em nossa programação difíceis de resolver usando interfaces. No momento, podemos usar a capacidade fornecida por classes internas de herdar várias classes concretas ou abstratas para resolver esses problemas de programação. Pode -se dizer que as interfaces resolvem apenas alguns problemas, enquanto as classes internas tornam a solução de herança múltipla mais completa.
Há uma frase em "Think in java": a razão mais atraente para o uso de classes internas é que cada classe interna pode herdar independentemente uma implementação (interface) de forma independente; portanto, se a classe periférica herdou uma certa implementação (interface) não tem efeito na classe interna.
interface pública Pai {} interface pública mãe {} public class filho implementa pai, mãe {} classe pública implementa o pai {classe mãe_ implementa a mãe {}}Recursos de classe interna
1. A classe interna pode usar várias instâncias, cada instância possui suas próprias informações de estado e é independente de outras informações de objeto periférico.
2. Em uma única classe periférica, várias classes internas podem implementar a mesma interface de maneiras diferentes ou herdar a mesma classe.
3. O momento em que a criação de um objeto de classe interna não depende da criação de objetos de classe periférica.
4. Não há relacionamento confuso "IS-A" na classe interna, é uma entidade independente.
5. A classe interna fornece melhor encapsulamento e outras classes não podem ser acessadas, exceto a classe periférica.
pacote com.java.test; public class OuterClass {private String Name; private Int Age; public String getName () {Return Name; } public void setName (nome da string) {this.name = name; } public int getage () {Age de retorno; } public void setage (int Age) {this.age = Age; } public void Display () {System.out.println ("A exibição do OuterClass é chamada"); } classe pública InnerClass {public innerClass () {name = "chenssy"; idade = 23; } public OuterClass getouterClass () {return OuterClass.This; } public void Display () {System.out.println ("Nome:" + getName () + "; Age:" + getage ()); }} public static void main (string [] args) {OuterClass OuterClass = new OuterClass (); ExterClass.innerClass Innerclass = OuterClass.New InnerClass (); inerclass.display (); inerclass.getouterclass (). Display (); }} nome: chenssy; idade: 23A exibição da OuterClass é chamada
Precisamos deixar claro que as classes internas são um conceito de tempo de compilação. Uma vez compilados com sucesso, eles pertencem a duas classes completamente diferentes de classes periféricas (é claro que ainda estão relacionadas).
Também vemos como fazer referência a classe interna: Referindo -se à classe interna, precisamos especificar o tipo desse objeto: OuterclasName.innerclassName. Ao mesmo tempo, se precisarmos criar um objeto de classe interna, devemos usar o objeto de classe externa para criar uma classe interna através do .New: Outerclass.innerclass inerclass = Outerclass.new inerclass ();.
Ao mesmo tempo, se precisarmos gerar uma referência ao objeto de classe externa, podemos usar o OuterClassName.Este, para que possamos gerar uma referência à classe externa corretamente.
Em Java, as classes internas são divididas principalmente em classes internas de membros, classes internas locais, classes internas anônimas e classes internas estáticas.
Classe interna do membro
A classe interna do membro também é a classe interna mais comum. É um membro da classe periférica, para que possa acessar todos os atributos e métodos da classe periférica sem limitação. Embora seja privado, se a classe periférica desejar acessar os atributos e métodos do membro da classe interna, ele precisará acessar através da instância da classe interna.
Dois pontos devem receber atenção na classe interna dos membros.
Não pode haver variáveis e métodos estáticos na classe interna do membro;
As classes internas do membro são anexadas às classes periféricas, para que as classes internas possam ser criadas apenas se as classes periféricas forem criadas primeiro.
public class OuterClass {private String str; public void OuterDisplay () {System.out.println ("OuterClass ..."); } classe pública InnerClass {public void innerDisplay () {// Use o atributo str no periférico str = "chenssy ..."; System.out.println (str); // Use o método OuterDisplay (); }} /*Recomendado para usar getxxx () para obter classes internas do membro, especialmente quando o construtor da classe interna não tem parâmetros* / public inerclass getinnerclass () {return new innerClass (); } public static void main (string [] args) {Outerclass Outer = new OuterClass (); OuterClass.innerclass interno = Outer.getInnerClass (); interno.innerDisplay (); }}Pessoalmente, recomendo usar getxxx () para obter a classe interna do membro, especialmente quando o construtor desta classe interna não tem parâmetros.
Sentença de classe interna local
As classes internas locais são aninhadas dentro de métodos e escopos. O uso desta classe é principalmente para aplicar e resolver problemas relativamente complexos. Eu quero criar uma classe para ajudar nossa solução. Naquela época, não quero que essa classe seja pública, para que possamos criar classes internas locais.
As classes internas locais são compiladas como as classes internas de membros. Eles só podem ser usados neste método e atributo. Se eles não estiverem nesse método e atributo, serão inválidos.
Definido no método:
classe pública Parcel5 {Public Destionation Destination (String str) {classe PDestionation implementa Destion {Private String Label; private pDestion (string whereto) {etiqueta = whereto; } public string readLabel () {return Label; }} retorna o novo PDestion (STR); } public static void main (string [] args) {parcel5 parcel5 = new parcel5 (); Destion D = Parcel5.Destionation ("Chenssy"); }}Definido no escopo:
classe pública parcel6 {private void internaltracking (boolean b) {if (b) {class rastretingslip {private string id; Rastrearslip (strings s) {id = s; } String getsLip () {return id; }} Rastreingslip ts = new rastretingslip ("chenssy"); String string = ts.getslip (); }} public void Track () {internalTracking (true); } public static void main (string [] args) {parcel6 parcel6 = new parcel6 (); parcel6.track (); }}Classe interna anônima
public class OUTERCLASS {public InnerClass getinnerClass (final int num, string str2) {return new innerClass () {int number = num + 3; public int getNumber () {Número de retorno; }}; / * Nota: os semicolons não podem salvar */} public static void main (string [] args) {OuterClass out = new OutterClass (); Interno interno = out.getinnerclass (2, "chenssy"); System.out.println (Inner.getNumber ()); }} interface inerclass {int getNumber ();}1. Classes internas anônimas não têm modificadores de acesso.
2. Nova classe interna anônima, esta classe deve existir primeiro. Se comentarmos que a interface da Innerclass, ocorrerá um erro de compilação.
3. Preste atenção aos parâmetros formais do método getinnerClass (). O primeiro parâmetro formal é modificado com o final, enquanto o segundo não. Ao mesmo tempo, também descobrimos que o segundo parâmetro formal não foi usado na classe interna anônima; portanto, quando o parâmetro formal do método precisa ser usado pela classe interna anônima, esse parâmetro formal deve ser final.
4. Não há construtor para classes internas anônimas. Porque nem sequer tem um nome para construí -lo.
Classe interna estática
A estática pode modificar variáveis, métodos, blocos de código e outras classes internas. Chamamos as classes internas modificadas com estática como estática, mas preferimos chamá -los de classes internas aninhadas. A maior diferença entre classes internas estáticas e classes internas não estáticas é que, após a conclusão da compilação, uma referência será oculta e o uso apontará para sua periferia. Mas a classe interna estática não, o que significa que a criação estática da classe interna não precisa confiar em classes periféricas e não pode usar variáveis e métodos não estáticos de membros de qualquer classe periférica.
classe pública OuterClass {Private String Sex; public static string name = "chenssy"; / ***classe interna estática*/ classe estática inerclass1 {/*Membros estáticos pode existir na classe interna estática*/ public static string _name1 = "chenssy_static"; public void Display () { /** A classe interna estática pode acessar apenas variáveis estáticas de membros e métodos de classe periférica* não podem acessar variáveis não estáticas e métodos de classe periférica* / System.out.println ("Nome outclass:" + nome); }} /** / * Qualquer membro da classe periférica pode ser chamado em classes internas não estáticas, seja estática ou não estática */ public void Display () {System.out.println ("Nome do OuterClass:" + Nome); }} /** * @DESC Método da classe periférica * @Author chenssy * @data 2013-10-25 * @return void * /public void Display () { / * classe periférica acessa a classe interna estática: classe interna. */ System.out.println (InnerClass1._Name1); /* Uma classe interna estática pode ser criada diretamente sem depender de classes periféricas*/ new InnerClass1 (). Display (); /* Uma criação interna não estática precisa confiar nas classes periféricas*/ OuterClass.innerClass2 Inner2 = new OuterClass (). New InnerClass2 (); /* Os membros da classe interna não estática precisam usar instâncias de classe interna não estática*/ System.out.println (Inner2._name2); iner2.display (); } public static void main (string [] args) {Outerclass Outer = new OuterClass (); Exter.Display (); }}Resumir
O exposto acima é o resumo dos três principais recursos de Java - conhecimento encapsulado que o editor apresentou a você. Espero que seja útil para você. Se você tiver alguma dúvida, deixe -me uma mensagem e o editor responderá a você a tempo. Muito obrigado pelo seu apoio ao site wulin.com!