泛型的存在是为了规范数据的统一性而形成的,此在1.5之后才形成的。并且在泛型中,必须使用包装类来进行操作。
1、泛型的基本操作。
以下分别为对应Int与String的泛型来理解使用泛型的好处。
设定为INTger类
class Point<T>
{ private T var;
public T getvar(){
return var;}
public void setvar(T var){
this.var=var;
}
}
public class demo10_1
{
public static void main(String args[]){
Point<Integer> a=new Point<Integer>(); //定义泛型为一个整数类型
a.setvar(20); //添加进Int类型的数字进去。
System.out.println(a.getvar()+3);
}
}
设定为String类。
class Info<T>
{
private T var;
public T getVar(){
return var;
}
public void setVar(T var){
this.var=var;
}
public String toString(){
return this.var.toString();
}
}
public class demo10_2
{ public static void main(String args[]){
Info<String> k=new Info<String>();
k.setVar("helad"); //接受String类型的对象进来。
System.out.println(k);
}
}
可以看出在面对不同的数据类型时,泛型都能够很的提供支持。
2、泛型的引用传递
class Info<T>
{
private T var;
public T getVar(){
return var;
}
public void setVar(T var){
this.var=var;
}
public String toString(){
return this.var.toString();
}
}
public class demo10_3
{
public static void main(String args[]){
Info<String> i=new Info<String>();//注意泛型时一种方法,必须加上括号。
i.setVar("1234"); //传递值进去
fun(i);
}
public static void fun(Info<?> temp){
System.out.println("内容是"+temp);
}
}
3、泛型的上限与下限。
在泛型中,我们可以设定其的范围上限或者下限。上限用extends来表示,只能够使用其的子类,Number类的话只能够接受数字,否则报错。劣质如下。
class Info<T>
{
private T var;
public T getVar(){
return var;
}
public void setVar(T var){
this.var=var;
}
public String toString(){
return this.var.toString();
}
}
public class demo10_3
{
public static void main(String args[]){
Info<Integer> i=new Info<Integer>();//注意泛型时一种方法,必须加上括号。
Info<Float> i1=new Info<Float>();
i.setVar(1234);
i1.setVar(12.4f) //传递值进去
fun(i);
fun(i1);
}
public static void fun(Info<? extends Number> temp)//为泛型规定了上限只能接受Number的子类。
{
System.out.println(temp+"、");
}
}
而下限的代码类似。只不过范围是不同的。
class Info<T>
{
private T var;
public T getVar(){
return var;
}
public void setVar(T var){
this.var=var;
}
public String toString(){
return this.var.toString();
}
}
public class demo10_4
{
public static void main(String args[]){
Info<Object> i=new Info<Object>();//注意泛型时一种方法,必须加上括号。
Info<String> i1=new Info<String>();
i.setVar(new Object());
i1.setVar("abcf") //传递值进去
fun(i);
fun(i1);
}
public static void fun(Info<? super String> temp)//为泛型规定了下限只能接受String及其父类Object。
{
System.out.println(temp+"、");
}
}
3、泛型的接口
泛型接口在Java的内裤中大量的使用,这样就可以接受不同的数据这一点在类集中的体现尤为明显。
下面来说明泛型接口的两种实现方式。
在要使用的时候才定义类型。
interface Info<T>
{
public T getVar();
}
class Infoa<T> implements Info<T>
{
private T var;
public Infoa(T var){
this.setVar(var);
}
public void setVar(T var){
this.var=var;
}
public T getVar(){
return this.var;
}
}
public class demo10_4
{
public static void main(String args[]){
Info<String> i=null; //定义接口的对象。
i=new Infoa<String>("asd");//子类实例化对象
System.out.println("内容是"+i.getVar());
}
}
另一种是在子类中把接口定义完毕。
interface Info<T>
{
public T getVar();
}
class Infoa implements Info<String>
{
private String var;
public Infoa(String var){
this.setVar(var);
}
public void setVar(String var){
this.var=var;
}
public String getVar(){ //在接口处定义好要接收的内容。
return this.var;
}
}
public class demo10_5
{
public static void main(String args[]){
Info<String> i=null;
i=new Infoa("fas1");
System.out.println("内容是"+i.getVar());
}
}
我们可以很明显的看出来,明显是第一种方法比较方便,模版设计模式的思想体现的很好,第二种泛型的使用范围也要更小,使用有一定的局限性。