Java Academy · บทเรียน

ชนิดข้อมูลพื้นฐานกับชนิดข้อมูลอ้างอิง

ทำความเข้าใจความแตกต่างพื้นฐานระหว่างชนิดข้อมูลพื้นฐานกับชนิดข้อมูลอ้างอิงใน Java

ชนิดข้อมูลพื้นฐานกับชนิดข้อมูลอ้างอิง เป็นบทเรียน Java Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Java Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Java Academy มีบทเรียนทั้งหมด 4 บทเรียน

ชนิดข้อมูลพื้นฐานเทียบกับชนิดข้อมูลอ้างอิง

Java มีชนิดข้อมูลพื้นฐานอยู่สองประเภทหลัก ได้แก่ ชนิดข้อมูลพื้นฐาน และ ชนิดข้อมูลอ้างอิง การเข้าใจความแตกต่างนี้มีความสำคัญอย่างยิ่งต่อการเขียนโค้ด Java ที่ถูกต้องและมีประสิทธิภาพ

ชนิดข้อมูลพื้นฐานทั้งแปด

Java มีชนิดข้อมูลพื้นฐานทั้งหมดแปดชนิด:

byte (จำนวนเต็ม 8 บิต)
short (จำนวนเต็ม 16 บิต)
int (จำนวนเต็ม 32 บิต)
long (จำนวนเต็ม 64 บิต)
float (เลขทศนิยม 32 บิต)
double (เลขทศนิยม 64 บิต)
char (อักขระยูนิโคด 16 บิต)
boolean (จริง/เท็จ)

ชนิดข้อมูลพื้นฐานเก็บค่าไว้โดยตรงในหน่วยความจำ จึงไม่มีค่าใช้จ่ายส่วนเกินของอ็อบเจกต์

int age = 25;
double price = 19.99;
boolean active = true;
char grade = 'A';
long population = 8_000_000_000L;

System.out.println(age);       // 25
System.out.println(price);     // 19.99
System.out.println(active);    // true

ชนิดข้อมูลอ้างอิง

ชนิดข้อมูลอ้างอิง เก็บที่อยู่หน่วยความจำ (ข้อมูลอ้างอิง) ที่ชี้ไปยังอ็อบเจกต์บนฮีป ซึ่งรวมถึง:

คลาส (เช่น String, Scanner)
อาร์เรย์ (เช่น int[])
อินเทอร์เฟซ
ประเภทแจกแจงและเรกคอร์ด

ตัวแปรไม่ได้เก็บอ็อบเจกต์ไว้ แต่เก็บตัวชี้ไปยังอ็อบเจกต์นั้น

String name = "Alice";       // reference to a String object
int[] scores = {90, 85, 92}; // reference to an array object

// name holds a reference, not the characters directly
System.out.println(name.length());   // 5
System.out.println(scores.length);   // 3

หน่วยความจำสแตกเทียบกับฮีป

ตัวแปรชนิดพื้นฐานจัดเก็บบนสแตก ซึ่งเป็นหน่วยความจำที่รวดเร็วและมีอายุสั้น ผูกอยู่กับการเรียกใช้เมธอด

อ็อบเจกต์ของชนิดข้อมูลอ้างอิงอยู่บนฮีป ซึ่งเป็นหน่วยความจำที่มีขนาดใหญ่กว่าและมีอายุยาวกว่า โดยมีการเก็บคืนหน่วยความจำเป็นผู้จัดการ ส่วนข้อมูลอ้างอิง (ที่อยู่) จะอยู่บนสแตก

// Stack: holds the int value directly
int x = 42;

// Stack: holds reference; Heap: holds the Person object
class Person {
    String name;
    int age;
}

Person p = new Person(); // p is a reference on stack, object on heap
p.name = "Bob";
p.age = 30;

null: ข้อมูลอ้างอิงที่ไม่มีอยู่

ตัวแปรอ้างอิงสามารถกำหนดเป็น null ได้ ซึ่งหมายความว่าตัวแปรนั้นไม่ได้ชี้ไปยังอ็อบเจกต์ใด ชนิดข้อมูลพื้นฐานไม่สามารถเป็น null ได้ เพราะจะมีค่าอยู่เสมอ

การเข้าถึงข้อมูลอ้างอิงที่เป็น null ทำให้เกิด NullPointerException (NPE) ซึ่งเป็นหนึ่งในข้อผิดพลาดขณะทำงานที่พบบ่อยที่สุดของ Java

String s = null;
// int n = null; // Compile error — primitives can't be null

try {
    System.out.println(s.length()); // NullPointerException!
} catch (NullPointerException e) {
    System.out.println("Caught NPE: reference was null");
}

ความหมายของการคัดลอก: ชนิดข้อมูลพื้นฐาน

เมื่อคุณกำหนดค่าตัวแปรชนิดข้อมูลพื้นฐานให้กับอีกตัวแปรหนึ่ง Java จะ< b>คัดลอกค่า การเปลี่ยนแปลงตัวแปรหนึ่งจะไม่ส่งผลต่อตัวแปรอีกตัว ทั้งสองตัวจึงเป็นอิสระจากกันโดยสมบูรณ์

int a = 10;
int b = a;  // b gets a copy of the value 10

b = 20;     // changing b does NOT affect a

System.out.println(a); // 10
System.out.println(b); // 20

ความหมายของการคัดลอก: ข้อมูลอ้างอิง

เมื่อคุณกำหนดค่าตัวแปรอ้างอิงให้กับอีกตัวแปรหนึ่ง ตัวแปรทั้งสองจะชี้ไปยัง อ็อบเจกต์เดียวกัน การแก้ไขอ็อบเจกต์ผ่านข้อมูลอ้างอิงหนึ่งจะมองเห็นได้ผ่านอีกข้อมูลอ้างอิงหนึ่ง

int[] arr1 = {1, 2, 3};
int[] arr2 = arr1; // arr2 points to the SAME array

arr2[0] = 99; // modifies the shared array

System.out.println(arr1[0]); // 99 — arr1 sees the change too!
System.out.println(arr2[0]); // 99

คลาสห่อหุ้ม: การบรรจุชนิดข้อมูลพื้นฐาน

ชนิดข้อมูลพื้นฐานแต่ละชนิดมี คลาสห่อหุ้ม ที่สอดคล้องกันใน java.lang:

int → Integer
double → Double
boolean → Boolean
char → Character

คลาสห่อหุ้มช่วยให้คุณใช้ชนิดข้อมูลพื้นฐานเป็นอ็อบเจกต์ได้ ซึ่งจำเป็นสำหรับคอลเลกชัน เช่น List<Integer>

Integer boxed = Integer.valueOf(42); // explicit boxing
int unboxed = boxed.intValue();       // explicit unboxing

// Autoboxing / auto-unboxing (Java does this automatically)
Integer auto = 100;  // autoboxed
int val = auto;      // auto-unboxed

System.out.println(Integer.MAX_VALUE);  // 2147483647
System.out.println(Double.MIN_VALUE);   // 5.0E-324

ข้อควรระวังของการบรรจุอัตโนมัติ

การบรรจุอัตโนมัติสะดวก แต่ก็อาจทำให้เกิดข้อผิดพลาดที่สังเกตได้ยาก คลาสจำนวนเต็มจะเก็บค่าตั้งแต่ -128 ถึง 127 ไว้ในแคช เมื่ออยู่นอกช่วงดังกล่าว == จะเปรียบเทียบข้อมูลอ้างอิง ไม่ใช่ค่า

โปรดใช้ .equals() เพื่อเปรียบเทียบอ็อบเจกต์คลาสห่อหุ้มเสมอ

Integer a = 127;
Integer b = 127;
System.out.println(a == b);      // true (cached)

Integer c = 200;
Integer d = 200;
System.out.println(c == d);      // false (different objects!)
System.out.println(c.equals(d)); // true (correct comparison)

การส่งให้เมธอด: การส่งผ่านค่า

Java ใช้การส่งผ่านค่าเสมอ สำหรับชนิดข้อมูลพื้นฐาน ค่าจะถูกคัดลอก สำหรับข้อมูลอ้างอิง ข้อมูลอ้างอิง (ที่อยู่) จะถูกคัดลอก ทั้งสองตัวจึงชี้ไปยังอ็อบเจกต์เดียวกัน แต่คุณไม่สามารถกำหนดค่าตัวแปรของผู้เรียกใหม่จากภายในเมธอดได้

static void doubleValue(int n) {
    n = n * 2; // only modifies the local copy
}

static void clearArray(int[] arr) {
    arr[0] = 0; // modifies the shared object
}

int x = 5;
doubleValue(x);
System.out.println(x); // still 5

int[] nums = {10, 20, 30};
clearArray(nums);
System.out.println(nums[0]); // 0 — object was mutated

ตารางสรุปเชิงปฏิบัติ

ข้อมูลอ้างอิงอย่างรวดเร็วเพื่อเปรียบเทียบชนิดข้อมูลพื้นฐานกับชนิดข้อมูลอ้างอิง:

การจัดเก็บ: ชนิดข้อมูลพื้นฐาน → ค่าในสแตก; ชนิดข้อมูลอ้างอิง → ที่อยู่บนสแตก + อ็อบเจกต์บนฮีป
ค่าเริ่มต้น: ชนิดข้อมูลพื้นฐาน → 0/false/\u0000; ชนิดข้อมูลอ้างอิง → null
เป็น null ได้หรือไม่: ชนิดข้อมูลพื้นฐาน → ไม่ได้; ชนิดข้อมูลอ้างอิง → ได้
สิ่งที่การกำหนดค่าคัดลอก: ชนิดข้อมูลพื้นฐาน → ค่า; ชนิดข้อมูลอ้างอิง → ที่อยู่
ในคอลเลกชัน: ชนิดข้อมูลพื้นฐานต้องใช้คลาสห่อหุ้ม

ตรวจสอบอย่างรวดเร็ว

จะเกิดอะไรขึ้นเมื่อเรียกใช้โค้ดต่อไปนี้

Integer x = 200;
Integer y = 200;
System.out.println(x == y);

สรุปทบทวน: ชนิดข้อมูลพื้นฐานเทียบกับชนิดข้อมูลอ้างอิง

ประเด็นสำคัญจากบทเรียนนี้:

Java มีชนิดข้อมูลพื้นฐาน 8 ชนิด ซึ่งจัดเก็บโดยตรงบนสแตก
ชนิดข้อมูลอ้างอิงเก็บที่อยู่ของอ็อบเจกต์บนฮีป โดยตัวแปรจะเก็บที่อยู่นั้น
ชนิดข้อมูลพื้นฐานถูกคัดลอกด้วยค่า ส่วนข้อมูลอ้างอิงถูกคัดลอกด้วยที่อยู่
ตัวแปรอ้างอิงเป็น null ได้ แต่ชนิดข้อมูลพื้นฐานเป็นไม่ได้
คลาสห่อหุ้ม เช่น คลาสจำนวนเต็มและคลาสเลขทศนิยม จะบรรจุชนิดข้อมูลพื้นฐานเป็นอ็อบเจกต์
Java ใช้การส่งผ่านค่าเสมอ แม้ในกรณีที่ส่งข้อมูลอ้างอิง

คำถามที่พบบ่อย

บทเรียน “ชนิดข้อมูลพื้นฐานกับชนิดข้อมูลอ้างอิง” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “ชนิดข้อมูลพื้นฐานกับชนิดข้อมูลอ้างอิง” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Java Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Java Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “ชนิดข้อมูลพื้นฐานกับชนิดข้อมูลอ้างอิง”

ทำความเข้าใจความแตกต่างพื้นฐานระหว่างชนิดข้อมูลพื้นฐานกับชนิดข้อมูลอ้างอิงใน Java คุณปฏิบัติ Java Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Java Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Java Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “ชนิดข้อมูลพื้นฐานกับชนิดข้อมูลอ้างอิง” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Java Academy นี้ได้ไหม

ได้ บทเรียน Java Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Java Academy