【JavaSE】之泛型

最新推荐文章于 2024-10-02 10:45:03 发布
最新推荐文章于 2024-10-02 10:45:03 发布
阅读量628 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gx123456sh/article/details/86762535
版权

目录

 

1.JDK1.5新特性

1.1可变参数

1.2for each 循环用于数组与类集的简单输出

1.3静态导入 

2.泛型

2.1泛型类

2.2泛型方法

2.3通配符（重点）

2.3.1 ？-可以接收任意类型（仅用于方法参数）

2.3.2 ？ extend 类：设置/取得泛型上限

2.3.3 ？ super 类：取得泛型下限-只能用于方法中

2.4泛型接口

2.5类型擦除（语法糖）

1.JDK1.5新特性

1.1可变参数

要求方法可以接收任意个整数并且返回它们的相加结果

可变参数：类型...参数名称

一个方法有且只能有一个可变参数，并且放在方法的最后一个参数。可变参数的本质还是数组。

例：早期实现方式

public class Test1{
    public static void main(String[] args) {
        System.out.println(add(new int[]{1,3}));
        System.out.println(add(new int[]{1,3,5,7}));
        System.out.println(add(new int[]{1,3,5,7,9}));
    }
    public static int add(int[] data){
        int result = 0;
        for(int i=0; i<data.length; i++){
            result += data[i];
        }
        return result;
    }
}

        这种最初的实现方式本身存在缺陷，现在要求设计的不是数组，而是任意多个参数。从JDK1.5之后追加了可变参数，这种方法的定义方式为：

public [static] [final] 返回值 方法名称([参数类型 参数名称][参数类型 ... 参数名称]){}

//这个参数上使用到的 ... 实际上表示一个数组的结构

例：方法的可变参数

public class Test1{
    public static void main(String[] args) {
        System.out.println(add(1,3));
        System.out.println(add(new int[]{1,3,5,7}));
        System.out.println(add(new int[]{1,3,5,7,9}));
    }
    public static int add(int ... data){  //本身还是一个数组
        int result = 0;
        for(int i=0; i<data.length; i++){
            result += data[i];
        }
        return result;
    }
}

注意：如果要传递多类参数，可变参数一定要放在最后，并且只能设置一个可变参数

1.2for each 循环用于数组与类集的简单输出

格式：

for(数据类型 临时变量 ： 数组(集合)){
    //循环次数为数组的长度，而每一次循环都会顺序取出数组中的一个元素赋值给临时变量
}

例：

public class Test1{
    public static void main(String[] args) {
        int[] data = new int[]{1,3,5,7,9};
        for(int i:data){
            System.out.print(i+" ");
        }
    }
}

通过此方式可以很好的避免数组越界问题，但是这种数组的操作只适合简单输出模式。

1.3静态导入

定义一个Test1类，这个类提供了static方法

package www.bit.java.util;

public class Test1{
    public static int add(int x,int y){
        return x+y;
    }
    public static int mul(int x,int y){
        return x*y;
    }
}

使用Test1类

package www.bit.java;
import www.bit.java.util.Test1;

public class Test{
    public static void main(String[] args) {
        //通过类名调用
        System.out.println(Test1.add(10,20));
        System.out.println(Test1.mul(10,20));
    }
}

        从JDK1.5开始，如果类中方法全是static方法，则可以直接把这个类的方法导入进来，就好比像在主类中定义的方法一样，可以被主方法直接调用。

例：静态导入

package www.bit.java;
import static www.bit.java.util.Test1.*;  //静态导入

public class Test{
    public static void main(String[] args) {
        //静态导入与和在自己的类中使用一样
        System.out.println(add(10,20));
        System.out.println(mul(10,20));
    }
}

2.泛型

假设需要定义一个描述坐标的程序类Point，需要提供两个属性x、y。对于这两个属性的内容可能有如下选择：

1.x = 10、 y = 20；

2.x = 10.1、y = 20.1；

3.x = 东经80度、y = 北纬20度；

此时需要保存的有int、double、String，所以在java中只有一种类型可以保存所有类型：Object型

例：

class Point{
    private Object x;
    private Object 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 Test1{
    public static void main(String[] args) {
        Point point = new Point();
        point.setX(10);  //自动装箱并且向上转型为Object
        point.setY("北纬20度");
        //取出数据
        String x = (String) point.getX();
        String y = (String) point.getY();
        System.out.println(x+"、"+y);
    }
}

        这个时候由于设置方的错误，经坐标内容设置成了int与String，但是接收方不知道，于是在执行时就会出现ClassCastException。

ClassCastException指的是两个没有关系的对象进行强转出现的异常。

为了解决ClassCastException，引出泛型。

2.1泛型类

泛型类指的是在类定义的时候并不会设置类的属性或方法中参数的具体类型，而是在类使用时在定义。

泛型类的基本语法：


class MyClass<T>{

    T value1;

}

        尖括号<>中的T被称作是类型参数，用于指定代任何类型。实际上这个T可以任意写，但出于规范，我们用单个大写字母来代表类型参数。

T：被称为类型参数，用于指代任何类型，代表一般的类

E：代表Element，常用于泛型类中的属性

K：代表Key的意思

V：代表Value的意思，通常与K一起配合使用

（K、V：键值对，见Map集合）

S：代表Subtype的意思

泛型只允许接收类，所有基本类型必须使用包装类

class Myclass<T>{
    private T value;
    public T getValue() {
        return value;
    }
    public void setValue(T value) {
        this.value = value;
    }
}
public class Test1{
    public static void main(String[] args) {
        Myclass<String> myclass = new Myclass<String>();
        myclass.setValue("hello");
        System.out.println(myclass.getValue());
        Myclass<Integer> myclass1 = new Myclass<Integer>();
        myclass1.setValue(10);
        System.out.println(myclass1.getValue());
    }
}

有两个属性需要不同类型时：

class Myclass<T,E>{
    private T value1;
    private E value2;
    public T getValue1() {
        return value1;
    }
    public void setValue1(T value1) {
        this.value1 = value1;
    }
    public E getValue2() {
        return value2;
    }
    public void setValue2(E value2) {
        this.value2 = value2;
    }
}
public class Test1{
    public static void main(String[] args) {
        Myclass<String,Integer> myclass = new Myclass<String,Integer>();
        myclass.setValue1("hello");
        System.out.println(myclass.getValue1());
        Myclass<String,Integer> myclass1 = new Myclass<String, Integer>();
        myclass1.setValue2(10);
        System.out.println(myclass1.getValue2());
    }
}

JDK1.7 新增 Myclass<String,Integer> myclass = new Myclass<>(); 后面尖括号中的内容可以省略

 

2.2泛型方法

public <T> T MyMethod(T t){
    System.out.print(t);
}

第一个T代表此方法是泛型，第二个T代表返回值是T，第三个T代表类型参数

class Myclass{
    public <T> void print(T t){
        System.out.println(t);
    }
}
public class Test1{
    public static void main(String[] args) {
        Myclass myclass = new Myclass();
        myclass.print("Hello");
        myclass.print(10);
    }
}

        当泛型类与泛型方法共存时，泛型类中的类型参数与泛型方法中的类型参数没有关系，泛型方法中的类型参数始终以自己定义的类型参数为准

规范：泛型方法类型参数与泛型类的类型参数不要同名。

class Myclass<T>{ //泛型类
    public void method1(T t){
        System.out.println(t);
    }
    //泛型方法
    public <E> void method2(E e){
        System.out.println(e);
    }
}
public class Test1{
    public static void main(String[] args) {
        Myclass<String> myclass = new Myclass();
        myclass.method1("hello");
        myclass.method2(10);
    }
}

因为Object向下转型要强转。并且在运行时才会出错，所以引入泛型。

引入泛型后，泛型方法的参数不统一，要写许多重载，所以引入通配符。

2.3通配符（重点）

2.3.1 ？-可以接收任意类型（仅用于方法参数）

用于方法中，表示参数可以接收任意类型的泛型类

只能取得类中数据，不能修改数据，因为类型不确定，无法设置确定类型。

class Myclass<T>{
    private T value1;
    public T getValue1() {
        return value1;
    }
    public void setValue1(T value1) {
        this.value1 = value1;
    }
}
public class Test1{
    public static void main(String[] args) {
        Myclass<String> myclass = new Myclass<>();
        myclass.setValue1("hello");
        print(myclass);
    }
    public static void print(Myclass<?> myclass){
        //不知道传进来的是什么类型
        System.out.println(myclass.getValue1());
    }
}

2.3.2 ？ extend 类：设置/取得泛型上限

eg：？ extends Number：表示泛型必须是Number及其子类的泛型类

只能取得类中属性值，不能修改值（发生父类到子类的向下转型，需要强转，由于具体子类不确定，因此无法转型）

class Myclass<T extends Number>{
    private T value1;
    public T getValue1() {
        return value1;
    }
    public void setValue1(T value1) {
        this.value1 = value1;
    }
}
public class Test1{
    public static void main(String[] args) {
        Myclass<Integer> myclass = new Myclass<>();
        myclass.setValue1(123);
        print(myclass);
    }
    public static void print(Myclass<? extends Number> myclass){
        //知道父类但是不知道传进来的是什么子类（如果要改相当于向下转型，但是没有经过向上转型）
        System.out.println(myclass.getValue1());
    }
}

2.3.3 ？ super 类：取得泛型下限-只能用于方法中

eg： ？ super String：表示此方法只能取得String以及其父类Object

可以设置属性值（子类到父类是自动的向上转型）

class Myclass<T>{
    private T value1;
    public T getValue1() {
        return value1;
    }
    public void setValue1(T value1) {
        this.value1 = value1;
    }
}
public class Test1{
    public static void main(String[] args) {
        Myclass<String> myclass = new Myclass<>();
        print(myclass);
    }
    public static void print(Myclass<? super String> myclass){
        //取得泛型下限，子类到父类是自动的向上转型
        myclass.setValue1("hello");
        System.out.println(myclass.getValue1());
    }
}

2.4泛型接口

interface IInterface<T> { //在接口上定义了泛型
    T test(T t);
}

对于这个接口的实现子类有两种做法：

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

//第一个T表示子类是一个泛型，第二个T表示接口是一个泛型,两个T是一个类型T，因为子类T是从接口继承的
interface IInterface<T> { // 在接口上定义了泛型
    public void print(T t) ;
}
class InterfaceImpl<T> implements IInterface<T> {
    @Override
    public void print(T t) {
        System.out.println(t);
    }
}

public class Test1{
    public static void main(String[] args){
        IInterface<String> msg = new InterfaceImpl();
        msg.print("hello");
    }
}

例2：子类定义时确定好类型

interface IInterface<T> { // 在接口上定义了泛型
    public void print(T t) ;
}
class InterfaceImpl implements IInterface<String> {
    @Override
    public void print(T t) {
        System.out.println(t);
    }
}

public class Test1{
    public static void main(String[] args){
        IInterface<String> msg = new InterfaceImpl();
        msg.print("hello");
    }
}

2.5类型擦除（语法糖）

        语法糖：仅存在与源码阶段，编译后就消失不见。Java中典型的语法糖：泛型、自动拆装箱。

        泛型信息仅存在于代码编译阶段，进入JVM之前，与泛型相关的信息会被擦除掉。专业术语：类型擦除。也就是说，泛型类与普通类在Java虚拟机中没有任何区别。

        泛型类进入JVM之前会进行类型擦除，之前泛型类的类型参数若没有指定上限，会被擦除为Object类型。如果指定上限，则类型参数会被替换为相应类型上限。

class Myclass<T>{
    T t;
}
public class Test1{
    public static void main(String[] args) {
        Myclass<String> myclass1 = new Myclass<>();
        Myclass<Integer> myclass2 = new Myclass<>();
        System.out.println(myclass1.getClass() == myclass2.getClass());
    }
}

例：观察类型擦除

class Myclass<T,E extends Number>{
    public T t;
    public E e;
}
public class Test1{
    public static void main(String[] args) {
        Myclass<Integer,Double> myclass1 = new Myclass<>();
        Field[] fields = myclass1.getClass().getDeclaredFields();
        for(Field field : fields){
            System.out.println(field.getType());
        }
    }
}

 

gx1500291
关注
专栏目录
Java泛型(面试用)
xuebaobao130526的博客
07-31 2672
摘自https://cloud.tencent.com/developer/article/1033693 1. Java中的泛型是什么 ? 使用泛型的好处是什么? 　　这是在各种Java泛型面试中，一开场你就会被问到的问题中的一个，主要集中在初级和中级面试中。那些拥有Java1.4或更早版本的开发背景的人都知道，在集合中存储对象并在使用前进行类型转换是多么的不方便。泛型防止了那种情况的发生。...
JavaSE之泛型
Java初学者的博客
08-19 116
泛型 理解 ​ 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。 ​ 这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时确定（即传入实际的类型参数，也称为类型实参）。 （在定义类、接口时标识了某一类型，当有对象实现方法时，方法的返回值或参数类型需与标识的类型一致） 引入原因 ​ 集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后
javaSe之 泛型
C++ JAVA的专栏
08-09 138
参考 https://blog.csdn.net/qq_44543508/article/details/102175114
JAVASE之泛型
u012315155的专栏
01-09 385
泛型的使用： （2016/01/08） 泛型是JDK1.5之后新增的新特性，主要目的是为了安全性考虑，这里要注意当使用的是Collection接口下的集合的时候，迭代器（Iterator）是相对于集合的，所以当集合使用泛型的时候这里的迭代器还是要使用泛型的，泛型是使用 简单实例代码： List list = new ArrayList(); list.add("Hello"); lis
JavaSe之泛型
qq_54227829的博客
02-10 186
JavaSe之泛型
JavaSE之泛型专题
最新发布
今心上的博客
10-02 206
作用：泛型提供了在编译阶段约束所能操作的是数据类型，并自动进行检查的能力。注意：类型变量建议用大写的字母，常用的有：E（元素类型）、T（返回值类型）、K（键类型）、V（值类型）等。可以把字符串类型的数值转换成数值本身对应的真实数据类型。，称为泛型类、泛型接口、泛型方法，它们统称为泛型。包装类就是把基本类型的数据包装成对象的类型。可以把基本类型的数据转换成字符串类型。：基本数据类型可以自动转换为包装类。：包装类型可以自动转换为基本类型。基本类型的数据包装成对象的方案。定义类、接口、方法时，
JavaSE之泛型和通配符
qq_63218110的博客
09-13 221
本篇主要介绍泛型，其中包含泛型的语法，泛型的上界，通配符上下界，以及包装类的自动装箱拆箱等知识，其中还讲解了关于包装类Integer的经典面试题。
javase之泛型（重点）
Richard_666的博客
02-22 249
泛型是从jdk1.5之后追加到java语言里面的 作用：主要目的是为了解决ClassCastException的问题 在进行对象的向下转型时永远都可能存在安全隐患，而java希望通过泛型慢慢解决掉此类问题。 Object造成泛型产生的主要依据 Java泛型(Generic) 的引入加强了参数类型的安全性，减少了类型的转换，它与C++中的模板(Temeplates) 比较类似，但是有一点不同...
javaSE——泛型
DF10f-0001A
11-01 174
一、泛型 1、定义 泛型：在Java 5以后，Java引入了“参数化类型”概念，允许程序在创建集合时指定集合元素的类型。比如List<String>，表明该List只能保存字符类型的对象，java的参数化类型称为泛型。 泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。 import java.uti
学习笔记-JavaSE之泛型
scc_make_belief的博客
03-27 97
泛型的概念， 为什么要有泛型 在集合中使用泛型 自定义泛型结构 泛型在继承上的体现 通配符的使用 泛型应用举例
Exer.java（JavaSE泛型学习笔记）
04-19
泛型学习笔记2的源代码，泛型 ： 要解决类型的安全问题， 如果使用Object类型会带来类型的损失。典型的应用就是在集合中， 集合中理论上可以保存任意对象，实际上我们应该让它泛型化，集合类<元素类型>, 添加元素...
minboo#JavaSE#3.泛型在继承上的体现1
07-25
泛型在继承上的体现:1. 泛型在继承方面的体现虽然类A是类B的父类，但是G 和G二者不具备子父类关系，二者是并列关系。public void show1(Lis
JavaSE泛型讲解
一个真ikun
09-12 1011
本篇详细讲解了java基础中泛型的相关理解和使用注意事项。
JavaSE--泛型
xiaochengxuyuan1的博客
01-29 291
1. 泛型的引例 1 List list = new ArrayList(); 2 list.add(1022); //向集合中添加一个 Integer 类型的数据 3 list.add("Yadiel"); //向集合中添加一个 String 类型的数据 4 5 //遍历list元素 6 for(int i = 0 ; i < list.size() ; i++){ 7 Object obj = list.get(i); //注意这里每个类型都是 Obj
一个数如果恰好等于它的因子之和，这个数就称为 "完数 "。例如6=1＋2＋3.编程 找出1000以内的所有完数。
热门推荐
gx123456sh的博客
11-03 2万+
        一个数如果恰好等于它的因子之和，这个数就称为 "完数 "。例如6=1＋2＋3.编程 找出1000以内的所有完数。 思路：首先求出一个数的所有因子            在判断这个数的所有因子之和与它本身是否相等 public class test{ public static void main(String[] args){ int i,j; ...
构造方法的定义与使用
gx123456sh的博客
10-26 1万+
构造方法（主要意义是对类中属性初始化） 构造方法的三大特征： a.构造方法名称必须与类名称相同 【1类名称】Persion   【2对象】per1  = 【3】 new  【4 构造方法】Persion（）； b.构造方法没有返回值类型声明（注意不是没有返回值） //命名不规范的普通构造 public void Person(){ System.out.println("###...
Java中的private
gx123456sh的博客
10-26 9365
private实现封装     将属性和方法用private封装后表示，被封装的属性与方法只能在本类中使用，类外部不可见。     此时要想访问被封装的属性，必须提供getter与setter方法         setter方法：主要进行属性内容的设置与修改         getter方法：主要进行属性内容的取得     类的设计原则：编写类的时候，没有额外说明，所有属性必须使用pr...
一个斐波那契数列是由数字1、1、2、3、5、8、13、21、34等等组成的，其中每一个数字(从第三个数字起)都是前两个数字的和。创建一个方法，接受一个整数参数，并显示从第一个元素开始总共由该参数指定的
gx123456sh的博客
10-26 4318
 思路：首先知道斐波那契数列中的每个数字都是前两个数字的和              其次通过递归的方法来实现（使用递归的方法一定要注意递归的跳出条件） public class Fibonacci{ public static void main(String[] args){ int n = Integer.parseInt(args[0]); //将St...
利用接口做参数，写个计算器，能完成加减乘除运算
gx123456sh的博客
11-05 3862
编程题:  利用接口做参数，写个计算器，能完成加减乘除运算。  （1）定义一个接口Compute含有一个方法int computer(int n, int m)。  （2）设计四个类分别实现此接口，完成加减乘除运算。  （3）设计一个类UseCompute，类中含有方法：public void useCom(Compute com, int one, int two)，     此方法能够用传递过...
JavaSE技术总结：基础到高级，包括注解、泛型、反射与代理
这份JavaSE笔记涵盖了从基础到高级的多个重要主题，包括JDK环境配置、类加载、流与并发、Java新特性、反射、泛型、类加载器、代理模式和AOP等，是Java学习者宝贵的参考资料。通过深入理解和实践这些知识点，开发者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

gx1500291

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值