บทที่ 0 — Java คืออะไร และทำไมต้องเรียน

← กลับไปที่สารบัญ Java | บทที่ 1: Setup + Hello World →

📱 อ่านบนเว็บหรือไฟล์ .md? — หนังสือเล่มนี้ออกแบบสำหรับเว็บ (VitePress): กล่อง ::: เช่น ::: details เฉลย เป็นกล่องกดเปิด/ปิดได้, แผนภาพ mermaid แสดงเป็นรูปภาพ — ถ้าอ่านไฟล์ .md ตรง ๆ ใน text editor หรือ GitHub จะเห็นเป็นข้อความธรรมดา ซึ่งไม่กระทบเนื้อหา

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

ผมรู้ว่าคุณอยากเริ่มเขียนโค้ดแล้ว แต่ขอเวลาประมาณ 20 นาที — บทนี้จะตอบคำถามว่า:

1. คอมพิวเตอร์ "ทำตามคำสั่ง" ได้ยังไง? (ภาพรวมสุดของการเขียนโปรแกรม)
2. Java เป็นภาษาแบบไหน?
   • compiled vs interpreted: คอมไพล์ล่วงหน้า vs แปลทีละบรรทัด
   • static vs dynamic: ต้องประกาศชนิดข้อมูลล่วงหน้า vs ไม่ต้อง
3. JVM, JDK, JRE คืออะไร? ทำไมต้องมีหลายอัน?
4. Java เก่าหรือยัง? ปี 2026 ยังเรียนคุ้มไหม?
5. Java ต่างจาก JavaScript ยังไง? (ทั้งสองไม่ใช่ภาษาเดียวกัน)

---

1. คอมพิวเตอร์ทำตามคำสั่งได้ยังไง

ก่อนจะรู้จัก Java เราต้องเข้าใจ "ของจริง" ที่อยู่ใต้ดินก่อน

1.1 CPU เข้าใจแค่ภาษาเดียว: machine code

CPU (Central Processing Unit — สมองของคอม) เข้าใจแค่ ตัวเลขฐาน 2 (0 กับ 1) เรียกว่า machine code

📖 ฐาน 2 = ระบบเลขที่มีแค่ 0 กับ 1 ต่างจากที่เราใช้ทุกวัน (ฐาน 10 มี 0-9)

หน้าตามันเหมือน:

10110000 01100001 00000000 ...

แน่นอนว่าคนเขียนแบบนี้ไม่ไหว เลยมี "ภาษากลาง" ให้คนเขียนแล้วค่อยมีโปรแกรมแปลงให้

1.2 ภาษาโปรแกรมแบ่งเป็น 2 ตระกูลใหญ่ ๆ

ตระกูล A: Compiled (คอมไพล์ทั้งหมดก่อนค่อย run)

เขียนโค้ด → compiler แปลงเป็น machine code ทั้งไฟล์ → ได้ไฟล์ binary (ไฟล์ที่มี machine code พร้อม run — เช่น .exe บน Windows) → ค่อย run

ตัวอย่าง: C, C++, Rust, Go

your-code.c  →  [compiler: gcc]  →  your-program.exe  →  CPU run

ข้อดี: เร็วมาก เพราะ CPU run machine code ตรง ๆ ข้อเสีย: ต้อง compile ใหม่ทุก platform (platform = ระบบที่โปรแกรมรัน — เช่น Windows, macOS, Linux) — Windows compile แล้ว run บน Mac ไม่ได้

ตระกูล B: Interpreted (อ่านโค้ดทีละบรรทัดแล้ว run)

เขียนโค้ด → interpreter อ่านทีละบรรทัด → แปลงเป็นคำสั่ง CPU ทีละนิด → run

ตัวอย่าง: Python, Ruby, PHP (JavaScript รุ่นเก่า)

💡 หมายเหตุ: JavaScript ยุคใหม่ (เช่น V8 engine ที่อยู่ใน Chrome/Node.js) ก็ใช้ JIT compilation เหมือนกัน ในทางปฏิบัติภาษาสมัยใหม่หลายตัวผสมสองแบบเข้าด้วยกัน ไม่ได้แยกขาดชัดเจนแบบในตำรา — ตอนนี้แค่รู้ว่าแต่ละตระกูลต่างกันตรงไหนก็พอ

your-code.py  →  [interpreter: python]  →  run ทีละบรรทัดเลย

ข้อดี: ไม่ต้อง compile, แก้โค้ดแล้ว run ได้เลย, ใช้ข้าม platform ง่าย ข้อเสีย: ช้ากว่า compiled (เพราะแปลงตอน run)

ตระกูล C: Hybrid (compile แล้ว run บนเครื่องสมมติ) — Java อยู่ตรงนี้

📖 เครื่องสมมติ (Virtual Machine) = "คอมจำลอง" ที่อยู่ในคอมจริงอีกที — โปรแกรมที่ทำตัวเหมือนเป็นคอมตัวหนึ่ง รับโค้ดแล้วรันให้

Java เลือกทางสายกลาง:

your-code.java  →  [compiler: javac]  →  your-code.class (bytecode)  →  [JVM]  →  CPU

ขั้นที่ 1: เขียน .java → javac compile → ได้ .class (ไฟล์ที่มี bytecode — รหัสกลางที่ JVM อ่านได้ ไม่ใช่ machine code โดยตรง) ขั้นที่ 2: ตอน run, JVM (Java Virtual Machine — เครื่องสมมติของ Java) อ่าน bytecode — ช่วงแรกแปลทีละคำสั่ง แล้ว JIT compiler (Just-In-Time — ระบบปรับแต่งโค้ดอัตโนมัติ) จะแปลง method ที่ถูกเรียกบ่อย ๆ ให้เป็น machine code ตรง ๆ เพื่อให้เร็วขึ้น

Bytecode = format กลาง — ไม่ใช่ machine code ของ CPU ใด ๆ แต่ทุก JVM เข้าใจ

นี่คือที่มาของสโลแกนเก่าของ Java: "Write Once, Run Anywhere" — เขียนทีเดียว, ใช้ได้ทุก OS (เพราะแต่ละ OS มี JVM ของตัวเอง)

ภาพรวม:

💡 หมายเหตุ: แผนภาพด้านล่างแสดงได้บนเว็บ (VitePress) — ถ้าอ่านไฟล์ .md ตรง ๆ ใน text editor หรือ GitHub อาจไม่เห็นภาพ แต่ไม่กระทบการเรียน

💡 เทียบให้เห็นภาพ: ถ้า machine code เปรียบเหมือนภาษาท้องถิ่น (ไทย/ญี่ปุ่น/เกาหลี), bytecode เปรียบเหมือน ภาษากลาง ที่ทุกฝ่ายแปลเป็นภาษาตัวเองได้ — เหมือนตอนคนไทย คนลาว คนเวียดนามประชุมกัน แล้วใช้ภาษาอังกฤษคุยกันแทน เพราะทุกคนแปลเป็นภาษาตัวเองได้

---

2. Java เป็นภาษาแบบไหน

2.1 Static typing — ตัวแปรต้องประกาศ "ประเภท" ก่อนใช้

ใน Java, ทุกตัวแปรต้อง บอก type ตั้งแต่ตอนประกาศ:

int age = 25;           // age เป็นจำนวนเต็ม — เปลี่ยนเป็น "hello" ไม่ได้
String name = "Anna";   // name เป็นข้อความ — เปลี่ยนเป็น 25 ไม่ได้

ถ้าเขียน:

int age = "twenty-five";  // ❌ Java จะ error ตอน compile (ก่อน run ด้วยซ้ำ)

นี่คือ static typing — compiler ตรวจ type ตั้งแต่ก่อน run

เทียบกับ JavaScript (dynamic typing):

let age = 25;
age = "twenty-five";  // ✅ JS ไม่ว่า — ใส่ string ก็ได้

ข้อดีของ static typing:

• เจอ bug เร็ว — compile ไม่ผ่าน = ไม่ต้อง run ก็รู้ว่าผิด
• IDE (IDE = โปรแกรมที่ใช้เขียนโค้ด เช่น IntelliJ — รายละเอียดเต็มบทที่ 1) ช่วย autocomplete และ refactor ได้ดีขึ้น (เพราะรู้ type)

  autocomplete = เดาโค้ดให้อัตโนมัติ · refactor = จัดโครงสร้างโค้ดใหม่

• โค้ดใหญ่ ๆ จะอ่านง่ายกว่า เพราะรู้แน่ว่าตัวแปรไหนเป็นอะไร

ข้อเสีย: เขียนยาวกว่านิดหน่อย

2.2 Object-Oriented — ทุกอย่างเป็น "object"

Java ออกแบบมาให้คิดเป็น "วัตถุ" (object) ที่มี "คุณสมบัติ" (field/property) และ "ความสามารถ" (method)

ตัวอย่าง: ในชีวิตจริงเรามี "หมาตัวหนึ่ง"

• คุณสมบัติ: ชื่อ, สี, อายุ
• ความสามารถ: เห่า, นั่ง, วิ่ง

ใน Java เราเขียนแบบนี้:

class Dog {
    String name;
    String color;
    int age;

    void bark() {
        System.out.println(name + " says: Woof!");
    }
}

แล้วเราสร้าง "หมาจริง ๆ" จาก class:

Dog buddy = new Dog();   // สร้างหมา 1 ตัว
buddy.name = "Buddy";
buddy.bark();            // พิมพ์: Buddy says: Woof!

เดี๋ยวบทที่ 5 จะอธิบาย OOP ละเอียดอีกที — ตอนนี้แค่รู้ว่า "Java คิดเป็น object เป็นหลัก"

2.3 Memory ดูแลตัวเอง — มี Garbage Collector

ในภาษาเก่า (C/C++) เวลาเราใช้ memory แล้ว ต้อง "คืน" memory ด้วยตัวเอง — ถ้าลืม จะเกิด memory leak (memory รั่ว, ใช้แล้วไม่คืน, สุดท้าย memory เต็ม)

Java มี Garbage Collector (GC) — โปรแกรมข้างหลังที่คอย "เก็บขยะ" ให้เรา

// เราสร้าง object ใหม่
String s = new String("hello");

// พอเลิกใช้ s — เราไม่ต้องคืน memory เอง
s = null;   // null = ค่าว่าง แปลว่าตัวแปรไม่ชี้ไปที่ข้อมูลไหนแล้ว (บทที่ 2 อธิบายละเอียด)
             // GC จะมาเก็บ "hello" ที่ค้างให้

// (ในทางปฏิบัติแทบไม่ต้องเขียน s = null เลย — JVM จัดการให้)

นี่คือเหตุผลที่ Java เขียนง่ายกว่า C/C++ มาก — ไม่ต้องคิดเรื่อง memory เอง

2.4 Verbose — Java ขึ้นชื่อเรื่อง "ยาว"

Java มีชื่อเสียงเรื่องโค้ดยาว — เช่น เขียน "Hello World":

Python (1 บรรทัด):

print("Hello, World!")

Java (5 บรรทัด):

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

อย่าเพิ่งกลัว — เหตุผลที่ Java ยาวเพราะ:

• บังคับให้คิดเป็น OOP ตั้งแต่แรก (class HelloWorld)
• บังคับเปิดเผย "ใครเรียกได้" (public)
• บังคับบอก type ตลอด (String[], void)

พอเขียนโค้ดใหญ่ ๆ ความ verbose นี้จะช่วยให้ "อ่านง่าย" และ "ปลอดภัยกว่า"

และ Java ใหม่ ๆ (Java 21, 25) ก็เริ่มสั้นลงเรื่อย ๆ ด้วยความสามารถใหม่ที่จะเรียนในบทที่ 10 (กำลังเขียน)

---

3. ศัพท์ที่ต้องจำให้ขึ้นใจ: JDK, JRE, JVM

มือใหม่งงสามตัวนี้บ่อยที่สุด — ผมจะอธิบายแบบเห็นภาพ

JVM (Java Virtual Machine)

คือ "เครื่อง run" Java — โปรแกรมที่อ่าน .class (bytecode) แล้ว run ให้

ถ้าจะ run โปรแกรม Java ที่คนอื่นเขียนไว้ → ต้องมี JVM

JRE (Java Runtime Environment)

คือ JVM + Java library พื้นฐาน

.class ของเราไม่ได้อยู่โดด ๆ — ใช้ class (class = พิมพ์เขียวของ object เดี๋ยวบทที่ 5 อธิบายละเอียด) อย่าง String, System, ArrayList (บทที่ 7) ที่ Java แถมมาให้ ซึ่งอยู่ใน JRE

ถ้า run อย่างเดียว → JRE ก็พอ แต่ในทางปฏิบัติปัจจุบันมักติดตั้ง JDK ไปเลย เพราะ:

• เมื่อก่อน Oracle แจก JRE แยกต่างหาก
• ตั้งแต่ Java 11+ distribution ส่วนใหญ่ (Oracle, Temurin) เลิกแจก JRE แยก มีแต่ JDK
• แต่บาง distribution เช่น Azul, Liberica ยังแจก JRE แยกอยู่

JDK (Java Development Kit)

คือ JRE + เครื่องมือพัฒนา (เช่น javac คือ compiler, javadoc คือ tool gen เอกสาร, jdb คือ debugger)

ถ้าจะ เขียน โค้ด Java → ต้องมี JDK

สรุปภาพ:

(แผนภาพนี้แสดงความสัมพันธ์แบบ "ครอบ" — JDK ครอบ JRE ครอบ JVM)

สำหรับเรา: ติดตั้ง JDK จบ — เพราะ JDK ครอบทุกอย่าง

3.1 JDK distribution — ใครแจกได้ ใช้ตัวไหน

Java มีหลาย distribution (กลุ่มบริษัทที่นำ OpenJDK ไปสร้างและแจกในเวอร์ชันของตัวเอง) — แต่มือใหม่ไม่ต้องเลือกเอง

🔰 มือใหม่อ่านสั้น ๆ: ติดตั้ง Temurin จบ — ข้ามรายละเอียดข้างล่างไปได้ ค่อยกลับมาอ่านตอนต้องเลือก distribution เอง

รายละเอียด distribution (ข้ามได้รอบแรก)

OpenJDK คืออะไร: source code กลางของ Java เป็น open source — บริษัทต่าง ๆ เอาไปใช้ build ของตัวเองได้

License GPL+CE คืออะไร: GNU GPL + Classpath Exception — เป็น license ที่อนุญาตให้เอา Java ไป link เข้า proprietary code ได้ โดยไม่ต้องเปิด source code ของเรา

ทำไมหลายบริษัทมาแจก: เพราะ source เปิด ใครก็ build เองได้ — แต่ละบริษัทจะปรับนิดหน่อย, ทำ test, แล้วแจกเวอร์ชันของตัวเอง ฟรีและใช้ commercial ได้ทั้งหมด

เปรียบเทียบ distribution หลัก:

🔤 ศัพท์ย่อในตาราง:

• TCK = Technology Compatibility Kit (ชุดทดสอบทางการของ Oracle ว่า JDK build นี้ตรงสเปก Java จริง)
• GPL+CE = GNU GPL + Classpath Exception (ฟรี + ใช้ใน proprietary code ได้)
• NFTC = No-Fee Terms and Conditions (license ใหม่ของ Oracle ตั้งแต่ Java 17 — ฟรีใน dev/prod)
• GFTC = GraalVM Free Terms and Conditions (license ของ Oracle GraalVM)
• AOT = Ahead-Of-Time compile (compile เป็น native binary ก่อน run — ตรงข้าม JIT)
• polyglot = รองรับหลายภาษาในตัวเดียว (เช่น GraalVM รัน Java + JS + Python ได้)
• workload = งานที่โปรแกรมรันจริง ๆ (เช่น เว็บ API, batch ประมวลผลข้อมูล)
• enterprise = องค์กรใหญ่ที่ต้องการ support เป็นทางการและความเสถียรสูง

Distribution	ผู้ดูแล	License	เหมาะกับ
Eclipse Temurin (ชื่อเดิม: AdoptOpenJDK)	Eclipse Foundation	GPL+CE	default ที่แนะนำ — TCK-certified (ผ่านการทดสอบมาตรฐาน Java), รองรับยาว, build บ่อย
Amazon Corretto	Amazon	GPL+CE	AWS workload, ได้ patch จาก Amazon ฟรี
Azul Zulu	Azul Systems	GPL+CE (community) / commercial	enterprise ที่ต้องการ support
GraalVM (Community / Oracle)	Oracle	GPL+CE / GFTC	Native Image (AOT compile), polyglot
Oracle JDK	Oracle	NFTC + commercial	✅ ฟรีใช้ใน dev/prod ตั้งแต่ Java 17 (NFTC license) — แต่ commercial support ต้องเสียเงิน
Microsoft Build of OpenJDK	Microsoft	GPL+CE	Azure workload
IBM Semeru	IBM	GPL+CE	ใช้ OpenJ9 JVM (gentle memory) แทน HotSpot

💡 ปี 2026 default ใน Spring Boot ecosystem: Temurin (มาตรฐานชุมชน) — ปลอดภัยและรองรับยาว ส่วน GraalVM ใช้เมื่อต้อง build native image (deploy เร็ว, RAM น้อย → ดี FaaS/serverless)

⚠️ Oracle JDK ก่อน Java 17: license OTN-PE จำกัด commercial use → หลายที่ swap เป็น Temurin ตั้งแต่ Java 17 (2021): Oracle เปลี่ยนเป็น NFTC license = ฟรีสำหรับ dev/prod แต่ commercial support เสียเงิน

---

4. Java เก่าหรือยัง? ปี 2026 เรียนคุ้มไหม

Java เกิดปี 1995 — เก่ากว่า Google เสียอีก แต่...

Java ยังเป็นภาษาอันดับต้น ๆ ของโลกในปี 2026

• ติดกลุ่มภาษาอันดับต้น ๆ ใน TIOBE Index อย่างต่อเนื่อง (สลับอันดับกับ Python, C, C++ — อันดับขยับขึ้นลงได้ทุกปี ตรวจอันดับล่าสุดได้ที่เว็บ TIOBE) — TIOBE Index = ชาร์ตอันดับความนิยมภาษาโปรแกรมประจำเดือน — ไม่ต้องจำชื่อ สำคัญแค่ว่า Java ยังเป็นภาษาใช้กันเยอะมาก
• Backend ของ Netflix, Amazon, Google, ธนาคารส่วนใหญ่ ใช้ Java
• Android เขียนด้วย Java/Kotlin (Kotlin run บน JVM เช่นกัน)
• Apache Kafka, Elasticsearch, Hadoop, Spark — เครื่องมือ data ใหญ่ ๆ เขียนด้วย Java

Java ไม่ได้อยู่นิ่ง — มี feature ใหม่ทุก 6 เดือน

Java release ใหม่ทุก 6 เดือน, มี LTS (Long-Term Support — รุ่นที่ได้รับการดูแล/อัปเดตความปลอดภัยยาวหลายปี เหมาะใช้งานจริง) ทุก 2 ปี:

Version	ปี	สำคัญที่ออก
Java 8	2014	Lambda, Stream — เขียนโค้ดแบบ functional ได้, เปลี่ยน Java ไปเลย
Java 10	2018	var (JEP 286) — ประกาศตัวแปรโดยไม่ต้องระบุ type เต็ม (compiler อนุมานให้)
Java 11 LTS	2018	HTTP Client (standard), String.isBlank(), Files.readString()
Java 17 LTS	2021	Sealed classes (จำกัดการสืบทอด), pattern matching เริ่ม (ตรวจ type ง่ายขึ้น)
Java 21 LTS	2023	Virtual threads — รองรับงานพร้อมกันเป็นล้าน ๆ ชิ้น, เปลี่ยนเกม concurrency; pattern matching features ส่วนใหญ่ finalize ใน Java 21-24
Java 25 LTS	2025	Structured concurrency (JEP 505) — finalize เป็น standard ใน Java 25 LTS (เป็น preview ใน Java 21-24); Compact Object Headers (JEP 519)

📖 JEP = JDK Enhancement Proposal — เลขข้อเสนอ feature ใหม่ของ Java (เช่น JEP 505 = ข้อเสนอ feature เลข 505)

ในปี 2026 เราจะใช้ Java 25 LTS เป็นหลัก (และจะเจอ Java 17/21 ใน project เก่าด้วย)

ทำไม Java ยังไม่ตาย

1. ทำงานเร็ว — JVM optimization 30 ปี ทำให้บาง workload เร็วใกล้เคียง C++ ได้ (ขึ้นอยู่กับลักษณะงานที่รัน)
   • JIT (Just-In-Time compilation) = JVM ปรับแต่งโค้ดให้เร็วขึ้นเรื่อย ๆ ขณะรัน — เรียนละเอียดในภาคขั้นสูง
2. ทีมใหญ่ดูแลได้ — static typing + tooling ดี = หลายคนช่วยกันเขียนได้
3. ecosystem ใหญ่มาก (ecosystem = ระบบนิเวศ คือบรรดา library/เครื่องมือ/ชุมชนรอบ ๆ ภาษา) — เกือบทุกปัญหามี library พร้อมใช้
4. Spring Boot — framework เขียน backend ที่ครองตลาด enterprise

---

5. Java ≠ JavaScript

ขอเคลียร์ก่อนเดินต่อ:

	Java	JavaScript
ปีเกิด	1995 (Sun Microsystems)	1995 (Netscape)
ออกแบบมาทำอะไร	desktop, server, mobile	ทำให้ webpage โต้ตอบได้
Type	Static (ประกาศ type)	Dynamic (ไม่ต้อง)
Run ที่ไหน	JVM	Browser, Node.js
ที่มาของชื่อ	จริง ๆ ตั้งใจชื่อ "Oak" แล้วเปลี่ยน	ตั้งชื่อเกาะกระแส Java ตอน Java กำลังฮิต — ไม่ได้เกี่ยวข้องทางเทคนิคเลย

💡 เรื่องเล่า: ปี 1995 Netscape ทำภาษาใหม่ชื่อ "Mocha" แล้วเปลี่ยนเป็น "LiveScript" — ตอนนั้น Java เพิ่งฮิตมาก เลยเปลี่ยนเป็น "JavaScript" เพื่อ เกาะกระแสการตลาด เท่านั้น ทำให้คนเข้าใจผิดมา 30 ปีจนถึงปัจจุบัน

ในหนังสือเล่มนี้:

• Java = ภาษาในส่วน "backend" (บทที่เราเรียนอยู่นี่ + Spring Boot)
• JavaScript / TypeScript = ภาษาในส่วน "frontend" (React)

ทั้งสองภาษาไม่เกี่ยวกัน แค่ชื่อคล้ายกัน

---

6. ภาพรวม: เราจะใช้ Java ทำอะไรในหนังสือเล่มนี้

1. ตอนแรก (บทที่ 1-4): เขียนโปรแกรม Java แบบง่าย — รับ input, ประมวลผล, output ออกจอ
2. ตอนกลาง (บทที่ 5-8): เริ่มเขียนแบบ OOP, ใช้ Collections, จัดการ Exception
3. ตอนปลาย (บทที่ 9-10): ใช้ Lambda/Stream เขียนแบบ functional, ใช้ feature ใหม่ ๆ
4. หลังจบ Java: ขึ้น Spring Boot — ใช้ Java เขียน backend (REST API, database, security)

เป้าหมาย: อ่านโค้ด Java ของคนอื่นออก + เขียนโค้ดที่อ่านได้ + แก้ bug ตัวเองได้ + ขึ้น Spring ได้

---

7. ก่อนไปบทต่อไป

🛠️ Checkpoint 0.1 — ทดสอบความเข้าใจ

ลองตอบในใจ (หรือจดลง notebook) ก่อนเลื่อนดูเฉลย:

1. ไฟล์ .java กับ .class ต่างกันยังไง?
2. JDK ต่างจาก JRE ยังไง?
3. Bytecode คืออะไร และทำไมต้องมี?
4. Java เป็น static typing — แปลว่าอะไร?
5. Java กับ JavaScript เกี่ยวข้องกันไหม?

📖 เฉลย (กดเพื่อดู)

1. .java = source code (โค้ดที่เราเขียน, อ่านออก) — .class = bytecode (compile แล้ว, JVM อ่าน)
2. JDK = JRE + เครื่องมือพัฒนา (compiler ฯลฯ) — JRE = แค่ที่ใช้ run โปรแกรม
3. Bytecode = format กลาง ไม่ขึ้นกับ OS — ทำให้ .class เดียวกัน run ได้ทุก OS ที่มี JVM
4. Static typing = ต้องประกาศ type ตัวแปรตั้งแต่ตอนเขียน — compiler ตรวจให้ก่อน run
5. ไม่เกี่ยวกัน — แค่ชื่อคล้ายเพราะ JavaScript เกาะกระแส Java ตอนปี 1995

---

สรุปสิ่งที่ได้จากบทนี้

✅ เข้าใจว่า CPU เข้าใจแค่ machine code, ภาษาโปรแกรมเลยเป็น "ภาษากลาง" ✅ Java ใช้ระบบ compile → bytecode → JVM run (ทำให้ portable ข้าม OS) ✅ Java = static-typed, object-oriented, มี garbage collector ✅ JDK = JRE + dev tools, JRE = JVM + library ✅ Java ปี 2026 ยังเป็นภาษาอันดับต้น ๆ — Spring Boot ครองตลาด backend ✅ Java ≠ JavaScript (คนละภาษากันสิ้นเชิง)

บทต่อไป: ติดตั้ง JDK + IntelliJ + เขียน Hello World แล้วอธิบายทุกบรรทัด

→ ไปบทที่ 1: Setup + Hello World

---

🔤 Glossary · 📋 Style guide · 📅 last_verified: 2026-06-23