java基础<泛型>

泛型概述

一、概述

泛型：JDK1.5版本以后出现的新特性。用于解决安全问题，是一个安全机制。

二、好处

1.将运行时期出现的问题ClassCastException，转移到了编译时期。

方便与程序员解决问题。让运行时问题减少，更加安全。

2.避免了强制转换的麻烦。

三、代码

class GenericDemo 
{
	public static void main(String[] args) 
	{
		ArrayList<String> a1=new ArrayList<String>();
		a1.add("abc01");
		a1.add("abc0991");
		a1.add("abc");

		Iterator<String> it=al.iterator();
		while(it.hasNext())
		{
			String s=it.next();
		}
	}
}

泛型类

一、概述

泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

为了让不同方法可以操作不同类型，而且类型还不确定，可以将泛型定义在方法上，如下一节所示。

二、代码

class Worker
{
	
}

class Utils<QQ>
{
	private QQ q;
	public void set(QQ q)
	{
		this.q=q;
	}
	public QQ get()
	{
		return q;
	}
}


class GenericDemo3
{
	public static void main(String[] args)
	{
	Utils<Worker> u=new Utils<Worker>();
	u.set(new Worker());
	Worker w=u.get();
	}
}

泛型方法

一、代码（泛型方法）

泛型定义在方法上时放在—— 修饰符的后面，返回值类型的前面

泛型方法的使用之前，需要在方法上定义，否则不可以使用。

class Demo
{
	public <T> void show(T t)
	{
		System.out.println(t);	
	}
	
	public <Q> void print(Q q)
	{
		System.out.println(q);
	}
}


class  GenericDemo4
{
	public static void main(String[] args) 
	{
		Demo d=new Demo();
		d.show("haha");
		d.show(1);
		d.print("hehe");
	}
}

二、代码（泛型类中的泛型方法）

class Demo<T>
{
	public void show(T t)
	{
		System.out.println(t);	
	}
	
	public <Q> void print(Q q)
	{
		System.out.println(q);
	}
}


class  GenericDemo4
{
	public static void main(String[] args) 
	{
		Demo d=new Demo();
		d.show("haha");
		d.show("hehe");
		d.print(1);
	}
}

三、代码（泛型类中的静态方法泛型）

class Demo<T>
{
	public void show(T t)
	{
		System.out.println(t);	
	}
	
	public <Q> void print(Q q)
	{
		System.out.println(q);
	}

	public static<W> void method(W w)//静态方法不可以访问类上定义的泛型。只可以在方法上定义泛型。
	{
		System.out.println("method"+t);
	}
}


class  GenericDemo4
{
	public static void main(String[] args) 
	{
		Demo d=new Demo();
		d.show("haha");
		d.show("hehe");
		d.print(1);
		Demo.method("hahahah");
	}
}

泛型接口

一、代码

interface Inter<T>
{
	void show(T t);
}

/*
class InterImpl implements Inter<String>
{
	public void show(String t)
	{
		System.out.println("show:"+t);
	}
}
*/

class InterImpl<T> implements Inter<T>
{
	public void show(T t)
	{
		System.out.println("show:"+t);
	}
}




class  
{
	public static void main(String[] args) 
	{
		InterImpl<Integer> i=new InterImpl<Integer>();
		i.show(1);
	}
}

泛型限定

一、通配符（?)

import java.util.*;

class  GenericDemo6
{
	public static void main(String[] args) 
	{
		ArrayList<String> a1=new ArrayList<String>();

		a1.add("abc1");
		a1.add("abc2");
		a1.add("abc3");

		ArrayList<Integer> a2=new ArrayList<Integer>();
		a2.add(4);
		a2.add(5);
		a2.add(6);

		printColl(a1);
		printColl(a2);

		printColl1(a1);
		printColl1(a2);
	}

		/*以下两种方法都可以*/
/*①*/	public static void printColl(ArrayList<?> al)//ArrayLise<String> a1=new ArrayList<Integer>();是错误的，类型不匹配。
	{
		Iterator<?> it=al.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
			//System.out.println(it.next().length());//不可以使用，因为不是每个对象都有length()方法。
			System.out.println(it.next().toString());//可以使用，因为每个对象都有这个方法。
		}
	}



/*②*/	public static<T> void printColl1(ArrayList<T> al)
	{
		Iterator<T> it=al.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}

}

二、泛型限定

1. ？ extends E  限定类型是E或者E的子类。（上限）

import java.util.*;
class GenericDemo7 
{
	public static void main(String[] args) 
	{
		ArrayList<Person> a1=new ArrayList<Person>();
		a1.add(new Person("abc"));
		a1.add(new Person("abc1"));
		a1.add(new Person("abc2"));
		printColl(a1);

		ArrayList<Student> a2=new ArrayList<Student>();
		a2.add(new Student("abc___"));
		a2.add(new Student("abc___1"));
		a2.add(new Student("abc___2"));
		printColl(a2);//ArrayList<Person> a1=new ArrayList<Student>();不可以，必须是相同类型

	}


	public static void printColl(ArrayList<? extends Person> p)
	{
		Iterator<? extends Person> it=p.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
		
	}
}

class Person
{
	private String name;
	Person(String name)
	{
		this.name=name;
	}
	public String getName()
	{
		return this.name;
	}
}


class Student extends Person
{
	Student(String name)
	{
		super(name);
	}
}

2. ？ super E     限定类型是E或者E的父类。（下限）

import java.util.*;

class GenericDemo8 
{
	public static void main(String[] args) 
	{
		TreeSet<Student> ts=new TreeSet<Student>(new Com());//根据TreeSet构造方法，可以使用Student的父类的比较器来对Student进行比较。

		ts.add(new Student("zhangsan3"));
		ts.add(new Student("zhangsan2"));
		ts.add(new Student("zhangsan1"));
		
		Iterator<Student> it=ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
	}
}


class Com implements Comparator<Person>
{
	public int compare(Person p1,Person p2)
	{
		return p1.getName().compareTo(p2.getName())	;
	}

}


class Comp implements Comparator<Student>
{
	public int compare(Student p1,Student p2)
	{
		return p1.getName().compareTo(p2.getName())	;
	}

}

class Person
{
	private String name;
	Person(String name)
	{
		this.name=name;
	}
	public String getName()
	{
		return this.name;
	}
}


class Student extends Person
{
	Student(String name)
	{
		super(name);
	}
}