黑马程序员——Java基础—泛型

时间：2023-02-26 19:37:02


Java基础之泛型

泛型 Generic：

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

泛型的好处：

1.将运行时期出现的问题ClassCastException转移到了编译时期，方便程序员解决问题，减少运行时期的问题，提高了安全性。

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

泛型的格式：通过<>来定义要操作的引用数据类型。

泛型通常在集合框架中很常见，在使用java提供的对象时，只要见到<>就要定义泛型。<>是用来接收类型的。

当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

泛型代码示例：

<pre name="code" class="html">import java.util.*;
class Generic
{ 
public static void main(String[] args)
{
TreeSet<String> ts = new TreeSet<String>(new Comparator<String>()
{
public int compare(String s1,String s2)
{
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num==0)
return s1.compareTo(s2);
return num;
}
});

ts.add("haha");
ts.add("nihao");
ts.add("zhu");
ts.add("aliluya");
ts.add("aliluyaamen");
ts.add("xuxiaoyu");
ts.add("lisi");

for(Iterator<String> it=ts.iterator(); it.hasNext();  )
{
System.out.println(it.next());
}
}
}

 

 
泛型类：当类中要操作的引用数据类型不确定的时候，就定义泛型来完成扩展。泛型类定义的泛型在整个类中有效，如果被方法使用，泛型类对象明确要操作的具体类型后，要操作的类型就固定了。代码演示： 

class Tool<HH> //定义的泛型类。
{
private HH h;

public void setObject(HH h)
{
this.h = h;
}
public HH getObject()
{
return h;
}
}
 

泛型方法：为了让不同方法可以操作不同类型，且类型还不确定，可以将泛型定义在方法上，<>要写在返回值类型的前面。示例： public <T> void show(T t){ }
 

泛型方法代码演示：
 

class GenericMethod
{
public <T> void show(T t) //泛型方法。
{
System.out.println("show:"+t);
}
public <E> void print(E e) //泛型方法。
{
System.out.println("print:"+e);
}
public <W> void function(W w) //泛型方法。
{
System.out.println("function:"+w);
}
}
 

 

静态方法泛型：静态方法不可以访问类上定义的泛型，因为静态是优先于对象的存在。如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。示例：public static <W> void method(W w){ }



静态方法泛型代码示例：
 

class Generic
{
public static <T> void show(T t) //静态方法泛型。
{
System.out.println("show:"+t);
}
public static <E> void print(E e) //静态方法泛型。
{
System.out.println("print:"+e);
}
public static <W> void function(W w) //静态方法泛型。
{
System.out.println("function:"+w);
}
}
 

 

泛型的限定：？是通配符或占位符。? extends E：上限，可以接收E类型或E的子类型。？ super E：下限，可以接收E类型或者E的父类型。代码示例：
 

import java.util.*;
class  GenericDemo2
{
public static void main(String[] args) 
{
ArrayList<Person> al = new ArrayList<Person>();
al.add(new Person("abcd01"));
al.add(new Person("abcd03"));
al.add(new Person("abcd04"));

ArrayList<Student> al1 = new ArrayList<Student>();
al1.add(new Student("bcd01"));
al1.add(new Student("bcd03"));
al1.add(new Student("bcd04"));

printColl(al1);
}

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

class Person
{
private String name;

Person(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
}
class Student extends Person
{
Student(String name)
{
super(name);
}
}



/*泛型的限定用于泛型的扩展。super E：下限，可以接收E类型或者E的父类型。*/import java.util.*;class  GenericDemo3{public static void main(String[] args) {TreeSet<Student> ts = new TreeSet<Student>(new MyComparator());ts.add(new Student("xyz06"));ts.add(new Student("xyz08"));ts.add(new Student("xyz03"));ts.add(new Student("xyz04"));for(Iterator<Student> it = ts.iterator(); it.hasNext(); ){System.out.println(it.next().getName());}TreeSet<Worker> st = new TreeSet<Worker>(new MyComparator());st.add(new Worker("wxyz 05"));st.add(new Worker("wxyz 08"));st.add(new Worker("wxyz 02"));st.add(new Worker("wxyz 04"));for(Iterator<Worker> it = st.iterator(); it.hasNext(); ){System.out.println(it.next().getName());}}}class MyComparator implements Comparator<Person>{public int compare(Person p1,Person p2){return p2.getName().compareTo(p1.getName());}}class Person{private String name;Person(String name){this.name = name;}public String getName(){return name;}}class Worker extends Person{Worker(String name){super(name);}}class Student extends Person {Student(String name){super(name);}}
 

 

泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译带类型说



明的集合时会去除掉"类型"信息，使程序运行效率不受影响。对于参数化的泛型类型，getClass()方法的返回值和原始类
 

型完全一样。由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器就可以往某个泛型集合中加入其他类型的
 

数据。例如：用泛型得到集合，再调用其add方法即可。
 

用反射的方式往实际类型参数是Integer的ArrayList集合中存入一个字符串元素，代码示例：
 

import java.util.*;
class Demo
{
public static void main(String[] args) throws Exception
{
ArrayList<Integer> al = new ArrayList<Integer>();

//通过反射跳过编译器往某个泛型集合中加入其他类型的元素。
al.getClass().getMethod("add",Object.class).invoke(al,"amen");

System.out.println(al.get(0));
}
}
 

 

泛型中的术语：
 

ArrayList<E> 称为泛型类型。 
 

ArrayList<E> 中的E称为类型变量或类型参数。



ArrayList<Integer> 称为参数化的类型。 
 

ArrayList<Integer> 中的Integer称为类型参数的实例或实际类型参数。
 

ArrayList 称为原始类型。<>读成typeof 。
 

参数化类型可以引用一个原始类型的对象，编译器会报出警告。例如：ArrayList<Integer> al = new ArrayList()。
 

原始类型也可以引用一个参数化类型的对象，编译器会报出警告。例如：ArrayList al = new ArrayList<Integer>()。
 

参数化类型不考虑类型参数的继承关系。
 

使用?通配符可以引用其他各种参数化的类型，?通配符定义的变量主要用作引用，可以调用与参数化无关的方法，不能调 
 

用与参数化有关的方法。 只有引用类型才能作为泛型方法的实际参数-->> <int>不可以<T>。
 

泛型的限定：
 

？是通配符或占位符。? extends E：上限，可以接收E类型或E的子类型。
 

示例：Vector<? extends Number> v = new Vector<Integer>();
 

？ super E：下限，可以接收E类型或者E的父类型。示例： Vector<? super Integer> v = new Vector<Number>();



通过反射的方式获得泛型的实际类型参数：
 

import java.util.*;
import java.lang.reflect.*;
class Test
{ 
public static void main(String[] args) throws Exception
{
Method applyMethod = Test.class.getMethod("apply",HashSet.class);

//得到该方法上的泛型的实际类型参数数组。
Type[] types = applyMethod.getGenericParameterTypes();

//知道只有一个元素，就是参数化类型
ParameterizedType pType = (ParameterizedType)types[0];

//获取方法参数的原始类型。
System.out.println(pType.getRawType());

//获取方法参数化类型上的实际类型参数。
System.out.println(pType.getActualTypeArguments()[0]);

}
public static void apply(HashSet<String> hs)
{
}
}
 

 

ParameterizedType 表示参数化类型，如 Collection<String>。  
 

getActualTypeArguments()：返回表示此类型实际类型参数的Type对象的数组。



getRawType()：返回Type对象，表示声明此类型的类或接口。
 


 


 


标签：
相关文章