// 泛型class 定义
public class Box {
    private T content;
    
    public void setContent(T content) {
        this.content = content;
    }
    
    public T getContent() {
        return content;
    }
}

// using泛型class
public class BoxExample {
    public static void main(String[] args) {
        // creationstoreIntegerclass型 Box
        Box integerBox = new Box<>();
        integerBox.setContent(10);
        Integer integerValue = integerBox.getContent();
        System.out.println("Integer value: " + integerValue);
        
        // creationstoreStringclass型 Box
        Box stringBox = new Box<>();
        stringBox.setContent("Hello, Generics!");
        String stringValue = stringBox.getContent();
        System.out.println("String value: " + stringValue);
    }
}

// 泛型interface 定义
public interface List {
    void add(T element);
    T get(int index);
    int size();
}

// implementation泛型interface
public class ArrayList implements List {
    private Object[] elements;
    private int size;
    
    public ArrayList(int capacity) {
        elements = new Object[capacity];
        size = 0;
    }
    
    @Override
    public void add(T element) {
        if (size < elements.length) {
            elements[size] = element;
            size++;
        }
    }
    
    @Override
    @SuppressWarnings("unchecked")
    public T get(int index) {
        if (index >= 0 && index < size) {
            return (T) elements[index];
        }
        throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
    }
    
    @Override
    public int size() {
        return size;
    }
}

// using泛型interface
public class ListExample {
    public static void main(String[] args) {
        List list = new ArrayList<>(10);
        list.add("Java");
        list.add("Generics");
        list.add("Tutorial");
        
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

//  many class型parameter 泛型class
public class Pair {
    private K key;
    private V value;
    
    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }
    
    public K getKey() {
        return key;
    }
    
    public V getValue() {
        return value;
    }
    
    public void setKey(K key) {
        this.key = key;
    }
    
    public void setValue(V value) {
        this.value = value;
    }
}

// using many class型parameter 泛型class
public class PairExample {
    public static void main(String[] args) {
        Pair pair1 = new Pair<>("Age", 25);
        System.out.println("Key: " + pair1.getKey() + ", Value: " + pair1.getValue());
        
        Pair pair2 = new Pair<>(1, "Java");
        System.out.println("Key: " + pair2.getKey() + ", Value: " + pair2.getValue());
    }
}

public class GenericMethodExample {
    // 泛型method
    public static  void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
    
    // 带 has return value 泛型method
    public static  T getFirstElement(T[] array) {
        if (array != null && array.length > 0) {
            return array[0];
        }
        return null;
    }
    
    public static void main(String[] args) {
        // test泛型method
        Integer[] intArray = {1, 2, 3, 4, 5};
        String[] stringArray = {"Java", "Generics", "Method"};
        Double[] doubleArray = {1.1, 2.2, 3.3};
        
        System.out.println("Integer array:");
        printArray(intArray);
        
        System.out.println("String array:");
        printArray(stringArray);
        
        System.out.println("Double array:");
        printArray(doubleArray);
        
        // test带 has return value 泛型method
        System.out.println("First element of intArray: " + getFirstElement(intArray));
        System.out.println("First element of stringArray: " + getFirstElement(stringArray));
    }
}

public class TypeInferenceExample {
    public static  T getDefaultValue() {
        return null;
    }
    
    public static  void printValue(T value) {
        System.out.println(value);
    }
    
    public static void main(String[] args) {
        // 显式指定class型parameter
        String str1 = TypeInferenceExample.getDefaultValue();
        
        // class型parameter推断
        String str2 = getDefaultValue(); // 编译器推断T for String
        Integer num = getDefaultValue(); // 编译器推断T for Integer
        
        // method调用in class型parameter推断
        printValue("Hello"); // 编译器推断T for String
        printValue(42); // 编译器推断T for Integer
        printValue(3.14); // 编译器推断T for Double
    }
}

public class UpperBoundExample {
    //  on 界通配符
    public static double sumOfList(List list) {
        double sum = 0.0;
        for (Number number : list) {
            sum += number.doubleValue();
        }
        return sum;
    }
    
    public static void main(String[] args) {
        List intList = new ArrayList<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);
        System.out.println("Sum of intList: " + sumOfList(intList));
        
        List doubleList = new ArrayList<>();
        doubleList.add(1.1);
        doubleList.add(2.2);
        doubleList.add(3.3);
        System.out.println("Sum of doubleList: " + sumOfList(doubleList));
    }
}

public class LowerBoundExample {
    //  under 界通配符
    public static void addNumbers(List list) {
        for (int i = 1; i <= 5; i++) {
            list.add(i);
        }
    }
    
    public static void main(String[] args) {
        List intList = new ArrayList<>();
        addNumbers(intList);
        System.out.println("intList: " + intList);
        
        List numberList = new ArrayList<>();
        addNumbers(numberList);
        System.out.println("numberList: " + numberList);
        
        List