Java là gì? Tổng quan về Java

Mục tiêu bài học

Sau bài này, bạn sẽ:

Hiểu Java là gì và tại sao nó quan trọng trong ngành phát triển phần mềm
Nắm được các đặc điểm chính của Java (WORA, OOP, strongly typed, garbage collection)
Phân biệt được JVM, JRE, và JDK cùng vai trò của từng thành phần
Biết được các phiên bản LTS của Java và khi nào nên sử dụng
Xác định được use cases phù hợp để áp dụng Java trong dự án

Java là một trong những ngôn ngữ lập trình phổ biến và mạnh mẽ nhất thế giới. Trong bài học này, chúng ta sẽ tìm hiểu Java là gì, tại sao nó lại quan trọng, và các đặc điểm nổi bật của Java.

Java là gì?

Java là một ngôn ngữ lập trình high-level, object-oriented, và platform-independent được thiết kế để developers có thể "Write Once, Run Anywhere" (WORA).

Lịch sử ngắn

1991: James Gosling và team tại Sun Microsystems bắt đầu phát triển Java (tên ban đầu: Oak)
1995: Java 1.0 chính thức ra mắt công chúng
2009: Oracle Corporation mua lại Sun Microsystems
Hiện tại: Java được duy trì bởi Oracle và cộng đồng open-source

Tại sao tên "Java"?

Tên "Java" được đặt theo tên của một loại cà phê từ đảo Java ở Indonesia. Team phát triển thường uống loại cà phê này khi làm việc!

Đặc điểm chính của Java

1. Platform Independent (Write Once, Run Anywhere)

Java code được compile thành bytecode chạy trên JVM (Java Virtual Machine), không phụ thuộc vào hardware hay OS cụ thể.

┌─────────────┐
│ Java Code   │ (.java file)
└──────┬──────┘
       │ javac (compile)
       ▼
┌─────────────┐
│  Bytecode   │ (.class file)
└──────┬──────┘
       │ Portable - chạy ở mọi nơi!
       ▼
┌──────────────────────────────────┐
│   JVM (Java Virtual Machine)      │
├──────────┬──────────┬────────────┤
│ Windows  │  macOS   │   Linux    │
└──────────┴──────────┴────────────┘

"Write Once, Run Anywhere" — Cơ chế Bytecode

Vấn đề truyền thống: Ngôn ngữ như C/C++ compile trực tiếp thành machine code.

Compile trên Windows → chỉ chạy trên Windows
Compile trên Linux → chỉ chạy trên Linux
Muốn cross-platform? Phải compile lại trên từng OS!

Giải pháp của Java: Bytecode làm "ngôn ngữ trung gian".

💡 Cách nhớ: Bytecode như "tiếng Anh quốc tế"

Source code (Java): Tiếng Việt (con người viết)
Bytecode (.class): Tiếng Anh (ngôn ngữ trung gian, ai cũng hiểu)
Machine code: Phương ngữ từng vùng (mỗi CPU khác nhau)
JVM như "thông dịch viên" — dịch tiếng Anh thành phương ngữ địa phương!

Quy trình chi tiết:

┌─────────────────────────────────────────────────────┐
│ Developer viết: HelloWorld.java                     │
│ public class HelloWorld {                           │
│     public static void main(String[] args) {        │
│         System.out.println("Hello");                │
│     }                                               │
│ }                                                   │
└────────────────┬────────────────────────────────────┘
                 │ javac (Java Compiler)
                 ▼
┌─────────────────────────────────────────────────────┐
│ Bytecode: HelloWorld.class                          │
│ (binary format, không phụ thuộc OS)                 │
│                                                     │
│ CA FE BA BE 00 00 00 3D  (magic number)            │
│ ... (bytecode instructions) ...                    │
│ 0x12: getstatic System.out                         │
│ 0x13: ldc "Hello"                                  │
│ 0x15: invokevirtual println                        │
└────────────────┬────────────────────────────────────┘
                 │ Portable! Chạy mọi nơi có JVM
         ┌───────┴──────┬──────────┐
         ▼              ▼          ▼
    JVM Windows    JVM macOS   JVM Linux
         │              │          │
         ▼              ▼          ▼
  Windows x86    macOS ARM64  Linux x86
  native code    native code  native code

Ví dụ bytecode thực tế:

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

Compile một lần:

javac HelloWorld.java  # Tạo HelloWorld.class

Xem bytecode (dùng javap):

javap -c HelloWorld

Output:

public static void main(java.lang.String[]);
  Code:
     0: getstatic     #7   // Field java/lang/System.out
     3: ldc           #13  // String Hello, World!
     5: invokevirtual #15  // Method println
     8: return

Chạy ở bất kỳ đâu có JVM:

java HelloWorld  # Windows, macOS, Linux - đều OK!

Tại sao bytecode portable?

Đặc điểm	C/C++ Executable	Java Bytecode
Format	Binary native code (CPU-specific)	Abstract bytecode (JVM-specific)
Phụ thuộc OS	✅ Có (system calls khác nhau)	❌ Không (JVM abstract OS)
Phụ thuộc CPU	✅ Có (x86, ARM khác nhau)	❌ Không (JVM dịch cho từng CPU)
Portable	❌ Không	✅ Có
Performance	Rất nhanh (native)	Hơi chậm hơn (qua JVM)

📖 Theo Oracle "Java Technology Overview"

Bytecode được thiết kế để:

Độc lập platform: Không chứa bất kỳ instruction CPU-specific nào
Compact: Tối ưu kích thước để truyền qua network (quan trọng cho applets thời xưa)
Verifiable: Dễ kiểm tra tính hợp lệ trước khi execute
Secure: Bytecode Verifier đảm bảo không có operations nguy hiểm

🔥 Bẫy OCP: WORA không hoàn hảo 100%

Đề thi có thể hỏi: "Java truly platform-independent?" → Đáp án: Gần như, nhưng có ngoại lệ:

JNI (Java Native Interface): Code gọi native C/C++ → mất tính portable
File paths: C:\path (Windows) vs /path (Linux) → dùng File.separator để portable
Line separators: \r\n (Windows) vs \n (Unix) → dùng System.lineSeparator()
GUI rendering: Swing/AWT có thể hiển thị khác nhau giữa các OS

Trade-offs của WORA:

Advantages:

✅ Code một lần, deploy nhiều nơi
✅ Không cần recompile cho từng OS
✅ Security: Bytecode Verifier ngăn chặn code độc hại

Disadvantages:

❌ Chậm hơn native code (có JVM layer trung gian)
❌ Cần cài JVM trên máy target
❌ Startup time chậm hơn (JVM phải khởi động)

2. Object-Oriented Programming (OOP)

Java được thiết kế hoàn toàn theo paradigm OOP với 4 trụ cột:

Encapsulation (Đóng gói)
Inheritance (Kế thừa)
Polymorphism (Đa hình)
Abstraction (Trừu tượng)

// OOP ví dụ
public class Dog {
    private String name;  // Encapsulation

    public Dog(String name) {
        this.name = name;
    }

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

3. Strongly Typed & Type Safe

Java yêu cầu khai báo type rõ ràng và kiểm tra type lúc compile-time.

int age = 25;           // OK
age = "twenty-five";    // ❌ Compile error!

4. Automatic Memory Management (Garbage Collection)

Java tự động quản lý memory thông qua Garbage Collector, giúp tránh memory leaks.

Dog dog = new Dog("Buddy");
dog = null;  // Object "Buddy" sẽ được GC tự động dọn dẹp

5. Rich Standard Library

Java đi kèm với thư viện chuẩn khổng lồ (Java API) cho mọi nhu cầu:

Collections (List, Set, Map)
I/O streams
Networking
Multithreading
Database connectivity (JDBC)

6. Multithreading Support

Java hỗ trợ multithreading built-in, cho phép chương trình chạy nhiều tasks đồng thời.

Thread thread = new Thread(() -> {
    System.out.println("Running in parallel!");
});
thread.start();

JVM / JRE / JDK - Sự khác nhau

Nhiều người hay nhầm lẫn giữa 3 khái niệm này. Hãy làm rõ:

┌───────────────────────────────────────┐
│              JDK                       │  Java Development Kit
│  (Công cụ để DEVELOP Java apps)       │
│                                        │
│  ┌─────────────────────────────────┐  │
│  │          JRE                     │  │  Java Runtime Environment
│  │  (Môi trường để CHẠY Java apps)  │  │
│  │                                  │  │
│  │  ┌────────────────────────────┐ │  │
│  │  │        JVM                  │ │  │  Java Virtual Machine
│  │  │  (Execute bytecode)         │ │  │
│  │  └────────────────────────────┘ │  │
│  │                                  │  │
│  │  + Java libraries                │  │
│  │  + Other supporting files        │  │
│  └─────────────────────────────────┘  │
│                                        │
│  + javac (compiler)                    │
│  + debugger, tools                     │
└───────────────────────────────────────┘

JVM (Java Virtual Machine)

Chức năng: Execute Java bytecode
Đặc điểm: Platform-specific (mỗi OS có JVM riêng)
Nhiệm vụ:
- Load bytecode
- Verify code
- Execute instructions
- Garbage collection

Kiến trúc JVM chi tiết

JVM hoạt động theo một quy trình chặt chẽ để biến bytecode thành machine code:

1. ClassLoader: Như một "thủ thư" trong thư viện.

Khi chương trình cần một class, ClassLoader tìm file .class tương ứng
Loading: Đọc bytecode từ file system hoặc network
Linking: Verify bytecode hợp lệ, chuẩn bị memory, resolve references
Initialization: Chạy static initializers, gán giá trị cho static variables

2. Bytecode Verifier: Như "nhân viên an ninh" tại sân bay.

Kiểm tra bytecode có hợp lệ không trước khi execute
Đảm bảo không có operations nguy hiểm (stack overflow, invalid type casting)
Verify không vi phạm access control (private, protected, public)

📖 Theo JLS §12.1 (Loading of Classes)

JVM chỉ load class khi cần thiết (lazy loading). Class User không được load cho đến khi code thực sự reference nó — giúp tiết kiệm memory và tăng tốc khởi động.

3. Execution Engine: Phần "não bộ" của JVM.

Interpreter:

Đọc bytecode từng instruction một và thực thi
Ưu điểm: Bắt đầu nhanh
Nhược điểm: Chậm (mỗi lần gặp instruction phải dịch lại)

JIT Compiler (Just-In-Time):

Phát hiện "hot code" (code chạy nhiều lần)
Compile bytecode → native machine code (binary) và cache lại
Lần sau: Chạy trực tiếp native code (cực nhanh!)

// Ví dụ: Loop này là "hot code" - JIT sẽ compile nó
for (int i = 0; i < 1_000_000; i++) {
    sum += i;  // JIT compile phần này thành native code
}

💡 Cách nhớ: JIT như "học vẹt thông minh"

Interpreter: Như đọc sách ngoại ngữ từng từ, tra từ điển mỗi lần gặp
JIT: Sau khi đọc một đoạn nhiều lần, bạn thuộc nó → lần sau đọc cực nhanh
JIT "thuộc lòng" những đoạn code chạy thường xuyên!

4. Garbage Collector (GC): Như "nhân viên dọn dẹp" tự động.

Quét Heap memory, tìm objects không còn reference
Giải phóng memory (khác C/C++ phải free() thủ công)
Nhiều thuật toán: Serial GC, Parallel GC, G1 GC, ZGC

Quy trình thực thi hoàn chỉnh:

HelloWorld.java  →  javac  →  HelloWorld.class (bytecode)
                                      ↓
                            ┌─────────────────┐
                            │   ClassLoader   │ Load .class
                            └────────┬────────┘
                                     ↓
                            ┌─────────────────┐
                            │ Bytecode Verify │ Kiểm tra an toàn
                            └────────┬────────┘
                                     ↓
                     ┌───────────────────────────┐
                     │   Execution Engine         │
                     ├────────────┬──────────────┤
                     │ Interpreter│ JIT Compiler │
                     │ (chậm)     │ (nhanh)      │
                     └────────────┴──────────────┘
                                     ↓
                            Machine Code (CPU chạy)

JRE (Java Runtime Environment)

Chức năng: Môi trường để CHẠY Java applications
Bao gồm: JVM + Java libraries + supporting files
Dùng khi: Chỉ muốn chạy Java apps, không develop

JDK (Java Development Kit)

Chức năng: Bộ công cụ để PHÁT TRIỂN Java applications
Bao gồm: JRE + compiler (javac) + debugger + tools
Dùng khi: Develop Java applications

Mối quan hệ JDK ⊃ JRE ⊃ JVM

Giải thích mối quan hệ "chứa trong" (containment) rõ ràng hơn:

Tóm tắt:

JVM = "Động cơ" execute bytecode
JRE = JVM + "Xăng" (libraries để chạy app)
JDK = JRE + "Bộ dụng cụ sửa chữa" (tools để develop)

💡 Cách nhớ: So sánh với ô tô

JVM: Động cơ (engine) — chạy bytecode
JRE: Động cơ + xăng + dầu nhớt — đủ để xe chạy (run apps)
JDK: Động cơ + xăng + bộ dụng cụ sửa chữa — đủ để sản xuất và bảo trì xe (develop apps)

Người lái xe (end-user) chỉ cần JRE. Thợ sửa xe (developer) cần JDK!

Khi nào dùng cái gì?

Vai trò	Cần gì?	Lý do
Developer	JDK	Cần `javac` để compile, `javadoc` để tạo docs, `jdb` để debug
End-user	JRE	Chỉ chạy app (có JVM + libraries là đủ)
Server production	JRE (hoặc JDK)	JRE nhẹ hơn, nhưng nhiều công ty vẫn dùng JDK để có tools debug

🔥 Bẫy OCP: JRE deprecated từ Java 11

Từ Java 11, Oracle không còn release JRE standalone. Lý do:

Modular system (JPMS) cho phép tạo custom runtime với jlink
jlink có thể tạo runtime nhỏ gọn chỉ chứa modules cần thiết

# Java 11+: Tạo custom runtime chỉ có java.base module
jlink --add-modules java.base --output custom-jre

Trong thực tế: Hầu hết developers vẫn download JDK đầy đủ.

Nhớ đơn giản

Developer: Cần JDK (có đầy đủ tools để code)
End-user: Chỉ cần JRE (chỉ chạy app) — nhưng từ Java 11, JRE không còn release riêng

Java Ecosystem

Java SE (Standard Edition) — Nền tảng cơ bản

Java SE là core platform, nền tảng của tất cả Java editions khác.

Bao gồm:

Core APIs: java.lang (String, Object), java.util (Collections), java.io (I/O)
JVM specification: Định nghĩa cách JVM hoạt động
Language specification: Cú pháp Java, type system, operators

Use cases:

Desktop applications (JavaFX, Swing)
Command-line tools
Foundation cho Java EE và frameworks khác

Ví dụ:

// Java SE core APIs
List<String> names = new ArrayList<>();  // java.util
String greeting = "Hello".toUpperCase(); // java.lang

Java EE (Enterprise Edition) → Jakarta EE

Java EE mở rộng Java SE cho enterprise applications (ứng dụng doanh nghiệp).

Bao gồm:

Servlets, JSP: Web components
EJB (Enterprise JavaBeans): Business logic components
JPA (Java Persistence API): Database ORM
CDI (Contexts and Dependency Injection): Dependency injection
JAX-RS: RESTful web services

Use cases:

Web applications (e-commerce, banking)
Microservices
RESTful APIs
Enterprise integration

Frameworks phổ biến:

Spring Boot: Most popular, easier than traditional Java EE
Quarkus: Cloud-native, Kubernetes-optimized
Micronaut: Fast startup, low memory

Lưu ý: Jakarta EE

Java EE đã được chuyển giao cho Eclipse Foundation (2018) và đổi tên thành Jakarta EE.

Java EE 8 (2017) → Jakarta EE 8 (2019) → Jakarta EE 9+ (namespace change)

Namespace change: javax.* → jakarta.*

// Old (Java EE):
import javax.servlet.http.HttpServlet;

// New (Jakarta EE 9+):
import jakarta.servlet.http.HttpServlet;

Java ME (Micro Edition)

Dành cho embedded systems và mobile devices (subset của Java SE)
Ít phổ biến hiện nay: feature phones đã thay bằng smartphones, IoT chuyển sang C/C++ hoặc Python
Chủ yếu còn gặp trong một số legacy embedded systems

Android — Trường hợp đặc biệt

Platform di động sử dụng Java syntax (và Kotlin)
KHÔNG chạy trên JVM → chạy trên Android Runtime (ART)

Sự khác biệt:

Đặc điểm	Java SE	Android
Runtime	JVM	ART (Android Runtime)
Bytecode	`.class` files	`.dex` (Dalvik Executable)
API	Java SE API	Android SDK API (khác biệt)
Packages	`java.`, `javax.`	`android.`, subset của `java.`

Ví dụ code Android:

// Android - Syntax giống Java, nhưng API khác
import android.app.Activity;          // Không có trong Java SE
import android.os.Bundle;

public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

🔥 Bẫy OCP: Android không phải Java SE

Đề thi có thể hỏi: "Can Java SE code run on Android without modification?"

Đáp án: Không — Android có API riêng (android.*), không dùng toàn bộ Java SE API
Phải dùng Android SDK và recompile thành .dex bytecode

So sánh Java Editions

Edition	Target	Runtime	APIs	Use case
Java SE	Desktop, Server	JVM	Core Java APIs	Foundation, command-line apps
Java EE / Jakarta EE	Enterprise server	JVM	Java SE + Enterprise APIs	Web apps, microservices
Java ME	Embedded	JVM variant	Subset of Java SE	IoT (ít dùng)
Android	Mobile	ART (không phải JVM)	Android SDK	Android apps

Use Cases - Java được dùng ở đâu?

1. Enterprise Applications (Spring Framework)

@RestController
@RequestMapping("/api/users")
public class UserController {
    @GetMapping
    public List<User> getAllUsers() {
        return userService.findAll();
    }
}

Ví dụ thực tế: Banking systems, E-commerce platforms, CRM systems

2. Android Development

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

Ví dụ thực tế: Uber, Spotify, Netflix (Android apps)

3. Big Data (Hadoop, Spark)

Apache Hadoop: Framework xử lý big data được viết bằng Java
Apache Kafka: Message broker phổ biến
Elasticsearch: Search engine

4. Web Applications

Backend: Spring Boot, Jakarta EE, Play Framework
Template engines: JSP, Thymeleaf
Microservices: Spring Cloud, Quarkus

5. Scientific Applications

MATLAB: Nhiều modules viết bằng Java
Trading systems: High-frequency trading platforms
Simulations: Physics, biology simulations

So sánh Java với các ngôn ngữ khác

Đặc điểm	Java	Python	JavaScript	C++
Type System	Strongly typed, static	Dynamically typed	Dynamically typed	Strongly typed, static
Performance	Nhanh (JIT compilation)	Chậm hơn	Trung bình	Rất nhanh (native)
Memory Management	Automatic (GC)	Automatic (GC)	Automatic (GC)	Manual
Platform	Platform-independent (JVM)	Platform-independent	Browser/Node.js	Platform-specific
Learning Curve	Trung bình	Dễ	Dễ	Khó
Use Cases	Enterprise, Android	Data science, scripting	Web frontend/backend	System programming, games
Concurrency	Built-in threads	GIL limitation	Event loop (async)	Manual threads
Syntax	Verbose	Concise	Flexible	Complex

Khi nào chọn Java?

✅ Chọn Java khi:

Cần build enterprise applications lớn
Quan tâm về type safety và maintainability
Cần performance tốt và scalability
Develop Android apps
Team lớn, cần codebase dễ maintain

❌ Không chọn Java khi:

Prototype nhanh (Python tốt hơn)
Web frontend (JavaScript/TypeScript)
System-level programming (C/C++, Rust)
Resource-constrained (embedded - C tốt hơn)

Phiên bản Java

Release Cycle

Trước Java 9: Release không đều (2-3 năm/version)
Từ Java 9+: Release mỗi 6 tháng (predictable)
- March: Version lẻ (9, 11, 13, 15...)
- September: Version chẵn (10, 12, 14, 16...)

LTS (Long-Term Support) Versions

Mỗi 3 năm có một LTS version với support dài hạn:

Version	Release Date	LTS	Support End	Đặc điểm nổi bật
Java 8	March 2014	✅	2030 (Oracle)	Lambda, Stream API, Optional
Java 9	Sept 2017	❌	-	Module system (JPMS)
Java 10	March 2018	❌	-	`var` keyword
Java 11	Sept 2018	✅	2026	HTTP Client, `var` in lambda
Java 17	Sept 2021	✅	2029	Sealed classes, Pattern matching
Java 21	Sept 2023	✅	2031	Virtual threads, Record patterns

Nên học version nào?

Beginners: Bắt đầu với Java 17 hoặc Java 21 (LTS mới nhất)
Industry: Nhiều công ty vẫn dùng Java 8 hoặc Java 11
Modern features: Java 21 có nhiều features hiện đại (virtual threads, pattern matching)

Tại sao LTS quan trọng?

Production stability: Các công ty chọn LTS cho môi trường production
Security updates: Oracle và vendors cung cấp security patches lâu dài
Ecosystem support: Libraries và frameworks ưu tiên hỗ trợ LTS

Khi nào upgrade?

Mới học: Bắt đầu với Java 17 hoặc Java 21 (LTS mới nhất)
Production: Chọn LTS gần nhất được vendor hỗ trợ
Legacy systems: Nhiều hệ thống vẫn chạy Java 8 (support đến 2030!)

🔥 Bẫy OCP: Non-LTS không có support dài hạn

Java 12, 13, 14, 15, 16, 18, 19, 20, 22, 23... chỉ được support 6 tháng (đến khi version tiếp theo ra mắt). Không nên dùng non-LTS cho production!

Tính năng quan trọng theo version

Java 8 (2014):

// Lambda expressions
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(name -> System.out.println(name));

// Stream API
long count = names.stream()
    .filter(name -> name.startsWith("A"))
    .count();

Java 10 (2018):

// var keyword - type inference
var message = "Hello";  // Compiler infer String
var numbers = List.of(1, 2, 3);  // Compiler infer List<Integer>

Java 14 (2020):

// Switch expressions
String result = switch (day) {
    case MONDAY, FRIDAY -> "Work day";
    case SATURDAY, SUNDAY -> "Weekend";
    default -> "Other";
};

Java 17 (2021):

// Sealed classes
public sealed class Shape
    permits Circle, Rectangle, Triangle {
}

// Pattern matching for instanceof
if (obj instanceof String s) {
    System.out.println(s.toUpperCase());  // s đã cast rồi!
}

Java 21 (2023):

// Virtual threads (lightweight)
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> System.out.println("Virtual thread!"));
}

// Record patterns
record Point(int x, int y) {}
if (obj instanceof Point(int x, int y)) {
    System.out.println("x: " + x + ", y: " + y);
}

Tại sao Java vẫn phổ biến?

1. Backward Compatibility

Java cam kết backward compatibility rất cao:

Code Java 8 vẫn chạy trên Java 21
Công ty có thể upgrade an toàn

2. Huge Ecosystem

Frameworks: Spring, Hibernate, Apache libraries
Build tools: Maven, Gradle
Testing: JUnit, Mockito, TestNG
IDEs: IntelliJ IDEA, Eclipse, NetBeans

3. Enterprise Adoption

Được tin dùng bởi các tập đoàn lớn: Google, Amazon, Netflix, Uber
Nhiều legacy systems được viết bằng Java
Dễ tìm developers có kinh nghiệm

4. Job Market

Một trong những ngôn ngữ có nhiều job openings nhất
Salary cạnh tranh, đặc biệt cho senior positions
Skill Java có thể transfer sang Kotlin, Scala

5. Community Support

Cộng đồng lớn và active
Nhiều tài liệu, tutorials, courses
Stack Overflow có hàng triệu câu hỏi về Java

6. GraalVM và Native Compilation

GraalVM là một JVM hiện đại hỗ trợ compile Java thành native executables (ahead-of-time compilation), giúp:

Startup time cực nhanh (milliseconds thay vì seconds)
Memory footprint nhỏ hơn đáng kể
Phù hợp cho serverless và containerized applications (Quarkus, Micronaut)

Bắt đầu học Java

Trong module này, bạn sẽ học:

Setup Environment - Cài đặt JDK, IDE, viết Hello World
Syntax Basics - Cú pháp cơ bản, naming conventions, comments
Data Types & Variables - Primitive types, reference types, casting
Type Casting & var - Chuyển đổi kiểu dữ liệu, var keyword
Operators - Toán tử arithmetic, logical, bitwise
Control Flow - If/else, loops, switch statements

Tổng kết

Java là ngôn ngữ lập trình:

✅ Platform-independent (WORA)
✅ Object-oriented
✅ Strongly typed & type-safe
✅ Automatic memory management (GC)
✅ Rich ecosystem và community
✅ Được tin dùng trong enterprise và Android

Sự khác nhau:

JVM: Execute bytecode
JRE: JVM + libraries (để CHẠY apps)
JDK: JRE + tools (để DEVELOP apps)

LTS versions: Java 8, 11, 17, 21

Bước tiếp theo

Bài tiếp theo chúng ta sẽ cài đặt JDK, setup IDE, và viết chương trình Java đầu tiên!

👉 Tiếp theo: Cài đặt môi trường phát triển →

Java là gì?​

Lịch sử ngắn​

Đặc điểm chính của Java​

1. Platform Independent (Write Once, Run Anywhere)​

"Write Once, Run Anywhere" — Cơ chế Bytecode​

2. Object-Oriented Programming (OOP)​

3. Strongly Typed & Type Safe​

4. Automatic Memory Management (Garbage Collection)​

5. Rich Standard Library​

6. Multithreading Support​

JVM / JRE / JDK - Sự khác nhau​

JVM (Java Virtual Machine)​

Kiến trúc JVM chi tiết​

JRE (Java Runtime Environment)​

JDK (Java Development Kit)​

Mối quan hệ JDK ⊃ JRE ⊃ JVM​

Java Ecosystem​

Java SE (Standard Edition) — Nền tảng cơ bản​

Java EE (Enterprise Edition) → Jakarta EE​

Java ME (Micro Edition)​

Android — Trường hợp đặc biệt​

So sánh Java Editions​

Use Cases - Java được dùng ở đâu?​

1. Enterprise Applications (Spring Framework)​

2. Android Development​

3. Big Data (Hadoop, Spark)​

4. Web Applications​

5. Scientific Applications​

So sánh Java với các ngôn ngữ khác​

Khi nào chọn Java?​

Phiên bản Java​

Release Cycle​

LTS (Long-Term Support) Versions​

Tính năng quan trọng theo version​

Tại sao Java vẫn phổ biến?​

1. Backward Compatibility​

2. Huge Ecosystem​

3. Enterprise Adoption​

4. Job Market​

5. Community Support​

6. GraalVM và Native Compilation​

Bắt đầu học Java​

Tổng kết​

Đọc thêm​