0Pricing
Java Academy · บทเรียน

การแปลงชนิดข้อมูลแบบขยายและแบบหด

เรียนรู้การแปลงชนิดข้อมูลแบบขยายโดยอัตโนมัติ และวิธีแปลงแบบหดอย่างชัดแจ้งให้ปลอดภัย

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

การแปลงชนิดข้อมูลใน Java

Java อนุญาตให้แปลงค่าระหว่างชนิดที่เข้ากันได้ โดยมีสองทิศทาง:

  • การแปลงแบบขยาย — แปลงเป็นชนิดที่ใหญ่กว่า (ปลอดภัยและอัตโนมัติ)
  • การแปลงแบบหด — แปลงเป็นชนิดที่เล็กกว่า (มีความเสี่ยงและต้องแคสต์อย่างชัดเจน)

การแปลงแบบขยาย

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

ลำดับการขยาย: byte → short → int → long → float → double

byte b = 42;
short s = b;    // byte → short (widening)
int i = s;      // short → int (widening)
long l = i;     // int → long (widening)
float f = l;    // long → float (widening)
double d = f;   // float → double (widening)

System.out.println(d); // 42.0

การแปลงแบบหด

การแปลงแบบหด ต้องดำเนินการอย่างชัดเจนด้วยตัวดำเนินการแคสต์ (type) ค่าอาจถูกตัดทอนหรือเสียหายหากไม่พอดีกับชนิดเป้าหมาย

double price = 99.99;
int wholePart = (int) price; // narrows — decimal truncated
System.out.println(wholePart); // 99 (not rounded!)

long bigNum = 130L;
byte small = (byte) bigNum;  // 130 overflows byte (max 127)
System.out.println(small);   // -126 (unexpected!)

ค่าเกินขอบเขตระหว่างการแปลงแบบหด

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

int million = 1_000_000;
byte narrowed = (byte) million;
System.out.println(narrowed); // 64 (wraps around)

// Safe narrowing: check bounds first
if (million >= Byte.MIN_VALUE && million <= Byte.MAX_VALUE) {
    byte safe = (byte) million;
} else {
    System.out.println("Value doesn't fit in byte!");
}

การแปลง char และ int

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

char letter = 'A';
int code = letter;          // widening: char → int
System.out.println(code);   // 65

int nextCode = code + 1;
char nextLetter = (char) nextCode; // narrowing: int → char
System.out.println(nextLetter);    // B

// Useful for Caesar cipher shifts
char shifted = (char) ('a' + 3);
System.out.println(shifted); // d

การตัดทอนจากเลขทศนิยมเป็นจำนวนเต็ม

การแคสต์จำนวนเลขทศนิยมเป็นจำนวนเต็มจะ ตัดทอนเข้าหาศูนย์ ไม่ได้ปัดเศษ ใช้ Math.round() หากต้องการปัดเศษ

double pos = 3.9;
double neg = -3.9;

System.out.println((int) pos);         // 3 (not 4)
System.out.println((int) neg);         // -3 (not -4)
System.out.println(Math.round(pos));   // 4
System.out.println(Math.round(neg));   // -4

การแปลง String เป็นตัวเลข

การแยกวิเคราะห์ String เป็นตัวเลขต้องใช้เมธอดของชนิดห่อหุ้ม ไม่ใช่การแคสต์ หากส่งสตริงที่ไม่ใช่ตัวเลข จะทำให้เกิด NumberFormatException

String input = "42";
int parsed = Integer.parseInt(input);
double parsedD = Double.parseDouble("3.14");

System.out.println(parsed + 1);  // 43
System.out.println(parsedD);     // 3.14

try {
    int bad = Integer.parseInt("abc");
} catch (NumberFormatException e) {
    System.out.println("Not a valid number!");
}

การแปลงตัวเลขเป็น String

สามารถแปลงตัวเลขเป็น String ได้ด้วย String.valueOf(), Integer.toString() หรือการต่อสตริงด้วย ""

int score = 95;
String s1 = String.valueOf(score);    // "95"
String s2 = Integer.toString(score);  // "95"
String s3 = score + "";              // "95" (concat trick)

System.out.println(s1.getClass().getSimpleName()); // String

// Converting to different bases
System.out.println(Integer.toBinaryString(42)); // 101010
System.out.println(Integer.toHexString(255));   // ff

การเลื่อนระดับในนิพจน์

ในนิพจน์ทางคณิตศาสตร์ Java จะ เลื่อนระดับ ตัวถูกดำเนินการโดยอัตโนมัติ:

  • byte, short, char → เลื่อนระดับเป็น int ก่อนดำเนินการ
  • หากตัวถูกดำเนินการตัวใดตัวหนึ่งเป็น long ผลลัพธ์จะเป็น long
  • หากตัวใดตัวหนึ่งเป็น float หรือ double ผลลัพธ์จะมีชนิดเดียวกับชนิดที่กว้างกว่า
byte x = 10;
byte y = 20;
// byte z = x + y; // compile error! sum is promoted to int
int z = x + y;      // correct

long a = 100L;
float b = 2.5f;
double result = a * b; // long * float → double
System.out.println(result); // 250.0

ตัวดำเนินการกำหนดค่าแบบผสม

ตัวดำเนินการแบบผสม เช่น +=, -=, *= จะรวมการแคสต์ให้แคบลงโดยนัยไว้ด้วย ทำให้สามารถเขียนรหัสที่กระชับเมื่อใช้กับตัวแปร byte และ short

byte count = 100;
// count = count + 1; // compile error — int result needs cast
count += 1;           // OK — compound op casts automatically
System.out.println(count); // 101

short total = 1000;
total *= 2;  // implicit narrow cast included
System.out.println(total); // 2000

เชิงปฏิบัติ: การแยกวิเคราะห์จำนวนเต็มอย่างปลอดภัย

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

public static byte parseAsByte(String input) {
    int value = Integer.parseInt(input); // can throw NumberFormatException
    if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
        throw new IllegalArgumentException(
            "Value " + value + " out of byte range");
    }
    return (byte) value;
}

// Usage
System.out.println(parseAsByte("100")); // 100
System.out.println(parseAsByte("200")); // IllegalArgumentException

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

รหัสต่อไปนี้จะแสดงผลลัพธ์เป็นอะไร

double d = -7.8;
int i = (int) d;
System.out.println(i);

สรุป: การขยายชนิดและการลดชนิด

ประเด็นสำคัญ:

  • การขยายชนิดทำได้โดยอัตโนมัติและปลอดภัย: byte→short→int→long→float→double
  • การลดชนิดต้องใช้การแคสต์อย่างชัดเจน และอาจทำให้ข้อมูลสูญหายหรือเกิดค่าล้น
  • char จะขยายเป็น int ส่วน int สามารถลดกลับเป็น char ได้ด้วยการแคสต์
  • การแปลงค่าทศนิยมเป็น int จะตัดเศษเข้าหาศูนย์ ไม่ใช่การปัดเศษ
  • ใช้ Integer.parseInt/Double.parseDouble เพื่อแปลง String เป็นตัวเลข
  • ตัวดำเนินการแบบผสม (+=, *=) รวมการแคสต์ให้แคบลงโดยนัยไว้ด้วย

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

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

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

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

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

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

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

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

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

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

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

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

  1. ชนิดข้อมูลพื้นฐานกับชนิดข้อมูลอ้างอิง
  2. การแปลงชนิดข้อมูลแบบขยายและแบบหด
  3. ตัวดำเนินการ instanceof
  4. การแคสต์ชนิดข้อมูลในทางปฏิบัติ
← กลับไปที่ Java Academy