泛型的理解与相关操作

package com.hncu.mygenericdemo4;

import java.util.ArrayList;

public class Demo4 {
    //泛型的类型通配符      ？   ？extends xxx   ? super xxx
    // java.lang.Object
    //java.lang.Number
    //java.lang.Integer 从下到上依次继承
    public static void main(String[] args) {
        ArrayList<Object> list1 = new ArrayList<>();
        ArrayList<Number> list2 = new ArrayList<>();
        ArrayList<Integer> list3 = new ArrayList<>();
        method1(list1);     //？可以接受任何类型，但是并不能把元素添加到ArraList中去了
        method1(list2);
        method1(list3);
        //method2(list1);   报错，？extends xxx 只能接受xxx的本身的对象和它的子类对象
        method2(list2);
        method2(list3);
        method3(list1);
        method3(list2);
        //method3(list3);   报错，？super xxx 只能接受xxx本身对象和它的父类对象
    }
    private static void method1(ArrayList<?> list){}
    private static void method2(ArrayList<? extends Number> list){}
    private static void method3(ArrayList<? super Number> list){}
}

 

package com.hncu.mygenericdemo1;

public class Genneric<T> {
    private T age;

    public T getAge() {
        return age;
    }

    public void setAge(T age) {
        this.age = age;
    }

    public Genneric() {
    }
}

package com.hncu.mygenericdemo1;

public class Demo1 {
    /*泛型类的使用，泛型的使用可以省去很多重复的步骤*/
    public static void main(String[] args) {
        Genneric<String> g1 = new Genneric<>();      //泛型为String，所以方法也会按照泛型去操作
        g1.setAge("12");
        System.out.println(g1.getAge());
        System.out.println("-----------------");
        Genneric<Integer> g2 = new Genneric<>();
        g2.setAge(19);
        System.out.println(g2.getAge());
    }
}

package com.hncu.mygenericdemo2;

public class Generic {
    public <T>void show(T t){
        System.out.println(t);
    }

    public Generic() {
    }
}

package com.hncu.mygenericdemo2;

public class Demo2 {
    //泛型方法的使用，使得类中大致相同的方法不用重载
    public static void main(String[] args) {
        Generic g = new Generic();      //Generic类中的方法是泛型方法，可以接收不同的类型
        g.show("hello");
        g.show(520);
        g.show(true);
    }
}

package com.hncu.mygenericdemo3;

public interface Generic <T>{
    //泛型接口
    public abstract void show(T t);
}

package com.hncu.mygenericdemo3;

public class Demo3 {
    //泛型接口的使用
    public static void main(String[] args) {
        GenericImple1<String> g1 = new GenericImple1<>();
        GenericImple1<Integer> g2 = new GenericImple1<>();
        g1.show("hello");
        g2.show(520);
        GenericImple2 g3 = new GenericImple2();
        g3.show(true);
    }
}

class GenericImple1<T> implements Generic<T>{
    //未传入实参实现接口的类也是泛型类

    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

class GenericImple2 implements Generic<Boolean>{
    //泛型接口传入实参后，类中的方法都以实参进行操作
    @Override
    public void show(Boolean b) {
        System.out.println(b);
    }
}