Java泛型基础

什么是泛型

泛型，即“参数化类型”，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

使用泛型的好处

• 代码更加简洁【不用强制转换】
• 程序更加健壮【只要编译时期没有警告，那么运行时期就不会出现ClassCastException异常】
• 可读性和稳定性【在编写集合的时候，就限定了类型】

泛型类

泛型类就是把泛型定义在类上，使用该类的时候，才把类型明确下来

//定义
class  类名<泛型类型标识>{
}
//应用
类名<具体类> 对象名　＝ new 　类名<具体类> ();

//在实例化泛型类时，必须指定T的具体类型
public class Point<T>{ //类型参数：通常用一个大写字母表示。多个类型参数用逗号分隔T,E,V,K
    private T x;//
	private T y;
	public T getX() {
		return x;
	}
	public void setX(T x) {
		this.x = x;
	}
	public T getY() {
		return y;
	}
	public void setY(T y) {
		this.y = y;
	}
}

当对泛型进行实例化的时候，同一个泛型类实例化出的对象getClass之后是相同的

//实例化时给出的是什么类型存放数据时就必须是什么类型
Point<Integer> p1 = new Point<>();
p1.setX(11); // int -> Integer -> Object
p1.setY(22);
Point<Double> p2 = new Point<>();
p2.setX(11.1);// double -> Double -> Object
p2.setY(22.2);
Point<String> p3 = new Point<>();
p3.setX("11.1");// String -> Object
p3.setY("22.2");
// 几个泛型类？一个泛型类
System.out.println(p1.getClass() == p2.getClass());
System.out.println(p1.getClass() == p3.getClass());
System.out.println(p2.getClass() == p3.getClass());
//以上输出均为true

之所以相同是因为Java在编译期间，所有的泛型信息都会被擦掉，Java的泛型基本上都是在编译器这个层次上实现的，在生成的字节码中是不包含泛型中的类型信息的，使用泛型的时候加上类型参数，在编译器编译的时候会去掉，这个过程称为类型擦除。

参数化类型:一个类型后边指定一个具体类型参数。

   Point<Integer>

原生类型：一个类型后边没有指定具体的类型参数。

   Point p2 ；

通配符

当泛型类对象作为参数被方法调用时，如果想调用不同类型参数的泛型对象，就要用到通配符
注意：泛型中的< Object >并不是像以前那样有继承关系的，也就是说List< Object >和List< String >是毫无关系的！！！！

• ？ 无界通配符 匹配 所有的引用类型
• ？extends 上限类 匹配 上限类 和 上限类的子类型
• ？ super 下限类 匹配 下限类和 下限类的父类

//所有类型都能用
public void showPoint(Point<?> p){// 应用
		System.out.println(p.getX() + ":" + p.getY());
}
// 集合装载的元素只能是Number的子类或自身
public void showPoint(Point<? extends Number> p){// 应用
		System.out.println(p.getX() + ":" + p.getY());
}
//传递进来的只能是Number或Number的父类
public void showPoint(Point<? super Number> p){// 应用
		System.out.println("p.getX() + ":" + p.getY());
}

泛型方法

泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型 。
如果我们仅仅在某一个方法上需要使用泛型，只关心该方法，而不关心类其他的属性，这样的话，我们就不必在整个类上定义泛型

//定义泛型方法..
/*
说明：
 * 1）public与返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
 * 2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
 * 3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
 * 4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
 */
    public <T> T show(T t) {//有返回值，类型为T
   // public <T> void show(T t){无返回值
        System.out.println(t);
        return t;
    }

泛型类中的泛型方法

参考链接

public class GenericFruit {
    class Fruit{
        @Override
        public String toString() {
            return "fruit";
        }
    }

    class Apple extends Fruit{
        @Override
        public String toString() {
            return "apple";
        }
    }

    class Person{
        @Override
        public String toString() {
            return "Person";
        }
    }

    class GenerateTest<T>{
        public void show_1(T t){
            System.out.println(t.toString());
        }

        //在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
        //由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
        public <E> void show_3(E t){
            System.out.println(t.toString());
        }

        //在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
        public <T> void show_2(T t){
            System.out.println(t.toString());
        }
    }

    public static void main(String[] args) {
        Apple apple = new Apple();
        Person person = new Person();

        GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
        //apple是Fruit的子类，所以这里可以
        generateTest.show_1(apple);
        //编译器会报错，因为泛型类型实参指定的是Fruit，而传入的实参类是Person
        //generateTest.show_1(person);

        //使用这两个方法都可以成功
        generateTest.show_2(apple);
        generateTest.show_2(person);

        //使用这两个方法也都可以成功
        generateTest.show_3(apple);
        generateTest.show_3(person);
    }
}

静态方法与泛型

如果一个静态方法要使用泛型的话，这个静态方法也必须声明为泛型方法，单纯的静态方法无法访问类上定义的泛型，

public static <T> void show(T t)

泛型类派生出的子类

泛型类是拥有泛型这个特性的类，它本质上还是一个Java类，那么它就可以被继承
在被继承的时候分两种情况：

• 子类明确泛型类的类型参数变量
• 子类不明确泛型类的类型参数变量

子类明确泛型类的类型参数变量

• 泛型接口

/*
    把泛型定义在接口上
 */
public interface Inter<T> {
    public abstract void show(T t);
}


/**
 * 子类明确泛型类的类型参数变量:
 */

public class InterImpl implements Inter<String> {
    @Override
    public void show(String s) {
        System.out.println(s);

    }
}

• 子类不明确泛型类的类型参数变量
  当子类不明确泛型类的类型参数变量时，外界使用子类的时候，也需要传递类型参数变量进来，在实现类上需要定义出类型参数变量

/**
 * 子类不明确泛型类的类型参数变量:
 *      实现类也要定义出<T>类型的
 *
 */
public class InterImpl<T> implements Inter<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}