2019-03-28

1 、 java泛型的介绍：

泛型实在jdk1.5添加的功能,现在应该是到12了，泛型的出现实际上就是为了相对安全。主要是就是解决数据类型相对安全问题，原理就是在声明类的时候通过某个某个标识表示类中的某个属性的类型或者某个方法的返回值及参数类型。则在实例化的时候或者声明类的时候指定所需类型即可
泛型的格式：
访问权限 class 类名称 <泛型类型1，泛型类型2……>{ }
        访问权限 泛型类型标识 变量名称；
        访问权限 泛型类型标识 方法名称（）；
        访问权限 返回值类型声明 方法名称（泛型类型标识 变量名称）{}；

2 、泛型对象的定义：

类名称 <具体类> 对象名称 = new 类名称 <具体类型>（）
例如我写了一个point类

class Point <T,F>{  //使用泛型 定义类型<用大写字符代替类型>
    private T x;
    private F y;
    
    public Point() {    //构造方法

    }
    public Point(T x, F y) {    //有参构造
        this.x = x;
        this.y = y;
    }
    public T getX() {
        return x;
    }
    public void setX(T x) {
        this.x = x;
    }
    public F getY() {
        return y;
    }
    public void setY(F y) {
        this.y = y;
    }
}
public class PointDemo {
    public static void main(String[] args) {
        //规定具体类型
        Point<String,Integer> p = new Point<String,Integer>();  //需要什么类型就使用什么类型
        p.setX("X坐标：123");
        p.setY(123);
        
        Point<Double,String> p2 = new Point<Double,String>();
        p2.setX(123.45);
        p2.setY("Y坐标：8851");
    }
}

也可以使用for循环输出，或者使用foreach输出

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

public class ListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("世界");
        list.add("你好");
        List<String> list2 = new ArrayList<String>();
        list2.add("Hello");
        list2.add("World");
        //使用for()循环输出：
        for(int i=0;i<list2.size();i++) {
            System.out.print(list2.get(i)+" ");
        }
        //foreach 格式: for(类型  名字 : 要循环的对象)
        for(String v :list) {
            System.out.print(v);
        }
    }
}

引用传递时泛型类型必须一致。

package CS0327;

class Info <T> {
    private T name;

    public T getName() {
        return name;
    }

    public void setName(T name) {
        this.name = name;
    }
    public String toString() {
        return this.name.toString();
    }
}
public class FXDemo01 {
    public static void main(String[] args) {
        Info <String> i = new Info<String>();       //使用String泛型
        i.setName("张三");        //赋值
        fun(i);
    }
    public static void fun(Info<String>temp) {//接收String类型的泛型对象Info 
        System.out.println("姓名："+temp);
    }
}

类型不一致编译就会报错

在这里插入图片描述

泛型在引用对象传递时类型必须一致否则就报错，如果一定要传递可以将方法中的参数泛型取消或者也可以使用通配符？，使用？就表示可以接受任意的内容，但是内容就无法直接使用<?>修饰的泛型对象进行修改了

public class FXDemo02 {
    public static void main(String[] args) {
        Info <String> i = new Info<String>();       //使用String泛型 实例化类Info
        i.setName("张三");        //赋值
        fun(i);
    }
    public static void fun(Info<?>temp) {//使用String泛型类型 
        System.out.println("姓名："+temp);
    }
}

在这里插入图片描述

3 、受限泛型：

以上设置泛型类型都是可以任意设置，只要是类就可以设置，在java泛型中可指定泛型的上限和下限。

在引用传递中，泛型操作中设置泛型对象的范围上限和范围下限，在范围上限使用extends关键字声明，表示参数化类型可能是所指定的类型，或者就是此类型的子类， 泛型的下限使用super关键字声明：表示参数化的类型可能是所指的类型或者此类的父类型，直到Object类。

格式：

设置上限：

• 声明对象：类名称<? extends 类> 对象名称
• 定义类： 访问权限 类名称 <泛型标识 extends 类>{ }

设置下限：

• 声明对象： 类名称<? super 类> 对象名称
• 定义类： 访问权限 类名称 <泛型标识 extends 类>{ }

举例泛型的上限：

package CS0327;

/*泛型的上限*/
public class FXDemo03 {
    public static void main(String[] args) {
        Info <Integer> i = new Info <Integer>();
        Info <Float> i2 = new Info <Float>();
        i.setName(30);
        i2.setName(30.5f);
        fun(i);
        fun(i2);
    }
    //接收Info 对象，范围上限设置Number，所以只能接收数字类型的值
    public static void fun(Info <? extends Number> temp) {
        System.out.println(temp);
    }
}

在这里插入图片描述

泛型的下限：
当时用的泛型只能在本类及父类中类型使用的的时候，就必须使用泛型的范围下限配置。

package CS0327;

class Info2 <T>{    
    private T var;      //定义泛型变量

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }
    public String toString() {  //打印
        return this.var.toString();
    }
    
}

public class FXDemo04 {
    public static void main(String[] args) {
        Info2 <String> i1 = new Info2 <String>();   //声明string类型的泛型对象
        Info2 <Object> i2 = new Info2 <Object>();   //声明Object类型的泛型对象
        i1.setVar("Hello Word");
        i2.setVar(new Object());
        fun(i1);
        fun(i2);
    }
    public static void fun(Info2<? super String> temp) {
        System.out.println(temp);
    }
}

像上例，使用Integer就不满足泛型的下限

在这里插入图片描述

泛型和子类继承的限制:

一个类的子类可以通过多态性为父类实例化，但是在泛型操作中，子类的泛型是不能使用父类的泛型来接收的，就好比Info<String>不能使用Info<Object>来接受一样