全面总结Java泛型

最新推荐文章于 2023-11-22 22:11:38 发布
最新推荐文章于 2023-11-22 22:11:38 发布
阅读量750 收藏
点赞数
分类专栏： java学习笔记

本文对Java泛型进行了全面的总结。文章内容包括普通泛型、通配符、受限泛型、泛型接口、泛型方法、返回泛型类型实例等等。

虽然Scala创始人Martin Odersky说当年正是因为Java泛型的丑陋，所以才想到要创建一个新的语言，不过这仍然不妨碍我们学习Java泛型。毕竟即使听说Java泛型不好用，但好不好用还是得会用了才知道。下面是一些有关Java泛型的总结：

普通泛型

class Point<T> { // 此处可以随便写标识符号，T是type的简称
	private T var; // var的类型由T指定，即：由外部指定

	public T getVar() { // 返回值的类型由外部决定
		return var;
	}

	public void setVar(T var) { // 设置的类型也由外部决定
		this.var = var;
	}
};

public class GenericsDemo06 {
	public static void main(String args[]) {
		Point<String> p = new Point<String>(); // 里面的var类型为String类型
		p.setVar("it"); // 设置字符串
		System.out.println(p.getVar()); // 取得字符串的长度

	}
};

======================================================================================

class Notepad<K, V> {// 此处指定了两个泛型类型
	private K key; // 此变量的类型由外部决定
	private V value; // 此变量的类型由外部决定

	public K getKey() {
		return this.key;
	}

	public V getValue() {
		return this.value;
	}

	public void setKey(K key) {
		this.key = key;
	}

	public void setValue(V value) {
		this.value = value;
	}
};

public class GenericsDemo09 {
	public static void main(String args[]) {
		Notepad<String, Integer> t = null; // 定义两个泛型类型的对象
		t = new Notepad<String, Integer>(); // 里面的key为String，value为Integer
		t.setKey("汤姆"); // 设置第一个内容
		t.setValue(20); // 设置第二个内容
		System.out.print("姓名；" + t.getKey()); // 取得信息
		System.out.print("，年龄；" + t.getValue()); // 取得信息

	}
};

通配符


    class Info< T>{  
     private T var ;  // 定义泛型变量  
     public void setVar(T var){  
      this.var = var ;  
     }  
     public T getVar(){  
      return this.var ;  
     }  
     public String toString(){ // 直接打印  
      return this.var.toString() ;  
     }  
    };  
    public class GenericsDemo14{  
     public static void main(String args[]){  
      Info< String> i = new Info< String>() ;  // 使用String为泛型类型  
      i.setVar("it") ;       // 设置内容  
      fun(i) ;  
     }  
     public static void fun(Info< ?> temp){  // 可以接收任意的泛型对象  
      System.out.println("内容：" + temp) ;  
     }  
    };

受限泛型 


class Info<T> {
	private T var; // 定义泛型变量

	public void setVar(T var) {
		this.var = var;
	}

	public T getVar() {
		return this.var;
	}

	public String toString() { // 直接打印
		return this.var.toString();
	}
};

public class GenericsDemo17 {
	public static void main(String args[]) {
		Info<Integer> i1 = new Info<Integer>(); // 声明Integer的泛型对象
		Info<Float> i2 = new Info<Float>(); // 声明Float的泛型对象
		i1.setVar(30); // 设置整数，自动装箱
		i2.setVar(30.1f); // 设置小数，自动装箱
		fun(i1);
		fun(i2);
	}

	public static void fun(Info<? extends Number> temp) { // 只能接收Number及其Number的子类
		System.out.print(temp + "、");
	}
};

=============================================================================================

class Info<T> {
	private T var; // 定义泛型变量

	public void setVar(T var) {
		this.var = var;
	}

	public T getVar() {
		return this.var;
	}

	public String toString() { // 直接打印
		return this.var.toString();
	}
};

public class GenericsDemo21 {
	public static void main(String args[]) {
		Info<String> i1 = new Info<String>(); // 声明String的泛型对象
		Info<Object> i2 = new Info<Object>(); // 声明Object的泛型对象
		i1.setVar("hello");
		i2.setVar(new Object());
		fun(i1);
		fun(i2);
	}

	public static void fun(Info<? super String> temp) { // 只能接收String或Object类型的泛型
		System.out.print(temp + "、");
	}
};
Java泛型无法向上转型 

class Info<T> {
	private T var; // 定义泛型变量

	public void setVar(T var) {
		this.var = var;
	}

	public T getVar() {
		return this.var;
	}

	public String toString() { // 直接打印
		return this.var.toString();
	}
};

public class GenericsDemo21 {
	public static void main(String args[]) {
		Info<String> i1 = new Info<String>(); // 泛型类型为String
		Info<Object> i2 = null;
		i2 = i1; // 这句会出错 incompatible types
	}
};
Java泛型接口 

interface Info<T> { // 在接口上定义泛型
	public T getVar(); // 定义抽象方法，抽象方法的返回值就是泛型类型
}

class InfoImpl<T> implements Info<T> { // 定义泛型接口的子类
	private T var; // 定义属性

	public InfoImpl(T var) { // 通过构造方法设置属性内容
		this.setVar(var);
	}

	public void setVar(T var) {
		this.var = var;
	}

	public T getVar() {
		return this.var;
	}
};

public class GenericsDemo24 {
	public static void main(String arsg[]) {
		Info<String> i = null; // 声明接口对象
		i = new InfoImpl<String>("汤姆"); // 通过子类实例化对象
		System.out.println("内容：" + i.getVar());
	}
};
================================================================================ 

interface Info<T> { // 在接口上定义泛型
	public T getVar(); // 定义抽象方法，抽象方法的返回值就是泛型类型
}

class InfoImpl implements Info<String> { // 定义泛型接口的子类
	private String var; // 定义属性

	public InfoImpl(String var) { // 通过构造方法设置属性内容
		this.setVar(var);
	}

	public void setVar(String var) {
		this.var = var;
	}

	public String getVar() {
		return this.var;
	}
};

public class GenericsDemo25 {
	public static void main(String arsg[]) {
		Info i = null; // 声明接口对象
		i = new InfoImpl("汤姆"); // 通过子类实例化对象
		System.out.println("内容：" + i.getVar());
	}
};
Java泛型方法 

class Demo {
	public <T> T fun(T t) { // 可以接收任意类型的数据
		return t; // 直接把参数返回
	}
};

public class GenericsDemo26 {
	public static void main(String args[]) {
		Demo d = new Demo(); // 实例化Demo对象
		String str = d.fun("汤姆"); // 传递字符串
		int i = d.fun(30); // 传递数字，自动装箱
		System.out.println(str); // 输出内容
		System.out.println(i); // 输出内容
	}
};

通过泛型方法返回泛型类型实例 

class Info<T extends Number> { // 指定上限，只能是数字类型
	private T var; // 此类型由外部决定

	public T getVar() {
		return this.var;
	}

	public void setVar(T var) {
		this.var = var;
	}

	public String toString() { // 覆写Object类中的toString()方法
		return this.var.toString();
	}
};

public class GenericsDemo27 {
	public static void main(String args[]) {
		Info<Integer> i = fun(30);
		System.out.println(i.getVar());
	}

	public static <T extends Number> Info<T> fun(T param) {// 方法中传入或返回的泛型类型由调用方法时所设置的参数类型决定
		Info<T> temp = new Info<T>(); // 根据传入的数据类型实例化Info
		temp.setVar(param); // 将传递的内容设置到Info对象的var属性之中
		return temp; // 返回实例化对象
	}
};

使用泛型统一传入的参数类型 
class Info<T> { 
	private T var; // 此类型由外部决定

	public T getVar() {
		return this.var;
	}

	public void setVar(T var) {
		this.var = var;
	}

	public String toString() { // 覆写Object类中的toString()方法
		return this.var.toString();
	}
};

public class GenericsDemo28 {
	public static void main(String args[]) {
		Info<String> i1 = new Info<String>();
		Info<String> i2 = new Info<String>();
		i1.setVar("HELLO"); // 设置内容
		i2.setVar("汤姆"); // 设置内容
		add(i1, i2);
	}

	public static <T> void add(Info<T> i1, Info<T> i2) {
		System.out.println(i1.getVar() + " " + i2.getVar());
	}
};
Java泛型数组 

public class GenericsDemo30 {
	public static void main(String args[]) {
		Integer i[] = fun1(1, 2, 3, 4, 5, 6); // 返回泛型数组
		fun2(i);
	}

	public static <T> T[] fun1(T... arg) { // 接收可变参数
		return arg; // 返回泛型数组
	}

	public static <T> void fun2(T param[]) { // 输出
		System.out.print("接收泛型数组：");
		for (T t : param) {
			System.out.print(t + "、");
		}
	}
};
Java泛型的嵌套设置 

class Info<T, V> { // 接收两个泛型类型
	private T var;
	private V value;

	public Info(T var, V value) {
		this.setVar(var);
		this.setValue(value);
	}

	public void setVar(T var) {
		this.var = var;
	}

	public void setValue(V value) {
		this.value = value;
	}

	public T getVar() {
		return this.var;
	}

	public V getValue() {
		return this.value;
	}
};

class Demo<S> {
	private S info;

	public Demo(S info) {
		this.setInfo(info);
	}

	public void setInfo(S info) {
		this.info = info;
	}

	public S getInfo() {
		return this.info;
	}
};

public class GenericsDemo31 {
	public static void main(String args[]) {
		Demo<Info<String, Integer>> d = null; // 将Info作为Demo的泛型类型
		Info<String, Integer> i = null; // Info指定两个泛型类型
		i = new Info<String, Integer>("汤姆", 30); // 实例化Info对象
		d = new Demo<Info<String, Integer>>(i); // 在Demo类中设置Info类的对象
		System.out.println("内容一：" + d.getInfo().getVar());
		System.out.println("内容二：" + d.getInfo().getValue());
	}
};


Java-我去
关注
专栏目录
java泛型知识点全面总结----
Gavin
07-15 139
不罗嗦,先看代码,在总结,比现总结在看代码似乎要好一点–毕竟实践出真知 看代码---- package baozhuang; class Person <E>{//泛型类 String name; int age; E grade; public Person(String name, int age,E grade) { this.name = name; this.age = age; this.gra..
java泛型详解
SKT_Nezra的博客
10-25 279
最初的接触到java范型更多的是数组，如下：import java.util.ArrayList; ArrayList<Integer> a = new ArrayList<Integer>();现在，我们开始详细介绍java范型,首先，java规定了<>内传入的必须是一个类！class Point<T>{ // 此处可以随便写标识符号，T是type的简称 private T
菜鸟笔记之Java泛型
muyangren100的博客
12-22 247
Java泛型 1. 泛型的意义     Java泛型的出现提高了集合的安全性，Java泛型只存于在编译期，是给编译器检查java语法用的，Java源码编译后形成.class字节码文件时会将泛型擦除掉。 因此，带有泛型的集合，仍然可以 通过反射的方式将不同类型的值设置进集合。
JAVA菜鸟学习-泛型
weixin_42048754的博客
04-04 160
JAVA菜鸟学习-泛型 泛型提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型。 泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。 泛型方法 在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。 下面是定义泛型方法的规则： 1、所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在...
菜鸟的java泛型学习教程
最强菜鸟
05-29 674
菜鸟的java泛型学习教程说明泛型类泛型接口泛型方法 说明 本文记录java泛型的简单使用，本文会持续更新，不断地扩充 本文仅为记录学习轨迹，如有侵权,联系删除 泛型类 例子1 //最简单的泛型类 class generic01 <T>{ private String key; private T value; public generic01() { } public generic01(String key, T value) {
Java 泛型
xiaowang_lj的博客
11-06 368
/姓名T name;//年龄U age;
全面总结Java泛型--实例
01-09
标题与描述均提到了“全面总结Java泛型--实例”，这表明文章旨在深入解析Java泛型的概念，并通过具体示例来展示其应用。Java泛型是Java编程语言的一个强大特性，它允许在编译时检查类型安全，并且所有的强制转换都是...
Java中泛型总结(全面)
qq_29545781的博客
07-28 1792
参考资料： 书：Java编程思想 博客： https://blog.csdn.net/wang__qin/article/details/81415223 https://blog.csdn.net/harvic880925/article/details/49883589 https://blog.csdn.net/qq_27093465/article/details/73229016 ...
Java系列全面总结:泛型+异常+反射+集合+注解+Lambda表达式等详解
m0_72730471的博客
07-27 89
Lambda表达式的举例1.lambda创建线程2.lambda事件处理3.lambda遍历List集合4.元素排序5.lambdaMap6.lambda过滤String7.lambda对集合应用函数8.lambda计算最大值、最小值、平均值。在过去的时间中，我写过Java基础的整个系列，为了方便大家的阅读，也为了让知识更系统化，这里我单独把Java基础系列一并罗列于此，希望对有用的人有用。Java注解分类1、Java自带的标准注解2、元注解3、自定义注解。Java反射详解入门+使用+原理+应用场景。...
逸学java【初级菜鸟篇】9.4 泛型
m0_59337285的博客
11-22 98
泛型是我们在定义某一个类型规格的时候使用的泛指，我们预先定义一个大方向，防止路线错误。实质上是程序员定义的安全类型，Object是顶级父类，在没有泛型很多程序员为了使程序更通用，设计程序时通常传入值和返回值对设置Object为主，但是必须正确的使用实例，正确转回原来类型，比较不方便，所以java提供了泛型。泛型标识是任意设置的（如果你想可以设置为YC都行）但是常见还是默认给予一些意义T ：代表一般的任何类。E ：代表 Element 元素的意思，或者 Exception 异常的意思。
Java知多少（41）泛型详解
weixin_33725807的博客
04-21 367
我们知道，使用变量之前要定义，定义一个变量时必须要指明它的数据类型，什么样的数据类型赋给什么样的值。假如我们现在要定义一个类来表示坐标，要求坐标的数据类型可以是整数、小数和字符串，例如： 1 x = 10、y = 10 2 x = 12.88、y = 129.65 3 x = "东京180度"、y = "北纬210度" 针对不同的数据类型，除了借助方法重载，还可以借助自动装箱和向上...
Java 泛型详解（一）
wei_zhi的博客
10-16 2111
一、泛型的引出假设要求定义一个表示坐标的操作类（Point），这个类可以表示三种类型的坐标： （1）整数坐标：x = 10、y = 20； （2）小数坐标：x = 10.1、y = 20.3； （3）字符串数据：x = “东经100度”、y = “北纬20度”。分析：类中如果想保存以上的数据，一定需要定义x和y两个属性，而这两个属性可以接收三种数据类型，这样的话，只能使用Object类来定义会
Java学习笔记（十二）：泛型的使用
汤圆学Java
08-17 716
来源：http://www.cnblogs.com/lwbqqyumidi/p/3837629.htmlJava总结篇系列：Java泛型 一. 泛型概念的提出（为什么需要泛型）？ 首先，我们看下下面这段简短的代码:public class GenericTest { public static void main(String[] args) { List list = ne
经济补偿金、赔偿金的核定及劳动合同解除后双方的义务.ppt
09-14
经济补偿金、赔偿金的核定及劳动合同解除后双方的义务.ppt
配电网分布式电源和储能选址定容 以配电网总成本最低为目标函数，其中包括年运行成本，设备维护折损成本、环境成本；以系统潮流运行为约
09-14
配电网分布式电源和储能选址定容 以配电网总成本最低为目标函数，其中包括年运行成本，设备维护折损成本、环境成本；以系统潮流运行为约束条件，采用粒子群算法求解，实现光伏、风电、储能设备的规划。 这是一个使用粒子群算法进行优化的程序。下面我将对程序进行详细的分析和解释。 首先，程序开始时加载了一些数据文件，包括光伏、风电和负荷的数据。然后，定义了一些参数，如蓄电池参数、迭代次数、种群大小、速度更新参数等。 接下来，程序进行了种群的初始化。使用随机数生成种群的初始位置，并初始化速度。然后，对种群中的每个个体进行潮流计算，并计算适应度。适应度的计算包括对电压、网损等进行评估，并考虑了一些约束条件，如储能容量、光伏容量等的限制。 接下来，程序进行了迭代优化过程。在每次迭代中，根据当前的速度和位置，更新粒子的速度和位置。然后，对更新后的粒子进行潮流计算，并计算适应度。如果个体的适应度优于个体历史最佳适应度，则更新个体历史最佳适应度和位置。如果个体的适应度优于全局最佳适应度，则更新全局最佳适应度和位置。 程序通过迭代优化过程不断更新粒子的速度和位置，直到达到指定的迭代次数。最后，程序输出优化结
Cpp-halcono-pencv互相转换
最新发布
09-14
Cpp_halcon_opencv互相转换 python halcon_opencv图像变量互相转换 C++ halcon 和opencv 图像变量互相转换 VS2022工程 无需配置环境即可 使用绝对路径 无需配置 无需配置 无需配置 下载即可编译生成 仅限交流学习使用;仅限交流学习使用;仅限交流学习使用;
××部20xx年人员裁员分流方案表.xlsx
09-14
××部20xx年人员裁员分流方案表.xlsx
深入解析Java集合与泛型实践与示例
总结来说，这篇文档为Java初学者提供了一个全面且易于理解的集合与泛型入门教程，特别强调了List接口的使用及其常见方法。通过学习这些概念，开发者能够更好地组织和管理数据，提升代码的灵活性和性能。对于深入理解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值