జావాలో ఫైనల్ కీవర్డ్ గురించి మాట్లాడుకుందాం

జావాకు ఈ కీవర్డ్ ఉంది — ఫైనల్. ఇది తరగతులు, పద్ధతులు, వేరియబుల్స్ (పద్ధతి పారామితులతో సహా)కి వర్తించవచ్చు. తరగతికి, చివరి కీవర్డ్ అంటే తరగతికి సబ్‌క్లాస్‌లు ఉండకూడదు, అంటే వారసత్వం నిషేధించబడింది... ఇది మార్పులేని (మారలేని) వస్తువులను సృష్టించేటప్పుడు ఉపయోగపడుతుంది. ఉదాహరణకు, స్ట్రింగ్ క్లాస్ ఫైనల్‌గా ప్రకటించబడింది.

    public final class String {
    }
    
    class SubString extends String { // Compilation error
    }

చివరి మాడిఫైయర్ అబ్‌స్ట్రాక్ట్ క్లాస్‌లకు (కీవర్డ్ అబ్‌స్ట్రాక్ట్‌తో ఉన్నవి) అన్వయించబడదని కూడా నేను గమనించాలి, ఎందుకంటే ఇవి పరస్పరం ప్రత్యేకమైన భావనలు. చివరి పద్ధతి కోసం, మాడిఫైయర్ అంటే ఉపవర్గాలలో పద్ధతిని భర్తీ చేయడం సాధ్యం కాదు. అసలు అమలులో మార్పును మేము నిరోధించాలనుకున్నప్పుడు ఇది ఉపయోగపడుతుంది.

    public class SuperClass {
        public final void printReport() {
            System.out.println("Report");
        }
    }

    class SubClass extends SuperClass { 
        public void printReport() { //Compilation error
            System.out.println("MyReport");
        }
    }

ఆదిమ రకం యొక్క వేరియబుల్స్ కోసం, తుది కీవర్డ్ అంటే విలువ, ఒకసారి కేటాయించబడితే, మార్చబడదు. రిఫరెన్స్ వేరియబుల్స్ కోసం, ఆబ్జెక్ట్ కేటాయించిన తర్వాత, మీరు ఆ వస్తువుకు సూచనను మార్చలేరు. ఇది ముఖ్యమైనది! సూచన మార్చబడదు, కానీ వస్తువు యొక్క స్థితిని మార్చవచ్చు. జావా 8 కొత్త కాన్సెప్ట్‌ను పరిచయం చేసింది: సమర్థవంతంగా ఫైనల్. ఇది వేరియబుల్స్‌కు మాత్రమే వర్తిస్తుంది (పద్ధతి పారామితులతో సహా). బాటమ్ లైన్ ఏమిటంటే, తుది కీవర్డ్ స్పష్టంగా లేనప్పటికీ, ప్రారంభించిన తర్వాత వేరియబుల్ విలువ మారదు. మరో మాటలో చెప్పాలంటే, కంపైలేషన్ లోపం లేకుండా తుది కీవర్డ్ అటువంటి వేరియబుల్‌కు వర్తించబడుతుంది. స్థానిక తరగతులు (స్థానిక అంతర్గత తరగతులు), అనామక తరగతులు (అనామక అంతర్గత తరగతులు) మరియు స్ట్రీమ్‌లు (స్ట్రీమ్ API) లోపల ప్రభావవంతంగా తుది వేరియబుల్‌లను ఉపయోగించవచ్చు.

        public void someMethod() {
            // In the example below, both a and b are effectively final, since they are assigned values only once:
            int a = 1;
            int b;
            if (a == 2) b = 3;
            else b = 4;
            // c is NOT effectively final since its value changes
            int c = 10;
            c++;
            
            Stream.of(1, 2).forEach(s-> System.out.println(s + a)); // OK
            Stream.of(1, 2).forEach(s-> System.out.println(s + c)); // Compilation error
        }

ఇప్పుడు, ఒక చిన్న ఇంటర్వ్యూ చేద్దాం. అన్నింటికంటే, కోడ్‌జిమ్ కోర్సును పూర్తి చేయడం యొక్క లక్ష్యం జావా డెవలపర్‌గా మారడం మరియు ఆసక్తికరమైన మరియు బాగా చెల్లించే ఉద్యోగాన్ని కనుగొనడం. కాబట్టి, ప్రారంభిద్దాం.

1. ఫైనల్‌గా ప్రకటించబడిన శ్రేణి గురించి మనం ఏమి చెప్పగలం?

2. స్ట్రింగ్ క్లాస్ మార్పులేనిదని మాకు తెలుసు: క్లాస్ ఫైనల్‌గా ప్రకటించబడింది. ఒక స్ట్రింగ్ విలువ కీవర్డ్ ఫైనల్‌తో గుర్తు పెట్టబడిన చార్ అర్రేలో నిల్వ చేయబడుతుంది.

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

మేము స్ట్రింగ్ ఆబ్జెక్ట్ యొక్క విలువను (ఆబ్జెక్ట్‌కు సూచనను మార్చకుండా) భర్తీ చేయగలమా? ఇవి నిజమైన ఇంటర్వ్యూ ప్రశ్నలు. మరియు చాలా మంది అభ్యర్థులు వాటికి సరిగ్గా సమాధానం ఇవ్వలేదని అభ్యాసం చూపిస్తుంది. తుది కీవర్డ్ ఎలా ఉపయోగించబడుతుందో అర్థం చేసుకోవడం, ముఖ్యంగా రిఫరెన్స్ వేరియబుల్స్ కోసం, చాలా ముఖ్యమైనది. మీరు దీన్ని ఆలోచిస్తున్నప్పుడు, నేను CodeGym బృందానికి ఒక చిన్న అభ్యర్థన చేస్తాను. దయచేసి మీరు దానిపై క్లిక్ చేసినప్పుడు కంటెంట్ చూపబడే/దాచబడే బ్లాక్‌ను జోడించగల సామర్థ్యాన్ని టెక్స్ట్ ఎడిటర్‌కు ఇవ్వండి. సమాధానాలు:

1. శ్రేణి అనేది ఒక వస్తువు, కాబట్టి చివరి కీవర్డ్ అంటే శ్రేణికి సూచనను కేటాయించిన తర్వాత, సూచన మార్చబడదు. మీరు వస్తువు యొక్క స్థితిని మార్చవచ్చు అని పేర్కొంది.

   
           final int[] array = {1, 2, 3, 4, 5};
           array[0] = 9;	 // OK, because we're changing the contents of the array: {9, 2, 3, 4, 5}
           array = new int[5]; // Compilation error
   

2. అవును మనం చేయగలం. వస్తువులతో ఉపయోగించినప్పుడు విసుగు పుట్టించే చివరి కీవర్డ్ అంటే ఏమిటో అర్థం చేసుకోవడం ప్రధాన విషయం. విలువలను భర్తీ చేయడానికి ప్రతిబింబ APIని ఉపయోగించవచ్చు.

import java.lang.reflect.Field;

class B {
    public static void main(String[] args) throws Exception {
        String value = "Old value";
        System.out.println(value);

        // Get the String class's value field
        Field field = value.getClass().getDeclaredField("value");
        // Make it mutable
        field.setAccessible(true);
        // Set a new value
        field.set(value, "CodeGym".toCharArray());

        System.out.println(value);

        /* Output:
         * Old value
         * CodeGym
         */
    }
}

దయచేసి మేము ఈ విధంగా ఆదిమ రకం యొక్క చివరి వేరియబుల్‌ని మార్చడానికి ప్రయత్నించినట్లయితే, ఏమీ జరగలేదని గమనించండి. మిమ్మల్ని మీరు ఒప్పించుకోవాలని నేను సూచిస్తున్నాను: జావా క్లాస్‌ని సృష్టించండి, ఉదాహరణకు, తుది పూర్ణాంక ఫీల్డ్‌తో మరియు రిఫ్లెక్షన్ APIని ఉపయోగించి దాని విలువను మార్చడానికి ప్రయత్నించండి. అందరికీ శుభోదయం!