黑马程序员--泛型

来源：互联网发布：csol for mac 编辑：程序博客网时间：2024/06/11 05:42

------- android培训、java培训、期待与您交流！ ----------

一、泛型总说：

泛型出现的必要性：

数组在定义时就已经确定了里面存储的数据类型如：

 int[ ] num = {1,5,6,7};
  String[ ] str = {"abc","fdg","uio"};

但是对于集合，他可以接受任何引用数据类型的对象，泛型之前的容器需要接受参数的大都是Object类型的，所以从集合框架中取出的数据还是Object类型的，还需要对其进行向下转型，还有因为他可以存储任何类型，你既可以存入Person对象，也可以存入Car类型，什么都可以往里面装，而且编译器还不能检测到语法错误。等到运行是才出现问题。程序的安全性不好。所以泛型来了。

泛型的好处：

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

好处

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

2，避免了强制转换麻烦。

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

在使用java提供的对象时，什么时候写泛型呢？

通常在集合框架中很常见，

只要见到<>就要定义泛型。

其实<> 就是用来接收类型的。

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

示例：

class GenericDemo { public static void main(String[] args)  {  ArrayList<String> al = new ArrayList<String>();
  al.add("abc01");  al.add("abc0991");  al.add("abc014");   for(Iterator<String> it = al.iterator();it.hasNext();)
  {   String s = it.next();   System.out.println(s+":"+s.length());  } }}

二、泛型类：

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

什么时候使用泛型类：

当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展。现在定义泛型来完成扩展。

/*class Tool{ private Worker w; public void setWorker(Worker w) {  this.w = w; } public Worker getWorker() {  return w; }}*/class Worker{ //do something}class Student{ //do something}//泛型前做法。class Tool{ private Object obj; public void setObject(Object obj) {  this.obj = obj; } public Object getObject() {  return obj; }}//泛型类。class Utils<QQ>{ private QQ q; public void setObject(QQ q) {  this.q = q; } public QQ getObject() {  return q; }}
class  GenericDemo3{ public static void main(String[] args)  {
  Utils<Worker> u = new Utils<Worker>();  u.setObject(new Student());  Worker w = u.getObject();;  /*  Tool t = new Tool();  t.setObject(new Student());  Worker w = (Worker)t.getObject();  */ }}

三、泛型方法：

那么可以将泛型定义在方法上。

特殊之处：静态方法不可以访问类上定义的泛型。（因为类上定义的泛型在创建对象是才确定具体的类型）

如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

泛型方法与泛型类比较示例代码：

说明：泛型类和泛型方法没有绝对的界限，而且可以混合使用，如果要操作某一特定类型T的数据，

就可以定义为泛型类，所有方法也可以定义为T类型，就像集合中的那样。

而泛型方法更具灵活性，可以操作所传入的任意类型。

class Demo<T>{
 //操作的类型为类上定义的<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 GenericDemo4 { public static void main(String[] args)  {  Demo <String> d = new Demo<String>();  d.show("haha");  //d.show(4);  d.print(5);  d.print("hehe");  Demo.method("hahahahha");  /*  Demo d = new Demo();  d.show("haha");  d.show(new Integer(4));  d.print("heihei");  */  /*
  //只有对象建立了才能确定数据类型，所以静态方法不能用类上定义的泛型
  Demo<Integer> d = new Demo<Integer>();  d.show(new Integer(4));  d.print("hah");  Demo<String> d1 = new Demo<String>();  d1.print("haha");  d1.show(5);  */ }}

四、泛型接口：

/泛型定义在接口上。  interface Inter<T>{      void show(T t);  }    /*将接口实现定义为String，只能操作String类型数据 class InterImpl implements Inter<String>{     public void show(String t){         System.out.println("show :"+t);     } }  */    //将接口实现类定义为不确定的类型，操作传入的类型  class InterImpl<T> implements Inter<T>{      public void show(T t){          System.out.println("show :"+t);      }  }    class GenericDemo5 {      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的父类型。下限

注意：

在使用下限的时候，一般在传入的为父类，因为这样，只要是子类就可以接收，提高了扩展性，但是只能用父类的方法。

示例一：

import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;class Person4 { private String name; Person4(String name) {  this.name = name; } public String getName() {  return name; }}class Student4 extends Person4 { private String name; Student4(String name) {  super(name); } // 这里定义之后打印的是null,因为覆盖了父类的getName方法，但是初始化是到父类初始化， // 所以使用的不是同一个name，本类中的name并没有赋值 public String getName() {  return name; }}class GenericDemo6 { public static void main(String[] args) {  /*   ArrayList<String> al = new ArrayList<String>();      al.add("abc1");   al.add("abc2");   al.add("abc3");       printColl(al);      ArrayList<Integer> al1 = new ArrayList<Integer>();   al1.add(4);   al1.add(7);   al1.add(1);      printColl(al1);   */  ArrayList<Person4> al = new ArrayList<Person4>();  al.add(new Person4("abc1"));  al.add(new Person4("abc2"));  al.add(new Person4("abc3"));  printColl(al);  ArrayList<Student4> al1 = new ArrayList<Student4>();  al1.add(new Student4("abc--1"));  al1.add(new Student4("abc--2"));  al1.add(new Student4("abc--3"));  printColl(al1); // ArrayList<? extends Person> al = new      // ArrayList<Student>();error } public static void printColl(Collection<? extends Person4> al)// 接收Person及Person的子类型，多态 {  Iterator<? extends Person4> it = al.iterator();  while (it.hasNext()) {   System.out.println(it.next().getName());  } } /*   如果明确定义为<T>类型，可以接收并操作T类型，而<?>因为没确定类型，   所以不可以使用类型的特有方法    public static void printColl(ArrayList<?> al){ //ArrayList al = new ArrayList<Integer>();error     Iterator<?> it = al.iterator();          while(it.hasNext()) {     System.out.println(it.next().toString()); }    }  */}

示例二：

import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;class Person4 { private String name; Person4(String name) {  this.name = name; } public String getName() {  return name; }}class Student4 extends Person4 { private String name; Student4(String name) {  super(name); } // 这里定义之后打印的是null,因为覆盖了父类的getName方法，但是初始化是到父类初始化， // 所以使用的不是同一个name，本类中的name并没有赋值 public String getName() {  return name; }}class GenericDemo6 { public static void main(String[] args) {  /*   ArrayList<String> al = new ArrayList<String>();      al.add("abc1");   al.add("abc2");   al.add("abc3");       printColl(al);      ArrayList<Integer> al1 = new ArrayList<Integer>();   al1.add(4);   al1.add(7);   al1.add(1);      printColl(al1);   */  ArrayList<Person4> al = new ArrayList<Person4>();  al.add(new Person4("abc1"));  al.add(new Person4("abc2"));  al.add(new Person4("abc3"));  printColl(al);  ArrayList<Student4> al1 = new ArrayList<Student4>();  al1.add(new Student4("abc--1"));  al1.add(new Student4("abc--2"));  al1.add(new Student4("abc--3"));  printColl(al1); // ArrayList<? extends Person> al = new      // ArrayList<Student>();error } public static void printColl(Collection<? extends Person4> al)// 接收Person及Person的子类型，多态 {  Iterator<? extends Person4> it = al.iterator();  while (it.hasNext()) {   System.out.println(it.next().getName());  } } /*   如果明确定义为<T>类型，可以接收并操作T类型，而<?>因为没确定类型，   所以不可以使用类型的特有方法    public static void printColl(ArrayList<?> al){ //ArrayList al = new ArrayList<Integer>();error     Iterator<?> it = al.iterator();          while(it.hasNext()) {     System.out.println(it.next().toString()); }    }  */}

0 0