Przykład klasy wewnętrznej
Klasa AbstractList ma klasę wewnętrzną Itr . Jest to implementacja interfejsu Iteratora , która pozwala pobierać elementy kolekcji jeden po drugim:
private class Itr implements Iterator<E> {
int cursor = 0;
int lastRet = -1;
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size();
}
public E next() {
checkForComodification();
try {
int i = cursor;
E next = get(i);
lastRet = i;
cursor = i + 1;
return next;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException(e);
}
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
Jest używany w metodzie iteratora :
public Iterator<E> iterator() {
return new Itr();
}
Zatem każda klasa, która dziedziczy po AbstractList, otrzymuje gotowy, działający iterator. A jeśli nadal potrzebujesz dostosować iterator, możesz zaimplementować własną klasę, dziedzicząc ją z Iteratora lub Itr i nadpisując metodę iteratora . Na przykład, jak to się robi w klasie ArrayList .
Klasa Itr jest niestatyczna. Dzięki temu instancja Itr ma referencję do instancji AbstractList i ma dostęp do jej metod ( size , get , remove ).
Przykład wewnętrznej klasy statycznej
Klasa Integer ma klasę wewnętrzną IntegerCache :
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer[] cache;
static Integer[] archivedCache;
static {
int h = 127;
String integerCacheHighPropValue =
VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
h = Math.max(parseInt(integerCacheHighPropValue), 127);
h = Math.min(h, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
}
}
high = h;
VM.initializeFromArchive(IntegerCache.class);
int size = (high - low) + 1;
if (archivedCache == null || size > archivedCache.length) {
Integer[] c = new Integer[size];
int j = low;
for(int i = 0; i < c.length; i++) {
c[i] = new Integer(j++);
}
archivedCache = c;
}
cache = archivedCache;
assert IntegerCache.high >= 127;
}
private IntegerCache() {}
}
IntegerCache hermetyzuje generowanie pamięci podręcznej, przechowuje zakresy pamięci podręcznej i same wartości w pamięci podręcznej. W ten sposób wszystko, co jest związane z pamięcią podręczną, jest umieszczane w osobnej klasie. Ułatwia to czytanie kodu i wprowadzanie w nim zmian. Kod użycia klasy:
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
Klasa IntegerCache nie ma dostępu do niestatycznych pól i metod klasy Integer i jest dostępna tylko w statycznej metodzie valueOf . To znaczy, możemy powiedzieć, że jest powiązany z całą klasą Integer , a nie z jej pojedynczymi instancjami – dlatego IntegerCache jest statyczny.
Przykład wewnętrznej anonimowej klasy
Weźmy klasę InputStream i jej statyczną metodę nullInputStream jako przykład klasy anonimowej :
public static InputStream nullInputStream() {
return new InputStream() {
private volatile boolean closed;
private void ensureOpen() throws IOException {
if (closed) {
throw new IOException("Stream closed");
}
}
@Override
public int available () throws IOException {
ensureOpen();
return 0;
}
@Override
public int read() throws IOException {
ensureOpen();
return -1;
}
@Override
public int read(byte[] b, int off, int len) throws IOException {
Objects.checkFromIndexSize(off, len, b.length);
if (len == 0) {
return 0;
}
ensureOpen();
return -1;
}
@Override
public byte[] readAllBytes() throws IOException {
ensureOpen();
return new byte[0];
}
@Override
public int readNBytes(byte[] b, int off, int len)throws IOException {
Objects.checkFromIndexSize(off, len, b.length);
ensureOpen();
return 0;
}
@Override
public byte[] readNBytes(int len) throws IOException {
if (len < 0) {
throw new IllegalArgumentException("len < 0");
}
ensureOpen();
return new byte[0];
}
@Override
public long skip(long n) throws IOException {
ensureOpen();
return 0L;
}
@Override
public void skipNBytes(long n) throws IOException {
ensureOpen();
if (n > 0) {
throw new EOFException();
}
}
@Override
public long transferTo(OutputStream out) throws IOException {
Objects.requireNonNull(out);
ensureOpen();
return 0L;
}
@Override
public void close() throws IOException {
closed = true;
}
};
}
Metoda zwraca pusty InputStream , a do jej implementacji używana jest klasa anonimowa. Ponieważ klasa nie miała mieć spadkobierców, uczyniono ją anonimową.
Wraz z dodaniem API Java Stream, anonimowe klasy stały się wszechobecne: wszystkie wyrażenia lambda są anonimowymi klasami, które implementują taki lub inny interfejs funkcjonalny. Rozważ przykłady.
W klasie AbstractStringBuilder jest rodzicem słynnych StringBuilder i StringBuffer :
@Override
public IntStream chars() {
return StreamSupport.intStream(
() -> {
byte[] val = this.value;
int count = this.count;
byte coder = this.coder;
return coder == LATIN1
? new StringLatin1.CharsSpliterator(val, 0, count, 0)
: new StringUTF16.CharsSpliterator(val, 0, count, 0);
},
Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED,
false);
}
W klasie Files metoda konwersji Closeable na Runnable :
private static Runnable asUncheckedRunnable(Closeable c) {
return () -> {
try {
c.close();
} catch (IOException e) {
throw new UncheckedIOException(e);
}
};
}
W klasie Class metoda odwzorowująca metodę łańcuchową:
private String methodToString(String name, Class<?>[] argTypes) {
return getName() + '.' + name +
((argTypes == null || argTypes.length == 0) ?
"()" :
Arrays.stream(argTypes)
.map(c -> c == null ? "null" : c.getName())
.collect(Collectors.joining(",", "(", ")")));
}
GO TO FULL VERSION