标签：
*java泛型
泛型避免了强转
import java.util.ArrayList;
import java.util.Iterator;
public class GenericDemo {
/**
* 泛型：JDK1.5版本以后出现的新特性，用于解决安全问题的，是一个类型
安全机制。
* 好处：
* 1.将运行时期出现的问题ClassCastException，转移到了编译时期，利于
程序员解决问题。
* 2.避免了强制转换的麻烦。
* 泛型格式：通过<>来定义要操作的引用数据类型。
* 在使用java提供的对象时，什么时候写泛型？
* 通常在集合框架中很常见
* 只要见到<>就要定义泛型
* 其实<>就是用来接收类型的。
* 当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
*/
public static void main(String[] args) {
ArrayList<String> al=new ArrayList<String>();
al.add("abc01");
al.add("abc0123");
al.add("abc014567");
//al.add(4);
Iterator<String> it=al.iterator();
while(it.hasNext()){
//System.out.println(it.next());
String s=it.next();
System.out.println(s+":"+s.length());
}
}
}
******
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class GenericDemo2 {
public static void main(String[] args) {
TreeSet<String> ts=new TreeSet<String>(new
LenComparator());
ts.add("abcd");
ts.add("cc");
ts.add("cba");
ts.add("aaa");
ts.add("z");
ts.add("hahaha");
Iterator<String> it=ts.iterator();
while(it.hasNext()){
String s=it.next();
System.out.println(s);
}
}
}
class LenComparator implements Comparator<String>{
@Override
public int compare(String o1, String o2) {
int num=new Integer(o1.length()).compareTo(new Integer
(o2.length()));
if(num==0){
return o1.compareTo(o2);
}
return num;
}
}
********
public class GenericDemo3 {
/**
* 什么时候定义泛型类？
* 当类中要操作的引用数据类型不确定的时候，
* 早期定义Object来完成扩展
* 现在定义泛型来完成扩展。
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
/*Tool t=new Tool();
t.setObject(new Worker());
Worker w=(Worker)t.getObject();*/
Utils<Worker> u=new Utils<Worker>();
u.setObject(new Worker());
Worker w= u.getObject();
}
}
class Worker{}
class Student{}
class Tool{
private Object obj;
public Object getObject() {
return obj;
}
public void setObject(Worker obj) {
this.obj = obj;
}
}
class Utils<Q>
{
private Q q;
public void setObject(Q q){
this.q=q;
}
public Q getObject(){
return q;
}
}
********
public class GenericDemo4 {
public static void main(String[] args) {
// TODO Auto-generated method stub
/*Demo<String> d=new Demo<String>();
d.show("hahah");
d.print("heihei");
Demo<Integer> d1=new Demo<Integer>();
d1.show(new Integer(6));
d1.print(9);*/
Demo d=new Demo();
d.show("hahah");
d.show(new Integer(8));
Demo1<Integer> d1=new Demo1();
d1.show(6);
//d1.show("sfdd");
d1.print("hahhah");
}
}
/*
* 泛型类定义的泛型，在整个类中有效。如果被方法使用，
* 那么泛型类的对象需明确要操作的具体类型后，所有要操作的
*/
/*class Demo<T>{
public void show(T t){
System.out.println("show:"+t);
}
public void print(T t){
System.out.println("print:"+t);
}
}*/
//泛型类定义的泛型，在整个类中有效。如果被方法使用
//那么泛型类的对象明确要操作的具体类型后，所有要小左的类型就已经固定了。
//为了让不同方法可以操作不同类型，而且类型还不确定。
//那么可以将泛型定义在方法
class Demo{
public <T> void show(T t){
System.out.println("show:"+t);
}
public <T> void print(T t1){
System.out.println("print:"+t1);
}
}
class Demo1<T>{
public void show(T t){
System.out.println("show:"+t);
}
public <T> void print(T t1){
System.out.println("print:"+t1);
}
/*
* 静态方法不可以访问类上定义的泛型。
* 如果静态方法操作的用数据类型不确定，可以将泛型定义在方法上
* public static void method(T t){
System.out.println("method:"+t);
}
}*/
public static <T> void method(T t){
System.out.println("method:"+t);
}
}
************
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
public class GenericDemo6 {
/**
* ?通配符，也可以理解为占位符。
* 泛型的限定：
* ？ extends E：可以接受E类型或者E的子类型。上限
* ？ super E：可以接受E类型或者E的父类型。下限
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
/*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(al);
printColl(al1);*/
ArrayList<Person> al=new ArrayList<Person>();
al.add(new Person("abc1"));
al.add(new Person("abc2"));
al.add(new Person("abc4"));
printColl(al);
ArrayList<Students> al1=new ArrayList<Students>();
al1.add(new Students("ab1c1"));
al1.add(new Students("ab1c2"));
al1.add(new Students("ab1c4"));
printColl(al1);
}
public static void printColl(ArrayList<? extends Person> al){
Iterator<? extends Person> it=al.iterator();
while(it.hasNext()){
System.out.println(it.next().getName());
}
}
/*public static void printColl(ArrayList<?> al){
Iterator<?> it=al.iterator();
while(it.hasNext()){
System.out.println(it.next());
//System.out.println(it.next().length());
//不能适用类型特有的方法
//System.out.println(it.next().toString());
//可以用
}
}*/
/*
* T可以接受并操作类型，T代表具体类型。？不明确类型叫做占位符
* public static <T> void printColl(ArrayList<T> al){
Iterator<T> it=al.iterator();
while(it.hasNext()){
T t=it.next();
System.out.println(t);
}
}*/
}
class Person{
private String name;
Person(String name){
this.name=name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class Students extends Person{
Students(String name){
super(name);
}
}
标签：
原文地址：http://www.cnblogs.com/jzxf-blogs/p/4869984.html
