CodeGym /Kursus Jawa /2. modul: Java Core /Conto macem-macem jinis kelas ing JDK

Conto macem-macem jinis kelas ing JDK

2. modul: Java Core
tingkat , wulangan
kasedhiya

Tuladha kelas batin

Kelas AbstractList nduweni kelas batin Itr . Iki minangka implementasi antarmuka Iterator , sing ndadekake bisa entuk unsur koleksi siji-siji:


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

Iki digunakake ing metode iterator :


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

Iki kepiye turunane AbstractList entuk iterator sing wis siap. Lan yen sampeyan kudu ngatur iterator, sampeyan bisa ngleksanakake kelas dhewe sing olèh warisan Iterator utawa Itr , lan banjur ngganti cara iterator . Contone, iki sing ditindakake kelas ArrayList .

Kelas Itr non-statis . Akibaté, obyek Itr duwe referensi kanggo conto AbstractList lan bisa ngakses cara ( ukuran , njaluk , mbusak ).

Conto kelas nested statis

Kelas Integer duwe kelas IntegerCache nested.


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 encapsulates fungsi sing nggawe cache lan nyimpen kisaran cache uga nilai cached dhewe. Mangkono, kabeh sing ana gandhengane karo cache disimpen ing kelas sing kapisah. Iki nggampangake maca lan ngowahi kode kasebut. Kode sing nggunakake 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 ora ngakses kolom non-statis lan metode kelas Integer . Kajaba iku, diakses mung ing metode statis valueOf . Tegese, iku kaiket ing kelas Integer dhewe, ora kanggo kedadean individu. Lan tegese IntegerCache statis.

Tuladha kelas batin anonim

Minangka conto kelas anonim, ayo njupuk InputStream lan metode nullInputStream statis :


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

Cara kasebut ngasilake InputStream kosong , sing ditindakake dening kelas anonim. Amarga kelas kasebut mesthine ora duwe turunan, mula kita nggawe anonim.

Kanthi tambahan Java Stream API, kelas anonim wis ana ing ngendi-endi: kabeh ekspresi lambda minangka kelas anonim sing ngetrapake sawetara antarmuka fungsional. Coba sawetara conto.

Kelas AbstractStringBuilder ngemot induk kelas StringBuilder lan StringBuffer sing misuwur :


@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 duwe kanggo ngowahi Closeable menyang Runnable :


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

Kelas Kelas duwe metode kanggo njupuk perwakilan string saka 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(",", "(", ")")));
}
Komentar
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION