java--泛型

泛型

1.什么是泛型
泛型从字面上理解，是指一个类、接口或方法支持多种类型，使之广泛化、一般化和更加通用。Java中使用Object类来定义类型也 能实现泛型，但缺点是造成原类型信息的丢失。
2.泛型的使用：

package fanxing;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Demo {
    public static void main(String[] args) {
        Collection c =new ArrayList();
        c.add("one");//这个有String
        c.add(2);//int类型
        c.add(3);
        Iterator it = c.iterator();
       //Object 为所有类的父类，所以可行
       /* while (it.hasNext()){
            Object obj =it.next();
            System.out.println("obj");
        }*/

        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

因为上述数组有String和int类型混杂的,编译报错
String s =(String) it.next()，这里面做了所有类型的强项行转换了，编译没有错误，但是运行报错了

强制转换后运行报错，Integer不能转换成String

Collection<String ->c =new ArrayList<String ->();
Iterator<String -> it = c.iterator();
对集合进行泛化处理，避免强制转换和让编译器不通过，提前报错。

package fanxing;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Demo {
    public static void main(String[] args) {
    
        Collection<String> c =new ArrayList<String>();
        c.add("one");//这个有String
        c.add(2);//int类型
        c.add(3);
        Iterator<String> it = c.iterator();
       //Object 为所有类的父类，所以可行
       /* while (it.hasNext()){
            Object obj =it.next();
            System.out.println("obj");
        }*/

        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

泛型类

泛型类定义格式：
修饰符 class 类名{
}

类型为T,E.K.V任意一个，表示泛型

这个类的对象只能写string类型的

泛型通俗来说就是不知道啥型，用字符T代替类型，等测试需要时就构造什么类型的对象

package fanxing;

public class Student<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

测试类：

package fanxing;

import com.sun.org.apache.bcel.internal.generic.NEW;

public class Demo1 {
    public static void main(String[] args) {
    //定义String类型对象
        Student<String> student = new Student<String>();
        student.setT("www");//使用String类型
        //定义Integer类型对象
        Student<Integer> student1 = new Student<Integer>();
        student1.setT(12);


    }
}

泛型方法：

格式：

修饰符 class 类名<T> {
    public void play(T t);
——————————————————————————————或者
修饰符 class 类名{
	public <T> void play(T t);
	System.out.println(t);
}

就是方法里面的类型和变量名用T，t 代替；测试需要传什么参数，就定义什么类的对象即可

package fanxing;

public class Student<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
    public void paly(T t){
        System.out.println(t);
    }
}

测试类

package fanxing;

import com.sun.org.apache.bcel.internal.generic.NEW;

public class Demo1 {
    public static void main(String[] args) {
    //和使用getName 方法差不多
        Student<String> student = new Student<String>();
        student.paly("www");
        Student<Integer> student1 = new Student<Integer>();
        student1.paly(12);


    }
}

泛型方法在方法里面写该类型，等实际调用时，传进去是什么类型的，该方法就变成了什么类型的

package fanxing;

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

package fanxing;

import com.sun.org.apache.bcel.internal.generic.NEW;

public class Demo1 {
    public static void main(String[] args) {
        Student student = new Student();
        student.paly("www");
        Student student1 = new Student();
        student1.paly(12);


    }
}

泛型接口：

格式：

修饰符 interface 接口名<T>{}

package fanxing;

public interface Person <T  > {
    void eat(T t);
}

package fanxing;

public class Student<T> implements Person<T>{

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

package fanxing;

import com.sun.org.apache.bcel.internal.generic.NEW;

public class Demo1 {
    public static void main(String[] args) {
        Student<String> student = new Student<String>();
        student.eat("www");
        Student<Integer> student1 = new Student<Integer>();
        student1.eat(12);


    }
}

类型通配符：

格式：<?>
List<?> :表示元素类型未知，元素可以匹配任意类型；
这种带通配符的List仅仅表示它是各种泛型List的父类，并不能把元素添加其中。

类型通配符上限：<?extends 类型>
List<?extends Number>:表示类型是Number或其子类型
//extends 是继承，继承父类，所以是子类

类型通配符下限：<?super类型>
List<?super Number>:表示类型是Number或其父类型
//super是表示父类的，所以是其父类型

package fanxing;

import com.sun.org.apache.bcel.internal.generic.NEW;

import java.util.ArrayList;
import java.util.List;

public class Demo1 {
    public static void main(String[] args) {
    //1、无边界的通配符
        List<?> list =new ArrayList<Object>();
        List<?> list1 =new ArrayList<String>();
        List<? extends Number> list3 =new ArrayList<Number>();
        List<?super Number> list4 =new ArrayList<Number>();
       list.add("1");
       list1.add("1");
       list4.add(2);
       list3.add();

    }
}

1、无边界的通配符

        List<?> list =new ArrayList<Object>();

无边界的通配符的主要作用就是让泛型能够接收未知类型的数据。

但是我们不能对List<?>使用add()方法，仅有一个例外就是add(null)
从上面的总结可以看出，extends 通配符偏向于内容的获取，而 super 通配符更偏向于内容的存入。我们有一个 PECS 原则(Producer Extends Consumer Super)很好的解释了这两个通配符的使用场景。
Producer Extends 说的是当你的情景是生产者类型，需要获取资源以供生产时，我们建议使用 extends 通配符，因为使用了 extends 通配符的类型更适合获取资源。
Consumer Super 说的是当你的场景是消费者类型，需要存入资源以供消费时，我们建议使用 super 通配符，因为使用 super 通配符的类型更适合存入资源。

3.泛型的应用及优点：
1.使得一个类或方法中的类型参数化，最终达到代码复用的效果。( 不使用泛型，你可能需要每种情况的类或方法都要定义一遍 )
2.实现类型检查的功能，避免ClassCastException。
3.但如果你既想存入，又想取出，那么你最好还是不要使用 extends 或 super 通配符。