Ejemplo de una clase interna
La clase AbstractList tiene una clase interna Itr . Es una implementación de la interfaz Iterator , que permite obtener elementos de colecciones uno por uno:
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();
}
}
Se utiliza en el método iterador :
public Iterator<E> iterator() {
return new Itr();
}
Así es como cualquier descendiente de AbstractList obtiene un iterador listo para usar. Y si necesita personalizar el iterador, puede implementar su propia clase que hereda Iterator o Itr y luego anular el método del iterador . Por ejemplo, esto es lo que hace la clase ArrayList .
La clase Itr no es estática. Como resultado, el objeto Itr tiene una referencia a la instancia de AbstractList y puede acceder a sus métodos ( size , get , remove ).
Ejemplo de una clase anidada estática
La clase Integer tiene una clase anidada 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 encapsula la funcionalidad que crea un caché y almacena los rangos de caché, así como los propios valores almacenados en caché. Por lo tanto, todo lo relacionado con el caché se mantiene en una clase separada. Esto facilita la lectura y modificación del código. Código que usa la clase:
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
La clase IntegerCache no accede a campos y métodos no estáticos de la clase Integer . Además, solo se accede a él en el método estático valueOf . Es decir, está vinculado a la clase Integer en sí misma, no a sus instancias individuales. Y eso significa que IntegerCache es estático.
Ejemplo de una clase interna anónima
Como ejemplo de una clase anónima, tomemos InputStream y su método estático nullInputStream :
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;
}
};
}
El método devuelve un InputStream vacío , implementado por una clase anónima. Debido a que se supone que la clase no tiene descendientes, la hicimos anónima.
Con la adición de la API Java Stream, las clases anónimas se han vuelto omnipresentes: todas las expresiones lambda son clases anónimas que implementan alguna interfaz funcional. Considere algunos ejemplos.
La clase AbstractStringBuilder contiene el padre de las famosas clases StringBuilder y 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);
}
La clase Files tiene un para convertir un Closeable a un Runnable :
private static Runnable asUncheckedRunnable(Closeable c) {
return () -> {
try {
c.close();
} catch (IOException e) {
throw new UncheckedIOException(e);
}
};
}
La clase Class tiene un método para obtener una representación de cadena de un método:
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