Példák a JDK különböző típusú osztályaira

Példa egy belső osztályra

Az AbstractList osztálynak van egy Itr belső osztálya. Ez az Iterator felület megvalósítása , amely lehetővé teszi a gyűjtemények elemeinek egyenkénti lekérését:

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();
	}
}

Az iterátor módszerben használatos :

public Iterator<E> iterator() {
	return new Itr();
}

Így kap az AbstractList bármely leszármazottja egy kész iterátort. És ha testre kell szabnia az iterátort, megvalósíthatja saját osztályát, amely örökli az Iterátort vagy az Itr -t , majd felülírhatja az iterátor metódust. Például ezt teszi az ArrayList osztály.

Az Itr osztály nem statikus. Ennek eredményeként az Itr objektum hivatkozik az AbstractList példányra, és hozzáférhet annak metódusaihoz ( size , get , remove ).

Példa egy statikus beágyazott osztályra

Az Integer osztálynak van egy IntegerCache beágyazott osztálya.

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() {}
}

Az IntegerCache olyan funkciókat foglal magában, amelyek gyorsítótárat hoznak létre, és tárolják a gyorsítótár-tartományokat, valamint magukat a gyorsítótárazott értékeket. Így minden, ami a gyorsítótárral kapcsolatos, külön osztályban van tárolva. Ez megkönnyíti a kód olvasását és módosítását. Az osztályt használó kód:

public static Integer valueOf(int i) {
	if (i >= IntegerCache.low && i <= IntegerCache.high)
    		return IntegerCache.cache[i + (-IntegerCache.low)];
	return new Integer(i);
}

Az IntegerCache osztály nem fér hozzá az Integer osztály nem statikus mezőihez és metódusaihoz. Ezenkívül csak a static valueOf metódussal érhető el . Vagyis magához az Integer osztályhoz van kötve, nem pedig az egyes példányaihoz. Ez azt jelenti, hogy az IntegerCache statikus.

Példa egy névtelen belső osztályra

Példaként egy névtelen osztályra vegyük az InputStream és annak statikus nullInputStream metódusát:

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;
    	}
    };
}

A metódus egy üres InputStream értéket ad vissza , amelyet egy névtelen osztály valósít meg. Mivel az osztálynak nem kellenek leszármazottai, anonimmá tettük.

A Java Stream API hozzáadásával az anonim osztályok mindenütt jelen vannak: minden lambda kifejezés névtelen osztály, amely valamilyen funkcionális interfészt valósít meg. Vegyünk néhány példát.

Az AbstractStringBuilder osztály tartalmazza a híres StringBuilder és StringBuffer osztályok szülőjét :

@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);
}

A Fájlok osztály rendelkezik a Closeable- ből futtathatóvá konvertálására :

private static Runnable asUncheckedRunnable(Closeable c) {
	return () -> {
    	try {
        	c.close();
    	} catch (IOException e) {
        	throw new UncheckedIOException(e);
    	}
	};
}

A Class osztálynak van egy metódusa egy metódus karakterlánc reprezentációjának lekérésére:

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(",", "(", ")")));
}