static மற்றும் final keywords என்ன அர்த்தம்?

Question

Accepted Answer

**`static`** என்றால் "instances-க்கு அல்ல, class-க்கே சொந்தமானது." **`final`** என்றால் "மாற்ற/விரிவாக்க முடியாது." அவை அடிக்கடி குழப்பப்படும் தனித்தனி keywords, ஆனால் அவை வெவ்வேறு கவலைகளை நிவர்த்தி செய்கின்றன — மேலும் constants-ஐ உருவாக்க இணைகின்றன. ## static — class-level, அனைத்து instances-களிலும் பகிரப்படுகிறது ```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` members தனிப்பட்ட objects-க்கு அல்ல, class-க்கு சொந்தமானவை — அனைத்து instances-களாலும் பகிரப்படும் ஒரே ஒரு copy உள்ளது, class name மூலம் அணுகப்படுகிறது. Static methods `this`-ஐ அல்லது instance fields-ஐ பயன்படுத்த முடியாது (instance எதுவும் இல்லை). ## final — மீண்டும் ஒதுக்க / override / விரிவாக்க முடியாது ```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` மூன்று பயன்பாடுகளைக் கொண்டுள்ளது: ஒரு final **variable** மீண்டும் ஒதுக்க முடியாது (ஒரு constant), ஒரு final **method** override செய்ய முடியாது, மற்றும் ஒரு final **class** விரிவாக்க முடியாது. ## ஒரு நுட்பமான விஷயம்: final references ```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` reference-க்கு, *reference* மீண்டும் ஒதுக்க முடியாது, ஆனால் *அது சுட்டிக்காட்டும் object* இன்னும் மாற்றப்படலாம் — ஒரு பொதுவான குழப்பப் புள்ளி. ## இணைந்தது: static final = ஒரு constant ```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` ஒன்றாக உண்மையான constants-ஐ உருவாக்குகின்றன — முழு class-க்கும் ஒரு பகிரப்பட்ட, மாற்ற முடியாத மதிப்பு, Java-வில் constants-ஐ வரையறுக்கும் நிலையான வழி. ## இது ஏன் முக்கியம் `static` மற்றும் `final` தனித்துவமான, முக்கியமான அர்த்தங்களைக் கொண்ட அடிப்படை Java keywords: `static` class-level state மற்றும் utility methods-ஐ சாத்தியமாக்குகிறது (shared counters, factory methods, `Math.PI`, `main` method-ஐயே), அதே சமயம் `final` immutability-ஐ அமல்படுத்தி inheritance/overriding-ஐ தடுக்கிறது (constants, String போன்ற immutable classes, முக்கியமான methods-ஐ sealing செய்தல்). அவற்றைப் புரிந்துகொள்வது — நுட்பமான final-reference behavior (reference நிலையானது, object மாற்றக்கூடியது) மற்றும் அவற்றை constants ஆக இணைப்பது உட்பட — classes-ஐ சரியாக வடிவமைப்பதற்கும், constants-ஐ சரியாக வரையறுப்பதற்கும், விரிவாக்கத்தைக் கட்டுப்படுத்துவதற்கும், shared vs per-instance state பற்றி நியாயப்படுத்துவதற்கும் அவசியம். அவை Java code-இல் பரவலாக உள்ளன மற்றும் அடிக்கடி interview தலைப்புகளாகும்.