Java拾贝第九天——泛型

Java拾贝不建议作为0基础学习，都是本人想到什么写什么

如果一个类中，不想限定一个属性的数据类型，或某个方法的返回值和传参。

可以在类声明时通过一个标识来表示。

这样只需要在实例化类的时候声明具体的数据类型即可，这就是泛型

也可以理解为广泛的数据类型，即不限制的数据类型

泛型类

泛型作用于类上就是泛型类。

声明一个泛型类

class 类名<泛型标识符>{//拥有标识符的类就是泛型类
 访问修饰符 泛型标识符 变量名;
 访问修饰符 泛型标识符 方法名(){};
 ....
}

栗子：

public class Test9 {
    public static void main(String[] args) {
        MyF<String> f = new MyF<String>();
	//外部指定数据类型  第二个<>中的String可以省略
        f.setName("泛型");
    }
}
class MyF<T> {//泛型类
    private T name;//属性不定义具体类型，使用泛型替代数据类型

    public MyF() {
    }
    public MyF(T name) {//构造方法也可也使用泛型
        this.name = name;
    }
    public T getName() {//返回类型使用泛型
        return name;
    }
    public void setName(T name) {//传参使用泛型
        this.name = name;
    }
}

上门的MyF类就是泛型的具体体现。其调用了"<T>"形式，泛型表示具体类型是由外部实例化MyF类时指定的。

<>中可以是任意的大写字母，<A>、<B>都可以。这里采用T仅仅是取type的开头而已。

泛型类在被初始化时指定类型

基本类型是无法指定的，只能指定引用类型

栗子：

MyF<int> f = new MyF<>();//错错错

传入的类型与泛型不一致。

栗子：

public class Test9 {
    public static void main(String[] args) {
        MyF<Integer> f = new MyF<>();
        f.setName("传入String类型");//编译错误 初始化时指定的是Integer类型
    }
}
class MyF<T> {
    private T name;

    public MyF() {
    }
    public MyF(T name) {
        this.name = name;
    }
    public T getName() {
        return name;
    }
    public void setName(T name) {
        this.name = name;
    }
}

传入的类型可以是某个类或其子类

栗子：

public class Test9 {
    public static void main(String[] args) {
        Point<Son> point = new Point<>();
	//Point<Dad> point = new Point<>();一样没问题的
    }
}
class Dad{
    
}
class Son extends Dad{
    
}
class Point<T>{
    private T name;

    public Point() {
    }

    public Point(T name) {
        this.name = name;
    }

    public T getName() {
        return name;
    }

    public void setName(T name) {
        this.name = name;
    }
}

静态属性不能使用泛型
栗子：

class Point<T>{
    static T t;//错错错

因为静态处于全局内存区，JVM对静态的初始化会在类实例化之前。

此时使用泛型会导致JVM初始化全局内存不成功。因为泛型是不确定的数据类型

多个泛型

栗子：

public class Test9 {
    public static void main(String[] args) {
        Point<String, Integer> point = new Point<>("小明",18);
	//外部指定属性name数据类型为String，属性age数据类型为Integer
    }
}

class Point<T,K>{//任意字母都行
    private T name;
    private K age;

    public Point() {
    }

    public Point(T name, K age) {
        this.name = name;
        this.age = age;
    }

    public T getName() {
        return name;
    }

    public void setName(T name) {
        this.name = name;
    }

    public K getAge() {
        return age;
    }

    public void setAge(K age) {
        this.age = age;
    }
}

泛型擦除

即外部不指定具体类型。
栗子：

public class Test9 {
    public static void main(String[] args) {
        Point point = new Point();
        point.setName("小明");
    }
}

class Point<T>{
    private T name;

    public Point() {
    }

    public Point(T name) {
        this.name = name;
    }

    public T getName() {
        return name;
    }

    public void setName(T name) {
        this.name = name;
    }
}

上述栗子会出现不安全警告信息。

虽然不指定泛型类型后编译出现了警告，但是并不影响程序运行。

这是因为Java在这种情况(不指定泛型类型)下默认采用Object进行接收。也称泛型擦除

泛型接口

泛型作用于接口上就是泛型接口。

interface 接口名<泛型标识符>{//泛型接口
}

栗子：

interface Cat<T>{
   void getCat(T t);
}

泛型接口在被继承，或被实现时需指定类型

栗子：

interface Cat<T>{
   void getCat(T t);
}
interface Dog extends Cat<String>{//被继承
}
class tc implements Cat<String>{//被实现
    @Override
    public void getCat(String s) {
        System.out.println("不定义会泛型擦除，记得确定数据类型");
    }
}

泛型方法

泛型作用于方法上就是泛型方法。

栗子：

    public <T> void opq(T temp1) {
        System.out.println(temp1);
    }

可以使用泛型类中的泛型标识符，或泛型方法中的泛型标识符。

栗子：

class Gen<T>{
    public <K,V> void tell(T t,K k){//可以使用泛型类中的泛型标识符，或泛型方法中的泛型标识符。
        System.out.println("泛型类中的泛型方法");
    }
}

泛型方法不光可以在泛型类中，还可以在普通类中：

栗子：

class Pen{
    public <K,V> void tell(K k){//泛型不一定要全部使用
        System.out.println("普通类中的泛型方法");
    }
}

普通方法也可也使用泛型：
栗子：

class Gen<T>{
    public <K> void tell(T t){//泛型方法
        System.out.println("泛型类中的泛型方法");
    }
    public void say(T t){//只是传参使用泛型而已 这不是泛型方法!!!
        System.out.println("普通方法使用泛型");
    }
}

补充
泛型方法中一个泛型可以当多个数据类型使用。
栗子：

public class Test10 {
    public static void main(String[] args) {
        opq("张三", 18);
    }

    public static <T> void opq(T temp1, T temp2) {
        System.out.println(temp1 + " + " + temp2);
    }
}

程序运行结果：

张三 + 18

静态方法的返回值不能使用泛型！
栗子：

    public static <T> opq(T temp1) {//错错错
        System.out.println(temp1);
    }