泛型

泛型

1.新特性

1.1. 可变参数

JDK1.5之后追加可变参数的概念 定义方法

public [static] [final] 返回值 方法名称（[参数类型...参数名称] []）

范例：方法的可变参数

package Test.zyj.com;
/**
 * @Name：
 * @Author：ZYJ
 * @Date：2019-05-31-17:24
 * @Description:
 */
public class TestDemo {
    public static void main(String[] args) {
        System.out.println(add(1,2,3,4));
        int[] a = new int[]{1,2,3};
        System.out.println(add(a));
    }
    public static int add(int...data){
        int result=0;
        for(int i=0;i<data.length;i++){
            result+=data[i];
        }
        return result;
    }
}
//打印结果
// 10
//6

1.将可变参数变成一个数组，通过数组访问可变参数。

2.int[] value 与 int… values 不是重载关系，等价关系。

3.可变参数必须定义在参数列表的最后的一个位置。一个方法中最多有一个可变参数。

public static int add(String msg,)

4.main方法中不建议写可变参数

1.2 静态导入(实际开发过程中很少使用)

静态属性 通过类名来访问

1.静态导入类的静态方法；

2.静态导入类的静态属性；

3.静态批量导入 ：通过类名.*;

4.采用静态导入时，如果类中存在使用的类的静态属性和方法，优先使用类中自己的（就近原则）;

5.集成开发工具关于类的导入比较智能，通常开发中不需要额外处理导入；

import static www.
class Test{
    public static void main(String[] args){
        
    }
}
calss MyMath{
    public static int add(int a,int b){
        return a+b;
    }
    public static int sub(int a,int b){
        return a-b;
    }
}

2.泛型(JDK1.5之后)

2.1 基本定义

泛型是一种未知的数据类型。我们不知道使用什么数据类型的时候可以使用泛型。所以泛型可以看做是一个变量用来接收数据类型。

2.2 集合类中使用泛型

ArrayList集合在定义的时候，不知道集合中都会储存什么类型的数据，所以类型使用泛型。

public class ArrayList<E>{
    public boolean add(E e){}
    public E get(int index){}
}

在创建集合对象时会确定泛型的数据类型，把数据类型作为参数传递，把String 赋值给泛型E

ArrayList<String> list = new ArrayList<String>();//创建对象，并确定泛型为String

public class ArrayList<String>{
    public boolean add(String e){}
    public String get(int index){}
}
ArrayList<Student> list = new ArrayList<Student>();
//此时E为Student类

2.2.1创建集合类不使用泛型

好处：集合不适用泛型，默认类型为Object类型，可以储存任意数据类型的数据。

package Test.zyj.com;

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

/**
 * @Name： 集合中不使用泛型和使用泛型
 * @Author：ZYJ
 * @Date：2019-06-01-14:47
 * @Description:
 */
public class Demo01Test {
    public static void main(String[] args) {
        showo1();
         show2();
    }

    /**
     * 集合类使用泛型
     */
    private static void showo1(){
        ArrayList list = new ArrayList();
        list.add("abc");
        list.add(11);
        //使用迭代器遍历
        Iterator it  = list.iterator();
        while (it.hasNext()){
            Object object = it.next();
            //向下转型 强制转换
            String s = (String) object;
            System.out.println(s.length());
        }
    }

    /**
     * 集合类使用泛型
     */
    private static void show2(){
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
        list.add("ddd");
        Iterator it2 = list.iterator();
        while (it2.hasNext()){
            Object o =it2.next();
            String ss = (String) o;
            System.out.println(ss.length());
        }
        System.out.println();
    }
}

若此时想要使用String类特有的方法length（），获取字符串的长度；不能直接使用，多态不能使用子类特有的方法。需要向下转型

Object object ="abc";
String s = (String) obj;
System.out.println(s.length());

此时程序报错 ClassCastException:类型转换异常，不能吧Integer类型转换为为String

创建集合对象使用泛型的好处：

1.避免类型转换的麻烦

1.把运行期异常提升到编译期

 private static void show2(){
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
        list.add(1);//此处在编译器产生异常      
    }

2.3 泛型类的定义

//基本语法
class Myclass<T>{
    T value1;
}

<>中的T被称为：类型参数，用于指代任何类型，实际上这个T可以任意写。

• T ：代表一般的任何类
• E ：代表Element的意思，或者Exception异常的意思
• K ：代表Key的意思
• V ：代表Value的意思，通常与K一个配合使用
• S ：代表Subtype的意思。

范例 ：定义一个泛型类

MyClass<String> myClass1 = new MyClass<String>();
MyClass<Integer> myClass2 = new MyClass<Integer>();

注意：泛型只能接受类，所有的基本数据类型必须使用包装类，即<>中的内容必须为一个类。

2.3.1 泛型可以接收多个类型参数

多个类型参数之间用“，”隔开

Class MyClass<T,E>{
    T value1;
    E value2;
}
public class Test{
    public static void mainI(String[] args){
        MyClass<String,Integer> myclass = new MyClass<String,Integer>();
    }
}

范例：使用泛型定义一个类

package Test.zyj.com;

/**
 * @Name： 使用泛型定义一个类
 * @Author：ZYJ
 * @Date：2019-06-01-15:12
 * @Description:
 */

/**
 * 定义Point类 使用泛型
 * @param <T>
 */
class Point<T>{
    private T x;
    private T y;

    public T getY() {
        return y;
    }

    public void setY(T y) {
        this.y = y;
    }

    public T getX() {
        return x;
    }

    public void setX(T x) {
        this.x = x;
    }
}
public class FunTypeDemo {
    public static void main(String[] args) {
        //创建对象时指定泛型类型，将类型作为参数传入
        Point<String> p = new Point<String>();
        p.setX("东京下雨");
        p.setY("淋湿巴黎");
        //取出数据
        String x = p.getX();//避免向下转型
        String y = p.getY();
        System.out.println(x+y+"....");
    }
}

总结：

​ 因为使用泛型之后，在创建类的对象的时候指定了类型，所以在接收这个对象的时候我们已经知道使用了哪一种类型，避免了向下转型。泛型的出现彻底改变了向下转型的需求。引入泛型之后，如果明确设置了类型，则为设置类型。如果没有设置类型，则默认为Object类型。

2.4 泛型方法的定义

泛型定义在方法的修饰符和返回值类型之间：

格式

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

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

含有泛型的方法，在调用方法的时候确定泛型的数据类型。传递什么类型的参数，泛型就是什么类型。

2.4.1.泛型方法是独立定义，可以单独定义泛型方法，和类没有直接关系

泛型方法始终以自己的类型为准

class MyClass{
    public <T>（T为类型参数） void test（T t）{//方法中T为参数化类型，不是真正运行时的参数
        //T:参数化类型 不是真正类型 具体调用那个类型就是那个类型
        return t;
    }
}
public static void main(String[] args){
    Point3 point3 = new Point3();
    //调用方法时传入什么类型 就是什么类型
    point3.print("helllo ！");//T=>String
    point3.print(22);//T=>int
}

####2.4.2.泛型方法的类型参数是写在方法返回值类型前面定义。<T,…>

public <T>（类型参数类型） T(返回值类型 类型参数的类型) getInfo(T v){
    return v;
}
public <T,V> E getInfo(T t ,E e){
    return e;
}

2.4.3 泛型类与泛型方法共存

package Test.zyj.com;

/**
 * @Name：泛型类与泛型方法同时存在
 * @Author：ZYJ
 * @Date：2019-06-01-15:52
 * @Description:
 */
public class FCaFF {
    public static void main(String[] args) {

        MyClass01<String> myClass01 = new MyClass01<>();//传入String类
        myClass01.testMethod("只能是String类型");
        //调用泛型方法 ，传入整形数据类型
        Integer i = myClass01.testMethod2(100);
        System.out.println(i);
        //调用泛型方法，传入字符串类型数据
        String s = myClass01.testMethod2("sdasd");
        System.out.println(s);
    }
}

/**
 * 定义泛型类  实例化对象传入什么类型就是什么类型
 * @param <T>
 */
class MyClass01<T>{
    /**
     * 定义泛型方法
     * 在调用方法的时候确定泛型的数据类型，传递什么参数，泛型就是什么类型
     * @param t
     */
    public <T> T testMethod2(T t){
        return t;
    }

    /**
     * 普通方法
     * @param t
     */
    public void testMethod(T t){
        System.out.println(t);
    }
}

泛型方法之间没关系，泛型方法和泛型类也没有关系

总结：泛型方法与泛型类稍有不同，类型参数也就是 < >写在返回值之前。中的T称为：类型参数，而方法中的T 也被称为参数化类型，它不是运行时真正的参数。

2.5 泛型与静态方法

定义一个含有泛型的静态方法

public static<S> void method(S s){
    System.out.println(s);
}

通过类名.方法名（参数）可以直接使用，也可以传递任意类型好的参数

2.4 通配符

泛型会产生新的问题：参数统一问题

public class Test{
    public static void main(String[] args){
        Message<>
    }
}

2.4.1. 用？表示任意数据类型，

使用方法：不能创建对象使用，只能作为方法的参数使用。集合类在定义时不能写通配符。

用在形参

package Test.zyj;

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

/**
 * @Name：集合类泛型和
 * @Author：ZYJ
 * @Date：2019-06-01-16:14
 * @Description:
 */
public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        ArrayList<String> list1= new ArrayList<>();
        list1.add("aaa");
        list1.add("bbb");
        list1.add("ccc");
        printArray(list);
       printArray(list1);
    }
    //遍历集合，但集合中数据类型不唯一，这是不确定写哪一种数据类型  所有写？ 写其他的数据类型会报错
    public static void printArray(ArrayList<?> list){
        Iterator<?> it = list.iterator();//
        while (it.hasNext()){
            System.out.print(it.next());
        }
    }
}

2.4.2.泛型上限及下限

• ？ extends 类 ：设置泛型上限：

  应用在类、方法（声明） 只有上限通配符可以用在泛型类与泛型方法的使用上

  应用到方法中仍然不能修改

  ？必须为 类的本类或 子类

• ？ super 类 ：设置泛型下限： 只有下限通配符用在方法形参时，可以修改形参对象内容（天然的向上转型）

  只能应用到方法参数中

  应用到的方法中是可以修改的，但是主要修改类型为、

  ？必须为本类或父类

三者皆可用在形参上

package Demo.zyj;

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

/**
 * @Name：
 * @Author：ZYJ
 * @Date：2019-06-01-16:38
 * @Description:
 */
public class TestDemo {
    public static void main(String[] args) {
        Collection<Integer> list1 = new ArrayList<Integer>();
        Collection<String> list2 = new ArrayList<String>();
        Collection<Number> list3 = new ArrayList<Number>();
        Collection<Object> list4 = new ArrayList<Object>();
        list1.add(1);
        list2.add("abs");
        list3.add(34);
        list4.add("sdas");
        list4.add(1212);

        /**
         * 泛型为Number 可以同时使用
         */
        getElement(list3);
        getElement2(list3);

        //getElement(list2);//报错 String类既不是Number类的子类也不是Number的父类
        //getElement2(list2); //报错

        getElement(list1);
        //getElement2(list1); //报错 Integer类不是Number类的父类

       // getElement(list4);//报错  Object类是Number类的父类
        getElement2(list4);
    }

    /**
     * 设置上限 ？必须是 Number的子类或本类
     * @param coll
     */
    public static void getElement(Collection<? extends Number> coll){
        Iterator<?> iterator = coll.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    /**
     * 设置下限 ？ 必须是Number 的父类或本类
     * @param coll
     */
    public static void getElement2(Collection<? super Number> coll){
        Iterator<?> iterator2 = coll.iterator();
        while (iterator2.hasNext()){
            System.out.println(iterator2.next());
        }
    }

}

2.5泛型接口

泛型除了可以定义在类中，也可以定义在接口中，这种情况我们称为泛型接口；

定义泛型接口

public interface IMessage<T> {
    void print (T t);
}

2.5.1 泛型接口的实现

1）在子类定义时继续使用泛型

接口使用什么泛型，实现类就使用什么泛型。实现类跟着接口走，就相当于定义了一个含有泛型的类，创建对象的时候确定泛型类型

class MessageImpl<T> implements IMessage<T>  {
    @Override
    public void print(T t) {
        System.out.println(t);
    }
}
public class TestDemo{
    public static void main(String[] args){
        IMessage<String> mas = new MessageImpl();
        msg.print("Hello world!!")；
    }
}

2）在子类实现接口时明确的给出具体类型

class MessageImpl implements IMessage<String>{
    @Override
    public void print(String t){
        System.out.println(t);
    }
}
public class TestDemo{
    public static void main(String[] args){
        IMessage<String> msg = new MessageImpl();
        msg.print("hello java")；
    }
}

2.6 泛型擦除

泛型代码能够很好的和之前版本得到代码很好的兼容，因为 泛型信息只存于代码编译阶段， 若为指定泛型上限：擦成Object类 ，若指定泛型上限 擦成相应的泛型上限

在进入JVM之前，与泛型相关的信息会被擦除，专业术语叫做类型擦除

1.编译时进行类型擦除，在运行时泛型和普通类型一样

2。如果泛型类型参数未指定上限，