JAVA 高级 什么是泛型

本文详细介绍了Java中的泛型,包括其定义、使用目的、语法示例、泛型通配符、限制以及泛型在接口和方法中的应用,旨在帮助读者理解和解决数据类型安全问题。
摘要由CSDN通过智能技术生成

1. 正文

1、什么是泛型
2. 为什么使用泛型
3. 如何定义泛型
4. 泛型通配符
5. 泛型的限制
6. 泛型接口
7. 泛型方法

2. 什么是泛型

思考: 之前我们使用ArrayList 和map时,<T> 它就是泛型标识。

泛型就是类在定义时无法确定类中成员[属性 方法 ]的类型,而在类对象创建时确定其数据类型。保证数据类型的安全问题。

3. 为什么使用泛型?

例子: 定义一个坐标点类, 点这个类具有什么属性。x坐标 y坐标。

要求: x和y坐标它们的值可以都是String类型。 也可以都是int类型,也可以都是double类型。

public class Point {
    private Object x;
    private Object y;
​
    public Point(Object x, Object y) {
        this.x = x;
        this.y = y;
    }
​
    public void show(){
        System.out.println("x坐标:"+x+";y坐标:"+y);
    }
    public Object getX() {
        return x;
    }
​
    public void setX(Object x) {
        this.x = x;
    }
​
    public Object getY() {
        return y;
    }
​
    public void setY(Object y) {
        this.y = y;
    }
}
​
public class Test01 {
    public static void main(String[] args) {
        Point p1=new Point("东经180度","北纬65度");
        p1.show();
​
        Point p2=new Point(18.5,65.6);
        p2.show();
​
        Point p3=new Point(19,25);
        p3.show();
​
        Integer x = (Integer) p3.getX();
        System.out.println(x);
//        //.ClassCastException数据类型安全问题。
//        String y = (String) p3.getY();
//        System.out.println(y);
​
        //不符合题目要求
        Point p4=new Point("东经18度",25);
        p4.show();
    }
}
​

在获取属性时,存在数据类型安全隐患问题。而且point属性赋值时,可以赋值一个字符串和整型。 为了解决数据安全隐患问题。我们可以使用泛型。

4. 泛型的语法

public class 类名<标识,标识...>{
    private 标识 属性名;
    public void set(标识 名称){}
    public 标识 get(){}
}
public class Point<T> {
    private T x;
    private T y;
​
    public Point(T x, T y) {
        this.x = x;
        this.y = 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;
    }
​
    public void show(){
        System.out.println("x坐标:"+x+";y坐标:"+y);
    }
​
}
​
public class Test02 {
    public static void main(String[] args) {
        Point<String> p1=new Point<String>("东经180度","北纬150度");
        String x = p1.getX();
​
        Point<Integer> p2=new Point<>(15,25);
        Integer x1 = p2.getX();
    }
}

使用泛型可以解决数据类型安全隐患问题。

5. 泛型通配符

在开发中==对象的引用传递==是最常见的,但是如果在泛型类的操作中,在进行引用传递时泛型类型必须匹配才可以传递,否则是无法传递的。

  1. 对象的引用传递 2. 值的传递【基本类型】 特殊:字符串 不可变。

public class Info<T> {
    private T var;
​
    public void show(){
        System.out.println("var=========="+var);
    }
    public Info(T var) {
        this.var = var;
    }
​
    public T getVar() {
        return var;
    }
​
    public void setVar(T var) {
        this.var = var;
    }
}
​
public class Test {
    public static void main(String[] args) {
        Info<Integer> i=new Info<>(18);
        fun(i);
​
        Info<String> i2=new Info<>("28");
        fun(i2);
​
    }
    //泛型的引用传递 除了数据类型匹配之外 还有泛型匹配。  能否接受任意泛型 可以。泛型统配 ?: 统配任意泛型
    public static void fun(Info<?> info){
        info.show();
    }
}

上面fun方法的参数泛型使用了? 作为通配符,表示它可以统配任意类型的泛型。

6.泛型的限制

在引用传递中,在泛型操作中也可以设置一个泛型对象的==范围上限==和==范围下限==。范围上限使用extends关键字声明,表示参数化的类型可能是所指定的类型或者是此类型的子类,而范围下限使用super进行声明,表示参数化的类型可能是所指定的类型或者此类型的父类型。

public class Test {
    public static void main(String[] args) {
        Info<Integer> i=new Info<>(18);
​
        Info<String> i2=new Info<>("28");
        Info<Number> i3=new Info<>(28.8);
        Info<Object> i4=new Info<>(28.8);
​
//        fun2(i);
//        fun2(i2);
//        fun2(i3);
        fun3(i);
        fun3(i2);
        fun3(i3);
        fun3(i4);
​
    }
    //super限制泛型的下限  泛型必须为number本身或Number的父类类型
    public static void fun3(Info<? super Integer> info){
        info.show();
    }
​
    //extends限制泛型的上限   泛型必须为Number或Number的子类。
    public static void fun2(Info<? extends Number> info){
          info.show();
    }
​
​
​
    //泛型的引用传递 除了数据类型匹配之外 还有泛型匹配。  能否接受任意泛型 可以。泛型统配 ?: 统配任意泛型
    public static void fun(Info<?> info){
        info.show();
    }
​
}
​

7.泛型接口

上面那些例子都是使用泛型类。而在jdk1.5以后,泛型也可以定义在接口上了,定义接口的泛型和定义泛型类语法相似。

语法: 1.8以前

public interface 接口名<泛型标识,泛型标识>{
      //属性: 静态常量
      //方法  抽象方法
}

类如何实现泛型的接口

第一种: 在实现泛型接口时为泛型指定类型。

public interface Usb<T> {
     void print(T t);
     T get();
}
class Upan implements Usb<String>{
​
​
    @Override
    public void print(String s) {
        System.out.println("~~~~~~~~~~~~~~~"+s);
    }
​
    @Override
    public String get() {
        return "hello";
    }
}

第二种: 在实现泛型接口时该类也是一个泛型,而且类的泛型标识必须和接口的标识一致。

//List---ArrayList
class Mouse<T> implements Usb<T>{
​
    @Override
    public void print(T t) {
        System.out.println("~~~~~~~~~~~~~~"+t);
    }
​
    @Override
    public T get() {
        return null;
    }
}

8. 泛型方法

前面学习的所有泛型操作都是将整个类进行泛型化,但同样也可以在类中定义泛型化的方法。泛型方法的定义与其所在的类是否是泛型类是没有任何关系的,所在的类可以是泛型类,也可以不是泛型类。

【泛型方法的简单定义】

[访问权限] ==<泛型标识>== 返回类型 方法名称(泛型标识 参数名称)

public class Test02 {
    public static void main(String[] args) {
       People p=new People();
       p.fun("hhhhh");
    }
}
​
class People{
    public <T> T fun(T t){
        System.out.println(t);
        return t;
    }
}

  • 17
    点赞
  • 29
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值