Contoh kelas dalam
Kelas AbstractList memiliki kelas dalam Itr . Ini adalah implementasi dari antarmuka Iterator , yang memungkinkan untuk mendapatkan elemen koleksi satu per satu:
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();
}
}Ini digunakan dalam metode iterator :
public Iterator<E> iterator() {
return new Itr();
}Ini adalah bagaimana setiap turunan dari AbstractList mendapatkan iterator yang sudah jadi. Dan jika Anda perlu menyesuaikan iterator, Anda dapat mengimplementasikan kelas Anda sendiri yang mewarisi Iterator atau Itr , lalu mengganti metode iterator . Sebagai contoh, inilah yang dilakukan oleh kelas ArrayList .
Kelas Itr tidak statis . Hasilnya, objek Itr memiliki referensi ke instance AbstractList dan dapat mengakses metodenya ( size , get , remove ).
Contoh kelas bersarang statis
Kelas Integer memiliki kelas bersarang 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 merangkum fungsionalitas yang membuat cache dan menyimpan rentang cache serta nilai cache itu sendiri. Dengan demikian, segala sesuatu yang berhubungan dengan cache disimpan dalam kelas yang terpisah. Ini membuatnya lebih mudah untuk membaca dan memodifikasi kode. Kode yang menggunakan kelas:
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}Kelas IntegerCache tidak mengakses bidang dan metode non-statis dari kelas Integer . Selain itu, ini diakses hanya dalam metode valueOf statis . Artinya, ia terikat pada kelas Integer itu sendiri, bukan pada instance individualnya. Dan itu berarti IntegerCache bersifat statis.
Contoh kelas dalam anonim
Sebagai contoh kelas anonim, mari kita ambil InputStream dan metode nullInputStream statisnya :
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;
}
};
}Metode mengembalikan InputStream kosong , diimplementasikan oleh kelas anonim. Karena class tidak seharusnya memiliki turunan, kami membuatnya anonim.
Dengan penambahan Java Stream API, kelas anonim menjadi ada di mana-mana: semua ekspresi lambda adalah kelas anonim yang mengimplementasikan beberapa antarmuka fungsional. Pertimbangkan beberapa contoh.
Kelas AbstractStringBuilder berisi induk dari kelas StringBuilder dan StringBuffer yang terkenal :
@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);
}Kelas Files memiliki untuk mengonversi Closeable menjadi Runnable :
private static Runnable asUncheckedRunnable(Closeable c) {
return () -> {
try {
c.close();
} catch (IOException e) {
throw new UncheckedIOException(e);
}
};
}Kelas Kelas memiliki metode untuk mendapatkan representasi string dari 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(",", "(", ")")));
}