class MyArray {
    public Object[] array = new Object[10];
    public Object getPos(int pos) {
        return this.array[pos];
    }
    public void setVal(int pos,Object val) {
        this.array[pos] = val;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        MyArray myArray = new MyArray();
        //存放整形
        myArray.setVal(0,10);
        //字符串也可以存放
        myArray.setVal(1,"hello");
        //也可以存放char，float,自定义类型……
        //编译报错，这里是向下转型，需要进行强制类型转换
        String ret = myArray.getPos(1);
        System.out.println(ret);
    }
}

class MyArray<T> {
    //不能实例化泛型类的数组
    public T[] array = (T[])new Object[10];//1
    public T getPos(int pos) {
        return this.array[pos];
    }
    public void setVal(int pos,T val) {
        this.array[pos] = val;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        //类型参数化，指定要放入的数据的类型
        MyArray<Integer> myArray = new MyArray<>();//2
        myArray.setVal(0,10);
        myArray.setVal(1,12);
        //不需要自己去实现强转
        int ret = myArray.getPos(1);//3
        System.out.println(ret);
        //编译错误，会进行类型检查
        //myArray.setVal(2,"bit");//4
    }
}

class MyArray<T> {
    public T[] array;
    public MyArray() {
    }
    /**
     * 通过反射创建，指定类型的数组
     * @param clazz 指定类型
     * @param capacity 指定容量
     */
    public MyArray(Class<T> clazz, int capacity) {
        array = (T[]) Array.newInstance(clazz, capacity);
    }
    public T getPos(int pos) {
        return this.array[pos];
    }
    public void setVal(int pos,T val) {
        this.array[pos] = val;
    }
    public T[] getArray() {
        return array;
    }
    public static void main(String[] args) {
        MyArray<Integer> myArray1 = new MyArray<>(Integer.class,10);
        Integer[] integers = myArray1.getArray();
    }
}

class Person implements Comparable<Person>{
    public int age;
    public Person(int age) {
        this.age = age;
    }
    @Override
    public int compareTo(Person o) {
        return this.age-o.age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                '}';
    }
}
class Alg1<T extends Comparable<T>> {
    //实例泛型方法，在类的泛型处设置上界
    public T findMax (T[] array) {
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if(max.compareTo(array[i]) < 0 ) {
                max = array[i];
            }
        }
        return max;
    }
}
class Alg2 {//类名处不设置泛型
    //实例泛型方法，在方法处设置泛型和上界
    public <T extends Comparable<T>> T findMax (T[] array) {
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            //if(max < array[i]) {
            if(max.compareTo(array[i]) < 0 ) {
                max = array[i];
            }
        }
        return max;
    }
}
class Alg3{
    //静态泛型方法
    //不依赖对象，必须在方法处设置上界
    public static<T extends Comparable<T>> T findMax (T[] array) {
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if(max.compareTo(array[i]) < 0 ) {
                max = array[i];
            }
        }
        return max;
    }
}
public class Test {
    public static void main(String[] args) {
        Person[] people = {new Person(10),new Person(15)};
        //Alg1<Person> alg = new Alg1<>();
        //Person person = alg.findMax(people);
        Alg2 alg = new Alg2();
        Person person = alg.findMax(people);
        //Person person = Alg3.findMax(people);
        System.out.println(person);
    }
}

class Message<T> {
    private T message ;
    public T getMessage() {
        return message;
    }
    public void setMessage(T message) {
        this.message = message;
    }
}
public class TestDemo1 {
    public static void main(String[] args) {
        Message<Integer> message = new Message() ;
        message.setMessage(99);
        fun(message); // 出现错误，只能接收String
    }
    public static void fun(Message<String> temp){
        System.out.println(temp.getMessage());
    }
}

<? extends 上界>
<? extends Number>//可以传入的实参类型是Number或者Number的子类

//装箱：把基本数据类型转换成包装类
//1、自动装箱
int i = 10;
Integer ii = i;
Integer ij = (Integer)i;
//2、手动装箱：使用构造方法
//新建一个 Integer 类型对象，将 i 的值放入对象的某个属性中
int i = 10;
Integer ii = Integer.valueOf(i);
Integer ij = new Integer(i);
//拆箱：把包装类转换成基本数据类型
//1、自动拆箱
int j = ii; 
int k = (int)ii;
//2、手动拆箱：使用intValue方法
int j = ii.intValue();