База знанияИзпитен център
BGБългарски
Избери език13

CKTIS / Java

Вътрешни класове и синтаксисът `outer.new Inner(...)`

Вътрешният клас член е свързан с конкретна инстанция на обхващащия клас и може да чете частните полета на този обект.

Версия: Java SE 21

Синтаксис

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);

В Java вътрешен клас е вложен клас, който не е static нито явно, нито неявно. Това включва нестатичните локални класове и анонимните класове. Ако такъв локален или анонимен клас е деклариран в статичен контекст, обектите му нямат непосредствена обхващаща инстанция. За разлика от тях обект на вътрешен клас член като Team.Member се свързва с конкретен обхващащ обект при създаването си.

В outer.new Inner(...) изразът outer определя обхващащия обект, а аргументите в скобите се подават на конструктора на Inner. Outer.Inner обозначава типа, а не обхващащия обект. В метод на инстанция на Outer изразът new Inner(...) може неявно да използва this като обхващащ обект. В статичен контекст пропускането на квалификатора води до грешка при компилация. Ако стойността на квалификатора е null, при изпълнение се хвърля NullPointerException. Типът и конструкторът трябва да са достъпни.

В метод на инстанция на Member изразът this обозначава обекта Member, а Team.this — неговия обхващащ обект Team. Team.this.name чете частното поле на отбора, въпреки че Member има собствено поле name. Статичният вложен клас няма неявен обхващащ обект: за да чете полетата на негова инстанция, му трябва явна референция към нея. В Java SE 21 вътрешен клас може да декларира членове static и статични инициализатори, без самият той да става статичен.

TaskList създава инстанция на частния клас final с име FilteringIterator и я връща като Iterator<Integer>. Всеки итератор има собствен индекс и чете source на обхващащия списък. Той пропуска неположителните стойности, а когато елементите свършат, next() хвърля NoSuchElementException. Запазването на итератора може да удължи живота на обхващащия обект TaskList.

Примери

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++];
        }
    }
}

Резултат

Red: Ada
Blue: Ada
4
7

Двата обекта `Member` имат едно и също име, но извеждат различни имена на отбори. След това итераторът извежда само `4` и `7` в реда, в който се срещат в `source`.

Свързани уроци

  • Java · Урок 7 · Средно · Версия: 2
  • Java · Урок 24 · Средно · Версия: 2

Източници