Classes Internas em Java: Design, Sintaxe e Usos Práticos

Neste capítulo, discutiremos classes internas (inner classes) do Java.

Classes Aninhadas (Nested Classes)

Em Java, assim como métodos, variáveis de uma classe podem ter outra classe como membro. Escrever uma classe dentro de outra é permitido. A classe escrita dentro é chamada de classe aninhada (nested class), e a classe que a contém é a classe externa (outer class).

Sintaxe

class Outer_Demo {
    class Inner_Demo {
    }
}

Classes aninhadas dividem-se em dois tipos:

• Classes aninhadas não-estáticas (Non-static nested classes) — Membros não-estáticos de uma classe.
• Classes aninhadas estáticas (Static nested classes) — Membros estáticos de uma classe.

Classes Internas (Inner Classes - Não-Estáticas)

Classes internas são um mecanismo de segurança em Java. Uma classe top-level não pode ser private, mas se for membro de outra classe, a classe interna pode ser privada. Isso também permite acessar membros privados da classe externa.

Classes internas são de três tipos:

• Inner Class (classe interna de membro)
• Method-local Inner Class (classe interna local a método)
• Anonymous Inner Class (classe interna anônima)

Inner Class (Classe Interna de Membro)

Criar uma classe interna é simples: escreva uma classe dentro de outra. Diferente de classe top-level, uma inner class pode ser private e, uma vez declarada privada, não pode ser acessada de fora da classe externa.

Exemplo

class Outer_Demo {
    int num;

    // inner class privada
    private class Inner_Demo {
        public void print() {
            System.out.println("Esta é uma classe interna");
        }
    }

    // Acessando a inner class de dentro de um método
    void display_Inner() {
        Inner_Demo inner = new Inner_Demo();
        inner.print();
    }
}

public class My_class {
    public static void main(String args[]) {
        Outer_Demo outer = new Outer_Demo();
        outer.display_Inner();
    }
}

Saída:

Esta é uma classe interna.

Acessando Membros Privados

Classes internas também servem para acessar membros privados da classe externa. Escreva uma inner class, retorne os membros privados de um método (ex.: getValue()), e chame esse método de outra classe.

Para instanciar a inner class, primeiro instancie a outer class:

Outer_Demo outer = new Outer_Demo();
Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();

Exemplo Completo

class Outer_Demo {
    private int num = 175;

    public class Inner_Demo {
        public int getNum() {
            System.out.println("Este é o método getNum da classe interna");
            return num;
        }
    }
}

public class My_class2 {
    public static void main(String args[]) {
        Outer_Demo outer = new Outer_Demo();
        Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();
        System.out.println(inner.getNum());
    }
}

Saída:

Este é o método getNum da classe interna: 175

Method-local Inner Class

Em Java, podemos escrever uma classe dentro de um método; seu escopo fica restrito ao método. Só pode ser instanciada dentro do método onde é definida.

Exemplo

public class Outerclass {
    void my_Method() {
        int num = 23;

        class MethodInner_Demo {
            public void print() {
                System.out.println("Esta é uma method inner class " + num);
            }
        }

        MethodInner_Demo inner = new MethodInner_Demo();
        inner.print();
    }

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

Saída:

Esta é uma method inner class 23

Anonymous Inner Class

Uma classe interna declarada sem nome é anonymous inner class. Declarada e instanciada ao mesmo tempo. Usada geralmente para sobrescrever método de uma classe ou interface.

Sintaxe

AnonymousInner an_inner = new AnonymousInner() {
    public void my_method() {
        // implementação
    }
};

Exemplo: Sobrescrevendo Método

abstract class AnonymousInner {
    public abstract void mymethod();
}

public class Outer_class {
    public static void main(String args[]) {
        AnonymousInner inner = new AnonymousInner() {
            public void mymethod() {
                System.out.println("Este é um exemplo de anonymous inner class");
            }
        };
        inner.mymethod();
    }
}

Saída:

Este é um exemplo de anonymous inner class

Anonymous Inner Class como Argumento

Se um método aceita objeto de interface, classe abstrata ou concreta, pode-se passar uma anonymous inner class.

Sintaxe

obj.my_Method(new My_Class() {
    public void Do() {
        // ...
    }
});

Exemplo

interface Message {
    String greet();
}

public class My_class {
    public void displayMessage(Message m) {
        System.out.println(m.greet() + ", Este é exemplo de anonymous inner class como argumento");
    }

    public static void main(String args[]) {
        My_class obj = new My_class();
        obj.displayMessage(new Message() {
            public String greet() {
                return "Olá";
            }
        });
    }
}

Saída:

Olá, Este é exemplo de anonymous inner class como argumento

Static Nested Class

Uma static inner class é uma nested class que é membro estático da classe externa. Pode ser acessada sem instanciar a classe externa. Assim como membros estáticos, não tem acesso a variáveis e métodos de instância da classe externa.

Sintaxe

class MyOuter {
    static class Nested_Demo {
    }
}

Exemplo

public class Outer {
    static class Nested_Demo {
        public void my_method() {
            System.out.println("Esta é minha nested class");
        }
    }

    public static void main(String args[]) {
        Outer.Nested_Demo nested = new Outer.Nested_Demo();
        nested.my_method();
    }
}

Saída:

Esta é minha nested class