泛 型

  刚才没发上，所以重新发一下

一、泛型的使用
那么类中凡是用泛型类型表示其数据类型的地方都要等到外部通知的类型才能决定，并且统一。
例如：
public class Point<T> { // 表示坐标
private T x; // x属性的类型由外部决定
private T y; // y属性的类型由外部决定
public Point(T x, T y) {//在构造方法上使用泛型
  this.setX(x);
  this.setY(y);
}
public Point() {}

public T getX() {
  return x;
}
public void setX(T x) {
  this.x = x;
}
public T getY() {
  return y;
}
public void setY(T y) {
  this.y = y;
}
}
public class GenDemo05 {
public static void main(String[] args) {
  Point<Integer> p = new Point<Integer>();//指定泛型为Integer类型
  p.setX(11);//此处对参数进行检查，如果不是所决定的Integer将编译不通过
  p.setY(20);
  int x = p.getX(); // 取出x坐标
  int y = p.getY();// 取出y坐标
  System.out.println("x的坐标是：" + x);
  System.out.println("y的坐标是：" + y);
}
}
二、泛型的擦除
在应用的时候，泛型如果没有设置的话，则将会进行擦除，擦除之后默认按照Object进行接收。
三、泛型转型问题
在泛型中，一个对象a实例化的时候指定为Integer，另一个对象b指定为Number或Object，并不表示a对象可以向上转型到b。
例如：
public class Point<T> { // 表示坐标
private T x; // x属性的类型由外部决定
private T y; // y属性的类型由外部决定
public T getX() {
  return x;
}
public void setX(T x) {
  this.x = x;
}
public T getY() {
  return y;
}
public void setY(T y) {
  this.y = y;
}
}
public class GenDemo09 {
public static void main(String[] args) {
  Point<Object> p1 = new Point<Object>();
  Point<Integer> p2 = new Point<Integer>() ;
  p1 = p2 ; // 此时无法转换
}
}
原因：p1，p2都是Point类型，只是其中的属性不同，其各自的属性间可以实现转型。
四、通配符？
在方法的参数设置的时候如果使用了？代表数据类型，就表示可以接受任意数据类型的对象。
package mldn.lin.test;
class Point<T> { // 表示坐标
private T x; // x属性的类型由外部决定
private T y; // y属性的类型由外部决定
public T getX() {
  return x;
}
public void setX(T x) {
  this.x = x;
}
public T getY() {
  return y;
}
public void setY(T y) {
  this.y = y;
}
}
public class Test {
public static void main(String[] args) {
  Point<Object> p1 = new Point<Object>();
  Point<Integer> p2 = new Point<Integer>();
  fun(p1) ;
  fun(p2) ;
}
public static void fun(Point<?> po) { // 表示，此时可以接收任意的类型
  System.out.println(po.getX());
  System.out.println(po.getY());
}
}
五、泛型上限和泛型下限
上限就指一个的操作泛型最大的操作父类，例如，现在最大的上限设置成“Number”类型，那么此时，所能够接收到的类型只能是Number及其子类（Integer）。
泛型的上限通过以下的语法完成：某个泛型  extends 类
例如：T extends Number
泛型的下限指的是只能设置其具体的类或者父类。设置的语法如下：某个泛型super 类
六、泛型接口
泛型不光可以在类上使用，还可以在接口中进行定义。操作的语法如下：
interface 接口名称<泛型类型,泛型类型,…>{}
例如：
public interface Demo<T> { // 定义泛型接口
public void print(T param);// 　此抽象方法中使用了泛型类型
}

泛型接口定义完成之后，下面就需要定义子类实现此接口，实现的方法有两种：
1、直接沿用接口的泛型
例如：
public class DemoImpl1<T> implements Demo<T> {
public void print(T param) {
  System.out.println("param = " + param);
}
}
2、用子类作为泛型
public class DemoImpl2 implements Demo<DemoImpl2> { //　设置具体类型
public void print(DemoImpl2 param) {
  System.out.println("param = " + param);
}
}
七、泛型方法
泛型除了在类中定义之外，还可以在方法上定义，而且在方法上使用泛型，此方法所在的类不一定是泛型的操作类。
权限修饰符 <泛型>  返回值类型 print(参数列表){}
方法的返回值类型及其中的变量的数据类型都可以用该泛型指定。
一般其中参数都有一个是泛型指定的，那么在调用该方法的时候，根据所传递的实参的数据类型来决定该泛型的具体类型。
例如：
class Demo {
public <T> T print(T param){ // 定义泛型方法
  return param ;
}
}
public class GenDemo17 {
public static void main(String[] args) {
  Demo d = new Demo() ;
  System.out.println(d.print(1)); // 如果输入１表示类型是Integer
}
}
-----------------------------------------------------------------------------
public class GenDemo18 {
public static void main(String[] args) {
  Integer i[] = fun(1, 2, 3, 4, 5, 6, 7, 8, 9);
  for (int x : i) {
   System.out.println(x);
  }
}
public static <T> T[] fun(T... param) {
  return param; // 返回数组
}
}
八、泛型的嵌套设置
例如：各个类在不同的包中
public class Info<T> {
private T param ;
public T getParam() {
  return param;
}
public void setParam(T param) {
  this.param = param;
}
}
public class Person<T> {
private T info;
public T getInfo() {
  return info;
}
public void setInfo(T info) {
  this.info = info;
}
}
public class Test {
public static void main(String[] args) {
        //同时即要指定Person的泛型类型，又要指定Info中的泛型类型
  Person<Info<String>> per = new Person<Info<String>>() ;
  per.setInfo(new Info<String>()) ;
  per.getInfo().setParam("mldnjava") ;
  System.out.println(per.getInfo().getParam()) ;
}
}
I
J
K

评论

2 楼 Javakeith 2010-10-10  

笔记很好，但是 LZ不觉得是这总是别人总结的吗？ 加些自己的看法和想法，实践 就更好了！加油,

1 楼 q821424508 2010-04-18  

帖子不错 收藏