big update, new chapter, more parts

Author: HaiAu2501

4. My Projects/TicTacToe.java renamed to .projects/TicTacToe.java

@@ -1,10 +1,12 @@
 {
     "java.project.sourcePaths": [
         "src",
-        "3. Data Structures and Algorithms",
-        "2. Object-oriented Programming Principles",
-        "1. Introduction",
-        "4. My Projects"
+        "1. The Java Language",
+        "2. Classes in Java",
+        "3. Core Ultilities",
+        "4. IO Facilities",
+        "5. Data Structures and Algorithms",
+        "6. Network Programming",
     ],
     "java.project.outputPath": "bin",
     "java.project.referencedLibraries": [

.vscode/settings.json

@@ -0,0 +1,85 @@
+// Callback (gọi lại) là một cơ chế trong lập trình cho phép một đối tượng truyền tham chiếu đến một 
+// hoặc nhiều phương thức của nó cho một đối tượng khác, để sau này đối tượng được gọi có thể gọi lại các phương thức đó. 
+// Hiểu đơn giản là, truyền một phương thức vào một phương thức khác để thực thi nó sau này.
+/*
+ * - Đây là một phương pháp thường được sử dụng trong các ngôn ngữ như C hay C++ thông qua con trỏ hàm, 
+ * nhưng trong Java, cách tiếp cận này được thực hiện bằng cách sử dụng interfaces.
+ * - Callback giúp chúng ta giảm sự phụ thuộc giữa các đối tượng với nhau, giúp chúng ta dễ dàng mở rộng
+ * ứng dụng của mình hơn.
+ */
+
+// Ví dụ:
+
+// Định nghĩa interface TaskListener với phương thức onTaskCompleted() để xử lý kết quả trả về từ một Task nào đó.
+interface TaskListener {
+    void onTaskCompleted(String result);
+}
+
+// Tạo class Task mà sẽ sử dụng interface TaskListener để thông báo cho đối
+// tượng khác khi nó hoàn thành công việc.
+class Task {
+    private TaskListener listener;
+
+    public void setTaskListener(TaskListener listener) {
+        this.listener = listener;
+    }
+
+    public void completeTask() {
+        // Do something
+        // Sau khi hoàn thành công việc, gọi phương thức onTaskCompleted() của interface
+        // TaskListener
+        if (listener != null) {
+            listener.onTaskCompleted("Task completed");
+        }
+    }
+}
+
+// Triển khai class Application mà triển khai interface TaskListener và đăng ký
+// nhận sự kiện từ Task.
+class Application implements TaskListener {
+    @Override
+    public void onTaskCompleted(String result) {
+        System.out.println("Notification from Task:: " + result);
+    }
+
+    public static void main(String[] args) {
+
+        Task task = new Task();
+        Application app = new Application();
+
+        // Đăng ký nhận sự kiện từ Task
+        task.setTaskListener(app);
+
+        // Thực thi Task
+        task.completeTask();
+    }
+}
+
+// Trong ví dụ này:
+/*
+ * - TaskListener là interface chứa phương thức onTaskCompleted() để xử lý kết
+ * quả trả về từ Task.
+ * - Task là class chứa phương thức completeTask() để thực thi công việc và
+ * thông báo kết quả trả về thông qua interface TaskListener.
+ * - Application là class triển khai interface TaskListener để xử lý kết quả trả
+ * về từ Task.
+ */
+
+// Như vậy, interface TaskListener có ý nghĩa:
+/*
+ * - Task không cần biết đối tượng nào sẽ xử lý kết quả trả về của nó.
+ * - Task chỉ cần gọi phương thức onTaskCompleted() của interface TaskListener
+ * để thông báo kết quả trả về.
+ * - Application sẽ triển khai interface TaskListener để xử lý kết quả trả về từ
+ * Task.
+ * -> Từ đó, chúng ta có thể dễ dàng thay đổi hoặc mở rộng ứng dụng mà không cần
+ * sửa đổi Task.
+ * -> Callback giúp chúng ta giảm sự phụ thuộc giữa các đối tượng với nhau, giúp
+ * chúng ta dễ dàng mở rộng ứng dụng của mình hơn.
+ */
+
+public class Callback {
+    public static void main(String[] args) {
+        Application.main(args);
+    }
+}

1. Introduction/ArgumentPassing.java renamed to 1. The Java Language/ArgumentPassing.java

@@ -0,0 +1,3 @@
+public class InnerClass {
+
+}

1. Introduction/Arrays.java renamed to 1. The Java Language/Arrays.java

@@ -0,0 +1,65 @@
+// Một interface có thể chứa các biến, nhưng các biến này mặc định là public, static và final;
+/*
+ * - Các biến này có thể được tham chiếu trực tiếp thông qua tên của interface.
+ * - Các biến này xuất hiện trong tất cả các class implement interface đó.
+ */
+
+// Ví dụ:
+interface Scaleable {
+    static final int BIG = 0, MEDIUM = 1, SMALL = 2;
+
+    void setScale(int size);
+}
+
+class Box implements Scaleable {
+    private int size;
+
+    @Override
+    public void setScale(int size) {
+        switch (size) {
+            case BIG:
+                this.size = 100;
+                break;
+            case MEDIUM:
+                this.size = 50;
+                break;
+            case SMALL:
+                this.size = 25;
+                break;
+            default:
+                System.out.println("Invalid size");
+        }
+    }
+
+    public void printSize() {
+        System.out.println("Size: " + size);
+    }
+}
+
+public class InterfaceVariables {
+    public static void main(String[] args) {
+        Box box = new Box();
+        box.setScale(Scaleable.BIG);
+        box.printSize(); // Size: 100
+    }
+}
+
+// Interfaces trong lập trình hướng đối tượng nên chỉ được sử dụng để định nghĩa
+// hành vi, không phải để lưu trữ trạng thái hay dữ liệu cụ thể. Việc sử dụng
+// interfaces để chứa biến (các hằng số) làm mờ đi mục đích chính của chúng và
+// có thể dẫn đến một thiết kế không sạch sẽ, khiến cho các hằng số và hành vi
+// được gói gọn cùng nhau một cách không cần thiết.
+
+/*
+ * - Tất cả biến trong interface đều là public static final. Điều này có nghĩa
+ * là
+ * chúng luôn luôn công khai và có sẵn cho bất kỳ ai sử dụng interface. Điều này
+ * cản trở khả năng đóng gói, khiến cho việc quản lý trạng thái của chương trình
+ * trở nên khó khăn hơn.
+ * - Việc mỗi lớp thực thi một interface kế thừa toàn bộ các hằng số có thể gây
+ * rối loạn API của lớp đó, khiến cho API bao gồm nhiều thành phần không cần
+ * thiết
+ */
+
+// -> Tóm lại, không nên sử dụng interface để chứa biến, hãy sử dụng class hoặc
+// enum thay thế.

1. Introduction/Boxing.java renamed to 1. The Java Language/Boxing.java

@@ -0,0 +1,75 @@
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+// Lớp chồng nhau (nested class) là một lớp được định nghĩa bên trong một lớp khác.
+
+// Ví dụ:
+class ContactBook {
+    public List<Contact> contacts = new ArrayList<>();
+    public Map<String, Group> groups = new HashMap<>();
+
+    class Contact {
+        private String name;
+        private String phone;
+
+        public Contact(String name, String phone) {
+            this.name = name;
+            this.phone = phone;
+        }
+
+        public void displayContact() {
+            System.out.println("Name: " + name + ", Phone: " + phone);
+        }
+    }
+
+    static class Group {
+        String name;
+        List<String> members = new ArrayList<>();
+
+        public Group(String name) {
+            this.name = name;
+        }
+
+        public void addMember(String contactName) {
+            members.add(contactName);
+        }
+
+        public void displayGroup() {
+            System.out.println("Group: " + name);
+            System.out.println("Members:");
+            for (String member : members) {
+                System.out.println(member);
+            }
+        }
+    }
+
+    public void addContact(String name, String phone) {
+        Contact contact = new Contact(name, phone);
+        contacts.add(contact);
+    }
+
+    public void addGroup(String name) {
+        Group group = new Group(name);
+        groups.put(name, group);
+    }
+}
+
+public class NestedClass {
+    public static void main(String[] args) {
+        ContactBook myBook = new ContactBook();
+        myBook.addContact("Alice", "1234567890");
+        myBook.addContact("Bob", "0987654321");
+
+        myBook.addGroup("Friends");
+        myBook.groups.get("Friends").addMember("Alice");
+        myBook.groups.get("Friends").addMember("Bob");
+
+        for (ContactBook.Contact contact : myBook.contacts) {
+            contact.displayContact();
+        }
+
+        myBook.groups.get("Friends").displayGroup();
+    }
+}

1. Introduction/DataTypes.java renamed to 1. The Java Language/DataTypes.java

@@ -0,0 +1,92 @@
+// Một interface có thể extends một hoặc nhiều interface khác. 
+// Điều này giúp chúng ta tạo ra một cấu trúc phân cấp của các interface, giúp chúng ta quản lý và sắp xếp các hành vi một cách có tổ chức.
+
+/*
+ * - Lưu ý, khác với class chỉ kế thừa từ một class cha duy nhất, một class có thể
+ * implements nhiều interface; còn một interface có thể extends nhiều interface khác.
+ * - Một interface không thể kế thừa từ class khác.
+ * - Một class implement một interface thì cũng phải implement tất cả interface mà
+ * interface đó extends.
+ */
+
+// Ví dụ:
+
+// Interface Vehicle định nghĩa các hành vi cơ bản của một phương tiện giao thông.
+interface Vehicle {
+    void start();
+
+    void stop();
+}
+
+// Interface FlyingVehicle định nghĩa các hành vi của một phương tiện bay.
+interface FlyingVehicle extends Vehicle {
+    void fly();
+
+    void land();
+}
+
+// Interface LandVehicle định nghĩa các hành vi của một phương tiện đường bộ.
+interface LandVehicle extends Vehicle {
+    void drive();
+
+    void brake();
+}
+
+// Interface AmphibiousVehicle kế thừa từ cả FlyingVehicle và LandVehicle, định
+// nghĩa
+// thêm hành vi floatOnWater().
+interface AmphibiousVehicle extends FlyingVehicle, LandVehicle {
+    void floatOnWater();
+}
+
+// Lớp HybridDrone thực thi interface AmphibiousVehicle.
+// -> Nó phải override tất cả các phương thức của các interface mà nó implement.
+class HybridDrone implements AmphibiousVehicle {
+    @Override
+    public void start() {
+        System.out.println("HybridDrone is starting...");
+    }
+
+    @Override
+    public void stop() {
+        System.out.println("HybridDrone is stopping...");
+    }
+
+    @Override
+    public void fly() {
+        System.out.println("HybridDrone is flying...");
+    }
+
+    @Override
+    public void land() {
+        System.out.println("HybridDrone is landing...");
+    }
+
+    @Override
+    public void drive() {
+        System.out.println("HybridDrone is driving...");
+    }
+
+    @Override
+    public void brake() {
+        System.out.println("HybridDrone is braking...");
+    }
+
+    @Override
+    public void floatOnWater() {
+        System.out.println("HybridDrone is floating on water...");
+    }
+}
+
+public class SubInterface {
+    public static void main(String[] args) {
+        HybridDrone drone = new HybridDrone();
+        drone.start();
+        drone.fly();
+        drone.land();
+        drone.drive();
+        drone.brake();
+        drone.floatOnWater();
+        drone.stop();
+    }
+}