Java 泛型的介绍和使用

最新推荐文章于 2024-03-09 19:53:38 发布
最新推荐文章于 2024-03-09 19:53:38 发布
阅读量576 收藏
点赞数
分类专栏： Java 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53064820/article/details/128625067
版权
泛型是Java中的一种特性，允许在定义集合时指定数据类型，从而约束集合内容并提高代码效率。泛型可以避免运行时类型转换，保证类型安全，例如在ArrayList<Person>中只能添加Person对象。此外，自定义泛型类可以用于创建具有特定数据类型的实例，如Customize<T>。在使用泛型时应注意，类型参数必须是引用类型，可以接受子类型作为参数。
摘要由CSDN通过智能技术生成

什么是泛型?

1.数据类型变得广泛,或者是数据类型变量化,这就是泛型.(广泛的类型).

2.有一个变量是用来存放一个数据类型,这就叫做泛型.

比如泛型T存放的是一个int 就表示为:T=int

当然T也可以是其他的数据类型,就取决我们给它数据类型.

3.泛型允许程序员在强类型程序设计语言中编写代码时使用一些以后才指定的类型，在实例化时作为参数指明这些类型。

泛型的作用

1.对集合的数据类型进行约束.

如下程序


import java.lang.reflect.Array;
import java.security.cert.CollectionCertStoreParameters;
import java.util.*;

public class Main {
    public static void main(String[] args) {

//        定义集合
        ArrayList<Person> people = new ArrayList<>();

//        添加数据
        people.add(new Person("Doch",23));

//        试图添加一个不是人的数据类型.
        people.add(new Cat("stanc",22));
        

    }
}

class Person{
    private  String name;
    private  int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return this.name+"\t"+this.age;
    }

}

class Cat{
    private String name;
    private  int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return this.name+"\t"+this.age;
    }
}

运行出错

这样就成功的限制了数据类型.

改进后


import java.lang.reflect.Array;
import java.security.cert.CollectionCertStoreParameters;
import java.util.*;

public class Main {
    public static void main(String[] args) {

//        定义集合
        ArrayList<Person> people = new ArrayList<>();

//        添加数据
        people.add(new Person("Doch",23));

//        遍历arraylist,限制了数据类型后,可以直接定义Person类型来遍历数据了.
        for(Person p :people)
        {
            System.out.println(p);
        }

    }
}

class Person{
    private  String name;
    private  int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return this.name+"\t"+this.age;
    }

}

class Cat{
    private String name;
    private  int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return this.name+"\t"+this.age;
    }
}

2.提高集合的效率.

当我们指定了集合的数据类型,在使用集合的时候就不会出现了Object类型的转换.因为数据类型已经指定了.

就比如在遍历的时候.

//没有泛型

//在输出的时候会隐藏式将Object数据类型转换成Person然后再输出。
        for(Object p :people)
        {
            System.out.println(p);
        }

有泛型

//        遍历arraylist,限制了数据类型后,可以直接定义Person类型来遍历数据了.
//        因此在遍历输出的时候就直接输出了，没必要进行数据转换。
        for(Person p :people)
        {
            System.out.println(p);
        }

例子


import java.lang.reflect.Array;
import java.security.cert.CollectionCertStoreParameters;
import java.util.*;

public class Main {
    public static void main(String[] args) {
//      定义集合
        HashSet<Student> students = new HashSet<>();
        HashMap<String, Student> studentHashMap = new HashMap<String, Student>();
//      插入集合
        students.add(new Student("chanbing",23));
        students.add(new Student("chuchu",12));
//      遍历集合
        for(Student st : students)
        {
            System.out.println(st);
        }
//      插入集合
        studentHashMap.put("first",new Student("cela",11));
        studentHashMap.put("second",new Student("dita",23));
//遍历集合
        Collection collection=studentHashMap.values();

        for (Object student: collection)
        {
            System.out.println(student);
        }

    }
}

class Student{
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

例子


import java.lang.reflect.Array;
import java.security.cert.CollectionCertStoreParameters;
import java.util.*;

public class Main {
    public static void main(String[] args) {

        ArrayList<Employee> employees = new ArrayList<>();

        MyDate myDate = new MyDate(1,1,2022);
        MyDate myDate1 = new MyDate(4,9,2023);
        MyDate myDate2 = new MyDate(11,25,2032);


        Employee employee = new Employee("Chandu",2344,myDate);
        Employee employee1 = new Employee("Jack",2334,myDate1);
        Employee employee2 = new Employee("Dister",4444,myDate2);

        employees.add(employee);
        employees.add(employee1);
        employees.add(employee2);

        employees.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee employee, Employee t1) {
                return (int)(employee.getSalary()-t1.getSalary()) ;
            }
        });



        for (Employee emp : employees)
        {
            System.out.println(emp);
        }
    }
}

class MyDate{
    private int month;
    private  int day;
    private  int year;

    public MyDate(int month ,int day,int year)
    {
        this.month=month;
        this.day=day;
        this.year=year;
    }
    public void setMonth(int month) {
        this.month = month;
    }

    public void setDay(int day) {
        this.day = day;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public int getDay() {
        return day;
    }

    public int getYear() {
        return year;
    }

    @Override
    public String toString() {
        return "MyDate{" +
                "month=" + month +
                ", day=" + day +
                ", year=" + year +
                '}';
    }
}
class Employee{
    private String name;
    private double salary;
    private MyDate birthday;

    public Employee(String name, double salary, MyDate birthday) {
        this.name = name;
        this.salary = salary;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

    public double getSalary() {
        return salary;
    }

    public MyDate getBirthday() {
        return birthday;
    }

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

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return this.name+"\t"+this.salary+"\t"+this.birthday;
    }
}

泛型编程(自定义泛型)

定义语法：

类

class Classname<Typename1,Typename2...> {

        Typename attributes;

        Constructor...

        Methods...

}

接口

interface Interfacename<Typename1,Typename2...> {

        Typename attributes;

        Constructor...

        Methods...

}

实例化语法

类

Classname<Type...> className = new Classname<Type...>(arguments)

Classname<> className = new Classname<>(arguments)

接口

Interfacename<Type...> interfaceName = new Interfacename<Type...>(arguments)

Interfacename<> interfaceName = new Interfacename<>(arguments)

如下例子：


import java.lang.reflect.Array;
import java.security.cert.CollectionCertStoreParameters;
import java.util.*;

public class Main {
    public static void main(String[] args) {

//       设置数据类型为string
        Customize<String> goodName = new Customize<>("good name");
//        输出
        System.out.println(goodName);
//        输出给定数据类型
        goodName.showType();
    }
}
//定义如下自定义数据类型的类《T》
class Customize<T> {
    //    name是一个不确定数据类型
    T name;
    //构造器
    public Customize(T name) {
        this.name = name;
    }
    //tostring
    @Override
    public String toString() {
        return "Customize{" +
                "name=" + name +
                '}';
    }
    public  void showType()
    {
        System.out.println(this.name.getClass());
    }
}

例子


import java.lang.reflect.Array;
import java.security.cert.CollectionCertStoreParameters;
import java.util.*;

public class Main {
    public static void main(String[] args) {

//    不指定数据的类型，让运行时自动推导，但是这样效率不高。
        Customize<Object> objectCustomize = new Customize<>(1234);
//      输出。
        System.out.println(objectCustomize);
//        输出给定数据类型
        objectCustomize.showTyep();
    }
}
//定义如下自定义数据类型的类《T》
class Customize<T> {
//    name是一个不确定数据类型
    T name;
//构造器
    public Customize(T name) {
        this.name = name;
    }
//tostring
    @Override
    public String toString() {
        return "Customize{" +
                "name=" + name +
                '}';
    }

//    展示数据类型。
    public void showTyep()
    {
        System.out.println(this.name.getClass());
    }

}

使用泛型的注意事项

1.指定数据的类型必须是引用类型，比如如下的这就错了。


import java.lang.reflect.Array;
import java.security.cert.CollectionCertStoreParameters;
import java.util.*;

public class Main {
    public static void main(String[] args) {
//    设置int类型
        Customize<int> customize = new Customize<int>();

    }
}
class Customize<T>{
    T attribute;

    public Customize(T attribute) {
        this.attribute = attribute;
    }
}

改正后


import java.lang.reflect.Array;
import java.security.cert.CollectionCertStoreParameters;
import java.util.*;

public class Main {
    public static void main(String[] args) {
//    现在设置成了 Integer 数据类型.
        Customize<Integer> customize = new Customize<Integer>(232);

    }
}
class Customize<T>{
    T attribute;

    public Customize(T attribute) {
        this.attribute = attribute;
    }
}

2.如果指定了数据类型，也可以传入其子类型。

如


import java.lang.reflect.Array;
import java.security.cert.CollectionCertStoreParameters;
import java.util.*;

public class Main {
    public static void main(String[] args) {
//        正确，传入的是A（）
        Customize<A> aCustomize = new Customize<A>(new A());
//        正确，传入的是A（）的子类
        Customize<A> aCustomize1 = new Customize<A>(new B());

//        输出运行是类型
        aCustomize.showType();
        aCustomize1.showType();

    }
}
class Customize<T>{
    T attribute;

    public Customize(T attribute) {
        this.attribute = attribute;
    }

    public void showType()
    {
        System.out.println(attribute.getClass());
    }
}

class A {

}

class B extends A{

}

3.如果没有指定数据类型,默认的就是Object数据类型.


import java.lang.reflect.Array;
import java.security.cert.CollectionCertStoreParameters;
import java.util.*;

public class Main {
    public static void main(String[] args) {

        Customize aCustomize = new Customize();

//        等价于
        Customize<Object> objectCustomize = new Customize<>();
        

    }
}
class Customize<T>{
    T attribute;

    public Customize(){};

    public Customize(T attribute) {
        this.attribute = attribute;
    }

    public void showType()
    {
        System.out.println(attribute.getClass());
    }
}

LIVE_Windstorm
关注
专栏目录
【Java基础知识 39】Java泛型方法的定义和使用
学Java，找哪吒
11-21 1万+
Java泛型是J2 SE1.5中引入的一个新特性，其本质是参数化类型，也就是说所操作的数据类型被指定为一个参数（type parameter）这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。
Java泛型<T> T与T的使用方法详解
08-18
主要介绍了Java泛型 T与T的使用方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java--泛型T
qq_42796306的博客
07-04 781
在上面的示例中，我们定义了一个名为 ExampleClass 的泛型类，使用 T 作为类型参数。在 main 方法中，我们创建了两个 ExampleClass 的实例，一个使用 String 作为 T 的具体类型参数，另一个使用 Integer。当我们定义一个泛型类、接口或方法时，可以使用 T 作为类型参数来表示一个未知的类型。在使用时，我们可以将具体的类型传递给 T ，以实现类型的参数化。通用类型参数允许我们在类、接口或方法中定义一个占位符类型，以便在实际使用时确定具体的类型。
夯实JAVA基本之一 —— 泛型详解(1):基本使用
热门推荐
启舰
11-16 2万+
前言：无论何时，相信自己。 相关文章： 1、《夯实JAVA基本之一 —— 泛型详解(1):基本使用》 2、《夯实JAVA基本之一——泛型详解(2)：高级进阶》 3、《夯实JAVA基本之二 —— 反射（1）：基本类周边信息获取》 4、《夯实JAVA基本之二 —— 反射（2）：泛型相关周边信息获取》 5、《夯实JAVA基本之二 —— 反射（3）：类内部信息获取》 一、引入 ...
Java泛型 ＜T＞ T、 T、＜T＞的用法
qq_27480007的博客
05-29 2752
Java泛型 ＜T＞ T、 T、＜T＞的用法
Java里的泛型＜T＞ T 的运用
最新发布
sundawei2016的博客
03-09 369
因为我总是写一些CRUD的代码，泛型的知识都忘得差不多了，今天特地来写一下。如果方法返回的是空的话，需要在public 和 void 之间加上 <T>在类的名称后面加上 <T>，构建类的时候在<>里写明类型。泛型可以认为是 把类型参数化，方便代码重用。我有两个数组，写一个方法得到最后的一个元素。
详谈Java泛型中T和问号(通配符)的区别
08-28
Java泛型中T和问号(通配符)的...Java泛型中T和问号(通配符)的区别在于它们的使用场景和含义。T是泛型类型参数的代表，而问号(通配符)是泛型类型参数的占位符。正确地使用T和问号(通配符)可以提高代码的重用率和安全性。
Java泛型的使用限制实例分析
08-25
Java泛型的使用限制是Java编程语言中的一個重要概念，泛型的使用可以提高代码的可读性和安全性，但是需要注意一些使用限制，否则可能会出现编译错误或运行时异常。 首先， Java泛型不能用于静态成员变量的定义，...
JAVA中的泛型,以及什么时候使用泛型
weixin_42947972的博客
11-18 4828
泛型: jdk1.5出现的安全机制. 好处: 1.将运行时期的问题ClassCastException转到编译时期. 2.避免了强制类转换的麻烦 不是泛型的例子: import java.util.ArrayList; public class Demo { public static void main(String[] args) { ArrayList ...
什么时候用java泛型_Java泛型何时在运行时使用转换？
weixin_42112658的博客
02-27 142
这是我写的一个简短的程序：public class Test {public T contents;public Test(T item) {contents = item;}public static void main(String[] args) {Test t = new Test("hello");System.out.println(t.contents);}}尝试用javac编译它,...
java 泛型t和,Java泛型 - 何时使用“T”和“？”
weixin_29029145的博客
02-12 117
What is the difference?public class MyClass extends MySuperClass> {private T data ;private MyClass extends MySuperClass> parent ;}andpublic class MyClass {private T data ;// the below line - no ...
java 什么时候用t_什么时候Java泛型需要<？延伸T>而不是,有任何不利的切换？
weixin_39783857的博客
02-24 349
给出以下示例(使用JUnit与Hamcrest匹配器)：Map> expected = null;Map> result = null;assertThat(result, is(expected));这不会使用JUnit assertThat方法签名来编译：public static void assertThat(T actual, Matcher matcher)编译器错误消息...
java t的使用_java中的t怎么用
weixin_36073697的博客
02-15 1253
T表示返回值是一个泛型，传递啥，就返回啥类型的数据，而单独的T就是表示限制你传递的参数类型，这个案例中，通过一个泛型的返回方式，获取每一个集合中的第一个数据， 通过返回值 T 和T的两种方法实现。T 用法返回值，直接写T表示限制参数的类型，这种方法一般多用于共同操作一个类对象，然后获取里面的集合信息啥的。public class Demo2 {public static void main(St...
java中什么时候不能用泛型_java中泛型的正确使用姿势
weixin_39602569的博客
02-25 274
image.png泛型是Java中一个非常重要的知识点，在Java集合类框架中泛型被广泛应用。利用好泛型，在系统架构中是一把利器。泛型类先看一个例子，restful架构中，需要定义api接口返回结构，定义如下：package com.company.project.core;import com.alibaba.fastjson.JSON;/*** 统一API响应结果封装*/public clas...
Java中的T怎么用
UtdPatch的博客
09-27 455
在上面的代码中，我们定义了一个名为MyGenericInterface的泛型接口，它使用T作为泛型类型参数。在这里，我们分别创建了一个MyGenericClass对象，一个使用整数类型，一个使用字符串类型。在上面的代码中，我们定义了一个名为MyGenericClass的泛型类，它使用T作为泛型类型参数。它允许我们编写通用的代码，适用于不同类型的数据，而不需要为每种类型都编写重复的代码。在上面的代码中，我们定义了一个名为printArray的泛型方法，它接受一个T类型的数组作为参数，并打印数组中的每个元素。
Java基础学习——第十二章 泛型
weixin_47392089的博客
04-11 500
Java基础学习——第十二章 泛型 一、泛型的概念 1. 泛型的设计背景 集合容器类在声明阶段无法确定实际存储的是什么类型的对象，故JDK5.0之前只能把元素类型声明为Object JDK1.5之后使用泛型来解决：由于此时除了元素的类型不确定之外，其他的部分都是确定的， 例如关于这个元素如何保存， 如何管理等。因此把元素的类型设计成一个参数， 这种参数化类型的概念就是泛型 Collection<E>， List<E>， ArrayList<E> 中的<E>
什么是Java泛型？泛型在Java中应用场景
2301_77899321的博客
01-15 1592
Java泛型是一种在编译时进行类型检查和类型安全的机制。它允许编写能够操作多种类型的代码，而不需要进行类型转换或使用Object类型。通过在定义类、接口或方法时使用泛型参数，可以使代码更加灵活、可重用和类型安全。
Java泛型详解：使用与优势
以上内容展示了Java泛型的基本使用和重要性，通过泛型，我们可以编写更加灵活且类型安全的代码，提高代码的可读性和可维护性。在实际开发中，熟练掌握和应用泛型是每个Java开发者必备的技能之一。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值