18---java中泛型01(了解泛型)

 

其实之所以用泛型：就是为了可以实现外界来定义某个类中属性的类型；
   即由外部决定类中的变量(属性)的类型；

1、为什么使用泛型（Generic）？
 为了保证数据的安全性：
  class Point{
   private Object x;
   private Object y;
   public void setX(Object x){
     this.x=x;
    }
   public void setY(Object y){
     this.y=y;
    }
   public Object getX(){
     return this.x;
    }
   public Object getY(){
     return this.y;
    }
  }

  public class Demo{
    public static void main(String args[]){
      Point p=new Point();
      p.setX(10);//利用自动装箱操作：int--->Integer
      p.setY(20);
      int x=(Integer)p.getX();//取出数据先变成Integer，自后自动拆箱
      int y=(Integer)p.getY();
      System.out.println("整数表示，x坐标为："+x);
      System.out.println("整数表示，y坐标为："+y);
     }
   }
 ======================================================================================
   class Point{
    private Object x;
    private Object y;
    public void setX(Object x){
      this.x=x;
     }
    public void setY(Object y){
      this.y=y;
     }
    public Object getX(){
      return this.x;
     }
    public Object getY(){
      return this.y;
     }
   }

   public class Demo{
     public static void main(String args[]){
       Point p=new Point();
       p.setX("东经180度");
       p.setY("北纬190度");
       String x=(String)p.getX();
       String y=(String)p.getY();
       System.out.println("字符串表示，x坐标为："+x);
       System.out.println("字符串表示，y坐标为："+y);
      }
    }
 以上代码的好处是：用Object类型可以接受任意类型的数据，这样可以实现通用型；
 但是也正是因为是Object，也很容易出现错误：
   p.setX(10);
   p.setY("北纬190度");//操作有误造成
   int x=(Integer)p.getX();//取出数据先变成Integer，自后自动拆箱
   int y=(Integer)p.getY();
 这样编译时检查不出来错误的，执行时错误；
 为了避免以上操作不当造成错误，这样就出现了泛型：

2、泛型：泛型可以解决数据类型的安全性问题，他的原理是在类声明的时候
 通过一标识表示类中某个属性的类型或者是某个方法的返回值即参数类型，
 这样在类声明或者实例化的时候只要指定好需要的类型即可；
  class Point<T>{//此处可以随便写标识符合，T是type的简写
   private T var;//var的类型由T指定，即由外部指定
   public void setVar(T var){//返回类型由外部决定
    this.var=var;
    }
   public T getVar(){//设置类型由外部决定
    return this.var;
    }
   }
   
  public class Demo{
   public static void main(String args[]){
     Point<String> p=new Point<String>();//里面的var为String类型
     p.setVar("LID");
     System.out.println(p.getVar().length());
    }
   }
 如果改成如下：
   Point<Integer> p=new Point<Integer>();//里面的var为String类型
   p.setVar("LID");
 这样编译就不通过，所以很好的保护了数据的安全；

3、构造方法中也可以用泛型：
  class Point<T>{//此处可以随便写标识符合，T是type的简写
   private T var;//var的类型由T指定，即由外部指定
   public Point(T var){
    this.var=var;
    }
   public void setVar(T var){//返回类型由外部决定
    this.var=var;
    }
   public T getVar(){//设置类型由外部决定
    return this.var;
    }
   }
   
  public class Demo{
   public static void main(String args[]){
     Point<String> p=new Point<String>("LID");//里面的var为String类型
     System.out.println(p.getVar().length());
    }
   }
4、设置多个泛型
  class Note<K,V>{
   private K key;
   private V value;
   
   public void setKey(K key){
     this.key=key;
    }
   public void setValue(V value){
     this.value=value;
    }
   public K getKey(){
     return this.key;
    }
   public V getValue(){
     return this.value;
    }
   }
   
  public class Demo{
   public static void main(String args[]){
     Note<String,Integer> n=new Note<String,Integer>();
     n.setKey("lid");
     n.setValue(20);
     System.out.println("姓名："+n.getKey());
     System.out.println("年龄："+n.getValue());
    }
   }
5、泛型的安全警告
 在泛型的应用中最好在声明类对象的时候指定好其内部的数据类型，例如：“Info<String>”
 但是也可以不指定
  class Info<T>{
   private T var;
   public void setVar(T var){
     this.var=var;
    }
   public T getVar(T var){
     return this.var;
    }
   public String toString(){
     return this.var.toString();
    }
   }
  public class Demo{
   public static void main(String args[]){
     Info i=new Info();//警告，没有指定泛型
     i.setVar("LID");
     System.out.print("姓名："+i.toString());
    }
   }
  编译以上的程序，会出现警告，但是程序不受影响；
  在程序中为保证程序依然可以使用，会将T设置成Object类型，这样一来，就可以
  接受任意类型的数据了，也就是说现在的var的类型是Object类型，所有的泛型信息将被
  删除；等同于：
   Info i=new Info();
   Info<Object> i=new Info<Object>();