Khóa học Frontend NextJS + React

class TenClassCuaBan {
    // Thuộc tính (Properties)
    thuocTinh1: kieuDuLieu;
    thuocTinh2: kieuDuLieu = giaTriKhoiTao;

    // Constructor (Hàm tạo) - Tùy chọn
    constructor(thamSo1: kieuDuLieu, thamSo2: kieuDuLieu) {
        // Khởi tạo thuộc tính cho đối tượng
        this.thuocTinh1 = thamSo1;
        this.thuocTinh2 = thamSo2;
    }

    // Phương thức (Methods)
    phuongThucCuaBan(thamSo: kieuDuLieu): kieuDuLieuTraVe {
        // Logic xử lý của phương thức
        console.log("Đây là một phương thức");
        return motGiaTri;
    }
}

class Car {
    // Properties (Thuộc tính)
    make: string; // Hãng xe
    model: string; // Mẫu xe
    year: number; // Năm sản xuất

    // Constructor (Hàm tạo)
    constructor(make: string, model: string, year: number) {
        this.make = make;
        this.model = model;
        this.year = year;
    }

    // Methods (Phương thức)
    startEngine(): void {
        console.log(`${this.make} ${this.model} động cơ đã khởi động!`);
    }

    getCarInfo(): string {
        return `Xe: ${this.year} ${this.make} ${this.model}`;
    }
}

const myCar = new Car("Toyota", "Camry", 2022);

console.log(myCar.make); // Output: Toyota
console.log(myCar.getCarInfo()); // Output: Xe: 2022 Toyota Camry
myCar.startEngine(); // Output: Toyota Camry động cơ đã khởi động!

class PublicExample {
    public publicProperty: string;

    public constructor(value: string) {
        this.publicProperty = value;
    }

    public publicMethod(): void {
        console.log("Đây là phương thức Public.");
        console.log("Có thể truy cập publicProperty:", this.publicProperty);
    }
}

const instance1 = new PublicExample("Tôi là dữ liệu Public");

console.log(instance1.publicProperty); // ✅ Có thể truy cập từ bên ngoài
instance1.publicMethod(); // ✅ Có thể gọi từ bên ngoài

// Mặc định là public:
class AnotherPublicExample {
    // Không cần public, đây là mặc định
    defaultPublicProperty: string = "Tôi cũng là Public";

    defaultPublicMethod(): void {
        console.log("Đây là phương thức Public (mặc định).");
    }
}

const instance2 = new AnotherPublicExample();
console.log(instance2.defaultPublicProperty); // ✅ Có thể truy cập
instance2.defaultPublicMethod(); // ✅ Có thể gọi

class PrivateExample {
    private privateProperty: number; // Dữ liệu riêng tư

    constructor(initialValue: number) {
        this.privateProperty = initialValue;
    }

    // Phương thức public để cho phép truy cập giá trị private một cách có kiểm soát
    public getPrivateValue(): number {
        console.log("Truy cập privateProperty từ bên trong Class.");
        return this.privateProperty;
    }

    // Phương thức private chỉ sử dụng nội bộ
    private internalMethod(): void {
        console.log("Đây là phương thức Private chỉ dùng nội bộ.");
        // Có thể truy cập privateProperty từ đây
        console.log("privateProperty trong internalMethod:", this.privateProperty);
    }

    public demonstrateInternalUse(): void {
        this.internalMethod(); // ✅ Có thể gọi phương thức private từ bên trong Class
    }
}

const instance3 = new PrivateExample(42);

// console.log(instance3.privateProperty); // ❌ LỖI: Property 'privateProperty' is private and only accessible within class 'PrivateExample'.
// instance3.internalMethod(); // ❌ LỖI: Property 'internalMethod' is private and only accessible within class 'PrivateExample'.

console.log(instance3.getPrivateValue()); // ✅ OK: Truy cập thông qua phương thức public
instance3.demonstrateInternalUse(); // ✅ OK: Gọi phương thức public để kích hoạt phương thức private

class BaseClass {
    protected protectedProperty: string; // Dữ liệu được bảo vệ

    constructor(value: string) {
        this.protectedProperty = value;
    }

    protected protectedMethod(): void { // Phương thức được bảo vệ
        console.log("Đây là phương thức Protected từ BaseClass.");
        console.log("Có thể truy cập protectedProperty từ BaseClass:", this.protectedProperty);
    }
}

class DerivedClass extends BaseClass { // DerivedClass kế thừa từ BaseClass
    constructor(value: string) {
        super(value); // Gọi constructor của Class cha
    }

    public accessProtectedMembers(): void {
        // ✅ Có thể truy cập protectedProperty từ DerivedClass (là Class con)
        console.log("Truy cập protectedProperty từ DerivedClass:", this.protectedProperty);

        // ✅ Có thể gọi protectedMethod từ DerivedClass
        this.protectedMethod();
    }

    // ❌ Không thể truy cập private members của BaseClass (nếu có)
    // private basePrivateProperty: number; // Giả định BaseClass có private member
    // this.basePrivateProperty; // Sẽ báo lỗi
}

const instance4 = new DerivedClass("Tôi là dữ liệu Protected");

// console.log(instance4.protectedProperty); // ❌ LỖI: Property 'protectedProperty' is protected and only accessible within class 'BaseClass' and its subclasses.
// instance4.protectedMethod(); // ❌ LỖI: Property 'protectedMethod' is protected and only accessible within class 'BaseClass' and its subclasses.

instance4.accessProtectedMembers(); // ✅ OK: Gọi phương thức public để truy cập các thành viên protected từ bên trong DerivedClass