Java-泛型

1. 泛型

1.1 泛型类

• 泛型类定义的时候，虽然有泛型，但是在使用的时候，可以不去使用
• 不加泛型。默认是Object类型

泛型类案例

package com.shujia.wyh.day20;
/*
        泛型类的案例：把泛型定义在类上面
        格式:public class 类名<泛型类型1,…>
        注意:泛型类型必须是引用类型

        定义的时候这里的<>里面到底写什么呢？
        这里面的内容仅仅表示的使一种参数数据类型，参数类型是一种变量
        既然是一种变量，肯定也是符合标识符命名规则的，可以是任意符合标识符命名规则的名字
 */
public class GenericDemo1<T> {
    private T obj;

    public T getObj() {
        return obj;
    }

    public void setObj(T obj) {
        this.obj = obj;
    }
}

泛型类的测试类

• 测试类中如果不定义，默认为Object类型的，一旦定义，就不能填成其他类型

package com.shujia.wyh.day20;

public class GenericTest1 {
    public static void main(String[] args) {
        //泛型类定义的时候，虽然有泛型，但是在使用的时候，可以不去使用
        //不加泛型。默认是Object类型
//        GenericDemo1 genericDemo1 = new GenericDemo1();

//        genericDemo1.setObj("hello");
//        genericDemo1.setObj(20);
//        genericDemo1.setObj(12.34);

        GenericDemo1<String> stringGenericDemo1 = new GenericDemo1<>();
        stringGenericDemo1.setObj("hello");
//        stringGenericDemo1.setObj(20);
//        stringGenericDemo1.setObj(12.34);
        String obj = stringGenericDemo1.getObj();
        System.out.println(obj);
    }
}

1.2 泛型方法

• 泛型方法
  把泛型定义在方法上
  格式:public <泛型类型> 返回类型 方法名(泛型类型 .)

代码如下

package com.shujia.wyh.day20;
/*
        泛型方法
            把泛型定义在方法上
            格式:public <泛型类型> 返回类型 方法名(泛型类型 .)

 */
public class GenericDemo2 {
//    public void show(String s){
//        System.out.println(s);
//    }
//
//    public void show(int i){
//        System.out.println(i);
//    }
//
//    public void show(double d){
//        System.out.println(d);
//    }

//    public void show(Object obj){
//        System.out.println(obj);
//    }

    //使用泛型方法进行改进
    public <T> void show(T t){
        System.out.println(t);
    }
}

1.3 泛型接口

package com.shujia.wyh.day20;
/*
        泛型接口：把泛型定义在接口上
 */
public interface GenericInter<T> {
    void show(T t);
}

实现类

package com.shujia.wyh.day20;

public class GenericInterImpl<T> implements GenericInter<T>{
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

泛型高级用法(前提-猫和狗继承了动物类)

• 泛型的高级用法：
  泛型通配符<?>任意类型，如果没有明确，那么就是Object以及任意的Java类了
• 向下限定，E及其子类
• 向上限定，E及其父类

package com.shujia.wyh.day20;

import java.util.ArrayList;

/*
        泛型的高级用法：
                泛型通配符<?>
                任意类型，如果没有明确，那么就是Object以及任意的Java类了
                <? extends E>
                向下限定，E及其子类
                <? super E>
                向上限定，E及其父类

 */
public class GenericDemo3 {
    public static void main(String[] args) {
        ArrayList<Animal> list1 = new ArrayList<>();
        ArrayList<Dog> list2 = new ArrayList<>();
        ArrayList<Cat> list3 = new ArrayList<>();

        //泛型通配符<?>
        //任意的引用数据类型，如果左边定义的时候没有明确，右边new的时候必须给出明确的类型，否则就是Object类型或者任意引用数据类型
        ArrayList<?> list4 = new ArrayList<>();
        ArrayList<?> list5 = new ArrayList<Animal>();
        ArrayList<?> list6 = new ArrayList<Dog>();
        ArrayList<?> list7 = new ArrayList<Cat>();

        //<? extends E>向下限定，E及其子类
        ArrayList<? extends Animal> list8 = new ArrayList<Animal>();
        ArrayList<? extends Animal> list9 = new ArrayList<Dog>();
        ArrayList<? extends Animal> list10 = new ArrayList<Cat>();
//        ArrayList<? extends Animal> list11 = new ArrayList<Object>();

        //<? super E> 向上限定，E及其父类
        ArrayList<? super Animal> list12 = new ArrayList<Animal>();
        ArrayList<? super Animal> list13 = new ArrayList<Object>();
//        ArrayList<? super Animal> list14 = new ArrayList<Cat>();
//        ArrayList<? super Animal> list15 = new ArrayList<Dog>();
    }
}