new content

Author: HaiAu2501

2. Classes in Java/AnonymousInnerClass.java

@@ -0,0 +1,106 @@
+// Tiếp tục về nội lớp (inner class).
+// 4. Nội lớp vô danh (anonymous inner class):
+/*
+ * - Là một loại nội lớp không có tên, được khai báo và khởi tạo ngay tại chỗ.
+ * - Dùng khi bạn cần tạo một lớp mà chỉ sử dụng một lần duy nhất.
+ */
+
+// Xét ví dụ sau:
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Iterator;
+
+// Lớp Book chứa thông tin về một cuốn sách (tên sách, tác giả)
+class Book {
+    String title;
+    String author;
+
+    Book(String title, String author) {
+        this.title = title;
+        this.author = author;
+    }
+
+    @Override
+    public String toString() {
+        return title + " by " + author;
+    }
+}
+
+// Lớp BookList chứa một danh sách các cuốn sách.
+class BookList {
+    private List<Book> books = new ArrayList<>();
+
+    public void addBook(Book book) {
+        books.add(book);
+    }
+
+    public int getSize() {
+        return books.size();
+    }
+
+    // Nội lớp cung cấp iterator để duyệt qua danh sách các cuốn sách.
+    public class BookIterator implements Iterator<Book> {
+        private int index = 0;
+
+        @Override
+        public boolean hasNext() {
+            return index < books.size();
+        }
+
+        @Override
+        public Book next() {
+            return books.get(index++);
+        }
+    }
+
+    public BookIterator getIterator() {
+        return new BookIterator();
+    }
+
+    // Sử dụng nội lớp vô danh để tạo một Iterator mới mà không cần phải tạo lớp
+    // mới.
+    public Iterator<Book> getReverseIterator() {
+        return new Iterator<Book>() {
+            private int index = books.size() - 1;
+
+            @Override
+            public boolean hasNext() {
+                return index >= 0;
+            }
+
+            @Override
+            public Book next() {
+                return books.get(index--);
+            }
+        };
+        // Đây là một nội lớp vô danh, không có tên, được khai báo và khởi tạo ngay
+        // tại chỗ.
+    }
+}
+
+public class AnonymousInnerClass {
+    public static void main(String[] args) {
+        BookList myList = new BookList();
+
+        myList.addBook(new Book("The Alchemist", "Paulo Coelho"));
+        myList.addBook(new Book("The Little Prince", "Antoine de Saint-Exupéry"));
+        myList.addBook(new Book("The Da Vinci Code", "Dan Brown"));
+
+        System.out.println("--Book list:");
+
+        // Sử dụng Iterator để duyệt qua danh sách các cuốn sách.
+        BookList.BookIterator iterator = myList.getIterator();
+        while (iterator.hasNext()) {
+            System.out.println(iterator.next());
+        }
+
+        System.out.println("\n--Book list in reverse order:");
+
+        // Sử dụng Iterator để duyệt qua danh sách các cuốn sách theo thứ tự ngược lại.
+        Iterator<Book> reverseIterator = myList.getReverseIterator();
+        while (reverseIterator.hasNext()) {
+            System.out.println(reverseIterator.next());
+        }
+    }
+}

2. Classes in Java/Equals.java

@@ -0,0 +1,70 @@
+// Trong Java, equals() là một phương thức của lớp Object được sử dụng để so sánh hai đối tượng.
+/*
+ * - Nó xem xét hai đối tượng là bằng nhau nếu chúng cùng tham chiếu đến cùng một vùng nhớ trong bộ nhớ.
+ * - Phương thức equals() được ghi đè bởi các lớp con để so sánh dữ liệu của đối tượng.
+ * - Nếu không ghi đè phương thức này, nó sẽ so sánh hai đối tượng bằng cách so sánh địa chỉ bộ nhớ của chúng. 
+ * -> Kết quả sẽ giống như sử dụng toán tử ==.
+ */
+
+// Ví dụ về equals() mặc định:
+@SuppressWarnings("unused")
+class Student {
+    private String name;
+    private int age;
+
+    public Student(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+}
+
+// Nếu ghi đè phương thức equals() để so sánh dữ liệu của đối tượng:
+class Teacher {
+    private String name;
+    private int age;
+
+    public Teacher(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    // Ghi đè phương thức equals() để so sánh dữ liệu của đối tượng.
+    @Override
+    public boolean equals(Object obj) {
+        // Nếu hai đối tượng cùng tham chiếu đến cùng một vùng nhớ.
+        if (this == obj) {
+            return true;
+        }
+
+        // Nếu obj là null hoặc không phải là một instance của lớp Teacher.
+        if (obj == null || getClass() != obj.getClass()) {
+            return false;
+        }
+
+        // Ép kiểu obj về lớp Teacher.
+        Teacher teacher = (Teacher) obj;
+        return age == teacher.age && name.equals(teacher.name);
+    }
+}
+
+@SuppressWarnings("unlikely-arg-type")
+public class Equals {
+    public static void main(String[] args) {
+        Student student1 = new Student("Alice", 20);
+        Student student2 = new Student("Alice", 20);
+
+        // So sánh hai đối tượng sử dụng equals() mặc định.
+        // Kết quả sẽ là false vì không ghi đè phương thức equals().
+        System.out.println(student1.equals(student2));
+
+        // So sánh hai đối tượng sử dụng equals() đã được ghi đè.
+        // Kết quả sẽ là true vì dữ liệu của hai đối tượng giống nhau.
+        Teacher teacher1 = new Teacher("Bob", 30);
+        Teacher teacher2 = new Teacher("Bob", 30);
+        System.out.println(teacher1.equals(teacher2));
+
+        // Nếu so sánh giữa hai đối tượng khác nhau.
+        System.out.println(teacher1.equals(student1));
+        // -> false vì student1 không phải là một instance của lớp Teacher.
+    }
+}

2. Classes in Java/EventHandling.java

@@ -0,0 +1,60 @@
+// Một tác dụng khác thường thấy của anonymous inner class là xử lý sự kiện (event handling).
+/*
+ * - Sự kiện (event) là một hành động xảy ra trong ứng dụng, ví dụ nhấn nút chuột, gõ phím, kéo thả, ...
+ * - Event handling là quá trình xử lý các sự kiện này.
+ * - Trong Java, event handling thường được thực hiện thông qua các listener (người nghe) và adapter (bộ chuyển đổi).
+ * - Listener là một interface chứa các phương thức để xử lý sự kiện.
+ * - Adapter là một lớp trung gian giữa listener và component (thành phần) để xử lý sự kiện.
+ * - Anonymous inner class thường được sử dụng để triển khai listener và adapter một cách nhanh chóng và tiện lợi.
+ */
+
+// Xét ví dụ sau:
+/*
+ * - Trong ví dụ này, chúng ta tạo một cửa sổ JFrame với một nút JButton.
+ * - Khi người dùng nhấn nút, chúng ta muốn in ra màn hình dòng chữ "Button clicked!".
+ * - Để xử lý sự kiện này, chúng ta sử dụng một anonymous inner class để triển khai ActionListener.
+ * - ActionListener là một interface trong gói java.awt.event, nó chứa một phương thức actionPerformed() để xử lý sự kiện.
+ * - Trong anonymous inner class, chúng ta triển khai phương thức actionPerformed() để in ra dòng chữ "Button clicked!".
+ */
+
+import java.awt.event.*;
+import javax.swing.*;
+
+// Sử dụng nội lớp vô danh để xử lý sự kiện khi người dùng nhấn nút.
+public class EventHandling {
+    public static void main(String[] args) {
+        // Tạo một cửa sổ JFrame
+        JFrame frame = new JFrame("Event Handling Example");
+
+        // Tạo một nút JButton
+        JButton button = new JButton("Click Me");
+
+        // Thêm nút vào cửa sổ
+        frame.add(button);
+
+        // Đặt kích thước cửa sổ
+        frame.setSize(300, 200);
+
+        // Đặt cửa sổ hiển thị ở giữa màn hình
+        frame.setLocationRelativeTo(null);
+
+        // Đặt cửa sổ hiển thị
+        frame.setVisible(true);
+
+        // Sử dụng nội lớp vô danh để xử lý sự kiện khi người dùng nhấn nút
+        button.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                System.out.println("Button clicked!");
+            }
+        });
+    }
+}
+
+// Tác dụng của nội lớp vô danh trong ví dụ trên:
+/*
+ * - Anonymous inner class này được truyền vào phương thức addActionListener()
+ * của JButton để xử lý sự kiện khi người dùng nhấn nút.
+ * - Anonymous inner class giúp viết mã ngắn gọn và dễ hiểu hơn so với việc tạo
+ * một lớp mới và triển khai ActionListener.
+ */

2. Classes in Java/StaticInnerClass.java

@@ -9,6 +9,87 @@
  * thay vì phải tạo nhiều lớp độc lập, từ đó làm tăng số lượng lớp trong gói.
  */
 
+import java.util.ArrayList;
+import java.util.List;
+
+// Xét ví dụ sau:
+/*
+ * - Class Department chứa một static inner class Employee.
+ * - Department quản lý thông tin về một phòng ban trong công ty, bao gồm tên phòng ban và danh sách nhân viên.
+ * - Employee chứa thông tin về một nhân viên, bao gồm tên, mã số và chức vụ.
+ */
+
+class Department {
+    private String name;
+    private List<Employee> employees;
+
+    public Department(String name) {
+        this.name = name;
+        this.employees = new ArrayList<>();
+    }
+
+    public void addEmployee(String empName, String empId, String position) {
+        Employee newEmployee = new Employee(empName, empId, position);
+        employees.add(newEmployee);
+    }
+
+    public List<Employee> getEmployees() {
+        return employees;
+    }
+
+    // Static inner class
+    public static class Employee {
+        private String name;
+        private String id;
+        private String position;
+
+        public Employee(String name, String id, String position) {
+            this.name = name;
+            this.id = id;
+            this.position = position;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public String getId() {
+            return id;
+        }
+
+        public String getPosition() {
+            return position;
+        }
+
+        @Override
+        public String toString() {
+            return "Employee{" +
+                    "name='" + name + '\'' +
+                    ", id='" + id + '\'' +
+                    ", position='" + position + '\'' +
+                    '}';
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "Department{" +
+                "name='" + name + '\'' +
+                ", employees=" + employees +
+                '}';
+    }
+}
+
 public class StaticInnerClass {
+    public static void main(String[] args) {
+        Department itDepartment = new Department("IT");
+        itDepartment.addEmployee("John", "0001", "Developer");
+        itDepartment.addEmployee("Jane", "0002", "Designer");
+
+        System.out.println(itDepartment);
 
+        // Khởi tạo Employee không thông qua Department
+        Department.Employee manager = new Department.Employee("Alice", "0010", "Manager");
+        System.out.println("Manager: " + manager);
+    }
 }

2. Classes in Java/TheObjectClass.java

@@ -0,0 +1,59 @@
+// Trong Java, mọi lớp đều kế thừa từ lớp Object. 
+/* - Lớp Object là lớp cha của tất cả các lớp trong Java. 
+ * - Nó chứa các phương thức mà mọi lớp kế thừa từ nó. 
+ * - Lớp Object cung cấp một số phương thức mặc định, nhưng chúng có thể được ghi đè bởi các lớp con để cung cấp cài đặt cụ thể.
+ * - Dưới đây là một số phương thức static quang trọng của lớp Object:
+ *   + Object clone(): Trả về một bản sao của đối tượng hiện tại.
+ *   + boolean equals(Object obj): So sánh hai đối tượng.
+ *   + void finalize(): Được gọi trước khi một đối tượng bị thu hồi bởi garbage collector.
+ *   + Class<?> getClass(): Trả về đối tượng Class của đối tượng hiện tại.
+ *   + int hashCode(): Trả về mã băm của đối tượng.
+ *   + void notify(): Thức tỉnh một luồng đang chờ đợi trên đối tượng hiện tại.
+ *   + void notifyAll(): Thức tỉnh tất cả các luồng đang chờ đợi trên đối tượng hiện tại.
+ *   + String toString(): Trả về chuỗi biểu diễn của đối tượng.
+ *   + void wait(): Chờ cho đến khi một luồng khác gọi notify() hoặc notifyAll() trên đối tượng hiện tại.
+ */
+
+// Ví dụ về phương thức toString():
+class Student {
+    private String name;
+    private int age;
+
+    public Student(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    // Ghi đè phương thức toString() để trả về thông tin của đối tượng.
+    @Override
+    public String toString() {
+        return "Student [name=" + name + ", age=" + age + "]";
+    }
+}
+
+@SuppressWarnings("unused")
+class Teacher {
+    private String name;
+    private int age;
+
+    public Teacher(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+}
+
+public class TheObjectClass {
+    public static void main(String[] args) {
+        Student student = new Student("Alice", 20);
+        System.out.println(student.toString());
+
+        // Lớp Object cung cấp phương thức toString() mặc định.
+        // Khi không ghi đè phương thức này,
+        // kết quả sẽ là: <tên gói>.<tên lớp>@<địa chỉ bộ nhớ>
+        Object obj = new Object();
+        System.out.println(obj.toString());
+
+        Teacher teacher = new Teacher("Bob", 30);
+        System.out.println(teacher.toString());
+    }
+}