泛型

1、什么是泛型

 　　 在定义类时，不给定类中成员 [ 属性   方法的返回类型   方法的参数 ] 的数据 类型，而在类对象创建时为其指定相应的数据类型。

2、为什么使用泛型　　

    例子: 定义一个点类。x坐标和y坐标。

    要求: x和y的值可以都是字符串类型,x和y的值都是小数类型,x和y的值都可以是整型。

//x,y的值都是字符串类型
Pate pate = new Pate("东经180度","北纬72度");
//x,y的值都是整型
Pate pate1 = new Pate(180,72);
//x,y的值都是小数类型
Pate pate2 = new Pate(180.9,72.9);
//可以一个是字符串一个是整型
Pate pate3 = new Pate("东经180度",72);
String x =(String) pate3.getX();
System.out.println(x);
//数据类型不安全问题。--因为你在定义Pate类型指定的属性类型为object
//代码运行就会报错
String y =(String) pate3.getY();
System.out.println(y);

所以导致我们在给Pate类中属性赋值时可以赋值任意类型，在后面获取相应属性时，会出现数据类型安全问题。

我们可以使用泛型来解决上面的数据类型安全问题。

3、如何定义泛型类

语法：

public class 类名<泛型标志，泛型标志.....>{
    public 泛型标志 属性名;

}
--泛型标志可以是任意字符。习惯使用T

public class Pate<T> {
    public T x;
    public T y;
    public Pate() {
    }
    public Pate(T x, T y) {
        this.x = x;
        this.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;
    }
    @Override
    public String toString() {
        return "Pate{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }

//定义String字符串类型
 Pate<String > pate = new Pate<String >("东经180度","北纬72度");
        String x = pate.getX();
        String y = pate.getY();
        System.out.println(x);
        System.out.println(y);
//定义Numbern类型
Pate<Number > pate1 = new Pate<Number>(180,72);
        Number x1 = pate1.getX();
        Number y1 = pate1.getY();
        System.out.println(x1);
        System.out.println(y1);
// //出现数据类型转换问题----不会出现数据类型安全问题。

 4、通配符

  在开发中对象的引用传递是最常见的，但是如果在泛型类的操作中，在进行引用传递时泛型类型必须匹配才可以传递，否则是无法传递的。

public class Pate<T> {
    public T x;
    public T y;
    public void show(){
        System.out.println(x);
        System.out.println(y);
    }
    public Pate() {
    }
    public Pate(T x, T y) {
        this.x = x;
        this.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;
    }
    @Override
    public String toString() {
        return "Pate{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }

public static void main(String[] args) {
        /*string类型*/
        Pate<String> pate = new Pate<String >("东经180度","北纬72度");
         /*Integer类型*/
        Pate<Integer> pate1 = new Pate<Integer>(180,72);
        /*Double类型*/
        Pate<Double> pate2 = new Pate<Double>(520.5,123.6) ; 
        /*任意类型*/
        fun2(pate);
    }
    public static void fun2(Pate<?> pate){pate.show();}

5、受限泛型

  在引用传递中，在泛型操作中也可以设置一个泛型对象的范围上限和范围下限。范围上限使用extends关键字声明，表示参数化的类型可能是所指定的类型或者是此类型的子类，而范围下限使用super进行声明，表示参数化的类型可能是所指定的类型或者此类型的父类型。

public class Pate<T> {
    public T x;
    public T y;
    public void show(){
        System.out.println(x);
        System.out.println(y);
    }
    public Pate() {
    }
    public Pate(T x, T y) {
        this.x = x;
        this.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;
    }
    @Override
    public String toString() {
        return "Pate{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }

public static void main(String[] args) {
    Pate<String > pate = new Pate<String >("东经180度","北纬72度");    
    Pate<Number > pate1 = new Pate<Number>(180,72);    
    Pate<Integer > pate2 = new Pate<Integer>(520,123) ; 
    /*string类型*/
    fun(pate1);
    /*Number类型*/
    fun1(pate2);
    /*Integer类型*/
    fun2(pate);
}
/**
 * 泛型的下限--泛型类型  不能小于Number类型要么为Number的父类
 * @param pate
 */
public static void fun(Pate<? super Number> pate){
    pate.show();
}
/**
 * 泛型的上限--泛型类型  不能大于Number类型要么为Number的子类
 * @param pate
 */
public static void fun1(Pate<? extends Number> pate){pate.show();}
/**
 * 泛型任意类型
 * @param pate
 */
public static void fun2(Pate<?> pate){pate.show();}

6. 泛型接口

语法：

public interface 接口名<泛型标识,....>{

}

接口用来被类实现。一个类如何实现泛型接口。有两种方式

（1）在实现泛型接口时为泛型接口指定类型。

(2) 该类也是一个泛型类，而且该类使用的泛型标志必须和接口的标志一致。

 

 

  public static void main(String[] args) {
        Mouse mouse = new Mouse();
        mouse.use("今日复明日");
        Upen<Integer> integerUpen = new Upen<>();
        integerUpen.use(456);
    }
}

    /**
     * 定义泛型的接口
     *
     * @param <T>
     */
    interface USB<T> {
        public abstract void use(T t);
    }

/**
 * 第一种  类实现泛型接口时为其指定泛型类型
 */
class Mouse implements USB<String> {
        public void use(String s) {
            System.out.println("---" + s);
        }
    }

/**
 * 第二种 类实现接口时该类也泛型类，标志必须和接口的泛型标志一致  List ArrayList
 * @param <T>
 */
class Upen<T> implements USB<T> {
        public void use(T t) {
            System.out.println("---" + t);
        }
    }

7. 泛型方法

前面学习的所有泛型操作都是将整个类进行泛型化，但同样也可以在类中定义泛型化的方法。泛型方法的定义与其所在的类是否是泛型类是==没有任何关系的==，所在的类可以是泛型类，也可以不是泛型类。

【泛型方法的简单定义】

[访问权限] <泛型标识> 泛型标识 方法名称(泛型标识 参数名称){

}

public static void main(String[] args) {
        PateTxt pateTxt = new PateTxt();
        Integer fun = pateTxt.fun(15);
        String i = pateTxt.fun("今日复明日");
    }

    /**
     * 泛型方法
     * @param t
     * @return
     * @param <T>
     */
    public <T> T fun(T t){
        System.out.println("----"+t);
        return t;
    }
}