Java માં આદિમ પ્રકારો વિરુદ્ધ સંદર્ભ પ્રકારો શું છે?

Question

Accepted Answer

Java પાસે બે મૌલિક શ્રેણીઓ છે: **આદિમ** (સરળ મૂલ્યો સીધા સંગ્રહિત) અને **સંદર્ભ પ્રકારો** (ઑબ્જેક્ટ્સ, જ્યાં ચલ ઑબ્જેક્ટ તરફ સંદર્ભ/નિર્દેશક ધરાવે છે). તેઓ મેમરી, સોંપણી અને સરખામણીમાં ખૂબ જ અલગ રીતે વર્તે છે. ## 8 આદિમ પ્રકારો ```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 ``` આદિમ **વાસ્તવિક મૂલ્ય** સીધો સંગ્રહ કરે છે, નિશ્ચિત-કદના છે, શૂન્ય નથી, અને સ્ટેક પર રહે છે (સ્થાનિક માટે). તેઓ ઝડપી અને મેમરી-કાર્યક્ષમ છે. ## સંદર્ભ પ્રકારો — ઑબ્જેક્ટ્સ ```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 ``` સંદર્ભ ચલો હીપ પર સંગ્રહિત ઑબ્જેક્ટ તરફ **સંદર્ભ** (મેમરી સરનામું) ધરાવે છે — ઑબ્જેક્ટ નહીં. તેઓ `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 ``` મહાન મુશ્કેલી: **ઑબ્જેક્ટ્સ પર `==` ઓળખાણ તુલના કરે છે (સમાન ઑબ્જેક્ટ?), સામગ્રી નહીં** — સામગ્રી સરખામણી માટે `.equals()` વાપરો. ## Wrapper વર્ગો બંનેને સેતુ આપે છે ```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 ``` પ્રત્યેક આદિમ પાસે wrapper વર્ગ છે (`int`→`Integer`, વગેરે) જેથી આદિમો ત્યાં વાપરી શકાય જ્યાં ઑબ્જેક્ટ્સ આવશ્યક છે (સંગ્રહો, સર્વસામાન્ય). ## શા માટે તે મહત્વપૂર્ણ છે આદિમ-વિરુદ્ધ-સંદર્ભ ભેદ Java માટે મૌલિક છે અને ઘણા સૂક્ષ્મ ભૂલો અને વર્તણુક માટે સ્ત્રોત છે: આદિમ માટે સોંપણી મૂલ્યો નકલ કરે છે પરંતુ ઑબ્જેક્ટ્સ માટે સંદર્ભો શેર કરે છે (તેથી શેર કરેલ ઑબ્જેક્ટને સુધારવું બધા સંદર્ભોને અસર કરે છે), અને ખાસ કરીને કે **ઑબ્જેક્ટ્સ પર `==` ઓળખાણ તુલના કરે છે** (એક ક્લાસીક ભૂલ — સામગ્રી માટે `.equals()` વાપરો). આ બાબતને સમજવું સરખામણીઓ, પદ્ધતિ દલીલો (ઑબ્જેક્ટ્સ અસરકારક રીતે સંદર્ભ મૂલ્ય દ્વારા પસાર થાય છે), null-હેન્ડલિંગ (શૂન્ય માત્ર સંદર્ભ હોઈ શકે છે), અને કાર્યક્ષમતાની સાચીતાને અસર કરે છે (આદિમો હળવા છે). Java સાચું લખવા માટે તે મુખ્ય જ્ઞાન છે.