Classes internas de Java

Em Java, algumas classes podem conter outras classes dentro delas. Essas classes são chamadas de classes aninhadas. As classes definidas em outras classes geralmente se enquadram em duas categorias – estáticas e não estáticas. Classes não estáticas aninhadas são chamadas de internas. Classes aninhadas declaradas estáticas são chamadas de classes aninhadas estáticas. Na verdade, não há nada complicado aqui, embora a terminologia pareça um tanto confusa e às vezes possa confundir até mesmo um desenvolvedor de software profissional.

Classes aninhadas e internas

Portanto, todas as classes localizadas dentro de outras classes são chamadas de classes aninhadas.

class OuterClass {
    ...
    class NestedClass {
        ...
    }
}

Classes aninhadas que não são estáticas são chamadas de classes internas , e aquelas que são estáticas são chamadas de classes aninhadas estáticas . Aulas internas de Java - 1

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

Assim, todas as classes internas são aninhadas, mas nem todas as classes aninhadas são internas. Estas são as principais definições. As classes internas são um tipo de mecanismo de segurança em Java. Sabemos que uma classe comum não pode ser associada a um modificador de acesso privado. No entanto, se nossa classe for membro de outra classe, a classe interna poderá se tornar privada. Este recurso também é usado para acessar membros de classes privadas.

Exemplo de classe interna

Então, vamos tentar criar alguma classe, e dentro dela — outra classe. Imagine algum tipo de console de jogo modular. Existe uma “caixa” propriamente dita e certos módulos podem ser conectados a ela. Por exemplo, um controlador de jogo, um volante, um capacete VR, que, via de regra, não funcionam sem o próprio console. Aqui temos a classe GameConsole. Possui 2 campos e 1 método — start() . A diferença entre GameCosole e a classe a que estamos acostumados é que ela possui uma classe GameController interna .

public class GameConsole {
    private String model;
    private int weight;

    public void run() {
        System.out.println("Game console is on");
    }


    public class GameController {

        private String color;

        public void start() {
            System.out.println("start button is pressed");
        }

        public void x() {
            System.out.println("x button is pressed");
        }

        public void y() {
            System.out.println("y button is pressed");
        }
        public void a() {
            System.out.println("a button is pressed");
        }

        public void b() {
            System.out.println("b button is pressed");
        }
        public void mover() {
            System.out.println("mover button is pressed");
        }

    }

}

Neste ponto, você deve estar se perguntando: por que não tornar essas classes “separadas”? Não é necessário torná-los aninhados. Na verdade, é possível. Pelo contrário, trata-se do design correto das classes em termos de seu uso. As classes internas são criadas para destacar no programa uma entidade que está inextricavelmente ligada a outra entidade. Um controlador ou, por exemplo, um capacete VR são componentes do console. Sim, eles podem ser adquiridos separadamente do console, mas não podem ser usados sem ele. Se separarmos todas essas classes de classes públicas, nosso programa poderia ter, por exemplo, o seguinte código:

public class Main {

   public static void main(String[] args) {
       GameController controller = new GameController();
       controller.x();
   }
}

O que acontece neste caso não está claro, já que o controlador em si não funciona sem um console. Criamos um objeto console de jogo. Criamos seu subobjeto — o controlador de jogo. E agora podemos jogar, basta pressionar as teclas certas. Os métodos que precisamos são chamados nos objetos certos. Tudo é simples e conveniente. Neste exemplo, extrair o controlador do jogo aprimora o encapsulamento (ocultamos os detalhes das partes do console dentro da classe correspondente) e permite uma abstração mais detalhada. Mas se criarmos, por exemplo, um programa que simule uma loja onde você pode comprar separadamente um capacete ou controlador VR, este exemplo irá falhar. Lá é melhor criar um controlador de jogo separadamente. Vejamos outro exemplo. Mencionamos acima que podemos tornar a classe interna privada e ainda chamá-la da classe externa. Abaixo está um exemplo de tais classes.

class OuterClass {

   // inner class
   private class InnerClass {
       public void print() {
           System.out.println("We are in the inner class...");
       }
   }

   // method of outer class. We are create an inner class from the method of outer one
   void display() {
       InnerClass inner = new InnerClass();
       inner.print();
   }
}

Aqui OuterClass é a classe externa, InnerClass é a classe interna, display() é o método dentro do qual estamos criando um objeto da classe interna. Agora vamos escrever uma classe demo com um método principal onde invocaremos o método display() .

public class OuterDemoMain {

       public static void main(String args[]) {
           // create an object of the outer class
           OuterDemo outer = new OuterDemo();

           outer.display();
       }
}

Se você executar este programa, obterá o seguinte resultado:

Estamos na classe interna...

Classificação das classes internas

As próprias classes internas ou classes não estáticas aninhadas se enquadram em três grupos.

Classe interna como está. Apenas uma classe não estática dentro da outra como demonstramos acima com o exemplo GameConsole e GameController .
A classe interna local do método é uma classe dentro de um método.
Classe interna anônima.

Método classe interna local

Em Java você pode escrever uma classe dentro de um método e é um tipo local. Assim como as variáveis locais, o escopo de uma classe interna é limitado dentro de um método. Uma classe interna local de método só pode ser criada dentro do método onde a classe interna está definida. Vamos demonstrar como usar a classe interna do método local.

public class OuterDemo2 {

   //instance method of the outer class OuterDemo2
   void myMethod() {
       String str = "and it's a value from OuterDemo2 class' myMethod ";

       // method-local inner class
       class methodInnerDemo {
           public void print() {
               System.out.println("Here we've got a method inner class... " );
               System.out.println(str);

           }
       }

       // Access to the inner class
       methodInnerDemo inn = new methodInnerDemo();
       inn.print();
   }
}

Agora vamos escrever uma classe demo com um método principal onde invocaremos o método outer() .

public class OuterDemoMain {


   public static void main(String args[]) {
       OuterDemo2 outer = new OuterDemo2();
       outer.myMethod();
   }
}

A saída é:

Aqui temos uma classe interna de método... e é um valor da classe OuterDemo2 'myMethod

Classe interna anônima

Uma classe interna declarada sem nome de classe é chamada de classe interna anônima. Quando declaramos uma classe interna anônima, nós a instanciamos imediatamente. Normalmente, essas classes são usadas sempre que você precisa substituir uma classe ou método de interface.

abstract class OuterDemo3 {
   public abstract void method();

}
   class outerClass {

       public static void main(String args[]) {
           OuterDemo3 inner = new OuterDemo3() {
               public void method() {
                   System.out.println("Here we've got an example of an  anonymous inner class");
               }
           };
           inner.method();
       }
   }

A saída está aqui:

Aqui temos um exemplo de uma classe interna anônima...

Classe interna anônima como argumento

Você também pode passar uma classe interna anônima como argumento para o método. Aqui está um exemplo.

interface OuterDemo4 {
       String hello();
   }

   class NewClass {
       // accepts the object of interface
       public void displayMessage(OuterDemo4 myMessage) {
           System.out.println(myMessage.hello());
           System.out.println("example of anonymous inner class as an argument");
       }

       public static void main(String args[]) {
           NewClass newClass = new NewClass();

           //here we pass an anonymous inner class as an argument
           newClass.displayMessage(new OuterDemo4() {
               public String hello() {
                   return "Hello!";
               }
           });
       }
}

A saída está aqui:

Olá! exemplo de classe interna anônima como argumento

Para reforçar o que você aprendeu, sugerimos que você assista a uma vídeo aula do nosso Curso Java