泛型

最新推荐文章于 2023-12-23 19:39:51 发布
最新推荐文章于 2023-12-23 19:39:51 发布
阅读量318 收藏
点赞数
文章标签： string class object fun integer interface
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luobiaogod/article/details/6493491
版权

·泛型类：在jdk1.5之后提供了支持泛型的技术，也是java的一个新特性。
      ·掌握泛型的基本操作·掌握泛型的通配符作用·掌握泛型接口和泛型方法的使用
 
 泛型类的引入：要求设计一个可以表示坐标的类（X,Y)，但是此类坐标可以同时满

足一下要求1）x=10、y=100；2）x=10.3、y=50.2；3）x=“东京180度”、y=“北纬310度”

。这个坐标该怎么设计？
 现在有3种类型的数据，int、float、String。
 int->Integer->Object;flaot->Float->Object;String->Object;
代码：
package org.demo;
class Point{
 private Object x;
 private Object y;
 public Object getX() {
  return x;
 }
 public Object getY() {
  return y;
 }
 public void setX(Object x) {
  this.x = x;
 }
 public void setY(Object y) {
  this.y = y;
 }
}

package org.demo;
public class GenDemo01 {
 public static void main(String args[]){
  Point p=new Point();
  p.setX(11);
  p.setY(20);
  int x=(Integer)p.getX();
  int y=(Integer)p.getY();
  System.out.println(x);
  System.out.println(y);
 }
}
该代码可以完成以上功能，但是存在一个问题，所有数据类型都可以被接受，程序的入口就

显得不那么规范了，而且存在安全漏洞。这就可以通过泛型来完成->此技术的最大特点就是

类中的属性的类型可以哟外部决定，而且生命类的时候应该采用如下形式：
class 类名称<泛型类型，泛型类型...>{

}
以上Point类可用泛型类：
package org.demo02;
class Point<T>{
 private T x;
 private T y;
 public T getX() {
  return x;
 }
 public T getY() {
  return y;
 }
 public void setX(T x) {
  this.x = x;
 }
 public void setY(T y) {
  this.y = y;
 }
}
可以发现一切的操作类型此时都不再有程序固定设置，而是由实例化对象时在外部进行指定

。
package org.demo02;
public class GenDemo05 {
 public static void main(String args[]){
  Point<String> p=new Point<String>();
  p.setX("东经22度");
  p.setY("西经33度");
  String x=p.getX();
  String y=p.getY();
  System.out.println(x);
  System.out.println(y);
 }
}
此时在使用Point类是只需加入属性声明即可，而且加入属性之后再取出属性的时候变得非

常容易。不用再使用向下转型。

·使用泛型的注意点：
 在使用泛型操作的时候，实际上有很多小的注意点，例如：构造方法上依然可以使

用泛型或者有一种称为泛型的擦除。
 在构造方法上应用泛型：
package org.demo03;
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 T getY() {
  return y;
 }
 public void setX(T x) {
  this.x = x;
 }
 public void setY(T y) {
  this.y = y;
 }
}

package org.demo03;
public class GenDemo07 {
 public static void main(String args[]){
  Point<String> p=new Point<String>("East","West");
  String x=p.getX();
  String y=p.getY();
  System.out.println(x);
  System.out.println(y);
 }
}

·擦除泛型：如果在使用的时候没有指定泛型的话，则表示擦除泛型。
 泛型一旦擦除，将按照Object进行接收，以保证程序不出现错误。
package org.demo03;
public class GenDemo08 {
 public static void main(String args[]){
  Point p=new Point("East","West");//两个字符串按Object类型接收；
      //此句存在警告信息；
  String x=(String)p.getX();
  String y=(String)p.getY();
  System.out.println(x);
  System.out.println(y);
 }
}
可以通过<Object>进行消除警告信息：Point<Object> p=nw Point<Object>();但是多余（

脱了裤子放屁，多次一举了），而且有些搞笑。一般开发中泛型没必要擦除。

·通配符：
 在泛型的操作中通配符使用较多，而且在日后的系统类库中有很多地方都要使用这

些操作。例如：
public class Test {
 public static void main(String[] args) {
  Object obj="hello";
 }
}
以上代码实际上表示向上转型操作，因为String是Object的子类，但是在泛型中却没有此概

念。

·？：
 在进行对象转型的时候可以使用自动的向上转型，但是在使用泛型的时候却没有此

操作。
package org.demo04;
class Point<T>{
 private T x;
 private T y;
 public T getX() {
  return x;
 }
 public T getY() {
  return y;
 }
 public void setX(T x) {
  this.x = x;
 }
 public void setY(T y) {
  this.y = y;
 }
}

package org.demo04;
public class GenDemo09 {
 public static void main(String args[]){
  Point<Object> p1=new Point<Object>();
  Point<String> p2=new Point<String>();
  p1=p2;//此时无法转换，出现错误
 }
}
为什么不能转换呢，实际实际上此时 的程序已经不完全属于对象的转型操作了，属于一个

大的类型和一个小的类型的划分。
    例如：将“Point<Object> p1=new Point<Object>();”表示整个商场的全部商品，

“Point<String> p2=new Point<String>();”表示每一个顾客购买的商品。如果现在执行

“p1=p2”，那就意味着本顾客购买的商品就是整个商场的全部商品，这样可定说不通，所

以不能接收。
 不能使用以上的方式接收最大的影响在于方法的参数接受上，例如：
package org.demo04;

public class GenDemo10 {
 public static void main(String args[]){
  Point<Object> p1=new Point<Object>();
  Point<String> p2=new Point<String>();
  fun(p1);
  fun(p2);
 }
 public static void fun(Point po){//出现警告信息，如果用Point<Object>有会 

  //不能接收String类型,那么可以使用<?>：表示可以接受任意类型泛型。
  System.out.println(po.getX());
  System.out.println(po.getY());
 }
}
程序中的"?"表述可以接收任意泛型类型，但是只是接受和输出，并不能修改。

·泛型的上限：
 上限就是一个泛型的最大操作父类，例如，现在最大的上限设置为“Number”类型

，那么此时，又有能够接受的类型只能是Number及其子类（Intege）。
泛型上限设置通过一下语法完成：? extends 类;
例如：在Point类中只能设置数字的坐标；
class Point<T extends Number>{//无法接受字符串
 private T x;
 private T y;
 public T getX() {
  return x;
 }
 public T getY() {
  return y;
 }
 public void setX(T x) {
  this.x = x;
 }
 public void setY(T y) {
  this.y = y;
 }
}

public class GenDemo11 {
 public static void main(String args[]){
  Point<Integer> p1=new Point<Integer>();
  Point<Float> p2=new Point<Float>();
  //Point<String> p3=new Point<String>();出现错误，只能接受数字
 }
}

泛型的上限也可以在方法中使用：
package org.demo05;

public class GenDemo10 {
 public static void main(String args[]){
  Point<Float> p2=new Point<Float>();
  fun(p2);
 }
 public static void fun(Point<? extends Number> po){
  System.out.println(po.getX());
  System.out.println(po.getY());
 }
}
·泛型下限：泛型的下限是指只能设置其具体的类或者父类。即设置其最小的类型
 设置语法如下: ? super 类；
例如：定义一个方法，此方法只能接受String或Object类型的泛型对象。

package org.demo06;
class Point<T>{//还是以此类为例，标准泛型
 private T x;
 private T y;
 public T getX() {
  return x;
 }
 public T getY() {
  return y;
 }
 public void setX(T x) {
  this.x = x;
 }
 public void setY(T y) {
  this.y = y;
 }
}

package org.demo06;
public class GenDemo12 {
 public static void main(String args[]){
  Point<String>p1=new Point<String>();
  Point<Object>p2=new Point<Object>();
  fun(p1);
  fun(p2);
 }
 public static void fun(Point<? super String> po){//方法中设置泛型下限,最 

    //小不能小于String，最大不能大于Object；
  System.out.println(po.getX());
  System.out.println(po.getY());
 }
}

·泛型接口：与泛型类类似。语法：interface 接口名称<泛型类型...>
package org.demo07;

public interface Demo<T> {
 public void print(T param);
}
可以有两种实现方法：
方法一：package org.demo07;
public class DemoIm01<T> implements Demo<T> {
 public void print(T param) {
  System.out.println("param="+param);  
 }
}
测试：package org.demo07;
public class TestDemo {
 public static void main(String args[]){
  Demo<String> demo=new DemoIm01<String>();
  demo.print("heel");
 }
}

方法二：package org.demo07;
public class DemoIm01 implements Demo<DemoIm01> {
 public void print(DemoIm01 param) {
  System.out.println("param="+param);  
 }
}
测试：package org.demo07;
public class TestDemo {
 public static void main(String args[]){
  Demo<DemoIm01> demo=new DemoIm01();
  demo.print(new DemoIm01());
 }
}

·泛型方法：泛型除了在类中定义外，还可以在方法中定义，而且在方法上使用泛型，此方

法所在的类不一定是泛型操作。
例一：package org.demo08;
public class Demo {
 public <T>T print(T param){
  return param;
  }
}
package org.demo08;
public class GenDemo12 {
 public static void main(String args[]){
  Demo d=new Demo();
  System.out.println(d.print("hello"));
  System.out.println(d.print(2));
 }
}
例二：package org.demo08;
public class GenDemo13 {
 public static void main(String args[]) {
  Integer s[]=fun(1,2,3,4,5,6,654);
  for(int x:s)
   System.out.println(x);
 }

 public static <T> T[] fun(T ...param) {
  return param;

 }
}
·泛型的嵌套设置：

luobiaogod
关注
golang泛型
Jcduhdt的博客
04-03 7326
泛型 go1.18版本开始支持 在函数上使用[T 支持的类型] 表示泛型，比如 func AddSum[T int|float64](params ...T)(sum T){ // 一些操作 return sum } 自带泛型： any 表示任何类型，即interface comparable 表示可以被比较的类型 comparable is an interface that is implemented by all comparable types (booleans, numbers,
Java泛型使用
12-22
Java泛型是Java编程语言中一个强大的特性，它允许开发者在编写代码时声明类型参数，从而增强了代码的灵活性和安全性。泛型的引入主要是为了解决代码复用和类型安全问题，避免在运行时出现类型转换异常...
Java 中的泛型（两万字超全详解）
林二月的博客
08-02 6万+
博主将用 CSDN 记录 Java 后端开发学习之路上的经验，并将自己整理的编程经验和知识分享出来，希望能帮助到有需要的小伙伴。博主也希望和一直在坚持努力学习的小伙伴们共勉！唯有努力钻研，多思考勤动手，方能在编程道路上行至所向。由于博主技术知识有限，博文中难免会有出错的地方，还望各位大佬包涵并批评指正，博主会及时改正；如果本文对小伙伴你有帮助的话，求求给博主一个赞支持一下，可以一起交流，一起加油！！Java泛型详解，史上最全图文详解java 泛型全解 - 绝对最详细Java 泛型，你了解类型擦除吗。
Java泛型
BroRiver
03-26 1169
泛型是一种在编译时实现类型安全的特性，它使得我们可以编写通用的代码，以适用于不同类型的数据。
Golang 泛型实现原理
Dablelv 的博客专栏。
12-23 2231
泛型（Generics）是 Go 语言在较早版本缺失的一个特性，直到 Go 1.18 版本中才引入了泛型。泛型提供了一种更灵活、更通用的方式来编写函数和数据结构，以处理不同类型的数据，而不必针对每种类型编写重复的代码。
java 泛型
Misszhoudandan的博客
06-10 1387
泛型就是将数据类型参数化，例如我们实现一个存储对象的容器时，并不是直接定义好只能存储一种类型，好的办法就是定义时将类型参数化，也就是泛型，在真实使用时再传入真正的参数，这种参数化类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
java 泛型详解-绝对是对泛型方法讲解最详细的，没有之一
热门推荐
s10461的博客
12-30 60万+
对java的泛型特性的了解仅限于表面的浅浅一层，直到在学习设计模式时发现有不了解的用法，才想起详细的记录一下。 本文参考java 泛型详解、Java中的泛型方法、 java泛型详解 1. 概述泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。什么是泛型？为什么要使用泛型？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传
Java泛型大全
weixin_45203607的博客
10-02 4268
Java泛型大全 1. 概述 泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。 什么是泛型？为什么要使用泛型？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法形参，然后调用此方法时 传递的 实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制
Java泛型入门篇: 泛型类、泛型接口以及泛型方法
笔墨的专栏
11-18 2780
专栏文章导航 Java泛型入门篇: 泛型类、泛型接口以及泛型方法 Java泛型进阶篇: 无界通配符、上界通配符以及下界通配符 Java泛型原理篇: 类型擦除以及桥接方法 文章目录前言1. 什么是泛型2. 泛型的使用泛型类使用方法泛型类继承泛型接口使用方法泛型接口实现类泛型方法使用方法静态泛型方法所属类为泛型类/泛型接口 前言     我们在平时的开发当中基本上无时无刻都在使用泛型，尤其是涉及到集合、多态或自定义类的场景，可以说是泛型是一个十分重要的特性。但包括我在内的大多数人，对泛型的掌握不够深刻，.
Java 泛型
xiaoguangtouqiang的博客
05-26 1160
泛型包括泛型类，泛型接口和泛型方法
Java泛型定义与用法实例详解
08-27
Java泛型定义与用法实例详解 Java泛型是Java语言中的一种重要机制，用于在编译期检查类型安全，避免在运行期引发ClassCastException。泛型的引入使得Java语言更加灵活和强大，本文将详细介绍Java泛型的定义、原理、...
java泛型总结
04-09
深入理解java泛型，包括类名泛型的定义，方法泛型定义，泛型的返回
24泛型
01-07
1.泛型 scala中的泛型可以作用在类,方法和函数上,泛型本身占位符没有任何意义。 只有当传入数据类型或参数时,当前的占位符才会有意义。 2.界定 在指定泛型时,可以对泛型进行范围界定,指定类型,而不是让其随意传入一...
详细介绍C# 泛型
01-19
在C#开发中，必不可少的要用到泛型。泛型是.NET2.0版本就有的，它广泛应用于C#框架中容器的使用中。下面我们来详细介绍一下。 　一、泛型的主要优势 　1.性能更高。 　2.类型更安全。 　3.代码更多的重用和扩展性。 ...
飞机大战系列 Space War1.0（免费，开源）
07-14
飞机大战系列 Space War1.0（免费，开源）
基于Hadoop的文件词频统计的实现（大数据技术课程设计）
07-14
使用Hadoop大数据架构体系中的HDFS、HBase以及Spark软件，完成大数据处理的典型案例：文件词频统计的实现。
湖科大计算机网络视频笔记，跟着视频系统学了一遍的记录
最新发布
07-14
视频链接：https://www.bilibili.com/video/BV1c4411d7jb/，适用于考研后期查缺补漏和前期确定复习方向、期末考和课前预习。做成PDF形式便于查阅和在iPad上查看。
matlab下载，表面张力，main.m
07-14
matlab下载，表面张力，main.m

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值