泛型(java基础)

泛型

一、二泛型概念以及基本使用(略）

三、泛型类

详细见代码：

package Container;

/*
 *******泛型类*********
 什么时候定义泛型类？
 当类中要操作中的引用数据类型不确定的时候，
 早期定义Object完成扩展。
 */

class Student//学生类
{
	
}
class Teacher//老师类
{
	
}
//泛型前做法
class edu//教育相关的职业
{
	private Object obj;//定义基类，可以使传入数据为多中类型
	public void setWorker(Object obj)
	{
		this.obj = obj;
	}
	public Object getWork()
	{
		return obj;
	}
}
//泛型后做法
class edu1<T>//定义一个参数类(教育相关的职业)
{
	private T q;
	public void setWorker(T obj)
	{
		this.q= obj;
	}
	public T getWork()
	{
		return q;
	}
}

public class GenericDemo_clss
{

	public static void main(String[] args)
	{
		edu1<Teacher> t = new edu1<Teacher>();//定义Teacher泛型
		t.setWorker(new Teacher());
		Teacher T = t.getWork();
		

	}

}

四、泛型方法

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

特殊方法：静态方法不可以访问类上定义的泛型，如果静态方法操作的应用的数据类型不确定，可以吧泛型定义在方法上。

示例代码：

class Demo1<T>
{
	public void show(T t)
	{
		System.out.println("show---"+t);
	}
	public void printf(T t)
	{
		System.out.println("printf---"+t);
	}
//	public static void method(T t)//这是错误的，静态方法不可以访问类上定义的泛型
//	{
//		System.out.println("method:"+t);
//	}
}

class Demo
{
	public <T> void show(T t)//泛型定义在方法上
	{
		System.out.println("show---"+t);
	}
	public <T> void printf(T t)//泛型定义在方法上
	{
		System.out.println("printf---"+t);
	}
	public static <T> void method(T t)//如果静态方法操作的应用的数据类型不确定，可以吧泛型定义在方法上
	{
		System.out.println("method:"+t);
	}
}



public class GenericDemo2
{

	public static void main(String[] args)
	{
		Demo t1 = new Demo();
		t1.show(1);
		t1.printf("String");
		Demo.method("hahahhahahah");//调用静态方法

	}

}

五、泛型接口(略)

六、泛型限定

    //public static<T> void print(ArrayList<T> al) //如果不用？就必须这样定义。
    public static void print(ArrayList<?> al)//不清楚类型的时候可以用问号，这样可以打印多种类型。？是占位符

package Container;

import java.util.ArrayList;
import java.util.Iterator;




public class GenericDemo3
{

	public static void main(String[] args)
	{
		ArrayList<String> al = new ArrayList<>();//String类型的
		al.add("abc1");
		al.add("abc2");
		al.add("abc3");
		
		ArrayList<Integer> AI = new ArrayList<>();//Integer类型
		AI.add(1);
		AI.add(1);
		AI.add(1);
		
		print(al);//打印字符串型
		print(AI);//打印整型
	}
	
//	public static<T> void print(ArrayList<T> al) //如果不用？就必须这样定义。
	public static void print(ArrayList<?> al)//不清楚类型的时候可以用问号，这样可以打印多种类型。？是占位符
	{
		for(Iterator<?> it = al.iterator();it.hasNext();)
		{
			System.out.println(it.next());
		}
	}

}

泛型限定：

package Container;
/*
****泛型限定*****
*“?”:通配符，可以理解为占位符
*泛型的限定：
*? extends E:可以接收E类型或者E类型的子类型。上限。
*? super E:可以接受E类型或者E的父类型。下限
*/

import java.util.*;
class Perso//人，避免冲突用了Perso
{
	private String name;
	Perso(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
}
class Studen extends Perso//学生继承人，同理
{
	Studen(String name)
	{
		super(name);
	}
}


class Comp implements Comparator<Perso>//<? extends Perso>这里既可以传perso  又可以传studen
{
	public int compare(Perso s1,Perso s2)
	{
	       s1 = new Studen("abcde1");
		return s1.getName().compareTo(s2.getName());
	}
}

public class GenericDemo4
{
	public static void main(String[] args)
	{
		ArrayList<Perso> al = new ArrayList<>();
		al.add(new Perso("abc1"));
		al.add(new Perso("abc2"));
		al.add(new Perso("abc3"));
		al.add(new Perso("abc4"));
		printColl(al);//打印
		
		ArrayList<Studen> al1 = new ArrayList<>();
		al1.add(new Studen("bcd--1"));
		al1.add(new Studen("bcd--2"));
		al1.add(new Studen("bcd--3"));
		al1.add(new Studen("bcd--4"));
		printColl(al1);//打印学生
	}
	public static void printColl(ArrayList<? extends Perso> al)//泛型限定，打印perso以及他的子类
	{
		for(Iterator<? extends Perso> it = al.iterator();it.hasNext();)
		{
			System.out.println(it.next().getName());
		}
	}
}