JDKలోని వివిధ రకాల తరగతులకు ఉదాహరణలు

అంతర్గత తరగతికి ఉదాహరణ

అబ్‌స్ట్రాక్ట్‌లిస్ట్ క్లాస్‌లో Itr ఇన్నర్ క్లాస్ ఉంది . ఇది ఇటరేటర్ ఇంటర్‌ఫేస్ యొక్క అమలు , ఇది సేకరణల యొక్క అంశాలను ఒక్కొక్కటిగా పొందడం సాధ్యం చేస్తుంది:

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

ఇది ఇటరేటర్ పద్ధతిలో ఉపయోగించబడుతుంది :

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

ఈ విధంగా అబ్‌స్ట్రాక్ట్‌లిస్ట్ యొక్క ఏ వారసుడైనా రెడీమేడ్ ఇటరేటర్‌ని పొందుతాడు. మరియు మీరు ఇటరేటర్‌ను అనుకూలీకరించాల్సిన అవసరం ఉన్నట్లయితే, మీరు ఇటరేటర్ లేదా Itr ను వారసత్వంగా పొందే మీ స్వంత తరగతిని అమలు చేయవచ్చు , ఆపై ఇటరేటర్ పద్ధతిని భర్తీ చేయవచ్చు. ఉదాహరణకు, అర్రేలిస్ట్ క్లాస్ చేసేది ఇదే .

Itr తరగతి స్థిరమైనది కాదు . ఫలితంగా, Itr ఆబ్జెక్ట్ వియుక్త జాబితా ఉదాహరణకి సూచనను కలిగి ఉంది మరియు దాని పద్ధతులను యాక్సెస్ చేయగలదు ( పరిమాణం , పొందండి , తీసివేయండి ).

స్టాటిక్ నెస్టెడ్ క్లాస్ యొక్క ఉదాహరణ

పూర్ణాంక తరగతిలో 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 క్యాష్‌ను సృష్టించే కార్యాచరణను కలుపుతుంది మరియు కాష్ పరిధులను అలాగే కాష్ చేయబడిన విలువలను నిల్వ చేస్తుంది. అందువలన, కాష్కు సంబంధించిన ప్రతిదీ ప్రత్యేక తరగతిలో ఉంచబడుతుంది. ఇది కోడ్‌ను చదవడం మరియు సవరించడం సులభం చేస్తుంది. తరగతిని ఉపయోగించే కోడ్:

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

IntegerCache క్లాస్ నాన్ -స్టాటిక్ ఫీల్డ్‌లు మరియు పూర్ణాంక తరగతి యొక్క పద్ధతులను యాక్సెస్ చేయదు . అదనంగా, ఇది స్టాటిక్ వాల్యూఆఫ్ పద్ధతిలో మాత్రమే యాక్సెస్ చేయబడుతుంది. అంటే, ఇది పూర్ణాంక తరగతికి కట్టుబడి ఉంటుంది, దాని వ్యక్తిగత ఉదాహరణలకు కాదు. మరియు దీని అర్థం IntegerCache స్థిరమైనది.

అనామక అంతర్గత తరగతికి ఉదాహరణ

అనామక తరగతికి ఉదాహరణగా, InputStream మరియు దాని స్టాటిక్ 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;
    	}
    };
}

పద్ధతి ఒక అనామక తరగతి ద్వారా అమలు చేయబడిన ఖాళీ ఇన్‌పుట్ స్ట్రీమ్‌ని అందిస్తుంది . తరగతికి వారసులు ఉండకూడదు కాబట్టి, మేము దానిని అనామకంగా చేసాము.

జావా స్ట్రీమ్ API చేరికతో, అనామక తరగతులు సర్వవ్యాప్తి చెందాయి: అన్ని లాంబ్డా వ్యక్తీకరణలు కొన్ని ఫంక్షనల్ ఇంటర్‌ఫేస్‌ను అమలు చేసే అనామక తరగతులు. కొన్ని ఉదాహరణలను పరిశీలించండి.

అబ్‌స్ట్రాక్ట్‌స్ట్రింగ్‌బిల్డర్ క్లాస్ ప్రసిద్ధ స్ట్రింగ్‌బిల్డర్ మరియు స్ట్రింగ్‌బఫర్ క్లాసుల పేరెంట్‌ని కలిగి ఉంది :

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

ఫైల్స్ క్లాస్‌లో క్లోజబుల్‌ని రన్ చేయదగినదిగా మార్చడం కోసం ఉంది :

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

క్లాస్ క్లాస్ పద్ధతి యొక్క స్ట్రింగ్ ప్రాతినిధ్యాన్ని పొందడానికి ఒక పద్ధతిని కలిగి ఉంది:

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