java学习笔记 genenic 范形

一   为什么要使用范型：

泛型使用的意义是把转型错误从程序运行时，提前到了编译器

例如：现要设置一个点Point类,有X坐标，Y坐标。要求这个Point的两个属性X,Y可以保存int、float和字符串类型。那么可以做如下设计，X,Y的类型定为Object来实现参数的任意化

class Point {
    private Object x;
    private Object y;

    public Object getX() {
        return this.x;    
    }
    
    public Object getY() {
        return this.y;    
    }
    
    public void setX(Object x) {
        this.x = x;
    }
    
    public void setY(Object y) {
        this.y = y;
    }
}

1.用整数表示坐标

public class Test {
    public static void main(String[] args) {
        Point p1 = new Point();
        p1.setX(3);//自动装箱操作 int  integer Object
        p1.setY(5);//自动装箱操作 int  integer Object
        
        //取出x,y坐标    
         int x = (Integer)p1.getX();//自动拆箱操作 interger int
        int y = (Integer)p1.getY();//自动拆箱操作 interger int
        
        System.out.println(x);
        System.out.println(y);
    }        
}

/*
错误之处：
1.Integer的I没有大写，注意类名每个单词的首字母都是大写的。
*/

输出：3

           5

2.用字符串表示坐标

public class Test {
    public static void main(String[] args) {
        Point p1 = new Point();
        p1.setX("东经3");
        p1.setY("北纬5");
        
        //取出x,y坐标    
         String x = (String)p1.getX();
        String y = (String)p1.getY();
        
        System.out.println(x);
        System.out.println(y);
    }        
}

输出：东经3

           北纬5

3.如果像下面这样就会出现转型错误

public class Test {
    public static void main(String[] args) {
        Point p1 = new Point();
        p1.setX("3");
        p1.setY("北纬5");
        
        //取出x,y坐标    
         int x = (Integer)p1.getX();
        int y = (Integer)p1.getY();
        
        System.out.println(x);
        System.out.println(y);
    }        
}

程序的语法并没有问题，可以正常的编译通过。在程序运行时会发生错误

输出：java.lang.ClassCastException:java.lang.String cannot be cast to java.lang.Integer

因为在Point类中的属性使用Object类进行接收，造成了安全问题，泛型的引用来解决这一问题。

 

 

二 泛型的使用

定义原理：主要是在类声明时通过一个标识标识类中某个属性类型或者方法的返回类型，形式参数类型

1.泛型参数

class Person<I,N> {
    I age;
    N name;
    String skinColor;
    
    Person(I age,N name,String skinColor) {
        this.age = age;
        this.name = name;
        this.skinColor = skinColor;    
    }    
    
    public String toString() {
        return this.age.toString() +" " + this.name.toString()+" " + this.skinColor.toString();    
    }
}

public class Test {
    public static void main(String[] args) {
        Person<Integer,String> p1 = new Person<Integer,String>(25,"雷锋","黑种人");
        
        System.out.println(p1.toString());    
    }
}

/*
错误之处：
1.Person<int,String>   这里面放的应该是类型  写为Integer
*/

输出：25 雷锋 黑种人

上面的Person类因为在Person的构造方法中使用了泛型，Person类是一个泛型类

2.泛型接口

应用一：直接在接口中指定具体类型

Comparable接口及compareTo定义如下

Interface Comparable<T>
int compareTo(T o)

class Person implements Comparable<Person> {
    int  age;
    String name;
    Person(int age,String name) {
        this.age = age;
        this.name = name;
    }    
    
    public String toString() {
        return this.age + " " + this.name;
    }
    
    public int compareTo(Person p) {
        if(this.age > p.age) {
            return 1;    
        }    else if (this.age < p.age) {
            return -1;    
        }else {
            return this.name.compareTo(p.name);    
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person(21,"张三");
        Person p2 = new Person(22,"李四");
        System.out.println(p1.compareTo(p2));    
    }
}

/*
错误之处：
1. this.age.toString() + " " + this.name;错误：无法取消引用int
*/

输出： –1