Java 泛型的介绍和使用

最新推荐文章于 2024-03-09 19:53:38 发布
最新推荐文章于 2024-03-09 19:53:38 发布
阅读量556 收藏
点赞数
分类专栏： Java 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53064820/article/details/128625067
版权

什么是泛型?

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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java泛型<T> T与T的使用方法详解
08-18
主要介绍了Java泛型 T与T的使用方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java--泛型T
qq_42796306的博客
07-04 709
在上面的示例中，我们定义了一个名为 ExampleClass 的泛型类，使用 T 作为类型参数。在 main 方法中，我们创建了两个 ExampleClass 的实例，一个使用 String 作为 T 的具体类型参数，另一个使用 Integer。当我们定义一个泛型类、接口或方法时，可以使用 T 作为类型参数来表示一个未知的类型。在使用时，我们可以将具体的类型传递给 T ，以实现类型的参数化。通用类型参数允许我们在类、接口或方法中定义一个占位符类型，以便在实际使用时确定具体的类型。
Java泛型 ＜T＞ T、 T、＜T＞的用法
qq_27480007的博客
05-29 2220
Java泛型 ＜T＞ T、 T、＜T＞的用法
Java里的泛型＜T＞ T 的运用
最新发布
sundawei2016的博客
03-09 322
因为我总是写一些CRUD的代码，泛型的知识都忘得差不多了，今天特地来写一下。如果方法返回的是空的话，需要在public 和 void 之间加上 <T>在类的名称后面加上 <T>，构建类的时候在<>里写明类型。泛型可以认为是 把类型参数化，方便代码重用。我有两个数组，写一个方法得到最后的一个元素。
JAVA中的泛型,以及什么时候使用泛型
weixin_42947972的博客
11-18 4734
泛型: jdk1.5出现的安全机制. 好处: 1.将运行时期的问题ClassCastException转到编译时期. 2.避免了强制类转换的麻烦 不是泛型的例子: import java.util.ArrayList; public class Demo { public static void main(String[] args) { ArrayList ...
Java泛型的使用限制实例分析
08-25
Java泛型的使用限制是Java编程语言中的一個重要概念，泛型的使用可以提高代码的可读性和安全性，但是需要注意一些使用限制，否则可能会出现编译错误或运行时异常。 首先， Java泛型不能用于静态成员变量的定义，...
Java泛型和Class类用法示例
08-25
Java泛型和Class类用法示例主要介绍了Java泛型和Class类用法，结合实例形式分析了java使用泛型限制class类避免强制类型转换相关操作技巧。本文将从以下几个方面详细讲解Java泛型和Class类用法。 泛型的概念 泛型...
详细分析Java 泛型的使用
08-18
本文将深入探讨Java泛型的使用，帮助开发者更好地理解和应用泛型。 1. **泛型的引入原因** 在没有泛型的情况下，集合类中的元素被视为`Object`类型，这意味着存储和取出数据时必须进行类型转换。这种转换可能导致`...
java泛型类的定义与使用详解
08-27
在本文中，我们将详细介绍java泛型类的定义与使用，包括泛型类的定义、泛型类的使用、泛型类的优点和泛型类的应用场景。 泛型类的定义 泛型类是一种特殊类型，它可以在编写类时使用类型参数来表示未知的类型。泛型...
Java泛型的继承和实现操作示例
08-25
Java泛型的继承和实现操作示例主要介绍了Java泛型的继承和实现操作，结合实例形式分析了Java泛型类的继承以及泛型接口的实现相关操作技巧。 一、泛型类的继承 在Java中，泛型类可以被继承，子类可以继承父类的泛型...
什么时候用java泛型_Java泛型何时在运行时使用转换？
weixin_42112658的博客
02-27 126
这是我写的一个简短的程序：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 102
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 339
给出以下示例(使用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 1201
T表示返回值是一个泛型，传递啥，就返回啥类型的数据，而单独的T就是表示限制你传递的参数类型，这个案例中，通过一个泛型的返回方式，获取每一个集合中的第一个数据， 通过返回值 T 和T的两种方法实现。T 用法返回值，直接写T表示限制参数的类型，这种方法一般多用于共同操作一个类对象，然后获取里面的集合信息啥的。public class Demo2 {public static void main(St...
java中什么时候不能用泛型_java中泛型的正确使用姿势
weixin_39602569的博客
02-25 251
image.png泛型是Java中一个非常重要的知识点，在Java集合类框架中泛型被广泛应用。利用好泛型，在系统架构中是一把利器。泛型类先看一个例子，restful架构中，需要定义api接口返回结构，定义如下：package com.company.project.core;import com.alibaba.fastjson.JSON;/*** 统一API响应结果封装*/public clas...
Java基础学习——第十二章 泛型
weixin_47392089的博客
04-11 354
Java基础学习——第十二章 泛型 一、泛型的概念 1. 泛型的设计背景 集合容器类在声明阶段无法确定实际存储的是什么类型的对象，故JDK5.0之前只能把元素类型声明为Object JDK1.5之后使用泛型来解决：由于此时除了元素的类型不确定之外，其他的部分都是确定的， 例如关于这个元素如何保存， 如何管理等。因此把元素的类型设计成一个参数， 这种参数化类型的概念就是泛型 Collection<E>， List<E>， ArrayList<E> 中的<E>
Java --- 泛型 ＜T＞ 的使用介绍 之 泛型类
yuanchenglong的博客
06-28 1800
    Java的面向对象，灵活度很大。开发中当不确定某个类的某属性类型时候，可先定义为泛型，实例化该类的时候再具体指明其类型，是非常方便的。今天跟着小编一起看看泛型类怎么操作的吧。...
java 泛型 t 用法_java 泛型T的使用
weixin_30951271的博客
02-19 576
1.设计背景 ，有common ，web，mgr 三个模块，cmomon做共有模块，web 作为app 的组件，mgr作为后管，在common模块 发起调用接口调用，但是common 模块不能引入web模块的bean 。为了使用面向对象编程，可以把web组件的bean 作为一个属性，传入到common组件的Bean 中代码如下：1.泛型的抽象类package com.qimh.springboot...
JAVA使用泛型存放两种集合_Java基础之集合与泛型
weixin_40001309的博客
03-08 893
一、集合概述当我们在使用java进行编程开发时，经常会遇到一些需要集中存放的多个数据，这时我们可以选择“数组”或者“集合”，关于数组的知识可以参考上一篇文章，今天我们主要讲集合的使用。集合和数组既然都是容器，它们有什么区别呢？1、数组长度固定，集合长度可变。数组是静态的，一个数组实例具有固定的大小，一旦创建了就无法改变容量了，而且生命周期也是不能改变的，还有数组也会做边界检查，如果发现有越界现象，...
Java泛型与集合深度解析
"Java泛型和集合" Java泛型是Java编程语言中的一种特性，它允许程序员在定义类、接口和方法时指定参数类型。这一特性引入于Java 5.0，大大增强了代码的类型安全性和可读性，减少了运行时的类型检查和强制类型转换。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值