黑马程序员------泛型

------- <a href="http://www.itheima.com"target="blank">android培训</a>、<a href="http://www.itheima.com"target="blank">java培训</a>、期待与您交流！ ----------

泛型

Jdk1.5版本以后出现了这个新特性，它用来解决安全问题，是一个类型安全机制。

 

泛型格式<>,<>中定义要操作的引用数据类型。

好处：1.将运行时期出现问题ClassCastException转移到了编译时期。方便在编译时就能解决问题，使得运行时更安全高效。

           2.避免再进行强制转换

何时使用泛型：当类中要操作的引用数据类型不确定的时候，早期用Object来扩展，现在定义泛型来扩展。比如在集合框架中泛型定义很常见，我们也可以根据需要在自己的类中，方法中使用泛型。

代码示例：

<span style="font-size: 14px;">package com.gzj.io;/*用到泛型示例 * 定义一个集合，存储字符串，并按照字符串长度进行升序排序*/import java.util.*;class </span><span style="font-family: Arial;"><span style="font-size: 14px;"> </span><span style="font-size:12px;">Generic</span></span><span style="font-size: 14px;"> {public static void main(String[] args) {TreeSet<String> ts = new TreeSet<String>(new LenComparator());ts.add("abcde");ts.add("cc");ts.add("cb");ts.add("aaa");ts.add("z");Iterator<String> it = ts.iterator();while(it.hasNext()){String s = it.next();//不需要再强转了System.out.println(s);}}}class LenComparator implements Comparator<String>{public int compare(String o1,String o2)//传入的对象也是String类型，与上面比较器保持一致{int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));if(num==0)   return o1.compareTo(o2);return num;}}</span>

如上代码可以看出，java的迭代器，比较器，集合都是泛型，我们也可以在自定义的类中定义泛型。

代码示例如下：

泛型类

class Utils<QQ>//定义一个工具类，用来操作对象，但什么对象不确定，所以可以加泛型{private QQ q;public void setObject(QQ q){this.q = q;}public QQ getObject(){return q;}}class  GenericDemo{public static void main(String[] args) {Utils<Worker> u = new Utils<Worker>();u.setObject(new Worker());Worker w = u.getObject();; }}<strong style="color: rgb(0, 112, 192);"></strong>

泛型方法：

泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。

代码示例如下：

class Demo{Public<T> void show(T t){System.out.println("show:"+t);}Public<Q> void print(Q q){System.out.println("print:"+t);}}class GenericDemo {public static void main(String[] args) {Demo d = new Demo();d.show(new Integer(4));d.print(5);d.print(“haha”);}}

注：可以既有泛型类又有泛型方法

静态方法泛型

代码示例：

class Demo<T>{public  void show(T t){System.out.println("show:"+t);}public <Q> void print(Q q){System.out.println("print:"+q);}public  static <W> void method(W t){System.out.println("method:"+t);}}class GenericDemo {public static void main(String[] args) {Demo <String> d = new Demo<String>();d.show("haha");d.print(5);d.print("haha");Demo.method("hahahahha");}}

接口泛型

1.泛型定义在接口上，实现时再制定类型

interface Inter<T>{void show(T t);}class InterImpl implements Inter<String>{public void show(String t){System.out.println("show :"+t);}}class GenericDemo{public static void main(String[] args) {InterImpl  i = new InterImpl ();i.show(“haha”);}}    

2.泛型定义在接口上，类实现时也不明确，方法被调用时再指定

interface Inter<T>{void show(T t);}class InterImpl<T> implements Inter<T>{public void show(T t){System.out.println("show :"+t);}}class GenericDemo{public static void main(String[] args) {InterImpl<Integer> i = new InterImpl<Integer>();i.show(4);//InterImpl i = new InterImpl();//i.show("haha");}} 

泛型限定

当传入的对象类型不确定时，用一个通配符来表示

?extends E:可以接收E类型或E的子类型。上限

?super E:可以接收E 或E的父类型。下限

代码示例如下：

package com.gzj.jihe;import java.util.*;class  Xianding{public static void main(String[] args) {ArrayList<Person> al = new ArrayList<Person>();al.add(new Person("abc1"));al.add(new Person("abc2"));al.add(new Person("abc3"));printColl(al);ArrayList<Student1> al1 = new ArrayList<Student1>();al1.add(new Student1("abc--1"));al1.add(new Student1("abc--2"));al1.add(new Student1("abc--3"));printColl(al1);  //ArrayList<? extends Person> al = new ArrayList<Student>();error}public static void printColl(ArrayList<? extends Person> al)//把 从存储不同类型元素操作单独封装成一个方法，{                                         //这个方法接收的参数类型是接收Person类或他的子类型元素的集合，属上限Iterator<? extends Person> it = al.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 name;}}class Student1 extends Person  {Student1(String name){super(name);}}