java自定义泛型类和接口

java泛型类

  什么是泛型类呢？

先了解一下java中包含的泛型类：

ArrayList<String> c = new ArrayList<>();

熟悉嘛，ArrayList<>。

熟悉的话，我们继续往下看。

自定义泛型类

什么时候使用泛型类？

  当定义类时，内部方法中其参数类型，返回值不确定时，就可以使用泛型代替。

看代码理解

注意使用格式和使用场景。

public class Demo {
    public static void main(String[] args) {
        Person<String> person = new Person<>();
    }
}

//自定义泛型类,类型为类型
class Person<H>{

    private H hobby;

    public Person(){

    }

    public Person(H hobby) {
        this.hobby = hobby;
    }

    public H getHobby() {
        return hobby;
    }

    public void setHobby(H hobby) {
        this.hobby = hobby;
    }

    @Override
    public String toString() {
        return "Person{" +
                "hobby=" + hobby +
                '}';
    }
}

自定义泛型接口

什么时候使用泛型接口

  当定义接口时，内部方法中其参数类型，返回值不确定时，就可以使用泛型替代。

定义泛型接口的格式

  接口名后面加上尖括号，里面定义泛型名。

泛型接口中的泛型确定时机？

  子类如果可以确定类型，在实现接口的时候，直接确定类型
  子类如果不确定类型，回到泛型类的使用。

看代码理解

着重理解格式

//自定义泛型接口

public interface MyCollection<E> {
    public abstract void add(E e);
}

//如果泛型没有指定，默认Object类型
class MyCollectionImpl1 implements MyCollection{

    @Override
    public void add(Object o) {

    }
}

class MyCollectionImpl2 implements MyCollection<String>{

    @Override
    public void add(String s) {

    }
}

//着重理解三张格式，特别时第三种
class MyCollectionImpl3<E> implements MyCollection<E>{

    @Override
    public void add(E e) {

    }
}

自定义泛型方法

  当定义方法时，方法中的参数类型，返回值类型不确定时，就可以使用泛型替代了。

定义格式

修饰符<泛型名> 返回值类型 方法名（参数类别）{
}

泛型的指定

  调用含有泛型的方法时，传入的数据其类型就是泛型的类型

代码理解

public class Demo {
    public static void main(String[] args) {
        show("abc");
        //String
        show(2);
        //Integer
        
        
    }

    //自定义泛型方法
    public static <E> void show (E e){
        //如果e的类型是String
        if(e instanceof String){
            System.out.println("String");
        }
        如果e的类型是Integer
        if(e instanceof Integer){
            System.out.println("Integer");
        }
    }
}

定义存储字符串的ArrayList集合，将字符串的集合转化为字符串数组

public class Demo2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("abc");
        list.add("ert");
        list.add("ghg");

        //将字符串的集合转化为字符串数组
        String[] strings = new String[list.size()];
        String[] array = list.toArray(strings);
        System.out.println(Arrays.toString(array));
        //[abc, ert, ghg]
    }
}

泛型通配符 ？

泛型上限的格式和含义

<? entends 类型> 只能是本类型或者子类型

泛型下限的格式

<? super 类型> 只能是本类型或者父类型，到顶只能是Object。

代码理解

public class Test1 {
    public static void main(String[] args) {
        ArrayList<Integer> integers = new ArrayList<>();
        ArrayList<Number> numbers = new ArrayList<>();
        ArrayList<String> strings = new ArrayList<>();
        ArrayList<Object> objects = new ArrayList<>();

        //下限
        show1(numbers);
        show1(objects);

        //上限
        show2(numbers);
        show2(integers);


    }
    //泛型的下限
    //show1方法，参数只接收元素类型Number或者其父类型的集合
    //接受的集合，集合中元素的类型可以是Number或者Number的父类型
    public static void show1(ArrayList<? super Number> List){

    }

    //泛型的上限
    //show2方法，参数只接收元素类型Number或者其子类型的集合
    //接受的集合，集合中元素的类型可以是Number或者Number的子类型
    public static void show2(ArrayList<? extends Number> List){

    }
}

学的不是技术，更是梦想！！！