java泛型

1 -定义

编译时的类型安全监测机制，也可以把这个数据类型理解成是一种可以传递的参数

泛型类、泛型方法、泛型接口

2 - 泛型定义格式

• <类型>：表示一种类型的格式

• <类型1，类型2......>:表示是多种类型的格式，用逗号分割

3 - 使用泛型的好处

• 把运行期间可能出现的问题，拿到编译期间（错误等级的提升）

• 避免强制类型转换丢失精度等问题的出现

4 - 泛型类

/**
 * @author Mr.乐
 * @Description 泛型类
 * E  -  Element
 * K  -  Key
 * T  -  Type
 * V  -  Value
 */
public class Generic<T> {
//这个成员变量的类型为T,T的类型由外部指定  
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}
-------------------------------------
/**
 * @author Mr.乐
 * @Description 泛型类测试类
 */
public class Demo01 {
    public static void main(String[] args) {
        Generic<String> strG = new Generic<>();//创建泛型类对象
        strG.setT("我是一个字符串！~");
        System.out.println(strG.getT());

        Generic<Integer> intG = new Generic<>();
        intG.setT(1314);
        System.out.println(intG.getT());
    }
}

5 -泛型方法

/**
 * @author Mr.乐
 * @Description
 */
public class Generic {
    //泛型方法
    /*public <T> void show(T i) {
        System.out.println(i);
    }*/
    //有返回值类型的泛型方法
    public <T> T show(T i) {
        return i;
    }
}
-----------------------------
/**
 * @author Mr.乐
 * @Description
 */
public class Demo02 {
    public static void main(String[] args) {
        Generic g = new Generic();//创建泛型方法类的对象
        System.out.println(g.show(1314));
        g.show("String");
        g.show(3.14f);
        g.show(new Student("Andy",18));
    }
}

6 - 泛型接口

/**
 * @author Mr.乐
 * @Description
 */
public interface Generic <T>{
    void show(T t);
}
----------------------------------
/**
 * @author Mr.乐
 * @Description
 */
public class GenericImpl <T> implements Generic<T>{
    @Override
    public void show(T t) {
        System.out.println("我是实现类中的show方法：" + t);
    }
}
---------------------------------------------------------------------
/**
 * @author Mr.乐
 * @Description
 */
public class Demo03 {
    public static void main(String[] args) {
        GenericImpl<String> strG = new GenericImpl<>();

        strG.show("字符串");

        //通过匿名内部类实现
        new Generic<Integer>() {
            @Override
            public void show(Integer integer) {
                System.out.println("我是匿名内部类的show方法" + integer);
            }
        }.show(1314);
    }
}

7 - 泛型通配符

import java.util.ArrayList;

/**
 * @author Mr.乐
 * @Description  泛型通配符
 */
public class demo04 {
    public static void main(String[] args) {
        //<?>  通配所有  相当于Object
        ArrayList<?> list01 = new ArrayList<Object>();
        ArrayList<?> list02 = new ArrayList<Integer>();//Integer为Object子类
        ArrayList<?> list03 = new ArrayList<Float>();
        ArrayList<?> list04 = new ArrayList<Number>();

        //<? extends Number>  上限  ？仅为Number类及子类
        ArrayList<? extends Number> list05 = new ArrayList<Number>();
        ArrayList<? extends Number> list06 = new ArrayList<Integer>();
        ArrayList<? extends Number> list07 = new ArrayList<Float>();
//        ArrayList<? extends Number> list08 = new ArrayList<String>();

        //<? super Number>   下限   ？仅为Number类及父类
        ArrayList<? super Number> list09 = new ArrayList<Number>();
//        ArrayList<? super Number> list10 = new ArrayList<Integer>();
//        ArrayList<? super Number> list11 = new ArrayList<String>();
        ArrayList<? super Number> list12 = new ArrayList<Object>();
    }
}

8 - 泛型通配符的基本应用

import java.util.ArrayList;

/**
 * @author Mr.乐
 * @Description  泛型通配符的基本应用
 */
public class Demo05 {
    public static void main(String[] args) {
        ArrayList<String> strList = new ArrayList<>();
        show(strList);
//        showUp(strList);
//        showDown(strList);
        ArrayList<Integer> intList = new ArrayList<>();
        show(intList);
        showUp(intList);
//        showDown(intList);
        ArrayList<Number> numList = new ArrayList<>();
        show(numList);
        showUp(numList);
        showDown(numList);
        ArrayList<Object> objList = new ArrayList<>();
        show(objList);
//        showUp(objList);
        showDown(objList);
    }
    //<?>  表示通配所有
    private static void show(ArrayList<?> list){

    }
    //表示上限
    private static void showUp(ArrayList<? extends Number> list){

    }
    //表示下限
    private static void showDown(ArrayList<? super Number> list){

    }
}

总结

        泛型，大家用到最多的就是在集合中，在实际的开发过程中，自己可以使用泛型去简化开发，保证同种类型，能很好的保证代码质量。