Java પાસે બે મૌલિક શ્રેણીઓ છે: આદિમ (સરળ મૂલ્યો સીધા સંગ્રહિત) અને સંદર્ભ પ્રકારો (ઑબ્જેક્ટ્સ, જ્યાં ચલ ઑબ્જેક્ટ તરફ સંદર્ભ/નિર્દેશક ધરાવે છે). તેઓ મેમરી, સોંપણી અને સરખામણીમાં ખૂબ જ અલગ રીતે વર્તે છે.
;
;
;
;
;
;
;
;
આદિમ વાસ્તવિક મૂલ્ય સીધો સંગ્રહ કરે છે, નિશ્ચિત-કદના છે, શૂન્ય નથી, અને સ્ટેક પર રહે છે (સ્થાનિક માટે). તેઓ ઝડપી અને મેમરી-કાર્યક્ષમ છે.
String name = "Ann"; // reference to a String object
int[] arr = {1, 2, 3}; // reference to an array object
List<String> list = new ArrayList<>(); // reference to a List object
Person p = new Person("Bob"); // reference to a Person object
સંદર્ભ ચલો હીપ પર સંગ્રહિત ઑબ્જેક્ટ તરફ સંદર્ભ (મેમરી સરનામું) ધરાવે છે — ઑબ્જેક્ટ નહીં. તેઓ null હોઈ શકે છે.
// 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)
// == 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() વાપરો.
Integer boxed = 42; // Integer is the OBJECT wrapper for int (autoboxing)
int unboxed = boxed; // auto-unboxing back to primitive
List<Integer> nums; // collections need objects, not primitives
પ્રત્યેક આદિમ પાસે wrapper વર્ગ છે (int→Integer, વગેરે) જેથી આદિમો ત્યાં વાપરી શકાય જ્યાં ઑબ્જેક્ટ્સ આવશ્યક છે (સંગ્રહો, સર્વસામાન્ય).
આદિમ-વિરુદ્ધ-સંદર્ભ ભેદ Java માટે મૌલિક છે અને ઘણા સૂક્ષ્મ ભૂલો અને વર્તણુક માટે સ્ત્રોત છે: આદિમ માટે સોંપણી મૂલ્યો નકલ કરે છે પરંતુ ઑબ્જેક્ટ્સ માટે સંદર્ભો શેર કરે છે (તેથી શેર કરેલ ઑબ્જેક્ટને સુધારવું બધા સંદર્ભોને અસર કરે છે), અને ખાસ કરીને કે ઑબ્જેક્ટ્સ પર == ઓળખાણ તુલના કરે છે (એક ક્લાસીક ભૂલ — સામગ્રી માટે .equals() વાપરો). આ બાબતને સમજવું સરખામણીઓ, પદ્ધતિ દલીલો (ઑબ્જેક્ટ્સ અસરકારક રીતે સંદર્ભ મૂલ્ય દ્વારા પસાર થાય છે), null-હેન્ડલિંગ (શૂન્ય માત્ર સંદર્ભ હોઈ શકે છે), અને કાર્યક્ષમતાની સાચીતાને અસર કરે છે (આદિમો હળવા છે).
Java સાચું લખવા માટે તે મુખ્ય જ્ઞાન છે.
વિગતવાર જવાબો સાથે IT ઇન્ટરવ્યૂ પ્રશ્નોની લાઇબ્રેરી — જુનિયરથી સિનિયર સુધી.
દાન કરો