Classes anônimas são classes que não podem ter nomes, portanto não há como referenciá-las. Eles devem ser declarados como parte da nova declaração no momento da criação. Isso requer outra forma de instrução new, como segue: new <class ou interface> <corpo da classe> Esta forma de instrução new declara uma nova classe anônima que estende uma determinada classe ou implementa uma determinada interface. Também cria uma nova instância dessa classe e a retorna como resultado da instrução. A classe a ser estendida e a interface a ser implementada são os operandos da nova instrução, seguidos pelo corpo da classe anônima. Se uma classe anônima estende outra classe, seu corpo pode acessar os membros da classe, substituir seus métodos, etc., assim como qualquer outra classe padrão. Se uma classe anônima implementa uma interface, seu corpo deve implementar os métodos da interface.
código java
Copie o código do código da seguinte forma:
interface pr
{
void print1();
}
classe pública noNameClass
{
destino público()
{
retornar novo pr(){
impressão de vazio público1()
{
System.out.println("Olá mundo!!");
}
};
}
público estático void principal(String args[])
{
noNameClass c = new noNameClass();
pr hw=c.dest();
print1();
}
}
PR também pode ser uma classe, mas o método que você chama externamente deve ser declarado em sua classe ou interface. Os métodos dentro da classe anônima não podem ser chamados de fora.
Talvez o local mais comumente usado para classes anônimas internas em Java seja adicionar Listner ao Frame.
do seguinte modo:
código java
Copie o código do código da seguinte forma:
importar java.awt.*;
importar java.awt.event.*;
classe pública QFrame estende Frame {
QFrame público() {
this.setTitle(/"meu aplicativo/");
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
dispor();
Sistema.exit(0);
}
});
this.setBounds(10,10,200,200);
}
}
Uma classe interna anônima serve para criar uma classe interna, mas não dá um nome, ou seja, não existe uma variável que se refira à instância.
Copie o código do código da seguinte forma:
novo WindowAdapter() {
public void windowClosing(WindowEvent e) {
dispor();
Sistema.exit(0);
}
}
new é criar um objeto WindowAdapter, e o seguinte {} indica que a operação entre colchetes atua no nome do objeto padrão, e o seguinte no programa Java acima é um corpo de função.
O objetivo deste uso é criar uma instância de um objeto e substituir uma de suas funções. Você pode encontrá-lo abrindo o código do WindowAdapter. É uma classe abstrata. É uma implementação da interface WindowListener. O parâmetro de Frame.addWindowListner(); é um WindowListner e a implementação é passar uma classe anônima derivada de WindowAdapter.
1. Como determinar a existência de uma classe anônima? Não consigo ver o nome, parece que é apenas um objeto criado por new da classe pai e não há nome para a classe anônima.
Vejamos primeiro o pseudocódigo
Copie o código do código da seguinte forma:
classe abstrata Pai(){
....
}
Teste de classe pública{
Father f1 = new Father(){ .... } //Há uma classe interna anônima aqui
}
De modo geral, quando novo um objeto, deve haver ponto e vírgula após os parênteses, ou seja, termina a declaração do novo objeto.
Mas é diferente quando existem classes internas anônimas. Os parênteses são seguidos por colchetes e os colchetes contêm o método de implementação específico do novo objeto.
Porque sabemos que uma classe abstrata não pode ser nova diretamente. Deve haver uma classe de implementação antes que possamos atualizar sua classe de implementação.
O pseudocódigo acima indica que new é a classe de implementação do Pai, e esta classe de implementação é uma classe interna anônima.
Na verdade, dividir a classe interna anônima acima pode ser
Copie o código do código da seguinte forma:
classe SonOne estende Pai{
...//O código aqui é o mesmo da classe interna anônima acima, o código entre colchetes
}
Teste de classe pública{
Pai f1 = new SonOne();
}
2. Precauções para classes internas anônimas Observe que a declaração de classes anônimas é feita em tempo de compilação e a instanciação é feita em tempo de execução. Isso significa que uma nova instrução em um loop for criará diversas instâncias da mesma classe anônima, em vez de criar uma instância de diversas classes anônimas diferentes.
Ao usar classes internas anônimas, tenha em mente os seguintes princípios:
・Classes internas anônimas não podem ter construtores.
・Classes internas anônimas não podem definir membros, métodos e classes estáticos.
・Classes internas anônimas não podem ser públicas, protegidas, privadas ou estáticas.
・Apenas uma instância de uma classe interna anônima pode ser criada.
・Uma classe interna anônima deve estar atrás de new e é usada para implementar implicitamente uma interface ou implementar uma classe.
・Como as classes internas anônimas são classes internas locais, todas as restrições às classes internas locais têm efeito sobre elas.
・As classes internas só podem acessar variáveis estáticas ou métodos estáticos de classes externas.
isso em classes anônimas e classes internas:
Às vezes, usaremos algumas classes internas e classes anônimas. Ao usar this em uma classe anônima, this se refere à classe anônima ou à própria classe interna. Neste momento, se quisermos usar os métodos e variáveis da classe externa, devemos adicionar o nome da classe externa
3. O papel das classes internas anônimas
As classes internas de Java são fundamentalmente diferentes das classes aninhadas em C++: as classes aninhadas de C++ não possuem identificadores para classes wrapper. Ele expressa apenas o conceito de encapsulamento, mas a classe interna do Java é diferente, ela pode acessar os membros da classe de encapsulamento (o que significa que possui um identificador para a classe de encapsulamento).
Classes internas anônimas são uma maneira simplificada de escrever classes internas: return new Wrapper {
...
};
Equivalente a: Wrapped estende Wrapper {
...
}
retornar novo Embrulhado();
Este é o único papel das classes internas anônimas?
Considere este caso:
Copie o código do código da seguinte forma:
interface ICount {
contagem int();
}
classe Pai {
int eu = 0;
contagem int() {
retornar i++;
}
}
Existe uma classe Child, que não apenas deseja herdar o método count() de Parent, mas também deseja implementar o método count na interface ICount. O que devo fazer neste momento? As classes internas podem entrar em jogo:
Copie o código do código da seguinte forma:
class Filho estende Pai {
ICount getCount() {
retornar novo ICont {
int eu = 0;
contagem int() {
retornar (eu *= 2);
}
}
}
}
olha esse código
Copie o código do código da seguinte forma:
public static void main(String[] args) {
theApp = new Analisador();
SwingUtilities.invokeLater(new Runnable() { // Classe Runnable anônima
// objeto
public void run() { // Método de execução executado na thread
theApp.creatGUI(); // Chama o criador da GUI estática
}
});
}
public static void main(String[] args) {
theApp = new Analisador(); // Cria um objeto
SwingUtilities.invokeLater(new Runnable() { // Classe Runnable anônima
// Uma classe interna anônima que implementa um thread
// Originalmente este método deveria passar um parâmetro do tipo Runnable // Isto pode ser conseguido através deste método de classe anônimo
// objeto
public void run() { // Método de execução executado na thread
theApp.creatGUI(); // Chama o criador da GUI estática
}
});
}
