- 浏览: 263406 次
- 性别:
- 来自: 大连
文章分类
最新评论
-
saishangxue123:
文章写的清楚、明了,一气呵成,支持
什么是反射、反射能干什么、如何使用反射? -
allen3010:
1,2,3,4,5这六个数字。。。。。
用1、2、2、3、4、5这六个数字,用java写一个main函数,打印出所有不同的排列
泛型是Java SE 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。
Java语言引入泛型的好处是安全简单。
在Java SE 1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,“任意化”带来的缺点是要做显式的强制类型转换,而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况,编译器可能不提示错误,在运行的时候才出现异常,这是一个安全隐患。
泛型的好处是在编译的时候检查类型安全,并且所有的强制转换都是自动和隐式的,提高代码的重用率。
泛型在使用中还有一些规则和限制:
1、泛型的类型参数只能是类类型(包括自定义类),不能是简单类型。
2、同一种泛型可以对应多个版本(因为参数类型是不确定的),不同版本的泛型类实例是不兼容的。
3、泛型的类型参数可以有多个。
4、泛型的参数类型可以使用extends语句,例如<T extends superclass>。习惯上成为“有界类型”。
5、泛型的参数类型还可以是通配符类型。例如Class<?> classType = Class.forName(java.lang.String);
学会这个基本上学会了泛型70%的内容。
例子一:使用了泛型
以下是代码片段:
public class Gen<T> {
private T ob; //定义泛型成员变量
public Gen(T ob) {
this.ob = ob;
}
public T getOb() {
return ob;
}
public void setOb(T ob) {
this.ob = ob;
}
public void showTyep() {
System.out.println("T的实际类型是: " + ob.getClass().getName());
}
}
public class GenDemo {
public static void main(String[] args){
//定义泛型类Gen的一个Integer版本
Gen<Integer> intOb=new Gen<Integer>(88);
intOb.showTyep();
int i= intOb.getOb();
System.out.println("value= " + i);
System.out.println("----------------------------------");
//定义泛型类Gen的一个String版本
Gen<String> strOb=new Gen<String>("Hello Gen!");
strOb.showTyep();
String s=strOb.getOb();
System.out.println("value= " + s);
}
}
例子二:没有使用泛型
以下是代码片段:
public class Gen2 {
private Object ob; //定义一个通用类型成员
public Gen2(Object ob) {
this.ob = ob;
}
public Object getOb() {
return ob;
}
public void setOb(Object ob) {
this.ob = ob;
}
public void showTyep() {
System.out.println("T的实际类型是: " + ob.getClass().getName());
}
}
public class GenDemo2 {
public static void main(String[] args) {
//定义类Gen2的一个Integer版本
Gen2 intOb = new Gen2(new Integer(88));
intOb.showTyep();
int i = (Integer) intOb.getOb();
System.out.println("value= " + i);
System.out.println("----------------------------------");
//定义类Gen2的一个String版本
Gen2 strOb = new Gen2("Hello Gen!");
strOb.showTyep();
String s = (String) strOb.getOb();
System.out.println("value= " + s);
}
}
运行结果:
两个例子运行Demo结果是相同的,控制台输出结果如下:
T的实际类型是:
以下是代码片段:
java.lang.Integer
value= 88
----------------------------------
T的实际类型是: java.lang.String
value= Hello Gen!
Process finished with exit code 0
看明白这个,以后基本的泛型应用和代码阅读就不成问题了。
Java语言引入泛型的好处是安全简单。
在Java SE 1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,“任意化”带来的缺点是要做显式的强制类型转换,而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况,编译器可能不提示错误,在运行的时候才出现异常,这是一个安全隐患。
泛型的好处是在编译的时候检查类型安全,并且所有的强制转换都是自动和隐式的,提高代码的重用率。
泛型在使用中还有一些规则和限制:
1、泛型的类型参数只能是类类型(包括自定义类),不能是简单类型。
2、同一种泛型可以对应多个版本(因为参数类型是不确定的),不同版本的泛型类实例是不兼容的。
3、泛型的类型参数可以有多个。
4、泛型的参数类型可以使用extends语句,例如<T extends superclass>。习惯上成为“有界类型”。
5、泛型的参数类型还可以是通配符类型。例如Class<?> classType = Class.forName(java.lang.String);
学会这个基本上学会了泛型70%的内容。
例子一:使用了泛型
以下是代码片段:
public class Gen<T> {
private T ob; //定义泛型成员变量
public Gen(T ob) {
this.ob = ob;
}
public T getOb() {
return ob;
}
public void setOb(T ob) {
this.ob = ob;
}
public void showTyep() {
System.out.println("T的实际类型是: " + ob.getClass().getName());
}
}
public class GenDemo {
public static void main(String[] args){
//定义泛型类Gen的一个Integer版本
Gen<Integer> intOb=new Gen<Integer>(88);
intOb.showTyep();
int i= intOb.getOb();
System.out.println("value= " + i);
System.out.println("----------------------------------");
//定义泛型类Gen的一个String版本
Gen<String> strOb=new Gen<String>("Hello Gen!");
strOb.showTyep();
String s=strOb.getOb();
System.out.println("value= " + s);
}
}
例子二:没有使用泛型
以下是代码片段:
public class Gen2 {
private Object ob; //定义一个通用类型成员
public Gen2(Object ob) {
this.ob = ob;
}
public Object getOb() {
return ob;
}
public void setOb(Object ob) {
this.ob = ob;
}
public void showTyep() {
System.out.println("T的实际类型是: " + ob.getClass().getName());
}
}
public class GenDemo2 {
public static void main(String[] args) {
//定义类Gen2的一个Integer版本
Gen2 intOb = new Gen2(new Integer(88));
intOb.showTyep();
int i = (Integer) intOb.getOb();
System.out.println("value= " + i);
System.out.println("----------------------------------");
//定义类Gen2的一个String版本
Gen2 strOb = new Gen2("Hello Gen!");
strOb.showTyep();
String s = (String) strOb.getOb();
System.out.println("value= " + s);
}
}
运行结果:
两个例子运行Demo结果是相同的,控制台输出结果如下:
T的实际类型是:
以下是代码片段:
java.lang.Integer
value= 88
----------------------------------
T的实际类型是: java.lang.String
value= Hello Gen!
Process finished with exit code 0
看明白这个,以后基本的泛型应用和代码阅读就不成问题了。
发表评论
-
java时间大小比较
2015-04-02 21:48 1005摘自: http://blog.sina.com.cn/s/b ... -
StringBuffer的常用方法
2015-03-30 16:06 997摘自:http://blog.csdn.net/deaful/ ... -
什么是反射、反射能干什么、如何使用反射?
2013-08-16 00:03 4890//来源互联网 一、什 ... -
Class.forName···关于Class. 的应用介绍
2013-08-15 23:36 1191//摘自互联网 Class.forName(xxx.xx ... -
java泛型map的用法(转2)
2013-07-25 23:04 92341.声明一个map: Map map = ne ... -
java泛型map的用法(转)
2013-07-25 22:56 3154http://www.apkbus.com/blog-2079 ... -
关于日期 Date Calendar
2013-07-23 22:46 1163import java.security.Timestam ... -
正则表达式 例子
2013-07-22 23:00 853import java.util.regex.Matche ... -
Iterator的使用方法
2013-07-18 21:45 0import java.util.*; publ ... -
泛型的写法种种
2013-07-18 21:41 1062public class Generics<T> ... -
ArrayList ,LinkedList, TreeSet的使用方法
2013-07-18 21:35 2354import java.util.*; public ... -
Stack的使用方法
2013-07-18 21:26 1401import java.util.Stack; ... -
Hashtable的使用方法介绍
2013-07-18 21:24 23211**************************** ... -
老式枚举的使用方法
2013-07-18 21:23 979import java.util.Enumeration; ... -
java中Map的各种排序介绍
2013-07-14 13:24 1754//本篇来源于互联网 HashMap: 最常用的Ma ... -
java配置文件用法
2013-04-14 22:43 1336package cn.com.mfsoft.config; ... -
java利用反射得到实例
2013-04-10 22:44 1309对于面向接口编程的项目免不了要一反射相接触,动态得到实例: ... -
spring的beanFactory和factoryBean
2013-04-05 16:10 2167spring的beanFactory和factoryBe ... -
Spring配置文件总结
2013-04-05 16:05 911Spring配置文件总结(转) 2010-06-07 23: ... -
Spring 的微内核与FactoryBean扩展机制
2013-04-05 15:49 1652Spring 的微内核与FactoryBean扩展机制 ...
相关推荐
"设计模式之从简单工厂到泛型简单工厂"这个主题关注的是创建型设计模式,特别是如何逐步改进简单工厂模式以提高其灵活性和可扩展性。简单工厂模式是一种静态工厂方法,用于创建对象,而泛型简单工厂则是对其的一种...
C# 泛型是.NET框架中的一个重要特性,它允许开发者创建可以使用多种数据类型的类、接口和方法。这种灵活性使得代码更加复用性,同时提高了性能,因为泛型避免了在运行时进行类型转换的开销。在本文中,我们将深入...
下面通过一个简单的例子来进一步解释泛型的用法: ```csharp public class GenericStack { private T[] items; private int top; public GenericStack(int size) { items = new T[size]; top = -1; } ...
### 泛型和泛型集合类用法详解 #### 一、泛型基础概念 泛型是现代编程语言中的一项重要特性,它允许开发者在不指定具体数据类型的情况下编写类或方法,从而达到代码重用的目的。在.NET Framework 2.0及以后版本中...
JAVA泛型源代码实现以下功能:返回数组元素的最大值/最小值下标;判断数组元素是否按升序排列;T对象数组排序;二分法查找key元素;
泛型是Java编程语言中的一个重要特性,它引入于JDK 5.0,极大地提高了代码的类型安全性和可读性。泛型允许我们在类、接口和方法中使用类型参数,这样我们可以在编译时检查类型,避免了运行时类型转换的麻烦和潜在的...
Delphi中的泛型基础及简单应用
本文将深入探讨C#中的泛型,它是C#的一个重要特性,对于初学者来说,理解并掌握泛型是提高编程效率和代码复用性的关键。 泛型在C#中引入的主要目的是为了提高类型安全性和性能。它允许我们在编写代码时定义不特定于...
"简单的List泛型模拟"这个主题就是关于如何理解和实现一个简单的泛型列表类的模拟。 泛型的基本概念: 1. 泛型是Java SE 5.0引入的新特性,主要用于增强类型安全。 2. 泛型允许在定义类、接口和方法时使用类型参数...
例如,以下是一个简单的泛型委托定义: ```csharp public delegate void MyGenericDelegate(T value); public class MyClass { public event MyGenericDelegate<int> IntEventHandler; public event ...
例如,我们可以定义一个简单的泛型类 `Box`: ```java public class Box<T> { private T item; public void setItem(T item) { this.item = item; } public T getItem() { return item; } } ``` 在这个例子...
Java语言引入泛型的好处是安全简单。 在Java SE 1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,“任意化”带来的缺点是要做显式的强制类型转换,而这种转换是要求开发者对实际参数...
在`Generic_InterfaceDemo`项目中,我们可以创建一个简单的程序,利用泛型接口处理不同类型的数据。例如,创建一个处理数字和字符串的类,并实现`IMyGenericInterface`: ```csharp public class NumberProcessor :...
例如,下面是一个简单的泛型方法,用于交换两个变量的值: ```java public static <T> void swap(T[] array, int i, int j) { T temp = array[i]; array[i] = array[j]; array[j] = temp; } ``` 在这个例子中,...
对泛型的简单举例,通过例子了解泛型这个知识点
但是,`List<Apple>` 和 `List<Fruit>` 之间的关系并不像非泛型类型那样简单。根据类型安全性原则,`List<Apple>` 不能自动赋值给 `List<Fruit>`,因为这可能导致运行时错误。 ```java List<Apple> apples = new ...
简单来说,泛型允许开发者创建可以处理多种数据类型的类、接口和方法。 #### 二、泛型的重要性 1. **类型安全性**:泛型提供了静态类型检查的能力,确保在编译时类型的安全性。 2. **代码重用**:通过泛型,可以...
- **Person** 类作为所有人的基本模型,包含了姓名(`Name`)、年龄(`Age`)等属性,并且提供了一个虚拟方法 `Introduce()` 用于返回一个简单的自我介绍字符串。 - **Student** 类继承自 `Person` 类,增加了一个 `...
自定义简单泛型: * public class Gclass<T>{ private T a; public T getA() { return a; } public void setA(T a) { this.a = a; } } 泛型与继承: * 泛型中有继承的概念吗? * ArrayList<Integer> al2=new ...