java泛型介绍

最新推荐文章于 2024-06-10 10:45:00 发布
最新推荐文章于 2024-06-10 10:45:00 发布
阅读量74 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oma1989/article/details/84218954
版权 
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().length());//取得字符串的长度
	}
};
----------------------------------------------------------
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) ;
	}
//只能接收Number及其Number的子类
	public static void fun(Info<? extends Number> temp){	
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) ;
	}
    //只能接收String或Object类型的泛型
	public static void fun(Info<? super String> temp){
		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 GenericsDemo23 {
	public static void main(String args[]) {
		Info<String> i1 = new Info<String>();//泛型类型为String
		Info<Object> i2 = null;
		i2 = i1;//这句会出错 incompatible types
	}
};

 

 

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()) ;
	}
};

 

 

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());
	}
};

 

 

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 + "、");
		}
	}
};

 

 

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());
	}
};

 

本文出自：http://www.cnblogs.com/sunwei2012/archive/2010/10/08/1845938.html

「已注销」
关注
专栏目录
java泛型 null_Java泛型
weixin_28874917的博客
02-24 722
1、什么是泛型泛型就是 参数类型化 ，简单说就是在定义类 接口 方法时时不支持具体的参数类型的。只有在实际使用时才确定。2、为何用泛型我觉得有两点好处a. 明确类型 避免类型转换如，没有泛型前，从List中取数据都是Object类型的 需要强制转换为确定的类型public static void main(String[] args) {List myList = new ArrayList()...
Java泛型的用法及T.class的获取过程解析
08-25
本文将详细介绍Java泛型的用法 及T.class的获取过程解析。 一、泛型的基本概念 泛型是Java 5中引入的一种新的语言特性，它允许开发者在编写代码时指定类型参数，从而提高代码的灵活性和可读性。泛型可以应用于类、...
Java 中的泛型（两万字超全详解）
林二月的博客
08-02 7万+
博主将用 CSDN 记录 Java 后端开发学习之路上的经验，并将自己整理的编程经验和知识分享出来，希望能帮助到有需要的小伙伴。博主也希望和一直在坚持努力学习的小伙伴们共勉！唯有努力钻研，多思考勤动手，方能在编程道路上行至所向。由于博主技术知识有限，博文中难免会有出错的地方，还望各位大佬包涵并批评指正，博主会及时改正；如果本文对小伙伴你有帮助的话，求求给博主一个赞支持一下，可以一起交流，一起加油！！Java泛型详解，史上最全图文详解java 泛型全解 - 绝对最详细Java 泛型，你了解类型擦除吗。
Java泛型
BroRiver
03-26 1337
泛型是一种在编译时实现类型安全的特性，它使得我们可以编写通用的代码，以适用于不同类型的数据。
java 泛型
Misszhoudandan的博客
06-10 1688
泛型就是将数据类型参数化，例如我们实现一个存储对象的容器时，并不是直接定义好只能存储一种类型，好的办法就是定义时将类型参数化，也就是泛型，在真实使用时再传入真正的参数，这种参数化类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
Java泛型详解
梦想不会灭
05-30 902
一、泛型的本质 Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。 泛型的本质是参数化类型，即给类型指定一个参数，然后在使用时再指定此参数具体的值，那样这个类型就可以在使用时决定了。这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。 二、泛型的作用 泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率 1、保证类型的安全性 在没有泛型之前，从集合中
java 泛型详解-绝对是对泛型方法讲解最详细的，没有之一
热门推荐
s10461的博客
12-30 61万+
对java的泛型特性的了解仅限于表面的浅浅一层，直到在学习设计模式时发现有不了解的用法，才想起详细的记录一下。 本文参考java 泛型详解、Java中的泛型方法、 java泛型详解 1. 概述泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。什么是泛型？为什么要使用泛型？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传
Java泛型大全
weixin_45203607的博客
10-02 4367
Java泛型大全 1. 概述 泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。 什么是泛型？为什么要使用泛型？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法形参，然后调用此方法时 传递的 实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制
JAVA泛型的应用
Theflowersea的博客
05-17 1736
声明泛型接口和声明普通接口语法相似，在接口名称后面多了泛型标识，可以拿泛型标识作为方法的返回值类型或参数类型T getkey();1、public与返回值类型中间的非常重要，可以理解为声明此方法为泛型方法。2、只有在泛型列表中声明了泛型标识的方法才是泛型方法3、表明该方法将使用泛型类型T4、与泛型类的定义一样，此处T可以写为任意标识泛型方法：就是将方法参数类型中的泛型，提前在前面声明，必须用包起来。​ 修饰符 返回值类型 方法名（形参）{
JAVA泛型接口
最新发布
2301_80884223的博客
06-10 876
泛型接口：允许在定义接口时声明类型参数，即泛型接口，这种类型参数在整个接口中可当成类型使用。class Sub<具体类型列表>implements IBase<具体类型列表>{}class Sub<类型参数表>implements IBase<类型参数表>{}泛型接口案例：子类Sub实现接口 IBase<T>1.实现子类没有明确地指明类型参数的具体类型。1.泛型的类型参数不能作为静态成员变量的类型。2.静态方法中不能有任何泛型类型参数出现。2.实现子类明确指明类型参数的具体类型。子类实现泛型接口形式。
java 泛型参数_Java泛型
weixin_34553861的博客
02-12 1228
一、概述Java泛型(generics)是JDK 5中引入的一个新特性，泛型提供了编译时类型安全监测机制，该机制允许程序员在编译时监测非法的类型。使用泛型机制编写的程序代码要比那些杂乱地使用Object变量，然后再进行强制类型转换的代码具有更好的安全性和可读性。泛型对于集合类尤其有用，例如，ArrayList就是一个无处不在的集合类。泛型的本质是参数化类型，也就是所操作的数据类型被指定为一个参数。...
Java泛型的简单实例
09-04
在本文中，我们将通过一个简单的示例来介绍Java泛型的使用。 泛型的概念 泛型是一种类型参数机制，它允许开发者在编写代码时指定类型参数。泛型的主要优点是它可以使代码更加灵活和可重用。例如，一个泛型集合可以...
Java给软件添加License
煎饼里的蛋
05-24 4421
通过license机制来保护我们的安全，可以限定只有购买了license的用户在特定的机器上使用我们的软件。 license机制有以下的主要功能点： 应用程序可以创建以及验证绑定给用户、系统等实体的license 防止用户随意拷贝软件和license licenses可以是永久性的或者临时性的（在某个特定时期内有效） licenses的验证由JAVA Secu...
设置背景图的Panel
煎饼里的蛋
11-18 1057
设置背景图片的JPanel import java.awt.Graphics; import java.awt.Image; import javax.swing.JPanel; /** *可设置背景图片的JPanel，提供了三种显示背景图片的方式：居中、平铺和拉伸。 *未设置背景图片的情况下，同JPanel。 */ public class JImagePa...
用JAVA实现P2P网络通信
煎饼里的蛋
10-31 1049
一、 前言     P2P（Peer-to-Peer 端到端）模型是与C/S（客户/服务器）模型相对应。基于C/S的用户间通信需要由服务器中转，在C/S中的服务器故障将导致整个网络通信的瘫痪。。而基于P2P的用户间通信则是直接通信，去掉了服务器这一层，带来的显著优点是通信时没有单一的失败点，一个用户的故障不会影响整个P2P网络。本文提供了一种用JAVA实现P2P网络通信的方法。    二、...
JAVA 按键精灵
煎饼里的蛋
10-16 812
JAVA按键精灵，模拟点击   主要方法： // 创建Robot对象 java.awt.Robot r = new java.awt.Robot(); // 将鼠标指针移动到坐标(x,y) r.mouseMove(x, y); // 鼠标按下某个键 r.mousePress(InputEvent.BUTTON1_MASK); // 暂停ms毫秒 r.delay(ms) ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值