Java ਵਿੱਚ primitive types ਬਨਾਮ reference types ਕੀ ਹਨ?

Question

Accepted Answer

Java ਵਿੱਚ ਦੋ ਬੁਨਿਆਦੀ ਕਿਸਮਾਂ ਦੀਆਂ ਸ਼ਰੇਣੀਆਂ ਹਨ: **primitives** (ਸਧਾਰਨ ਮੁੱਲ ਸਿੱਧੇ ਸਟੋਰ ਕੀਤੇ ਗਏ) ਅਤੇ **reference types** (objects, ਜਿੱਥੇ variable object ਦਾ ਇੱਕ reference/pointer ਰੱਖਦਾ ਹੈ)। ਇਹ memory, assignment, ਅਤੇ comparison ਵਿੱਚ ਬਹੁਤ ਵੱਖਰੇ ਢੰਗ ਨਾਲ ਵਿਵਹਾਰ ਕਰਦੇ ਹਨ। ## 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 ``` Primitives **ਅਸਲ ਮੁੱਲ** ਸਿੱਧੇ ਸਟੋਰ ਕਰਦੇ ਹਨ, fixed-size ਹੁੰਦੇ ਹਨ, null ਨਹੀਂ ਹੋ ਸਕਦੇ, ਅਤੇ stack ਉੱਤੇ (locals ਲਈ) ਰਹਿੰਦੇ ਹਨ। ਇਹ ਤੇਜ਼ ਅਤੇ memory-efficient ਹੁੰਦੇ ਹਨ। ## 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 variables **reference** (memory address) ਰੱਖਦੇ ਹਨ heap ਉੱਤੇ ਸਟੋਰ ਕੀਤਾ object — object ਆਪ ਨਹੀਂ। ਇਹ `null` ਹੋ ਸਕਦੇ ਹਨ। ## ਮਹੱਤਵਪੂਰਨ ਅੰਤਰ: assignment ਅਤੇ comparison ```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 ``` ਇਹ ਇੱਕ ਵੱਡਾ pitfall ਹੈ: **objects ਉੱਤੇ `==` identity (ਇੱਕੋ object?) ਦਾ ਤੁਲਨਾ ਕਰਦਾ ਹੈ, content ਨਹੀਂ** — content comparison ਲਈ `.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 ਕੋਲ ਇੱਕ wrapper class ਹੁੰਦੀ ਹੈ (`int`→`Integer`, ਆਦਿ) ਤਾਂ ਕਿ primitives ਉਹਨਾਂ ਸਥਾਨਾਂ ਵਿੱਚ ਵਰਤੀਆਂ ਜਾ ਸਕਣ ਜਿੱਥੇ objects ਲੋੜੀਂਦੇ ਹਨ (collections, generics)। ## ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ Primitive-versus-reference ਅਤੰਤਰ Java ਲਈ ਬੁਨਿਆਦੀ ਹੈ ਅਤੇ ਬਹੁਤ ਸਾਰੀਆਂ ਸੂਖਮ bugs ਅਤੇ behaviors ਦਾ ਸਰੋਤ ਹੈ: assignment primitives ਲਈ values ਦੀ ਨਕਲ ਕਰਦਾ ਹੈ ਪਰ objects ਲਈ references ਸਾਂਝੇ ਕਰਦਾ ਹੈ (ਇਸ ਲਈ shared object ਵਿੱਚ ਤਬਦੀਲੀ ਸਾਰੇ references ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦੀ ਹੈ), ਅਤੇ ਖਾਸ ਤੌਰ ਉੱਤੇ ਕਿ **`==` objects ਲਈ identity ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ** (ਇੱਕ ਕਲਾਸਿਕ ਗਲਤੀ — content ਲਈ `.equals()` ਵਰਤੋ)। ਇਹ ਸਮਝ comparisons ਵਿੱਚ correctness, method arguments (objects ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਤੌਰ ਉੱਤੇ reference value ਦੁਆਰਾ pass ਹੁੰਦੇ ਹਨ), null-handling (ਸਿਰਫ references null ਹੋ ਸਕਦੇ ਹਨ), ਅਤੇ performance (primitives ਲਘੂ ਹੁੰਦੇ ਹਨ) ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦੀ ਹੈ। ਇਹ ਸਹੀ Java ਲਿਖਣ ਲਈ ਮੂਲ ਜਾਣਕਾਰੀ ਹੈ।