Eksempel på en indre klasse
AbstractList - klassen har en indre Itr- klasse. Det er en implementering af Iterator- grænsefladen, som gør det muligt at hente elementer af samlinger én efter é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();
}
}
Det bruges i iteratormetoden :
public Iterator<E> iterator() {
return new Itr();
}
Sådan får enhver efterkommer af AbstractList en færdig iterator. Og hvis du har brug for at tilpasse iteratoren, kan du implementere din egen klasse, der arver Iterator eller Itr , og derefter tilsidesætte iteratormetoden . Det er for eksempel, hvad ArrayList- klassen gør.
Itr - klassen er ikke-statisk. Som et resultat har Itr- objektet en reference til AbstractList- forekomsten og kan få adgang til dets metoder ( size , get , remove ).
Eksempel på en statisk indlejret klasse
Integer - klassen har en IntegerCache- indlejret 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 indkapsler funktionalitet, der opretter en cache og gemmer cacheintervallerne såvel som selve cacheværdierne. Alt relateret til cachen opbevares således i en separat klasse. Dette gør det nemmere at læse og ændre koden. Kode, der bruger 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 ikke adgang til ikke-statiske felter og metoder i Integer- klassen. Derudover er den kun tilgængelig i den statiske valueOf- metode. Det vil sige, at den er bundet til selve Integer- klassen, ikke til dens individuelle instanser. Og det betyder, at IntegerCache er statisk.
Eksempel på en anonym indre klasse
Som et eksempel på en anonym klasse, lad os tage 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 , implementeret af en anonym klasse. Fordi klassen ikke skal have efterkommere, gjorde vi den anonym.
Med tilføjelsen af Java Stream API er anonyme klasser blevet allestedsnærværende: alle lambda-udtryk er anonyme klasser, der implementerer en funktionel grænseflade. Overvej nogle eksempler.
Klassen AbstractStringBuilder indeholder forælderen til de berømte StringBuilder- og StringBuffer- klasser:
@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 til at 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 til at få en strengrepræsentation af 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