Generics — kiểu tổng quát

// ❌ Không có generics: List chứa Object
List ds = new ArrayList();
ds.add("Xin chào");
ds.add(42);              // ⚠️ trình biên dịch không phản đối gì
ds.add(new SinhVien());   // ⚠️ cũng được luôn

String s = (String) ds.get(0);   // phải ép kiểu bằng tay
String t = (String) ds.get(1);   // 💥 ClassCastException LÚC CHẠY

// Vấn đề: lỗi chỉ lộ ra khi chương trình ĐANG CHẠY, có khi ở máy khách hàng


// ✅ Với generics: lỗi bị bắt ngay LÚC BIÊN DỊCH
List<String> ds2 = new ArrayList<>();
ds2.add("Xin chào");
// ds2.add(42);          // ❌ error: incompatible types: int cannot be
                         //    converted to String

String s2 = ds2.get(0);       // ✅ không cần ép kiểu

// <T> là THAM SỐ KIỂU — một chỗ trống sẽ được điền khi dùng
public class Hop<T> {
    private T noiDung;

    public void dat(T x)  { this.noiDung = x; }
    public T lay()      { return noiDung; }
    public boolean rong() { return noiDung == null; }
}

Hop<String> h1 = new Hop<>();     // <> = diamond, Java 7+ tự suy ra
h1.dat("Xin chào");
String s = h1.lay();               // không cần ép kiểu ✅
// h1.dat(42);                       // ❌ lỗi biên dịch

Hop<Integer> h2 = new Hop<>();
h2.dat(42);

// --- Nhiều tham số kiểu ---
public class Cap<A, B> {
    private final A dau;
    private final B sau;

    public Cap(A dau, B sau) { this.dau = dau; this.sau = sau; }
    public A dau() { return dau; }
    public B sau() { return sau; }

    // Đổi chỗ — trả về Cap với thứ tự kiểu ngược lại
    public Cap<B, A> doiCho() { return new Cap<>(sau, dau); }
}

Cap<String, Integer> c = new Cap<>("tuoi", 22);
Cap<Integer, String> d = c.doiCho();

// ✅ Java 16+: record generic — gọn hơn hẳn
public record Cap<A, B>(A dau, B sau) {
    public Cap<B, A> doiCho() { return new Cap<>(sau, dau); }
}

// <T> đặt TRƯỚC kiểu trả về — đây là điểm hay quên
public static <T> void in(List<T> ds) {
    for (T x : ds) System.out.println(x);
}

public static <T> T phanTuDau(List<T> ds) {
    return ds.isEmpty() ? null : ds.get(0);
}

// Nhiều tham số kiểu
public static <K, V> Map<V, K> daoNguoc(Map<K, V> m) {
    Map<V, K> kq = new HashMap<>();
    m.forEach((k, v) -> kq.put(v, k));
    return kq;
}

// Java tự SUY RA kiểu từ tham số — không cần nói
in(List.of("a", "b"));                    // T = String
Integer n = phanTuDau(List.of(1, 2, 3));   // T = Integer

// Chỉ định tường minh khi cần (hiếm)
List<String> rong = Collections.<String>emptyList();

// ❌ T bất kỳ → không gọi được method nào ngoài của Object
static <T> T lonNhat(List<T> ds) {
    T max = ds.get(0);
    for (T x : ds)
        if (x.compareTo(max) > 0) max = x;   // ❌ error: cannot find symbol
    return max;
}

// ✅ Giới hạn trên: T phải cài đặt Comparable<T>
static <T extends Comparable<T>> T lonNhat(List<T> ds) {
    T max = ds.get(0);
    for (T x : ds)
        if (x.compareTo(max) > 0) max = x;   // ✅ giờ gọi được
    return max;
}
lonNhat(List.of(3, 1, 4));         // 4
lonNhat(List.of("b", "a", "c"));   // "c"
// lonNhat(List.of(new Object()));  // ❌ Object không cài Comparable

// --- Giới hạn bằng class ---
static <T extends Number> double tong(List<T> ds) {
    double t = 0;
    for (T x : ds) t += x.doubleValue();   // method của Number
    return t;
}

// --- NHIỀU giới hạn: dùng &, class phải đứng ĐẦU ---
static <T extends Number & Comparable<T> & Serializable> T xuLy(T x) {
    ...
}

// --- Giới hạn đệ quy — mẫu hay gặp trong JDK ---
public abstract class Enum<E extends Enum<E>> implements Comparable<E> { }
// Nghĩa: "E là một enum có thể so sánh với chính loại E của nó"
// → mỗi enum chỉ so sánh được với enum cùng loại, không so chéo

// Mảng thì HIỆP BIẾN (covariant) — cha con truyền được
Object[] mang = new String[3];       // ✅ biên dịch được
mang[0] = 42;                        // 💥 ArrayStoreException LÚC CHẠY

// Generic thì BẤT BIẾN (invariant) — bắt lỗi ngay lúc biên dịch
// List<Object> ds = new ArrayList<String>();
//   ❌ error: incompatible types

// ① ? — kiểu bất kỳ, không biết là gì
static void inSoLuong(List<?> ds) {
    System.out.println(ds.size());
    for (Object o : ds) System.out.println(o);   // đọc ra Object thì được
    // ds.add("x");   // ❌ KHÔNG thêm được gì (trừ null)
}
inSoLuong(List.of("a"));      // ✅
inSoLuong(List.of(1, 2));    // ✅ nhận được mọi List


// ② ? extends T — giới hạn TRÊN: "T hoặc bất kỳ con nào của T"
static double tong(List<? extends Number> ds) {
    double t = 0;
    for (Number n : ds) t += n.doubleValue();   // ✅ ĐỌC được (là Number)
    // ds.add(1);      // ❌ KHÔNG GHI được — không biết chính xác kiểu gì
    return t;
}
tong(List.of(1, 2, 3));         // List<Integer> ✅
tong(List.of(1.5, 2.5));       // List<Double>  ✅


// ③ ? super T — giới hạn DƯỚI: "T hoặc bất kỳ cha nào của T"
static void themSo(List<? super Integer> ds) {
    ds.add(1);                // ✅ GHI được (Integer chắc chắn vừa)
    ds.add(2);
    Object o = ds.get(0);      // ⚠️ đọc ra chỉ chắc là Object
    // Integer i = ds.get(0);   // ❌ có thể là List<Number> hoặc List<Object>
}
themSo(new ArrayList<Integer>());   // ✅
themSo(new ArrayList<Number>());    // ✅
themSo(new ArrayList<Object>());    // ✅

// Chữ ký thật của Collections.copy trong JDK:
public static <T> void copy(List<? super T> dich,      // CONSUMER → super
                               List<? extends T> nguon) { // PRODUCER → extends
    for (int i = 0; i < nguon.size(); i++)
        dich.set(i, nguon.get(i));
}

// Nhờ vậy lời gọi này hợp lệ:
List<Object>  dich  = new ArrayList<>(Collections.nCopies(3, null));
List<Integer> nguon = List.of(1, 2, 3);
Collections.copy(dich, nguon);      // ✅ Object ⊃ Integer


// --- Ví dụ tự viết ---
static <T> void chuyenHet(Collection<? extends T> tu,   // đọc → extends
                             Collection<? super T> den) {   // ghi → super
    for (T x : tu) den.add(x);
}

List<Integer> a = List.of(1, 2, 3);
List<Number>  b = new ArrayList<>();
chuyenHet(a, b);                    // ✅ Integer → Number


// --- Comparator cũng theo PECS ---
// Chữ ký thật của List.sort:
void sort(Comparator<? super E> c);
// Comparator TIÊU THỤ phần tử → super
// Nhờ vậy Comparator<Object> dùng được cho List<String>

Comparator<Object> theoChuoi = Comparator.comparing(Object::toString);
List<String> ds = new ArrayList<>(List.of("b", "a"));
ds.sort(theoChuoi);                  // ✅ nhờ ? super E

// Trước khi xoá                        Sau khi xoá
List<String>                    →     List
Map<String, Integer>           →     Map
<T> void f(T x)                 →     void f(Object x)
<T extends Number> void g(T x) →     void g(Number x)   // thay bằng GIỚI HẠN

// Kiểm chứng bằng javap:
// $ javap -c Hop.class
//   public java.lang.Object lay();     ← T đã biến thành Object

// ① Mọi List<X> là CÙNG MỘT class lúc chạy
List<String>  a = new ArrayList<>();
List<Integer> b = new ArrayList<>();
System.out.println(a.getClass() == b.getClass());   // true
System.out.println(a.getClass());                   // class java.util.ArrayList


// ② Không dùng instanceof với kiểu tham số
// if (x instanceof List<String>)   // ❌ error: illegal generic type
if (x instanceof List<?>) { }              // ✅ chỉ kiểm tra được đến đây


// ③ Không tạo được instance của T
class Hop<T> {
    // T tao() { return new T(); }   // ❌ error: type parameter T cannot be
                                     //    instantiated directly

    // ✅ Giải pháp 1: truyền Class<T> vào (gọi là "type token")
    T tao(Class<T> cls) throws Exception {
        return cls.getDeclaredConstructor().newInstance();
    }
    // ✅ Giải pháp 2: truyền factory — cách hiện đại, sạch hơn
    T tao(Supplier<T> factory) { return factory.get(); }
}


// ④ Không tạo được MẢNG generic
// T[] m = new T[10];                    // ❌
// List<String>[] ds = new List<String>[10];  // ❌ generic array creation

// ✅ Cách JDK lách (chính ArrayList làm y hệt):
@SuppressWarnings("unchecked")
T[] m = (T[]) new Object[10];
// ✅ Hoặc dùng List<T> thay mảng — luôn tốt hơn


// ⑤ Không dùng kiểu nguyên thủy làm tham số kiểu
// List<int> ds;      // ❌ — vì sau khi xoá, T thành Object,
                      //    mà int không phải Object
List<Integer> ds;      // ✅ phải dùng wrapper


// ⑥ Không nạp chồng method chỉ khác ở tham số kiểu
class X {
    void f(List<String> a) { }
    // void f(List<Integer> a) { }   // ❌ error: name clash — both erase to f(List)
}


// ⑦ Không tạo được exception generic
// class MyException<T> extends Exception { }   // ❌
// catch (MyException<String> e)                // không phân biệt được lúc chạy

// RAW TYPE — generic class dùng mà không có tham số kiểu
List raw = new ArrayList();   // ⚠️ chỉ tồn tại vì tương thích ngược
raw.add("a");
raw.add(42);                // không ai ngăn
String s = (String) raw.get(1);   // 💥 ClassCastException

// Raw type LÂY LAN — vô hiệu hoá generics ở mọi nơi nó đi qua
List raw2 = new ArrayList<String>();
raw2.add(42);               // ⚠️ biên dịch được, chỉ cảnh báo unchecked!

// ✅ Không biết kiểu gì? Dùng wildcard, KHÔNG dùng raw type
List<?> anToan = new ArrayList<String>();
// anToan.add(42);       // ❌ bị chặn ✅


// --- @SuppressWarnings: dùng đúng cách ---

// ❌ Đặt trên cả method — che luôn cảnh báo khác
@SuppressWarnings("unchecked")
public void phuongThucDai() {
    ... 50 dòng ...
}

// ✅ Thu hẹp tới đúng dòng cần, kèm comment giải thích VÌ SAO an toàn
public <T> T[] toArray(T[] a) {
    // An toàn: mảng được tạo từ chính component type của a
    @SuppressWarnings("unchecked")
    T[] kq = (T[]) Arrays.copyOf(mang, soLuong, a.getClass());
    return kq;
}

// ✅ ① Ưu tiên List<T> hơn mảng T[]
// Mảng hiệp biến + generic bất biến = không trộn được an toàn.
// List an toàn hơn, linh hoạt hơn, và có sẵn nhiều method.

// ✅ ② Dùng wildcard cho THAM SỐ, không dùng cho KIỂU TRẢ VỀ
static double tong(List<? extends Number> ds) { ... }   // ✅ linh hoạt
static List<? extends Number> lay() { ... }             // ❌ ép người gọi
                                                             //    cũng phải dùng wildcard

// ✅ ③ Tên tham số kiểu theo quy ước: T, E, K, V, R

// ✅ ④ Generic method thay wildcard khi hai tham số phải CÙNG kiểu
static void doiCho(List<?> ds, int i, int j) {
    // ds.set(i, ds.get(j));   // ❌ không ghi được vào List<?>
}
static <T> void doiCho(List<T> ds, int i, int j) {   // ✅
    T tam = ds.get(i);
    ds.set(i, ds.get(j));
    ds.set(j, tam);
}

// ✅ ⑤ Kiểu trả về generic tránh phải ép kiểu
static <T> List<T> loc(List<T> ds, Predicate<? super T> dk) {
    List<T> kq = new ArrayList<>();
    for (T x : ds) if (dk.test(x)) kq.add(x);
    return kq;
}
List<String> dai = loc(List.of("a", "abc"), s -> s.length() > 1);

// ✅ ⑥ Bounded type khi cần gọi method của kiểu đó
static <T extends Comparable<? super T>> T max(List<? extends T> ds) { ... }
// ↑ Đây là chữ ký thật của Collections.max — PECS áp dụng ở CẢ HAI chỗ