泛型(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());
		}
	}
}