Final--
Final é usado para indicar que a classe não pode derivar subclasses.
Final é usado para indicar que o método não pode ser reescrito por uma subclasse.
Final é usado para representar constantes quando variáveis, semelhantes à palavra -chave const em C/C ++.
Final é usado para variáveis de membro para indicar que a variável de membro é uma constante e não pode ser modificada.
Final é usado para indicar que a variável local é uma constante e não pode ser modificada.
estático---
A estática é usada para indicar que existe apenas uma cópia da variável, ou seja, a variável estática pertence à classe, mas não a um objeto de instância de classe específico. Variável de membro, o nome da classe correspondente é concluído. As variáveis estáticas podem ser inicializadas quando definidas ou não.
A estática é usada para métodos, para que os métodos estáticos possam ser chamados por meio de nomes de classe sem instanciar a classe. referenciado.
A estática é usada para classes, que se refere à classe interna aqui, para que você possa se referir a esta classe interna estática através do nome da classe externa em outro lugar.
O estático também pode ser usado para blocos de código de classe, chamados de código estático A JVM carrega a classe, ele executará esses blocos de código estático.
Permissões de acesso aulas (S/N)
||
|
|
|
|
As três palavras -chave públicas, protegidas e privadas podem ser usadas para classes (classes internas), variáveis de membro e funções de membro. Funções, selecione a menor permissão de acesso.
interface/implementos/estends/classe - -
A interface é usada para declarar a interface.
Os implementos são usados para implementar interfaces e todos os métodos na interface são necessários para implementar várias interfaces ao mesmo tempo.
estends é usado para herdar a classe pai ou interface dos pais.
A classe é usada para declarar as classes de acesso.
resumo-
O resumo é usado para representar que esta classe é uma classe abstrata e não pode ser instanciada.
O resumo é usado para representar que esse método é um método abstrato.
Vamos nos concentrar no uso disso e super:
Esse
A palavra -chave Java, que só pode ser usada no corpo do método. Quando um objeto é criado, a Java Virtual Machine (JVM) atribui um ponteiro ao objeto que se refere a si mesmo, e o nome desse ponteiro é esse. Portanto, isso só pode ser usado em métodos não estáticos na classe. E isso está associado apenas a objetos específicos, não a classes, e diferentes objetos da mesma classe têm isso diferente. Aqui está um exemplo abrangente usando isso para ilustrar o problema:
pacote org.leizhimin; classe pública Test6 {Número privado; = n; ". this.Username = nome de usuário; this. Senha = senha;} // O construtor padrão sem parâmetros public test6 () {this (0," desconhecido "," vazio "); // chama outro construtor por meio deste teste público. (Nome da string) {this (1, nome, "vazio"); Convidado "); t1.outinfo (t1); t2.outinfo (t2);} private void outinfo (test6 t) {System.out.println (" ------------------ -"); system.out.println (t.number); System.out.println (t.UserName); System.out.println (t.password); f (); // Isso pode ser escrito como: this.f ();} vazio privado F () {// As variáveis locais têm o mesmo nome que as variáveis de membro, e a variável de membro é bloqueada e a variável de membro é acessada na forma de "this x;
Os resultados da operação são os seguintes:
-------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- ------
Olhando para o exemplo acima, explicaremos em que circunstâncias isso é necessário:
Primeiro, chame outro construtor por meio disso, e o uso é esta (lista de parâmetros).
Segundo, quando os parâmetros de função ou variáveis locais na função têm o mesmo nome da variável do membro, a variável do membro é bloqueada. Referência à variável do membro. Obviamente, sem o mesmo nome, você pode usar o nome da variável do membro diretamente em vez disso, não é errado usá -lo, haha.
Terceiro, na função, quando você precisa se referir ao objeto atual da classe à qual a função pertence, use -a diretamente.
De fato, esses resumos de uso são todos derivados de uma compreensão mais profunda da frase "Este é um ponteiro para o próprio objeto".
super
A chave para super é semelhante a isso, que é que a variável de membro bloqueada ou o método do membro se torna visível ou é usado para se referir à variável de membro bloqueada e ao método do membro do membro.
No entanto, o Super é usado em subclasses, com o objetivo de acessar os membros bloqueados na classe de pai direto. A seguir, é apresentado um exemplo de Super Super, com duas classes: uma aula de pai e uma subclasse do filho da classe Pai.
pacote org.Leizhimin; Pai Pai Pai {public String v = "Pai"; é chamado! ");} Pai público (String v) {this.v =" Método de construtor de parâmetros da classe Pai! ); ; na frente do corpo do construtor. Void Outinfo () {System.out.println ("Método do SON é chamado"); System.out.println ("---------"); (Subclass) Variável V System.out.println (Super.V); println (x); -"); outinfo (); // chamando o método outinfo () da subclasse this.outinfo (); // chamando o método outinfo () super.outinfo (); // chamando o método outinfo () do método do classe pai} public static void main (string [] args) {new SON (). Test ();
Resultados da execução do filho da subclasse:
O construtor do pai é chamado! -------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- x !!! A variável de membro público da classe de paternidade X !!! --------------------------------- -------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- -------------------------------------------------------- --------