Eksempel på en indre klasse
AbstractList - klassen har en indre Itr- klasse. Det er en implementering av Iterator- grensesnittet, som gjør det mulig å hente elementer av samlinger én etter én:
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();
}
}
Den brukes i iteratormetoden :
public Iterator<E> iterator() {
return new Itr();
}
Dette er hvordan enhver etterkommer av AbstractList får en ferdig iterator. Og hvis du trenger å tilpasse iteratoren, kan du implementere din egen klasse som arver Iterator eller Itr , og deretter overstyre iteratormetoden . Dette er for eksempel hva ArrayList -klassen gjør.
Itr - klassen er ikke-statisk. Som et resultat har Itr- objektet en referanse til AbstractList- forekomsten og kan få tilgang til metodene ( size , get , remove ).
Eksempel på en statisk nestet klasse
Integer - klassen har en IntegerCache nestet klasse.
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 innkapsler funksjonalitet som lager en hurtigbuffer og lagrer hurtigbufferområdene så vel som selve de bufrede verdiene. Dermed holdes alt relatert til cachen i en egen klasse. Dette gjør det lettere å lese og endre koden. Kode som bruker klassen:
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
IntegerCache - klassen har ikke tilgang til ikke-statiske felt og metoder for Integer- klassen. I tillegg er den bare tilgjengelig i den statiske valueOf- metoden. Det vil si at den er bundet til selve Integer- klassen, ikke til dens individuelle forekomster. Og det betyr at IntegerCache er statisk.
Eksempel på en anonym indre klasse
Som et eksempel på en anonym klasse, la oss ta InputStream og dens statiske nullInputStream- metode:
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 returnerer en tom InputStream , implementert av en anonym klasse. Fordi klassen ikke skal ha etterkommere, gjorde vi den anonym.
Med tillegg av Java Stream API, har anonyme klasser blitt allestedsnærværende: alle lambda-uttrykk er anonyme klasser som implementerer et funksjonelt grensesnitt. Tenk på noen eksempler.
AbstractStringBuilder - klassen inneholder overordnet til de berømte StringBuilder- og StringBuffer -klassene:
@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);
}
Filer - klassen har en for å konvertere en Closeable til en Runnable :
private static Runnable asUncheckedRunnable(Closeable c) {
return () -> {
try {
c.close();
} catch (IOException e) {
throw new UncheckedIOException(e);
}
};
}
Klasseklassen har en metode for å få en strengrepresentasjon av en metode:
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