Java笔记--泛型

吾尝终日而思矣，不如须臾之所学也；吾尝跂而望矣，不如登高之博见也。

                                                                                                                         --苟子《劝学》

一、泛型的概念

        泛型实现了参数化类型的概念，使代码可以应用于多种类型。 “泛型”这个术语的意思是：“适用于许多许多的类型”。泛型在编程语言中出现时，其最初的目的是希望类或方法能够具备最广泛的表达能力。

二、泛型的格式和命名规则

        我们刚刚说过泛型实际上就是将引用数据类型当作参数一样进行传递。

        那我们在定义类上的泛型，实际上又可以称作为泛型参数，将来可以接受任意一种数据类型。

        既然是充当参数接收值的作用，也就是要符合参数变量的规则，将来创造泛型的时候，这里的参数名只要符合标识符命名规则即可。

package day14.bao1;
public class Demo1 {
    public class Demo1<S>{
        //在类中可以使用这个S参数的值
        public void fun1(S s){
            System.out.println(s);
        }
    }
}

三、泛型类

泛型类：将泛型定义在类上

package day14.bao1;

public class FanXingDemo1 {
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
        demo1.fun1("hello");
        demo1.fun1(12345);

        System.out.println("=========================");

        Demo1 <String> d1 = new Demo1<>();
        d1.fun1("hello");
        //d1.fun1(12345);

        System.out.println("==============================");
        Demo1<Integer> d2 = new Demo1<>();
//        d2.fun1("hello");
        d2.fun1(12345);
    }
}

四、泛型方法

泛型方法：将泛型定义在方法上

package day14.bao2;
public class FanXingDemo2 {
    public static void main(String[] args) {
        Demo1 demo1 =new Demo1();
        demo1.fun1("qwe");
        demo1.fun1(123);
    }
}

package day14.bao2;
public class Demo1 {
    //泛型方法
    public <E> void fun1(E e){
        System.out.println(e);
    }
}

五、泛型接口

泛型接口：将泛型定义在接口上

package day14.bao3;

//泛型接口：将泛型定义在接口上

public class FanXingDemo3 {
    public static void main(String[] args) {
        InterImpl<String> inter = new InterImpl<>();
        inter.fun1("hello world");
    }
}

package day14.bao3;
public interface Inter <W>{
    public abstract void fun1(W w);
}

class InterImpl<W> implements Inter<W>{
    @Override
    public void fun1(W w){
        System.out.println("java: "+w);
    }
}

六、泛型高级（通配符）

泛型通配符<?>

        任意类型，如果没有明确，那么就是Object以及任意的Java类了

？ extends E

        向下限定，E及其子类

？ super E

        向上限定，E及其父类

package day14.bao4;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

class Demo1{
}

class Animal extends Demo1{
}

class Dog extends Animal{
}

class SmallDog extends Dog{}

class Cat extends Animal{}

class Demo2 <W>{
    public void fun1(Collection<? super W> c){}
    
    public void fun2(Collection<?> c){}
}


public class FanXingDemo4 {
    public static void main(String[] args) {
        ArrayList <Animal> list1 = new ArrayList<>();
        //public boolean addAll(Collection<? extends Animal> c)
        //可以添加一个Collection集合，集合中的元素类型只能是Animal类型或者Animal的子类
        //Collection<? extends Animal>向下限定，限定集合的元素类型只能是Animal类型或者Animal的子类
//        list1.addAll(new ArrayList<Demo1>());//错误的，Demo1是Animal的父类
        
        Demo2 <Dog> demo2 = new Demo2<>();
        //public void fun1(Collection<? super W> c)
        //向上限定，限定集合的元素类型只能是Dog类型或者Dog的父类类型
//        demo2.fun1(new ArrayList<SmallDog>());
//        demo2.fun2(new ArrayList<Demo1>());<?>表示可以是任意引用数据类型
    }
}