CodeGym /Kurso sa Java /Module 2: Java Core /Mga halimbawa ng iba't ibang uri ng klase sa JDK

Mga halimbawa ng iba't ibang uri ng klase sa JDK

Module 2: Java Core
Antas , Aral
Available

Halimbawa ng isang panloob na klase

Ang klase ng AbstractList ay may panloob na klase ng Itr . Ito ay isang pagpapatupad ng interface ng Iterator , na ginagawang posible na makakuha ng mga elemento ng mga koleksyon nang paisa-isa:


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

Ginagamit ito sa pamamaraan ng iterator :


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

Ito ay kung paano nakakakuha ang sinumang inapo ng AbstractList ng isang yari na iterator. At kung kailangan mong i-customize ang iterator, maaari mong ipatupad ang iyong sariling klase na nagmamana ng Iterator o Itr , at pagkatapos ay i-override ang pamamaraan ng iterator . Halimbawa, ito ang ginagawa ng klase ng ArrayList .

Ang klase ng Itr ay hindi static. Bilang resulta, ang Itr object ay may reference sa AbstractList instance at maaaring ma-access ang mga pamamaraan nito ( size , get , remove ).

Halimbawa ng isang static na nested na klase

Ang Integer class ay may isang IntegerCache nested class.


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 functionality na lumilikha ng isang cache at nag-iimbak ng mga hanay ng cache pati na rin ang mga naka-cache na halaga sa kanilang sarili. Kaya, lahat ng bagay na nauugnay sa cache ay pinananatili sa isang hiwalay na klase. Ginagawa nitong mas madaling basahin at baguhin ang code. Code na gumagamit ng klase:


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

Hindi ina-access ng klase ng IntegerCache ang mga non-static na field at pamamaraan ng klase ng Integer . Bilang karagdagan, ito ay naa-access lamang sa static na valueOf method. Iyon ay, ito ay nakasalalay sa klase ng Integer mismo, hindi sa mga indibidwal na pagkakataon nito. At nangangahulugan ito na ang IntegerCache ay static.

Halimbawa ng hindi kilalang panloob na klase

Bilang isang halimbawa ng isang hindi kilalang klase, kunin natin ang InputStream at ang static na nullInputStream na pamamaraan nito:


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

Ang pamamaraan ay nagbabalik ng isang walang laman na InputStream , na ipinatupad ng isang hindi kilalang klase. Dahil ang klase ay hindi dapat magkaroon ng mga inapo, ginawa namin itong anonymous.

Sa pagdaragdag ng Java Stream API, ang mga anonymous na klase ay naging ubiquitous: lahat ng lambda expression ay mga anonymous na klase na nagpapatupad ng ilang functional na interface. Isaalang-alang ang ilang halimbawa.

Ang klase ng AbstractStringBuilder ay naglalaman ng magulang ng sikat na StringBuilder at StringBuffer na mga klase:


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

Ang klase ng Files ay may para sa pag-convert ng isang Closeable sa isang Runnable :


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

Ang klase ng Klase ay may pamamaraan para sa pagkuha ng isang string na representasyon ng isang pamamaraan:


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(",", "(", ")")));
}
Mga komento
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION