static અને final કીવર્ડ્સ શું મતલબ રાખે છે?

Question

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` ત્રણ ઉપયોગો છે: અંતિમ **ચલ** પુનઃનિયુક્ત કરી શકાતું નથી (એક અચલ), અંતિમ **પદ્ધતિ** ઓવરરાઇડ કરી શકાતી નથી, અને અંતિમ **ક્લાસ** વિસ્તૃત કરી શકાતી નથી. ## એક સૂક્ષ્મ બિંદુ: અંતિમ સંદર્ભો ```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` સાથે સાચા અચલો બનાવે છે — એક શેર, અપરિવર્તનશીલ મૂલ્ય સમગ્ર ક્લાસ માટે, Java માં અચલો વ્યાખ્યાયિત કરવાની પ્રમાણભૂત રીત. ## તે શા માટે મહત્વપૂર્ણ છે `static` અને `final` અલગ, મહત્વપૂર્ણ અર્થો સાથે મૌલિક Java કીવર્ડ્સ છે: `static` ક્લાસ-સ્તરીય સ્થિતિ અને ઉપયોગિતા પદ્ધતિઓ સક્ષમ કરે છે (શેર કાઉન્ટરો, ફેક્ટરી પદ્ધતિઓ, `Math.PI`, `main` પદ્ધતિ પોતે), જ્યારે `final` અપરિવર્તનશીલતા લાગુ કરે છે અને વારસો/ઓવરરાઇડિંગ અટકાવે છે (અચલો, અપરિવર્તનશીલ ક્લાસો જેમ કે String, નિર્ણાયક પદ્ધતિઓ સીલ કરવી). તેમને સમજવું — સૂક્ષ્મ અંતિમ-સંદર્ભ વર્તણૂક (સંદર્ભ નિશ્ચિત, ઑબ્જેક્ટ રૂપાંતરણશીલ) અને તેમનો સંયોજન અચલોમાં સહિત — ક્લાસો સાચી રીતે ડિઝાઇન કરવા, અચલો યોગ્ય રીતે વ્યાખ્યાયિત કરવા, વિસ્તારણીયતા નિયંત્રણ કરવા અને શેર વિ. પ્રતિ-ઇન્સ્ટન્સ સ્થિતિ વિશે તર્કશીલ કરવા માટે આવશ્યક છે. તે Java કોડમાં સર્વવ્યાપી છે અને સતત ઇન્ટરવ્યૂ વિષયો છે.