Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Classes internas e a sintaxe `outer.new Inner(...)`

Uma classe membro interna fica ligada a uma instância específica da classe envolvente e pode ler os campos privados desse objeto.

Versão: Java SE 21

Sintaxe

class Outer {
    class Inner {
        Inner(int value) { /* initialize this Inner object */ }
    }

    Inner create(int value) {
        return new Inner(value); // enclosing instance: this Outer
    }
}

// In a method or initializer where the type and constructor are accessible:
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner(42);

Em Java, uma classe interna é uma classe aninhada que não é static, quer explícita quer implicitamente. As classes locais não estáticas e as classes anónimas também são internas. Quando uma destas classes locais ou anónimas é declarada num contexto estático, os seus objetos não têm uma instância envolvente imediata. Em contrapartida, um objeto de uma classe membro interna como Team.Member fica ligado, ao ser criado, a um objeto envolvente específico.

Em outer.new Inner(...), outer fornece o objeto envolvente e os argumentos entre parênteses são passados ao construtor de Inner. Outer.Inner identifica o tipo, não o objeto envolvente. Num método de instância de Outer, new Inner(...) pode usar this como objeto envolvente implícito. Num contexto estático, omitir o qualificador provoca um erro de compilação; se o qualificador tiver o valor null, ocorre uma NullPointerException em tempo de execução. Tanto o tipo como o construtor têm de estar acessíveis.

Num método de instância de Member, this designa o objeto Member e Team.this designa o objeto Team envolvente. Team.this.name lê o campo privado da equipa, mesmo que Member tenha o seu próprio campo name. Uma classe aninhada estática não tem um objeto envolvente implícito: precisa de uma referência explícita para ler os campos de instância desse objeto. Em Java SE 21, uma classe interna pode declarar membros static e inicializadores estáticos sem se tornar uma classe aninhada estática.

TaskList cria um objeto da classe privada final chamada FilteringIterator e devolve-o como Iterator<Integer>. Cada iterador tem o seu próprio índice e lê source da lista envolvente. Ignora os valores não positivos e, quando não restam elementos, next() lança NoSuchElementException. Manter o iterador pode prolongar a vida do objeto TaskList envolvente.

Exemplos

import java.util.Iterator;
import java.util.NoSuchElementException;

public class Main {
    public static void main(String[] args) {
        Team red = new Team("Red");
        Team blue = new Team("Blue");
        Team.Member first = red.new Member("Ada");
        Team.Member second = blue.new Member("Ada");
        System.out.println(first.label());
        System.out.println(second.label());

        TaskList tasks = new TaskList(0, 4, -1, 7);
        Iterator<Integer> positives = tasks.positiveIterator();
        while (positives.hasNext()) {
            System.out.println(positives.next());
        }
    }
}

final class Team {
    private final String name;

    Team(String name) {
        this.name = name;
    }

    class Member {
        private final String name;

        Member(String name) {
            this.name = name;
        }

        String label() {
            return Team.this.name + ": " + this.name;
        }
    }
}

final class TaskList {
    private final int[] source;

    TaskList(int... values) {
        source = values.clone();
    }

    Iterator<Integer> positiveIterator() {
        return new FilteringIterator();
    }

    private final class FilteringIterator implements Iterator<Integer> {
        private int index;

        @Override
        public boolean hasNext() {
            while (index < source.length && source[index] <= 0) {
                index++;
            }
            return index < source.length;
        }

        @Override
        public Integer next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            return source[index++];
        }
    }
}

Resultado

Red: Ada
Blue: Ada
4
7

Os dois objetos `Member` têm o mesmo nome, mas mostram nomes de equipa diferentes. Depois, o iterador escreve apenas `4` e `7`, pela ordem em que aparecem em `source`.

Lições relacionadas

  • Java · Lição 7 · Intermédio · Versão: 2
  • Java · Lição 24 · Intermédio · Versão: 2

Fontes