Java泛型 - 技术栈

泛型只支持引用数据类型,不支持基本数据类型.
作用:用于约束可操作的数据类型.
本质:把类型作为参数传递给类型参数,如<E>
泛型擦除:泛型存在于在编译阶段,一旦程序编译成class文件,泛型就不存在了,泛型类并没有自己独有的Class类对象。比如并不存在List<String>.class或是List<Integer>.class，而只有List.class。

java 复制代码

public class GenericTypes {

    public static void method(List<String> list) {
        System.out.println("invoke method(List<String> list)");
    }

    public static void method(List<Integer> list) {
        System.out.println("invoke method(List<Integer> list)");
    }
}

上面代码编译不通过,参数List<Integer>和List<String>编译之后泛型都被擦除了，都变成了原生类型List，擦除动作导致这两个方法的特征签名变得一模一样。

泛型类

类名后面的参数是类型参数,通常为T,E,V,K等.

java 复制代码

import java.util.ArrayList;  
import java.util.Arrays;  
import java.util.Iterator;  
  
class Test<E>{  
    Object [] obj=new Object[10];  
    int size;  
    public Boolean add (E e){  
       obj[size]=e;//size默认为0;  
        size++;  
        return true;  
    }  
    public E get(int index){  
        return (E)obj[index];//强制转换为E类型  
    }  
  
    @Override  
    public String toString() {  
        return Arrays.toString(obj);  
    }  
}  
public class javatest {  
    public static void main(String[] args) {  
        Test<String> t =new Test<>();//创建时需要指明E的类型  
        t.add("Warren");  
        t.add("Ricci");  
         System.out.println(t);  
    }  
}

示例:一个泛型

java 复制代码

package JavaProjets;  
  
class Box<T>{  
    T t;  
    public Box() {  
    }  
  
    public Box(T t) {  
        this.t = t;  
    }  
  
    /**  
     * 获取  
     * @return t  
     */   
    public T getT() {  
        return t;  
    }  
  
    /**  
     * 设置  
     * @param t  
     */  
    public void setT(T t) {  
        this.t = t;  
    }  
  
    public String toString() {  
        return "Box{t = " + t + "}";  
    }  
}  
public class Main {  
    public static void main(String[] args) {  
        Box<Integer> box = new Box<>(5);  
        System.out.println(box.getT());  
  
        Box<String>box1 =new Box<>("Warren");  
        box1.setT("ricci");  
        System.out.println(box1.getT());  
    }  
}

多个泛型

java 复制代码

package JavaProjets;  
  
class Person<K,V>{  
    K key;  
    V value;  
  
    public Person() {  
    }  
  
    public Person(K key, V value) {  
        this.key = key;  
        this.value = value;  
    }  
  
    /**  
     * 获取  
     * @return key  
     */    public K getKey() {  
        return key;  
    }  
  
    /**  
     * 设置  
     * @param key  
     */  
    public void setKey(K key) {  
        this.key = key;  
    }  
  
    /**  
     * 获取  
     * @return value  
     */    public V getValue() {  
        return value;  
    }  
  
    /**  
     * 设置  
     * @param value  
     */  
    public void setValue(V value) {  
        this.value = value;  
    }  
  
    public String toString() {  
        return "person{key = " + key + ", value = " + value + "}";  
    }  
}  
public class Main {  
    public static void main(String[] args) {  
        Person<String,Integer> p= new Person<>("Age",1);  
        System.out.println(p);  
    }  
}

泛型类和继承

java 复制代码

package JavaProjets;  
  
class Box<T> {  
    private T data;  
  
    public Box(T data) {  
        this.data = data;  
    }  
  
    public T getData() {  
        return data;  
    }  
}  
  
class IntegerBox extends Box<Integer> {  
    public IntegerBox(Integer data) {  
        super(data);  
    }  
}  
class DoubleBox extends Box<Double> {  
    public DoubleBox(Double data) {  
        super(data);  
    }  
}  
  
public class Main {  
    public static void main(String[] args) {  
      IntegerBox box1 = new IntegerBox(1);  
        System.out.println(box1.getData());  
        DoubleBox box2 = new DoubleBox(1.2);  
        System.out.println(box2.getData());  
    }  
}

泛型方法

示例

java 复制代码

package JavaProjets;  
  
import java.util.ArrayList;  
  
public class Main {  
    public static void main(String[] args) {  
        ArrayList<String> list=new ArrayList<>();  
  
        addAll(list,"warren","ricci","jim");  
    }  
    public static <E>  void addAll(ArrayList<E> a,E...e){//可变参数,然后可以添加任意数量的元素  
        for (E e1 : e) {  
            a.add(e1);  
        }  
        for (E e1 : a) {  
            System.out.println(e1);  
        }  
  
    }  
}

java 复制代码

package JavaProjets;  
  
public class Main {  
  
    // 定义一个泛型方法，T代表泛型类型  
    public static <T> void printArray(T[] array) {  
        for (T element : array) {  
            System.out.println(element);  
        }  
    }  
  
    public static void main(String[] args) {  
        Integer[] intArray = {1, 2, 3, 4, 5};  
        String[] strArray = {"apple", "banana", "cherry"};  
          
        printArray(intArray);  // 输出: 1 2 3 4 5  
        printArray(strArray);  // 输出: apple banana cherry  
    }  
}

多个泛型

java 复制代码

package JavaProjets;  
  
public class Main {  
  
    // 定义一个有两个泛型类型参数的方法  
    public static <T, U> void print(T t, U u) {  
        System.out.println("First: " + t);  
        System.out.println("Second: " + u);  
    }  
  
    public static void main(String[] args) {  
        print(1, "apple");  
        print(3.14, true);  
    }  
}

可变参数:

可变参数:允许在方法中传递任意数量的参数。语法是在参数类型后加三个点（...），例如 Type... params。

java 复制代码

public static double avg(double ...values){  //这里的values是一个数组
    double sum=0;  
    for (double value : values) {  
        sum+=value;  
    }  
    return sum/values.length;  
}

泛型接口

java 复制代码

interface A<E>{  
    E getValue();  
}  
class B implements A<String>{  
    public String getValue(){  
        return "B";  
    }  
}

通配符

泛型不支持继承:
?表示不确定的类型,可以进行类型的限定,如 ? extends E 表示可以传递E或者E所有的子类类型;
? super E表示可以传递E或者E所有的父类类型.
类型不确定时,但是可以确定是某一个继承体系中的,就可以使用通配符.

java 复制代码

import java.util.ArrayList;  
  
abstract class animal{  
    private String name;  
    private int age;  
  
    public animal() {  
    }  
  
    public animal(String name, int age) {  
        this.name = name;  
        this.age = age;  
    }  
  
    public abstract void eat();  
  
  
    public String getName() {  
        return name;  
    }  
  
    
    public void setName(String name) {  
        this.name = name;  
    }  
  

    public int getAge() {  
        return age;  
    }  
   
    public void setAge(int age) {  
        this.age = age;  
    }  
  
    public String toString() {  
        return "animal{name = " + name + ", age = " + age + "}";  
    }  
}  
  
abstract  class dog extends animal{  
  
}  
abstract class cat extends animal{  
  
}  
class lihuacat extends cat{  
    @Override  
    public void eat() {  
        System.out.println("lihua "+getName()+getAge()+"cat eat fish");  
    }  
}  
class bosicat extends cat{  
    @Override  
    public void eat() {  
        System.out.println("bosicat "+getName()+getAge()+"cat eat fish");  
    }  
}  
  
class hashiqi extends dog{  
    @Override  
    public void eat() {  
        System.out.println("hashiqi "+getName()+getAge()+"dog eat bone");  
    }  
}  
class taidi extends dog{  
    @Override  
    public void eat() {  
        System.out.println("taidi "+getName()+getAge()+"dog eat bone");  
    }  
}  
public class javatest {  
    public static void main(String[] args) {  
        ArrayList<bosicat> list1=new ArrayList<>();  
        ArrayList<lihuacat> list2=new ArrayList<>();  
        ArrayList<taidi> list3=new ArrayList<>();  
        ArrayList<hashiqi> list4=new ArrayList<>();  
  
        keep(list1);  
        keep(list2);  
    }  
    public static void keep(ArrayList<? extends cat> list){  
  
    }  //可以传递猫的子类或猫类
    public static void keep1(ArrayList<? extends dog> list){  
  
    }  
    public static void keep2(ArrayList<? extends animal> list){  
  
    }  
}