java编程思想笔记（九）泛型

程序员文章站 2022-03-15 12:01:36

...

泛型:JAVA5时引入，泛型实现了参数化类型的概念，使代码可以应用于多种类型.

常用的泛型实现：<T> /<k,v>/Object/<?>/<? extends xxx>/<? super xxx>

1.泛型类/接口：

(1).泛型接口：

如一个提*生指定类的接口：

public interface Gernerator<T>{  
    T next() ;  
}  
public class A implement Generator<A>{  
    A next(){  
        return new A();  
    }  
}

(2).泛型类：

public class Test1<T>{  
}

2.泛型方法：

例如：

public class GenericMethods{  
    public <T> void f(T x){  
        System.out.println(x.getClass().getName()) ;  
}  
public static void main(String[] args){  
    GenericMethods gm = new GenericMethods();  
    gm.f(“”);  
    gm.f(1);  
    gm.f(1.0);  
    ……  
}   
}

输出结果为：

java.lang.String

java.lang.Integer

java.lang.Double

3.泛型集合：

Java中泛型集合使用的非常广泛，在Java5以前，java中没有引入泛型机制，使用java集合容器时经常遇到如下两个问题：

a. java容器默认存放Object类型对象，如果一个容器中即存放有A类型对象，又存放有B类型对象，如果用户将A对象和B对象类型弄混淆，则容易产生转换错误，会发生类型转换异常。

b. 如果用户不知道集合容器中元素的数据类型，同样也可能会产生类型转换异常。

鉴于上述的问题，java5中引入了泛型机制，在定义集合容器对象时显式指定其元素的数据类型，在使用集合容器时，编译器会检查数据类型是否和容器指定的数据类型相符合，如果不符合在无法编译通过，从编译器层面强制保证数据类型安全。

(1).java常用集合容器泛型使用方法：

如：

public class New{  
    public static <K, V> Map<K, V> map(){  
        return new HashMap<K, V>();  
}  
public static <T> List<T> list(){  
    return new ArrayList<T>() ;  
}  
public static <T> LinkedList<T> lList(){  
    return new LinkedList<T>();  
}  
public static <T> Set<T> set(){  
    return new HashSet<T>();  
}  
public static <T> Queue<T> queue(){  
    return new LinkedList<T>() ;  
}  
;public static void main(String[] args){  
    Map<String, List<String>> sls = New.map();  
    List<String> ls = New.list();  
    LinkedList<String> lls = New.lList();  
    Set<String> ss = New.set();  
    Queue<String> qs = New.queue();  
}  
}  
 
(2).Java中的Set集合是数学上逻辑意义的集合，使用泛型可以很方便地对任何类型的Set集合进行数学运算，代码如下：
public class Sets{  
    //并集  
    public static <T> Set<T> union(Set<T> a, Set<T> b){  
        Set<T> result = new HashSet<T>(a);  
        result.addAll(b);  
        return result;  
}  
//交集  
public static <T> Set<T> intersection(Set<T> a, Set<T> b){  
    Set<T> result = new HashSet<T>(a);  
    result.retainAll(b);  
    return result;  
}  
//差集  
public static <T> Set<T> difference(Set<T> a, Set<T> b){  
    Set<T> result = new HashSet<T>(a);  
    result.removeAll(b);  
    return Result;  
}  
//补集  
public static <T> Set<T> complement(Set<T> a, Set<T> b){  
    return difference(union(a, b), intersection(a, b));  
}  
}

4.泛型也可用于匿名内部类

class Customer {
	private static long counter = 1;
	private final long id = counter++;

	private Customer() {
	}

	public String toString() {
		return "Customer " + id;
	}

	// A method to produce Generator objects:
	public static Generator<Customer> generator() {
		//匿名内部类
		return new Generator<Customer>() {
			public Customer next() {
				return new Customer();
			}
		};
	}
}

class Teller {
	private static long counter = 1;
	private final long id = counter++;

	private Teller() {
	}

	public String toString() {
		return "Teller " + id;
	}

	// A single Generator object:
	public static Generator<Teller> generator = new Generator<Teller>() {
		//匿名内部类
		public Teller next() {
			return new Teller();
		}
	};
}

5.用泛型构建复杂数据结构模型

泛型能够简单而安全的创建复杂的数据结构模型，例如下面的泛型List ：

public class TupleList<A, B, C, D> extends ArrayList<FourTuple<A, B, C, D>> {
	public static void main(String[] args) {
		TupleList<Vehicle, Amphibian, String, Integer> tl = new TupleList<Vehicle, Amphibian, String, Integer>();
		tl.add(TupleTest.h());
		tl.add(TupleTest.h());
		for (FourTuple<Vehicle, Amphibian, String, Integer> i : tl)
			System.out.println(i);
	}
} /*
 * Output:
 * (75% match) (Vehicle@11b86e7, Amphibian@35ce36, hi, 47)
 * (Vehicle@757aef, Amphibian@d9f9c3, hi, 47)
 */// :~

尽管看起来复杂，但依旧是一个强大的数据结构.

6.泛型边界：

边界使得你可以在用于泛型的参数类型上设置限制条件。

Java泛型编程时，编译器忽略泛型参数的具体类型，认为使用泛型的类、方法对Object都适用，这在泛型编程中称为类型信息檫除。

例如：

class GenericType{  
    public static void main(String[] args){  
        System.out.println(new ArrayList<String>().getClass());  
        System.out.println(new ArrayList<Integer>().getClass());  
}  
}

输出结果为：

java.util.ArrayList

泛型忽略了集合容器中具体的类型，这就是类型檫除。

7.类型通配符

Box<Number>和Box<Integer>实际上都是Box类型，现在需要继续探讨一个问题，那么在逻辑上，类似于Box<Number>和Box<Integer>是否可以看成具有父子关系的泛型类型呢？

为了弄清这个问题，我们继续看下下面这个例子:

 class Box<T> {
 
     private T data;
 
     public Box() {
 
     }
 
     public Box(T data) {
         setData(data);
     }
 
     public T getData() {
         return data;
     }
 
     public void setData(T data) {
         this.data = data;
     }
 
 }

public class GenericTest {
 
      public static void main(String[] args) {
  
          Box<Number> name = new Box<Number>(99);
          Box<Integer> age = new Box<Integer>(712);
  
          getData(name);
          
         //The method getData(Box<Number>) in the type GenericTest is 
         //not applicable for the arguments (Box<Integer>)
         getData(age);   // 1
 
     }
     
     public static void getData(Box<Number> data){
         System.out.println("data :" + data.getData());
     }
19 
20 }

假设Box<Number>在逻辑上可以视为Box<Integer>的父类，那么//1和//2处将不会有错误提示了，那么问题就出来了，通过getData()方法取出数据时到底是什么类型呢？Integer? Float? 还是Number？且由于在编程过程中的顺序不可控性，导致在必要的时候必须要进行类型判断，且进行强制类型转换。显然，这与泛型的理念矛盾，因此，在逻辑上Box<Number>不能视为Box<Integer>的父类。

好，那我们回过头来继续看“类型通配符”中的第一个例子，我们知道其具体的错误提示的深层次原因了。那么如何解决呢？总部能再定义一个新的函数吧。这和Java中的多态理念显然是违背的，因此，我们需要一个在逻辑上可以用来表示同时是Box<Integer>和Box<Number>的父类的一个引用类型，由此，类型通配符应运而生。

类型通配符一般是使用 ? 代替具体的类型实参。注意了，此处是类型实参，而不是类型形参！且Box<?>在逻辑上是Box<Integer>、Box<Number>...等所有Box<具体类型实参>的父类。由此，我们依然可以定义泛型方法，来完成此类需求。

在代码//1处出现了错误提示信息：The method getData(Box<Number>) in the t ype GenericTest is not applicable for the arguments (Box<Integer>)。显然，通过提示信息，我们知道Box<Number>在逻辑上不能视为Box<Integer>的父类。那么，原因何在呢？

public class GenericTest {
 
      public static void main(String[] args) {
  
          Box<String> name = new Box<String>("corn");
          Box<Integer> age = new Box<Integer>(712);
          Box<Number> number = new Box<Number>(314);
  
          getData(name);
         getData(age);
         getData(number);
     }
 
     public static void getData(Box<?> data) {
         System.out.println("data :" + data.getData());
     }
 
 }

有时候，我们还可能听到类型通配符上限和类型通配符下限。具体有是怎么样的呢？

在上面的例子中，如果需要定义一个功能类似于getData()的方法，但对类型实参又有进一步的限制：只能是Number类及其子类。此时，需要用到类型通配符上限。

  public class GenericTest {
  
      public static void main(String[] args) {
  
          Box<String> name = new Box<String>("corn");
          Box<Integer> age = new Box<Integer>(712);
          Box<Number> number = new Box<Number>(314);
  
          getData(name);
         getData(age);
         getData(number);
         
         //getUpperNumberData(name); // 1
         getUpperNumberData(age);    // 2
         getUpperNumberData(number); // 3
     }
 
     public static void getData(Box<?> data) {
         System.out.println("data :" + data.getData());
     }
     
     public static void getUpperNumberData(Box<? extends Number> data){
         System.out.println("data :" + data.getData());
     }
 
 }

此时，显然，在代码//1处调用将出现错误提示，而//2 //3处调用正常。

类型通配符上限通过形如Box<? extends Number>形式定义，相对应的，类型通配符下限为Box<? super Number>形式，其含义与类型通配符上限正好相反，在此不作过多阐述了。

另外

Java中没有所谓的泛型数组一说。

对于泛型，最主要的还是需要理解其背后的思想和目的。

上一篇：科大讯飞吴晓如：过去5年语音交互系统在二千多万辆车上形成应用

下一篇：学习系统

java编程思想笔记（九）泛型

Java编程思想里的泛型实现一个堆栈类分享

Java编程思想里的泛型实现一个堆栈类分享

Java 笔记 21：modcount, 泛型

《Java 编程思想》读书笔记之并发（一）

《Java编程思想》笔记第十三章字符串

Java开发笔记（七十）Java8新增的几种泛型接口

Java分享笔记：泛型机制的程序演示

Java分享笔记：泛型类的定义与使用

Java学习笔记之泛型(四)：泛型接口

Java：集合、泛型、枚举、反射学习笔记

java编程思想笔记（九）泛型

Java编程思想里的泛型实现一个堆栈类 分享

Java编程思想里的泛型实现一个堆栈类 分享

Java 笔记 21：modcount, 泛型

《Java 编程思想》读书笔记之并发（一）

《Java编程思想》笔记 第十三章 字符串

Java开发笔记（七十）Java8新增的几种泛型接口

Java分享笔记：泛型机制的程序演示

Java分享笔记：泛型类的定义与使用

Java学习笔记之泛型(四)：泛型接口

Java：集合、泛型、枚举、反射 学习笔记

Java编程思想里的泛型实现一个堆栈类分享

Java编程思想里的泛型实现一个堆栈类分享

《Java编程思想》笔记第十三章字符串

Java：集合、泛型、枚举、反射学习笔记