Classes An�nimas e Aninhadas em Java

Neste artigo veremos dois assuntos que est�o intimamente ligados e podem ser usados em conjunto: Classes Aninhadas e Classes An�nimas. Veremos teoria e pr�tica de ambos os conceitos, assim como o uso de ambos de forma conjunta.

Classes Aninhadas

Iremos iniciar nosso artigo com as classes aninhadas, em teoria e pr�tica. A palavra �aninhadas� em programaç�o diz respeito que � uma subrotina encapsulada noutra. O escopo da subrotina aninhada � limitado a subrotina que a encapsula. Isso significa que ela pode ser chamada somente pela subrotina que a encapsula, ou pelas subrotinas diretamente ou indiretamente aninhadas pela mesma subrotina encapsuladora. O aninhamento � teoricamente ilimitado, ainda que na pr�tica somente alguns n�veis s�o aceitos, o que depende da implementaç�o.

O trecho acima cita um conceito gen�rico de subrotinas aninhadas no contexto de desenvolvimento de software. Podemos usar esse mesmo conceito e aplicar a classes em Java, ou seja, as Classes Aninhadas s�o classes que est�o dentro de outra classe, ou do ingl�s Nested Classes. Um classe pode ter uma ou v�rias classes aninhadas, e uma classe aninhada pode ter uma ou v�rias outras classes aninhadas e assim por diante.

Vejamos um exemplo de classe aninhada na Listagem 1.

Listagem 1. Nested Class Java


   
  public class EnclosingClass {
  . . .
   public class NestedClass {
   . . .
   
   }
  }

Temos a classe externa chamada �EclosingClass� e a classe aninhada chamada �NestedClass�. Elas s�o muito �teis quando a classe aninhada est� ligada diretamente a classe externa e n�o h� necessidade de criar uma classe externa j� que ela n�o ser� utilizada em mais nenhum local, mas deve-se tomar cuidado com este recurso j� que quando utilizado em demasia pode tornar o c�digo bagunçado e de dif�cil manutenç�o.

Classes Aninhadas s�o dividas em quatro categorias: Est�tica, N�o-Est�tica (Interna Comum), Interna a um m�todo e Interna An�nima. Vejamos a Listagem 2.

Listagem 2. Static e Non-Static


  class OuterClass {
      ...
      static class StaticNestedClass {
          ...
      }
      class InnerClass {
          ...
      }
  }

Classes Aninhadas n�o est�ticas tem acesso a membros privados da classe que a tem (classe externa), enquanto que classes aninhadas est�ticas n�o tem acesso aos membros da classe externa. Veremos os outros casos mais a frente, sendo que o �ltimo caso de �Interna An�nima� ser� visto junto da seç�o sobre classes an�nimas.

Porque usar classes aninhadas?

Porque dever�amos criar uma classe aninhada em vez de uma top-level? Quais as vantagens no seu uso?

Agrupamento de classes que s�o usadas em apenas um lugar: Se voc� possui uma classe B que com certeza ser� usada apenas dentro da classe A, o melhor � criar a classe B como interna a classe A.
Aumento de Encapsulamento: Sendo que a classe B e A s�o duas classes top-level e B precisa acessar os membros de A, poder�amos colocar a classe B dentro de A e colocar os membros de A como privados e ainda assim B conseguiria continuar acessando os membros de A por ser uma classe aninhada.
C�digo mais leg�vel e de f�cil manutenç�o: Colocar classes pequenas dentro de classes top-level, j� que apenas esta a usar�, faz com que a l�gica da classe top-level seja mais f�cil de ser identificada, consequentemente tornando o c�digo mais leg�vel e de f�cil manutenç�o.

Classes Aninhadas Est�ticas

Revendo os conceitos, � importante lembrar que uma classe est�tica n�o tem acesso aos membros da inst�ncia da classe externa, somente aos membros est�ticos, ou seja, elas tem a mesma visibilidade de uma classe externa. Vejamos um exemplo na Listagem 3.

Listagem 3. Classe Aninhada Est�tica

public class Ex03 {  
     static int CountStatic = 0;  
     int CountNonStatic = 0;  
    
     public static class Inner {  
     }  
  }

O exemplo acima demonstra de forma simples e f�cil como utilizar uma classe aninhada est�tica (nested static class). Pelo fato da classe Inner ser est�tica ela n�o pode chamar diretamente a vari�vel CountNonStatic pois isso causaria um erro de compilaç�o como mostrado na Listagem 4.

Listagem 4. Chamando CountNonStatic


  public class Ex03 {  
     static int CountStatic = 0;  
     int CountNonStatic = 0;  
    
     public static class Inner {  
        public void doInner() {  
           System.out.println( CountNonStatic );  
        }  
     }  
  }  
  Erro gerado: Erro de compilaç�o: non-static variable CountNonStatic cannot be referenced from a static context

Voc� precisaria de uma inst�ncia de Ex03 para usar a vari�vel CountNonStatic, pois a classe Inner est� em um contexto diferente da vari�vel CountNonStatic. Por outro lado, a Listagem 5 compila sem problemas:

Listagem 5. Chamando CountStatic


  public class Ex03 {  
                     static int CountStatic = 0;  
                     int CountNonStatic = 0;  
                    
                     public static class Inner {  
                        public void doInner() {  
                           System.out.println( CountStatic );  
                        }  
                     }  
                  }

A vantagem de utilizar-se uma classe est�tica aninhada est� no fato de poder acessar membros privados da classe externa (que sejam est�ticos tamb�m, � claro).

Vejamos um exemplo mais completo do seu uso em detalhes na Listagem 6.

Listagem 6. Exemplo completo Classe Aninhada Est�tica


  import java.util.*;  
  public class Week {  
     private int weeknr;  
     private int year;  
     public Week(int weeknr, int year) {  
        this.weeknr = weeknr;  
        this.year = year;  
     }  
     public Iterator getDays() {  
        return new DayIterator(this);  
     }  
     public int getWeeknr() {  
        return weeknr;  
     }  
     public int getYear() {  
        return year;  
     }  
     public static class DayIterator implements Iterator {  
        private int index = 0;  
        private Calendar cal = null;  
    
        DayIterator (Week aWeek) {  
           cal = new GregorianCalendar();  
           cal.clear();  
           cal.set(Calendar.YEAR, aWeek.getYear());  
           cal.set(Calendar.WEEK_OF_YEAR, aWeek.getWeeknr());  
        }  
        public boolean hasNext() {  
           return index < 7;  
        }  
        public Object next() {  
           cal.set(Calendar.DAY_OF_WEEK, index++);  
           return cal.getTime();  
        }  
        public void remove() {  
           // not implemented  
        }  
     }  
    
     public static void main(String[] args) {  
     // list the days of the week  
     if (args.length < 2) {  
        System.err.println("Usage: java Week <weeknr> year>");  
        System.exit(1);  
     } else {  
        try {  
          int weeknr = Integer.parseInt(args[0]);  
          int year = Integer.parseInt(args[1]);  
          Week wk = new Week(weeknr, year);  
          for (Iterator i=wk.getDays();i.hasNext();) {  
            System.err.println(i.next());  
          }  
        } catch (NumberFormatException x) {  
          System.err.println("Illegal week or year");  
        }  
     }  
     }  
  }

Vamos destrinchar a classe acima e entender seu funcionamento. Mostrando apenas as assinaturas dos m�todos sem levar em consideraç�o seu �corpo� temos a Listagem 7.

Listagem 7. Mostrando apenas assinaturas dos m�todos da Listagem 6


  import java.util.*;  
  public class Week {  
     private int weeknr;  
     private int year;  
     public Week(int weeknr, int year) {  
    
     
     public Iterator getDays(){}
   
     public int getWeeknr(){}  
     
     public int getYear(){}
       
     public static class DayIterator implements Iterator {}  
    
     public static void main(String[] args){}    
       
  }

A classe Week tem uma funç�o bem simples. No construtor � passado o n�mero da semana e o ano desejado e com esses par�metros podemos começar a trabalhar. O m�todo getWeeknr() apenas retorna o n�mero da semana que foi passado, assim como o getYear() retorna o ano que foi passado, sem realizar nenhum tratamento. Mas o ponto principal est� na classe aninhada chamada DayIterator, onde sua funç�o � retornar um Iterator para que possamos percorrer os dias da semana naquele determinado ano.

Perceba que a classe aninhada DayIterator n�o tem acesso aos membros da classe Week, isso porque eles s�o membros de inst�ncia. Neste caso optamos por usar uma classe aninhada est�tica apenas para n�o precisar criar um novo �.java� separado para controlar a iteraç�o entre os dias, pois como sabemos que apenas a classe Week ir� utilizar essa funcionalidade, � muito melhor criar o DayIterator interno a ela e facilitar a manutenç�o e legibilidade do c�digo.

Classe Interna Comum (Classe N�o Est�tica)

Uma classe interna comum s� pode ser instanciada se estiver dentro de um objeto da classe externa. Vejamos a Listagem 8.

Listagem 8. Instanciando a classe interna de forma errada


  public class Outer {  
     public static void main(String[] args) {  
        Inner i = new Inner();  
  }  
    
     class Inner {  
     }  
  }

Logo acima citamos que a classe interna n�o pode ser instanciada sem que seja por um objeto da classe externa, e no exemplo da Listagem 8 ocorrer� um erro por este motivo. Acontece que o m�todo main � est�tico, ou seja, da classe e n�o do objeto. Sendo assim n�o podemos instanciar a classe Inner a partir deste m�todo est�tico.

Veja como far�amos da maneira correta na Listagem 9.

Listagem 9. Instanciando a classe interna de forma correta


  public class Outer {  
     public static void main(String[] args) {  
        Outer o = new Outer();  
        Inner i = o.new Inner();  
  }  
    
     class Inner {  
     }  
  }

Acima temos a criaç�o do objeto �o� do tipo Outer e posteriormente (a partir do objeto �o�) a criaç�o do objeto �i� do tipo Inner, usando o objeto �o�. O c�digo mostrado na Listagem 9 � a forma correta de realizar a instanciaç�o de uma classe interna, diferente da Listagem 8.

Uma classe interna � considerada um membro da classe externa, sendo esta um membro ent�o deve ter acesso a todos os outros membros da classe externa, sejam eles private ou n�o. Observe a Listagem 10.

Listagem 10. Acessando membros privados da classe externa


  public class Outer {  
      private int x = 0;  
     public static void main(String[] args) {  
        Outer o = new Outer();  
        Inner i = o.new Inner();  
        o.print();  
     }  
     public void print() {  
         System.out.println("x before "+x);  
         Inner i = new Inner();  
         i.print();  
     }  
     class Inner {  
         public void print() {  
        x++;  
        System.out.println("x after: "+x);  
         }  
     }  
  }

Acima temos a classe externa Outer e a classe interna Inner. Perceba que a classe Inner usa o atributo �x� que foi declarado como private na classe Outer, ou seja, ela tem total acesso a mesma. Se voc� executar o c�digo da Listagem 10 teremos como sa�da o que est� na Listagem 11.

Listagem 11. Sa�da da Listagem 10


  x before 0
  x after: 1

Podemos ainda instanciar a classe interna fora da classe externa, por�m seguindo a mesma regra de que isso deve ser feito atrav�s de um objeto da classe externa. Vejamos a Listagem 12.

Listagem 12. Instanciando a classe interna de fora da classe externa


  public class TestOuter {  
     public static void main(String[] args) {  
        Outer o = new Outer();  
        Outer.Inner i = o.new Inner();  
     }  
  }  
  class Outer {  
      class Inner { }  
  }

A nossa classe TestOuter possui um m�todo est�tico chamado main , perceba que dentro deste m�todo estamos criando o objeto Outer e a partir dele conseguimos criar o objeto Inner.

A classe interna em alguns casos pode precisar referenciar a classe externa, e isso � poss�vel atrav�s da palavra reservada �this�, precedida do nome da classe externa. Observe a Listagem 13.

Listagem 13. Referenciando a classe externa com 'this'


  public class TestOuter {  
     public static void main(String[] args) {  
        Outer o = new Outer();  
        Outer.Inner i = o.new Inner();  
        i.see();  
     }  
  }  
  class Outer {  
      private int x = 10;  
      class Inner {  
     public void see() {  
         System.out.println(x);  
         System.out.println(this);      
         System.out.println(Outer.this);   
     }  
      }  
  }

No exemplo da Listagem 13 estamos usando o �this� de duas formas:

Em �System.out.println(this)� estamos referenciando a classe Inner;
Em �System.out.println(Outer.this)� estamos referenciando a classe Outer;

Ent�o o nome da classe na frente do �this� faz toda a diferença na hora de apontar a referencia correta. Tamb�m vale ressaltar que classes aninhadas comuns podem possuir os seguintes modificadores presentes na Listagem 14.

Listagem 14. Modificadores de acesso


   
  final
 
 abstract
 
 public
 
 private
 
 protected
 
 static
 
 Strictfp

Classe Interna a um m�todo

Vimos nas seç�es acima Classes Internas Est�ticas e N�o est�ticas, todas dentro de um escopo onde a classe externa as delimita, mas agora veremos um escopo mais restrito ainda, classes internas dentro de um m�todo. Observe a Listagem 15.

Listagem 15. Classe interna dentro de um m�todo


  public class TestOuter {  
     public static void main(String[] args) {  
        Outer o = new Outer();  
        o.see();  
     }  
  }  
  class Outer {  
      private int x = 10;  
      public void see() {  
     System.out.println("before "+x);  
     class Inner {  
         public Inner() {  
        x = 0;  
         }  
     }  
     System.out.println("after "+x);  
      }  
  }

Se a pergunta fosse: Qual a sa�da do c�digo acima? Voc� responderia como a Listagem 16?

Listagem 16. Sa�da da Listagem 15


  before 10
  after 10

Acontece que o construtor da classe interna Inner n�o foi chamado e por conta disso a vari�vel x n�o recebeu o valor �0�. Vejamos como ficaria chamando o construtor e atribuindo o valor zero a vari�vel x na Listagem 17.

Listagem 17. Chamando construtor da classe Inner


  public class TestOuter {  
     public static void main(String[] args) {  
        Outer o = new Outer();  
        o.see();  
     }  
  }  
  class Outer {  
      private int x = 10;  
      public void see() {  
     System.out.println("before "+x);  
     class Inner {  
         public Inner() {  
        x = 0;  
         }  
     }  
     Inner i = new Inner();  
     System.out.println("after "+x);  
      }  
  }

Agora teremos a seguinte sa�da da Listagem 18.

Listagem 18. Sa�da da Listagem 17


  before 10
  after 0

Lembre-se que uma classe Interna a um m�todo, s� pode ser instanciada dentro deste pr�prio m�todo, n�o h� como realizar a instanciaç�o dessa classe de fora do m�todo ou mesmo de fora da classe externa, o escopo � muito restrito neste caso. Por esse fato o modificador padr�o de acesso de uma classe de m�todo � private, visto que esse n�o pode ser instanciado de nenhum local fora do m�todo. Outros modificadores de podem ser aplicados a este tipo de classe s�o: abstract e final.

H� uma exceç�o a ser notada quando utilizamos classes de m�todos, n�o podemos fazer refer�ncia as vari�veis do m�todo, estranho mas � isso mesmo, n�o podemos usar as vari�veis declaradas no m�todo. Vejamos a Listagem 19.

Listagem 19. Usando vari�veis de m�todo em classes de m�todo


  public class TestOuter {  
     public static void main(String[] args) {  
        Outer o = new Outer();  
        o.see();  
     }  
  }  
    
  class Outer {  
      private int x = 10;  
      public void see() {  
     int y = 5;  
     System.out.println("before "+x);  
     class Inner {  
         public String s = "string inner";  
         public Inner() {  
        x = y;  
         }  
     }  
     Inner i = new Inner();  
     System.out.println("after "+x);  
      }  
  }

O c�digo acima lança uma exceç�o pelo fato da vari�vel y est� sendo utilizada dentro da classe Inner. O seguinte erro ser� mostrado:


  local variable y is accessed from within inner class; needs to be declared final

E como o pr�prio erro sugere, n�s devemos declarar a vari�vel y como final para poder utiliz�-la dentro da classe, como mostra a Listagem 20.

Listagem 20. Declarando y como final


  public class TestOuter {  
     public static void main(String[] args) {  
        Outer o = new Outer();  
        o.see();  
     }  
  }  
    
  class Outer {  
      private int x = 10;  
      public void see() {  
     final int y = 5;  
     System.out.println("before "+x);  
     class Inner {  
         public String s = "string inner";  
         public Inner() {  
        x = y;  
         }  
     }  
     Inner i = new Inner();  
     System.out.println("after "+x);  
      }  
  }

Classes Internas An�nimas

Classe an�nima nada mais � do que a herança de determinada classe em um local exclusivo, ou seja, apenas naquele determinado ponto eu preciso redefinir minha classe-pai. Veja a Listagem 21.

Listagem 21. Usando Classe An�nima


  class Car {  
     public void run() { ... }  
  }  
    
  class Gol {  
    
  Car car = new Car() {  
     public void run() { ... }  
  };  
  }

Temos acima a classe Car e a classe Gol. A classe Gol possui em seu corpo a instanciaç�o de um objeto Car, mais ainda, ela al�m de instanciar um objeto Car muda o comportamento interno da classe, aplicando a herança ao mesmo tempo. Vejamos outro exemplo na Listagem 22.

Listagem 22. Classe An�nima, exemplo 2


  class Empregado {  
     public void trabalhar() {  
         System.out.println("trabalhar");  
     }  
  }  
    
  class QuadroFuncionario {  
     Empregado mgr  = new Empregado() {  
        public void trabalhar() {  
           System.out.println("mandar");  
        }  
     };  
    
     Empregado peao = new Empregado() {  
        public void trabalhar() {  
           System.out.println("executar");  
        }  
     };  
  }

Este segundo exemplo fica bem mais f�cil de entender o uso deste tipo de classe. Temos uma superclasse chama Empregado que possui a aç�o de �trabalhar()� onde imprime uma mensagem �trabalhar�.

Dentro da classe QuadroFuncionario n�s criamos dois tipos de funcion�rios: peao e mgr (gerente). O mgr muda a aç�o de trabalhar() imprimindo uma mensagem �mandar� e o peao tamb�m muda mas imprimindo a mensagem �executar�.

Se fossemos fazer uma herança �comum�, ter�amos que criar uma classe �Peao extends Empregado� e mudar o comportamento do m�todo trabalhar, e tamb�m criar�amos uma classe �Mgr extends Empregado�, isso � o que normalmente se faz quando h� necessidade do uso de tais comportamentos distintos em v�rios locais distintos, mas em nosso caso s� precisamos desses comportamentos dentro da classe QuadroFuncionario e a melhor pr�tica � usar classes an�nimas.

Vejamos um exemplo erro do uso de classes an�nimas na Listagem 23.

Listagem 23. Uso errado e classes an�nimas


  class Empregado {  
     public void trabalhar() {  
         System.out.println("trabalhar");  
     }  
  }  
    
  class QuadroFuncionario {  
     Empregado mgr  = new Empregado() {  
        public void trabalhar() {  
           System.out.println("mandar");  
        }  
    
        public void demite() {  
               System.out.println("demite");  
        }  
     };  
    
     public void work() {  
         mgr.trabalhar();      
         mgr.demite();  
     }  
  }

O erro do c�digo acima est� no m�todo work(), pois ele est� tentando executar o m�todo demite() que n�o existe no objeto �mgr�. Acontece que mesmo voc� criando o m�todo demite() o que importa � a declaraç�o na superclasse e nesse caso esse m�todo n�o existe. Assim como na herança voc� precisaria referir-se a classe �Mgr� em vez de �Empregado� para usar o m�todo demite(), se fosse o caso.

Classes an�nimas s�o classes internas, por isso esta seç�o ficou por �ltimo j� que abrange dois assuntos distintos mas que est�o diretamente ligados. Voc� n�o tem como criar uma classe an�nima sem que seja uma classe interna, perderia o objetivo.

As classes an�nimas ainda tem algo muito interessante, o uso de Interfaces, como podemos ver na Listagem 24.

Listagem 24. Usando interface direto em classe an�nimas


  public class Ex04 {  
     public static void main(String[] args) {  
        acao( new Evento() {  
           public void clicar() {  
              System.out.println("clicou");  
           }  
           public void arrastar() {  
              System.out.println("arrastou");  
           }  
        });  
     }  
     public static void acao(Evento e) {  
        e.clicar();  
        e.arrastar();  
     }  
  }  
  interface Evento {  
     public abstract void clicar();  
     public abstract void arrastar();  
  }

O que voc� provavelmente percebeu com o c�digo acima � que estamos fazendo uma instanciaç�o da interface Evento como uma classe an�nima, mas como isso � poss�vel se o java n�o permite que uma interface seja instanciada?

Verdade, e n�o permite mesmo e continua n�o permitindo. Acontece que ao usar a interface Evento como uma classe an�nima, � criada uma classe que estende a interface Evento e n�o a interface � instanciada diretamente, tanto que voc� � obrigado a usar todos os m�todos que est�o na interface.

Vimos neste artigo o conceito de Classes Aninhadas ou Nested Class, muito importante para aumentar a produtividade de um projeto, a legibilidade do c�digo e prover maior facilidade de manutenç�o (quando usado de forma correta). Aproveitamos para entrar em outro assunto que tem tudo haver com Classes Aninhadas, as Classes An�nimas, que s�o utilizadas em demasia por listeners, voc� j� deve ter se deparado muito com a construç�o de um c�digo que possui um listener para o click de um bot�o e geralmente � usado uma classe an�nima para facilitar tal trabalho e evitar c�digo desnecess�rio.