Exempel på en inre klass
Klassen AbstractList har en inre Itr- klass. Det är en implementering av Iterator- gränssnittet, som gör det möjligt att hämta element från samlingar en efter en:
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();
}
}Det används i iteratormetoden :
public Iterator<E> iterator() {
return new Itr();
}Så här får alla ättlingar till AbstractList en färdig iterator. Och om du behöver anpassa iteratorn kan du implementera din egen klass som ärver Iterator eller Itr , och sedan åsidosätta iteratormetoden . Detta är till exempel vad ArrayList -klassen gör.
Itr - klassen är icke-statisk. Som ett resultat har Itr -objektet en referens till AbstractList- instansen och kan komma åt dess metoder ( size , get , remove ).
Exempel på en statisk kapslad klass
Klassen Integer har en kapslad klass 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 kapslar in funktionalitet som skapar en cache och lagrar cacheintervallen såväl som själva cachade värden. Allt relaterat till cachen hålls alltså i en separat klass. Detta gör det lättare att läsa och ändra koden. Kod som använder klassen:
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}Klassen IntegerCache har inte åtkomst till icke-statiska fält och metoder för Integer- klassen. Dessutom nås den endast i metoden static valueOf . Det vill säga, den är bunden till själva klassen Integer , inte till dess individuella instanser. Och det betyder att IntegerCache är statisk.
Exempel på en anonym inre klass
Som ett exempel på en anonym klass, låt oss ta InputStream och dess statiska nullInputStream- metod:
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;
}
};
}Metoden returnerar en tom InputStream , implementerad av en anonym klass. Eftersom klassen inte ska ha ättlingar gjorde vi den anonym.
Med tillägget av Java Stream API har anonyma klasser blivit allestädes närvarande: alla lambda-uttryck är anonyma klasser som implementerar något funktionellt gränssnitt. Tänk på några exempel.
Klassen AbstractStringBuilder innehåller föräldern till de berömda StringBuilder- och StringBuffer - klasserna:
@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);
}Klassen Files har en för att konvertera en stängbar till en körbar :
private static Runnable asUncheckedRunnable(Closeable c) {
return () -> {
try {
c.close();
} catch (IOException e) {
throw new UncheckedIOException(e);
}
};
}Klassen Class har en metod för att få en strängrepresentation av en metod:
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(",", "(", ")")));
}