您当前的位置： 首页 > 学无止境 > 心得笔记 网站首页心得笔记

【第10章：泛型】_泛型入门

发布时间：2020-12-22 15:09:46编辑：雪饮阅读（）

 对于经纬度的设置一般有x(int)、 y(int)或x(string)、y(string)或x(float),y(float)或错误的设置x(int)、y(string)。毕竟输入端是不可控的。那么如果针对该需要设计一个类。

Object实现
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 Hello{
   public static void main(String args[]){
          Point p=new Point();
          p.setX(10);
          p.setY(20);
          int x=(Integer)p.getX();
          int y=(Integer)p.getY();
          System.out.println(x);
          System.out.println(y);
   }
}
D:\>javac Hello.java
D:\>java Hello
10
20
这里用到了Object始祖类，所以支持各种类型参数进行构造，只是取回来后需要手动向下转型，比如float也是可以的。
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 Hello{
   public static void main(String args[]){
          Point p=new Point();
          p.setX(10.5f);
          p.setY(20.5f);
          float x=(Float)p.getX();
          float y=(Float)p.getY();
          System.out.println(x);
          System.out.println(y);
   }
}
D:\>javac Hello.java
D:\>java Hello
10.5
20.5
或者String类型
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 Hello{
   public static void main(String args[]){
          Point p=new Point();
          p.setX("东经10.5");
          p.setY("北纬20.5");
          String x=(String)p.getX();
          String y=(String)p.getY();
          System.out.println(x);
          System.out.println(y);
   }
}
D:\>javac Hello.java
 
D:\>java Hello
东经10.5
北纬20.5
但如果是类型混用，如下面这种情况虽然编译不报错，但是运行时会报错。
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 Hello{
   public static void main(String args[]){
          Point p=new Point();
          p.setX(10);
          p.setY("北纬20.5");
          int x=(Integer)p.getX();
          int y=(Integer)p.getY();
          System.out.println(x);
          System.out.println(y);
   }
}
D:\>javac Hello.java
 
D:\>java Hello
Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
        at Hello.main(Hello.java:23)
泛型实现
泛型即类的定义类型由使用的的调用者来确定类用<泛型变量>的格式来声明，则类内部的返回值若用到泛型类型同样调用类定义的泛型变量，而对于调用类的使用者来说栈变量类型与new该类的时候用<泛型变量值>的形式。如：
class Point<T>{
       private T x;
       private T y;
       public void setX(T x){
              this.x=x;
       }
       public void setY(T y){
              this.y=y;
       }
       public T getX(){
              return this.x;
       }
       public T getY(){
              return this.y;
       }
}
public class Hello{
   public static void main(String args[]){
          Point<String> p=new Point<String>();
          p.setX("东经10.5");
          p.setY("北纬20.5");
          System.out.println(p.getX());
          System.out.println(p.getY());
   }
}
D:\>javac Hello.java
 
D:\>java Hello
东经10.5
北纬20.5
这样操作会省去调用者获取到结果后还要手动向下转型的缺点（于Object实现方式）
但是如果类型混用还是会出错的，但与上面通过Object实现方式不同的是Object方式实现的时候是在运行时才报错，这里在编译期间就已经出错了。
class Point<T>{
       private T x;
       private T y;
       public void setX(T x){
              this.x=x;
       }
       public void setY(T y){
              this.y=y;
       }
       public T getX(){
              return this.x;
       }
       public T getY(){
              return this.y;
       }
}
public class Hello{
   public static void main(String args[]){
          Point<Integer> p=new Point<Integer>();
          p.setX("东经10.5");
          p.setY("北纬20.5");
          System.out.println(p.getX());
          System.out.println(p.getY());
   }
}
D:\>javac Hello.java
Hello.java:20: 无法将 Point<java.lang.Integer> 中的 setX(java.lang.Integer) 应用于 (java.lang.String)
           p.setX("东经10.5");
            ^
Hello.java:21: 无法将 Point<java.lang.Integer> 中的 setY(java.lang.Integer) 应用于 (java.lang.String)
           p.setY("北纬20.5");
            ^
2 错误
对于Integer类型的还是得用回int
class Point<T>{
       private T x;
       private T y;
       public void setX(T x){
              this.x=x;
       }
       public void setY(T y){
              this.y=y;
       }
       public T getX(){
              return this.x;
       }
       public T getY(){
              return this.y;
       }
}
public class Hello{
   public static void main(String args[]){
          Point<Integer> p=new Point<Integer>();
          p.setX(10);
          p.setY(20);
          System.out.println(p.getX());
          System.out.println(p.getY());
   }
}
D:\>javac Hello.java
 
D:\>java Hello
10
20
泛型也支持泛型构造
class Point<T>{
       private T x;
       private T y;
       public void setX(T x){
              this.x=x;
       }
       public void setY(T y){
              this.y=y;
       }
       public T getX(){
              return this.x;
       }
       public T getY(){
              return this.y;
       }
       public Point(T x,T y){
              this.x=x;
              this.y=y;
       }
}
public class Hello{
   public static void main(String args[]){
          Point<String> p=new Point<String>("东经10.5","北纬20.5");
          System.out.println(p.getX());
          System.out.println(p.getY());
  }
}
D:\>javac Hello.java
 
D:\>java Hello
东经10.5
北纬20.5
类型混用的解决（多类型的泛型）
泛型的类型变量可以多个，则可以支持多个泛型运用于同一个泛型类中。利用该特性可以解决上面类型混用的问题，如：
class Point<X,Y>{
       private X x;
       private Y y;
       public void setX(X x){
              this.x=x;
       }
       public void setY(Y y){
              this.y=y;
       }
       public X getX(){
              return this.x;
       }
       public Y getY(){
              return this.y;
       }
       public Point(X x,Y y){
              this.x=x;
              this.y=y;
       }
}
public class Hello{
   public static void main(String args[]){
          Point<String,Integer> p=new Point<String,Integer>("东经10.5",20);
         System.out.println(p.getX());
          System.out.println(p.getY());
   }
}
D:\>javac Hello.java
 
D:\>java Hello
东经10.5
20
泛型警告
当使用了泛型类产生新实例的时候不显式指定泛型类型，则会在编译过程中报出警告，但是并不会影响编译，编译还是可以通过，程序还是可以运行。如
class Point<X,Y>{
       private X x;
       private Y y;
       public void setX(X x){
              this.x=x;
       }
       public void setY(Y y){
              this.y=y;
       }
       public X getX(){
              return this.x;
       }
       public Y getY(){
              return this.y;
       }
       public Point(X x,Y y){
              this.x=x;
              this.y=y;
       }
}
public class Hello{
   public static void main(String args[]){
         Point p=new Point("东经10.5",22);
          System.out.println(p.getX());
          System.out.println(p.getY());
   }
}
D:\>javac Hello.java
注意：Hello.java 使用了未经检查或不安全的操作。
注意：要了解详细信息，请使用 -Xlint:unchecked 重新编译。
 
D:\>java Hello
东经10.5
22
这是因为java再处理调用时对于泛型类没有显式指定泛型类型时候会给出警告的同时会将泛型擦除更换为Object，形同如下：
class Point<X,Y>{
       private X x;
       private Y y;
       public void setX(X x){
              this.x=x;
       }
       public void setY(Y y){
              this.y=y;
       }
       public X getX(){
              return this.x;
       }
       public Y getY(){
              return this.y;
       }
       public Point(X x,Y y){
              this.x=x;
              this.y=y;
       }
}
public class Hello{
   public static void main(String args[]){
          Point<Object,Object> p=new Point<Object,Object>("东经10.5",23);
          System.out.println(p.getX());
          System.out.println(p.getY());
   }
}

所以对于一开始的需求现在发现还是泛型结合Object才是正解。