java学习笔记泛型简述
来源：互联网 发布：手机淘宝回到顶部 编辑：程序博客网 时间：2024/06/05 02:31
一、范型简介
泛型：JDK1.5版本以后出现的新特性。用于解决安全问题，是一个类型安全机制。
好处一：将运行时期出现问题ClassCastException，转移到了编译时期。方便于程序员解决问题，让运行时期问题减少。安全。
好处二：避免了强制转换麻烦。
泛型格式：通过<>来定义要操作的引用数据类型。
在使用JAVA提供的对象时什么时候写泛型呢？
通常在集合框架中很常见。只要见到<>就要定义泛型。其实<>就是用来接受类型的。当使用集合时，将集合中要存储的数据类型作为参数传到<>中即可。二、范型的应用
什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展，现在定义泛型来完成扩展。
自定义泛型应用
classWorker // 定义工人类
{
}
classStudent // 定义学生类
{
}
classTool // 第一种：定义操作类的工具类
{
private Worker w;
public void setWorker(Worker w)
{
this.w = w;
}
public Worker getWorker()
{
return w;
}
}
classNormalTool // 第二种：定义操作类的通用工具类（泛型前1.4版本办法，需要强转）
{
private Object obj;
public void setObject(Object obj)
{
this.obj = obj;
}
public Object getObject()
{
return obj;
}
}
classUtils<QQ> // 第三种：泛型类，即带泛型的类。（1.5版本以后）
{
private QQ q;
public void setObject(QQ q)
{
this.q = q;
}
public QQ getObject()
{
return q;
}
}
class GenericDemo3
{
public static void main(String[] args) // 主函数
{
// System.out.println(“HelloWorld!”); // 第一种工具类应用只能应用于某个类。
Tool t = new Tool();
t.setWorker(new Worker());
t.getWorker();
NormalTool nt = newNormalTool(); // 第二种工具类可应用于多个类但需要强制转换
nt.setObject(new Student());
Worker w =(Worker)nt.getObject();
Utils<Worker> u = newUtils<Worker>(); // 利用泛型避免强制转换。
u.setObject(newWorker()); // 传值不一致会在编译时提示错误
Worker w = u.getObject();
}
}
泛型定义在方法上
泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有方法要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。
classDemo<T> // 将泛型定义在类上。
{
public void show(T t) // 参数可以接受任意类型
{
System.out.println(“show：”+t);
}
public <Q> void print(Q q) // 将泛型定义在泛型类中的方法上
{
System.out.println(“print：”+q);
}
public static <W> void method(Ww) // 静态方法不可以访问类上定义的泛型
{
System.out.println(“method：”+w);
}
}
classDemo1 // 泛型定义在方法上。
{
public<T> void show(T t)
{
System.out.println(“print：”+t);
}
public<Q> void print(Q q)
{
System.out.println(“print：”+q);
}
}
classGenericDemo4
{
public static void main(String[] args)
{
Demo<String> d = newDemo<String>(); // 实例时指明用什么类型，指定后参数类型就被固定了。
d.show(new Integer(4));
d.print(9);
Demo1 d1 = new Demo();
d1.show(“haha”);
d1.show(new Integer(4));
d1.print(“heihei”);
}
}
静态泛型
泛型可以同时既设置在类上也设置在类中方法中。
特殊之处：静态方法不可以访问类上定义的泛型。如果静态方法操作的引用数据类型不确定可以将泛型定义在方法上。（例子在上例子中体现）
泛型定义在接口上
注：见到带泛型的要记得传参数。
interfaceInter<T>
{
void show(T t);
}
/*
classInterImpl implements Inter<String> // 实现接口的类不带泛型
{
public void show(String t)
{
System.out.println(“show：”+t);
}
}
*/
classInterImpl implements Inter<T> // 实现接口的类带泛型
{
public void show(T t)
{
System.out.println(“show：”+t);
}
}
classGenericDemo5
{
public static void main(String[] args)
{
InterImpl<Integer> I =new InterImpl<Integer>();
i.show(4);
/*
InterImpl I = newInterImpl();
i.show(“haha”);
*/
}
}
三、范型的高级应用
泛型的高级应用
通配符<?> 占位与<T>不同，<T>是传什么类型就是什么类型。
泛型不可以使用类型的特有方法。因为不明确到底是什么类型。
？通配符，也可以理解为占位符。
泛型的限定：
?extends E：可以接受E类型或者E的子类型。上限<? extends Person>
?super E：可以接受E类型或者E的父类型。下限<? super Person>
// 例一
classGenericDemo6
{
public static void main(String[] args)
{
ArrayList<String> al =new ArrayList<String>();
al.add(“abc1”);
al.add(“abc2”);
al.add(“abc3”);
ArrayList<Integer> al1= new ArrayList<Integer>();
al1.add(4);
al1.add(7);
al1.add(1);
printColl(al1); // 因为通配符，所以两种类型都可以打印出来。
printColl(al);
}
/*
public static void printColl(ArrayList<String>al) // 参数类型指定不利于复用。此时用到通配符。
{
Iterator<String> it =al.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
*/
public static void printColl(ArrayList<?>al) // 用到通配符后便可以实现通用。
{
Iterator<?> it =al.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
// 例二 泛型限定
classGenericDemo6
{
public static void main(String[] args)
{
ArrayList<Person> al =new ArrayList<Person>();
al.add(new Persoon(“abc1”));
al.add(newPersoon(“abc2”));
al.add(new Persoon(“abc3”));
printColl(al);
ArrayList<Student> al1= new ArrayList<Student>();
al.add(new Student (“abc--1”));
al.add(new Student (“abc--2”));
al.add(newStudent (“abc--3”));
printColl(al1); // ArrayList<Person> al = newArrayList<Student>(); 这种不可以两边类型必需一致
}
/*
public static voidprintColl(ArrayList<Person> al) // 指定接受类型为Person，在接受Student时会失败。
{
Iterator<Person> it =al.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}
}
*/
public static void printColl(ArrayList<?extends Person> al) // 参数用泛型限定，限定只能接受的类范围。
{
Iterator<? extends Person> it = al.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}
}
}
classPerson // 定义Person类
{
private String name;
Person(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
public String ToString()
{
return ”person：”+name;
}
}
classStudent extends Person // 定义Person类子类Student类
{
Student(String name)
{
super(name);
}
}
泛型限定
importjava.util.*;
classGenericDemo7
{
public static void main(String[] args)
{
TreeSet<Student> ts =new TreeSet<Student>(new StuComp); // 学生
ts.add(new Student(“abc03”));
ts.add(new Student(“abc02”));
ts.add(new Student(“abc02”));
ts.add(new Student(“abc01”));
Iterator<Student> it =ts.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}
TreeSet<Student> ts1 =new TreeSet<WorComp>(new WorkerComp()); // 工人
ts1.add(new Worker(“wabc--03”));
ts1.add(new Worker (“wabc--02”));
ts1.add(new Worker (“wabc--02”));
ts1.add(new Worker (“wabc--01”));
Iterator<Worker> it1 =ts1.iterator();
while(it1.hasNext())
{
System.out.println(it1.next().getName());
}
}
}
/*
class StuCompimplements Comparator<Student> // 定义Student比较器
{
public int compare(Student s1,Students2)
{
returns1.getName().compareTo(s2.getName()); //按名排序从大到小
}
}
classWorkerComp implements Comparator<Worker> // 定义Worker比较器
{
public int compare(Worker s1, Workers2)
{
returns1.getName().compareTo(s2.getName()); //按名排序从大到小
}
}
*/
// 由于需要定义多个比较器麻烦
classComp implements Comparator<Person> // 泛型参数可以通用于Student和Worker。
{
public int compare(Persong p1,Personp2)
{
returnp2.getName().compareTo(p1.getName()); // 泛型中只能用父类中方法不能有子类的特有方法。
}
}
classPerson // 定义Person类
{
private String name;
Person(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
public String ToString()
{
return ”person：”+name;
}
}
classStudent extends Person // 定义Person类子类Student类
{
Student(String name)
{
super(name);
}
}
classWorker extends Person
{
Worker(String name)
{
super(name);
}
}
- java学习笔记泛型简述
- java泛型简述
- Java 泛型简述
- Java框架学习笔记——初识Spring之简述
- java设计模式学习笔记（一）-- 简述设计模式
- Java反射reflect学习笔记_1：反射的简述
- java IO笔记(IO简述)
- java基础—泛型简述
- 简述Java泛型以及原理
- Java学习之道：简述泛型通配符<? extends T>和<? super T>
- Java for Web学习笔记（五二）：Spring框架简介（1）特点简述
- 学习笔记-CIFAR10模型理解简述
- STL学习笔记— —STL简述
- Hadoop学习笔记(1)----项目简述
- OpenCV（学习笔记1）-简述
- Scala学习笔记（二） ---- 基础简述
- Unity3D_uGUI学习笔记（1）_Canvas简述
- 学习笔记TF012:卷积网络简述
- 如下代码可以实现点击页面获得被点击元素的id
- stemapp读取当前的配置文件以及整个项目的配置文件
- mysql数据库使用注意事项
- error LNK2038: 检测到“_ITERATOR_DEBUG_LEVEL”的不匹配项: 值“0”不匹配值“2”的解决方案
- 博客开篇
- java学习笔记泛型简述
- SpringMVC 分页
- POJ 3273 Monthly Expense (二分答案)
- wchar_t与string 互转换的两种方法自己用了好使
- html5实现多文件上传
- 100%正确的内存泄漏分析工具 ------ tMemMonitor (TMM)
- Spring+MyBatis组合开发简单实例
- HDU 5438 Ponds
- java截取字符串，截串，substring和split，分割字母和数字，正则缝隙
