static మరియు final కీవర్డ్‌ల అర్థం ఏమిటి?

Question

IT Interview Practice · Accepted Answer

**`static`** అంటే "క్లాస్‌కు చెందినది, ఇన్‌స్టెన్సులకు కాదు." **`final`** అంటే "మార్చబడటానికి/విస్తరించబడటానికి వీలు లేనిది." ఇవి స్వతంత్ర కీవర్డ్‌లు తరచుగా గందరగోళానికి గురవుతాయి, కానీ అవి విభిన్న సమస్యలను పరిష్కరిస్తాయి — మరియు స్థిరాంకాలను చేయడానికి కలిసి ఉపయోగించబడతాయి. ## static — క్లాస్‌-స్థర, అన్ని ఇన్‌స్టెన్సులలో భాగస్వామ్య ```java public class Counter { static int count = 0; // ONE shared variable for the whole class int id; // each instance has its OWN id Counter() { count++; // increments the shared counter id = count; } static void reset() { // static method — called on the class count = 0; } } Counter.count; // access via the CLASS name, no instance needed Counter.reset(); // call a static method on the class new Counter(); // each new instance shares `count` ``` `static` సభ్యులు క్లాస్‌కు చెందుతాయి, వ్యక్తిగత వస్తువులకు కాదు — అన్ని ఇన్‌స్టెన్సులచే భాగస్వామ్యం చేయబడిన ఒక కాపీ ఉంటుంది, క్లాస్‌ పేరు ద్వారా ప్రాప్యత. Static విధులు `this` లేదా ఇన్‌స్టెన్స్ ఫీల్డ్‌లను ఉపయోగించలేవు (ఇన్‌స్టెన్స్ లేనిది). ## final — పునర్నిర్ధారణ / ఓవర్‌రైడ్ / విస్తరణ చేయలేనిది ```java final int MAX = 100; // a constant — can't be reassigned MAX = 200; // ❌ compile error final class Util { } // a final CLASS can't be subclassed (e.g. String is final) class Base { final void critical() { } // a final METHOD can't be overridden } ``` `final` మూడు ఉపయోగాలను కలిగి ఉంది: ఒక చివరి **variable** పునర్నిర్ధారణ చేయబడదు (స్థిరాంకం), చివరి **method** ఓవర్‌రైడ్ చేయబడదు, మరియు చివరి **class** విస్తరించబడదు. ## సూక్ష్ముడైన పాయింట్: చివరి సూచనలు ```java final List list = new ArrayList<>(); list.add("a"); // ✅ ALLOWED — modifying the OBJECT, not the reference list = new ArrayList<>(); // ❌ ERROR — can't REASSIGN the reference ``` `final` సూచన కోసం, *సూచన* పునర్నిర్ధారణ చేయబడదు, కానీ ఇది సూచించే *వస్తువు* ఇప్పటికీ మార్పు చేయబడవచ్చు — గందరగోళానికి సాధారణ పాయింట్. ## సంయుక్తం: static final = స్థిరాంకం ```java public static final double PI = 3.14159; // class-level, unchangeable constant public static final String APP_NAME = "MyApp"; // convention: UPPER_SNAKE_CASE for static final constants ``` `static final` కలిసి నిజమైన స్థిరాంకాలను సృష్టిస్తాయి — మొత్తం క్లాస్‌ కోసం ఒక భాగస్వామ్య, మార్చలేని విలువ, జావాలో స్థిరాంకాలను నిర్వచించే ప్రామాణిక మార్గం. ## ఇది ఎందుకు ముఖ్యమైనది `static` మరియు `final` జావాలో ప్రాథమిక కీవర్డ్‌లు, విభిన్న, ముఖ్యమైన అర్థాలతో: `static` క్లాస్‌-స్థర స్థితి మరియు యుటిలిటీ విధులను ప్రారంభం చేస్తుంది (భాగస్వామ్య కౌంటర్‌లు, ఫ్యాక్టరీ విధులు, `Math.PI`, `main` విధి కూడా), అయితే `final` మార్పులేనితను ఖరారు చేస్తుంది మరియు వారసత్వం/ఓవర్‌రైడ్‌ను నిరోధిస్తుంది (స్థిరాంకాలు, String వంటి మార్పులేని తరగతులు, క్లిష్టమైన విధులను సీలింగ్). వాటిని అర్థం చేసుకోవడం — సూక్ష్ముడైన చివరి-సూచన ప్రవర్తన (సూచన స్థిర, వస్తువు మార్చదగినది) మరియు వాటి స్థిరాంకాలలో సంయోజనం సహా — తరగతులను సరిగ్గా రూపొందించడానికి, స్థిరాంకాలను సరిగ్గా నిర్వచించడానికి, విస్తరణను నియంత్రించడానికి, మరియు భాగస్వామ్య వర్సెస్ ఇన్‌స్టెన్స్-స్థర స్థితి గురించి తార్కికంగా ఆలోచించడానికి అవసరం. జావా కోడ్‌లో అవి విస్తృతమైనవి మరియు తరచుగా ఇంటర్వ్యూ విషయాలు.

static — క్లాస్‌-స్థర, అన్ని ఇన్‌స్టెన్సులలో భాగస్వామ్య

final — పునర్నిర్ధారణ / ఓవర్‌రైడ్ / విస్తరణ చేయలేనిది

సూక్ష్ముడైన పాయింట్: చివరి సూచనలు

సంయుక్తం: static final = స్థిరాంకం

ఇది ఎందుకు ముఖ్యమైనది

సంబంధిత ప్రశ్నలు