ஜாவாவில் primitive types மற்றும் reference types என்ன?

Question

IT Interview Practice · Accepted Answer

ஜாவாவில் இரண்டு அடிப்படை வகைகளின் வகைகள் உள்ளன: **primitive types** (நேரடியாக சேமிக்கப்பட்ட எளிய மதிப்புகள்) மற்றும் **reference types** (பொருள், இதில் மாறி பொருளுக்கு 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 — பொருள்கள் ```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 இல் சேமிக்கப்பட்ட பொருளுக்கு **reference** (நினைவக முகவரி) வைத்திருக்கின்றன — பொருளையே அல்ல. அவை `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 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 பொருள் தேவைப்படும் இடங்களில் பயன்படுத்தப்படலாம் (collections, generics). ## இது ஏன் முக்கியமாக உள்ளது Primitive மற்றும் reference வேறுபாடு ஜாவாவிற்கு அடிப்படை மற்றும் பல நுண்ணிய பிழைகள் மற்றும் நடத்தைகளின் மூலம்: ஒதுக்கல் primitive types க்கு மதிப்புகளை நகலெடுக்கிறது ஆனால் பொருள்களுக்கு references ஐ பகிர்ந்து கொள்கிறது (எனவே பகிரப்பட்ட பொருளை மாற்றுவது அனைத்து references ஐ பாதிக்கிறது), மற்றும் குறிப்பாக **`==` பொருள்களுக்கு பரிচயத்தை ஒப்பிடுகிறது** (ஒரு உன்னதமான பிழை — உள்ளடக்க ஒப்பீட்டிற்கு `.equals()` ஐ பயன்படுத்தவும்). இதை புரிந்துகொள்வது ஒப்பீடுகளில் சரியான தன்மை, முறை வாதங்கள் (பொருள்கள் reference மதிப்பின் மூலம் பயனுள்ள முறையில் அனுப்பப்படுகிறது), null கையாளுதல் (reference only null ஆக இருக்கலாம்) மற்றும் செயல்திறன் (primitive types இல்லை) ஆகியவற்றை பாதிக்கிறது. இது சரியான ஜாவா எழுதுவதற்கான முக்கிய அறிவாகும்.

8 primitive types

Reference types — பொருள்கள்

முக்கியமான வேறுபாடு: ஒதுக்கல் மற்றும் ஒப்பீடு

Wrapper classes இரண்டையும் பாலம்

இது ஏன் முக்கியமாக உள்ளது

தொடர்புடைய கேள்விகள்