Khởi đầu với Java: Ngày đầu trong hành trình phát triển Backend

Hôm nay đánh dấu bước đầu tiên trong hành trình phát triển Backend với Java, và thật sự là một khởi đầu thú vị! Từ việc thiết lập môi trường đến việc viết mã Java đầu tiên, tôi đã khám phá những khái niệm cơ bản tạo nền tảng cho phát triển Java. Hãy cùng tìm hiểu sâu hơn vào chi tiết của Ngày đầu tiên.

🛠️ JVM, JRE và JDK

Trước khi viết một dòng mã nào, điều quan trọng là phải hiểu cách Java thực thi chương trình:

• JVM (Java Virtual Machine): JVM là trái tim của triết lý "viết một lần, chạy ở mọi nơi" của Java. Khi biên dịch một chương trình Java, nó được dịch sang bytecode (.class files). JVM diễn giải bytecode này thành mã máy cụ thể cho hệ điều hành chủ, giúp Java độc lập với nền tảng.

• JRE (Java Runtime Environment): JRE bao gồm cả JVM và các thư viện chuẩn (như java.lang, java.util, v.v.). Nó cung cấp mọi thứ cần thiết để chạy chương trình Java nhưng không bao gồm các công cụ phát triển.

• JDK (Java Development Kit): JDK là gói phát triển đầy đủ. Nó chứa JRE, trình biên dịch (javac), gỡ lỗi và các công cụ phát triển khác. Không có JDK, bạn không thể viết và biên dịch mã Java.

👉 Công thức để nhớ: JDK = JRE + Công cụ phát triển; JRE = JVM + Thư viện

✍️ Cú pháp cơ bản & Các khối xây dựng

Cấu trúc cơ bản của mỗi chương trình Java xoay quanh các lớp và phương thức:

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

• Lớp (Class): Java là ngôn ngữ lập trình hướng đối tượng, vì vậy mọi đoạn mã đều nằm trong một lớp.
• Phương thức main(): Điểm vào cho bất kỳ ứng dụng Java độc lập nào.

Các biến và kiểu dữ liệu

Java là ngôn ngữ kiểu tĩnh, nghĩa là bạn phải khai báo kiểu của biến trước khi sử dụng nó.

int age = 25; // số nguyên
double price = 99.99; // số thập phân
char grade = 'A'; // ký tự đơn
String name = "Alice"; // chuỗi ký tự
boolean isActive = true; // giá trị logic

• Kiểu dữ liệu nguyên thủy: byte, short, int, long, float, double, char, boolean.
• Kiểu dữ liệu không nguyên thủy: String, mảng, đối tượng, v.v.

Các toán tử

Toán tử cho phép chúng ta thao tác với các biến:

int sum = 10 + 5;   // Toán tử số học
int remainder = 10 % 3; // Toán tử chia lấy dư
boolean result = (5 > 2) && (3 < 4); // Toán tử logic

🔄 Cấu trúc điều khiển

Chương trình cần quyết định và vòng lặp:

If-Else

if (age >= 18) {
    System.out.println("Bạn là người trưởng thành.");
} else {
    System.out.println("Bạn là người chưa trưởng thành.");
}

Switch

switch (grade) {
    case 'A':
        System.out.println("Xuất sắc");
        break;
    case 'B':
        System.out.println("Tốt");
        break;
    default:
        System.out.println("Cố gắng hơn nữa");
}

Vòng lặp

for (int i = 1; i <= 5; i++) {
    System.out.println("Lượt lặp: " + i);
}

int count = 1;
while (count <= 3) {
    System.out.println("Đếm trong vòng lặp: " + count);
    count++;
}

🧠 Cơ bản về mô hình bộ nhớ

Java trừu tượng hóa việc quản lý bộ nhớ nhưng việc hiểu biết này giúp tránh những cạm bẫy:

• Bộ nhớ Stack: Lưu trữ các cuộc gọi phương thức, biến nguyên thủy và tham chiếu đến các đối tượng. Nó nhanh và được quản lý theo mỗi luồng.
• Bộ nhớ Heap: Lưu trữ các đối tượng và thể hiện lớp. Tất cả các đối tượng đều sống ở đây.
• Garbage Collection: JVM tự động thu hồi bộ nhớ từ các đối tượng không còn được tham chiếu. Các lập trình viên không cần phải giải phóng bộ nhớ thủ công, khác với C/C++.

⚙️ Phương thức & Hàm

Phương thức cải thiện khả năng tái sử dụng và tính mô-đun:

public class Calculator {
    int add(int a, int b) {
        return a + b;
    }

    double add(double a, double b) { // Nạp chồng phương thức
        return a + b;
    }
}

• Kiểu trả về xác định giá trị mà phương thức trả về.
• Tham số cho phép truyền dữ liệu vào phương thức.
• Nạp chồng cung cấp sự linh hoạt với các danh sách tham số khác nhau.

🏛️ Cơ bản về lập trình hướng đối tượng (OOP)

Sức mạnh của Java nằm trong các nguyên tắc OOP:

Đóng gói

Ràng buộc các biến và phương thức trong một lớp:

class Person {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Kế thừa

Tái sử dụng mã bằng cách mở rộng các lớp:

class Animal {
    void sound() {
        System.out.println("Âm thanh của động vật");
    }
}

class Dog extends Animal {
    void sound() {
        System.out.println("Chó sủa");
    }
}

Đa hình

Phương thức giống nhau hoạt động khác nhau dựa trên ngữ cảnh (nạp chồng phương thức, ghi đè phương thức).

Trừu tượng

Các lớp trừu tượng và giao diện ẩn đi sự phức tạp và phơi bày các tính năng thiết yếu.

abstract class Vehicle {
    abstract void start();
}

class Car extends Vehicle {
    void start() {
        System.out.println("Xe bắt đầu bằng chìa khóa");
    }
}

⚡ Xử lý ngoại lệ

Ngoại lệ ngăn chặn lỗi thời gian chạy làm gián đoạn ứng dụng:

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Lỗi: " + e.getMessage());
} finally {
    System.out.println("Khối này luôn được thực hiện.");
}

• try: Mã có thể gây ra ngoại lệ.
• catch: Xử lý ngoại lệ.
• finally: Thực thi bất kể có ngoại lệ hay không.
• throw/throws: Được sử dụng để khai báo và phát tán ngoại lệ.

🎯 Kết luận Ngày 1

Ngày đầu tiên tập trung vào việc thiết lập một nền tảng vững chắc cho Java. Tôi đã hiểu:

• Cách Java thực thi chương trình (JVM, JRE, JDK).
• Cú pháp cơ bản, biến, toán tử và cấu trúc điều khiển.
• Mô hình bộ nhớ và cách Java xử lý việc thu hồi bộ nhớ.
• Viết các phương thức có thể tái sử dụng và áp dụng các nguyên tắc OOP.
• Xử lý ngoại lệ một cách thanh lịch.

Tôi cảm thấy sẵn sàng để xây dựng dựa trên những kiến thức cơ bản này và tiến về phía trước.

💡 Hãy theo dõi Ngày 2