జావాలో primitive types మరియు reference types ఏమిటి?

Question

Accepted Answer

జావాలో రెండు ప్రాథమిక రకాల వర్గాలు ఉన్నాయి: **primitive types** (నేరుగా నిల్వ చేయబడిన సరళ విలువలు) మరియు **reference types** (objects, ఇక్కడ వేరియబల్ object కు reference/pointer ను కలిగి ఉంటుంది). అవి మెమరీ, అసైన్‌మెంట్ మరియు పోలికలో చాలా భిన్నంగా ప్రవర్తిస్తాయి. ## 8 primitive types ```java int i = 42; // 32-bit integer long l = 100L; // 64-bit integer double d = 3.14; // 64-bit floating point float f = 1.5f; // 32-bit floating point boolean b = true; // true/false char c = 'A'; // 16-bit Unicode character byte by = 127; // 8-bit short s = 1000; // 16-bit ``` Primitive types **వాస్తవ విలువను** నేరుగా నిల్వ చేస్తాయి, స్థిర-సైజ్‌గా ఉంటాయి, null ఉండకూడదు, మరియు stack పై (స్థానిక వేరియబల్‌ల కోసం) నివసిస్తాయి. అవి వేగవంతమైనవి మరియు మెమరీ-సమర్థవంతమైనవి. ## Reference types — objects ```java String name = "Ann"; // reference to a String object int[] arr = {1, 2, 3}; // reference to an array object List list = new ArrayList<>(); // reference to a List object Person p = new Person("Bob"); // reference to a Person object ``` Reference వేరియబల్‌లు heap పై నిల్వ చేయబడిన object కు **reference** (మెమరీ చిరునామా) ను కలిగి ఉంటాయి — object కాదు. అవి `null` ఉండవచ్చు. ## విమర్శనీయమైన వ్యత్యాసం: అసైన్‌మెంట్ మరియు పోలిక ```java // primitives — assignment COPIES the value (independent) int a = 5; int b = a; // b is a COPY b = 10; // a is still 5 // references — assignment COPIES the reference (both point to the SAME object) int[] x = {1, 2, 3}; int[] y = x; // y points to the SAME array y[0] = 99; // x[0] is now 99 too! (shared object) ``` ```java // == compares VALUES for primitives, but REFERENCES (identity) for objects String s1 = new String("hi"); String s2 = new String("hi"); s1 == s2; // false — different objects (different references) s1.equals(s2); // true — equals() compares CONTENT ``` ఇది ఒక పెద్ద ఫంపు: **objects పై `==` గుర్తింపుని (ఒకే object?) పోలుస్తుంది, కంటెంట్ కాదు** — కంటెంట్ పోలిక కోసం `.equals()` ని ఉపయోగించండి. ## Wrapper classes రెండింటిని సంతరించుకుంటాయి ```java Integer boxed = 42; // Integer is the OBJECT wrapper for int (autoboxing) int unboxed = boxed; // auto-unboxing back to primitive List nums; // collections need objects, not primitives ``` ప్రతి primitive type కు wrapper class ఉంటుంది (`int`→`Integer`, మొదలైనవి) కాబట్టి primitives objects అవసరమైన చోట ఉపయోగించబడతాయి (collections, generics). ## ఇది ఎందుకు ముఖ్యమైనది Primitive-vs-reference వ్యత్యాసం జావాకు ప్రాథమికమైనది మరియు చాలా సూక్ష్మమైన బగ్‌లు మరియు ప్రవర్తనల మూలం: అసైన్‌మెంట్ primitives కోసం విలువలను కాపీ చేస్తుంది కానీ objects కోసం references ను విభజిస్తుంది (కాబట్టి విభజిత object ను సవరించడం అన్ని references ను ప్రభావితం చేస్తుంది), మరియు ముఖ్యంగా **objects కోసం `==` గుర్తింపుని పోలుస్తుంది** (ఒక గతిక పొరపాటు — కంటెంట్ పోలిక కోసం `.equals()` ని ఉపయోగించండి). ఇది అర్థం చేసుకోవడం పోలికలలో సరిదనం, మెథడ్ ఆర్గ్యుమెంట్‌లు (objects reference విలువ ద్వారా సమర్థవంతంగా పంపబడతాయి), null-హ్యాండ్లింగ్ (references మాత్రమే null ఉండవచ్చు) మరియు పనితీరు (primitives తేలికవైనవి) లను ప్రభావితం చేస్తుంది. ఇది సరైన జావా రాయడానికి కోర్ జ్ఞానం.