java定义列表泛型 java定义泛型方法的格式

1.在集合中泛型的使用

a.新建Test类，在main中测试那是属于集合中泛型的方式

import java.util.ArrayList;

public class Test {

    // 集合上泛型

    // 将运行时异常提前至编译时
    // 减少不必要的强制转换
    // 泛型，两边类型一致，或右边不写，或左边不写（为了兼容老版本）


    public static void main(String[] args) {

        // 不是泛型
        ArrayList list = new ArrayList();// 基本集合的对象，没有使用泛型,可以装任意类型的对象
        list.add(1);
        list.add("asd");

        // 不是泛型
        ArrayList d3 = new ArrayList<Integer>();
        d3.add(1);
        d3.add("teacher");
        System.out.println(d3.get(1));

        // ArrayList<>a=new ArrayList<Object>();不能这样使用

        //是泛型
        ArrayList<Double> d = new ArrayList<>();
        ArrayList<Double> d2 = new ArrayList<Double>();

        ArrayList<Integer> l = new ArrayList();// 一边使用泛型，兼容老版本
        // 自动装箱技术，l集合把1转换成Integer对象，引用数据类型。
        // 在泛型中本不能使用基本类型，接收需要使用对应包类型 
        //int Integer short Short long Long double Double等
        l.add(1);
        l.add((int) 'c');
        l.add((int) 2.34);

        // 有限制
        ArrayList<String> mList = new ArrayList<>();// 只能存字符串容器
        mList.add("aa");
        mList.add("bb");
        mList.add("AbCdEf12345");
        // mList.add(22);//报错
        for (int i = 0; i < mList.size(); i++) {
        System.out.println(mList.get(i).toUpperCase());
        }

        // 添加javaBean
        Stu s1 = new Stu("jack", 12);
        Stu s2 = new Stu("jan", 13);
        ArrayList<Stu> mStu = new ArrayList<Stu>();
        mStu.add(s1);
        mStu.add(s2);
//打印添加信息
        for (int i = 0; i < mStu.size(); i++) {
            System.out.println(mStu.get(i).toString());
        }

    }

}

b.由于集合中泛型可以添加任意一类对象，在main中测试Stu类如下。

public class Stu {

    public String name;
    public Integer age;

    public Stu(String name, Integer age) {

        this.name = name;
        this.age = age;

    }

    @Override
    public String toString() {
        return "学生类信息： [name=" + name + ", age=" + age + "]";
    }


}

c.运行效果

2.在定义方法中泛型的使用

a.新建Test2

public class Test2 {

    /*
     * 自定义方法泛型 格式： 
     * 修饰符 <T> 返回类型 方法名（T 参数） {
     * 
     * }
     */
    public static void main(String[] args) {

        println(12345);
        println("abcde");

        Stu s = call(new Stu());
    }

    // 自定义泛型，在调用实参才确定占位符，确定类型，一般占位符用T或E
    // 输出 任意类型 t 并换行
    public static <T> void println(T t) {

        System.out.println(t);

    }

    public static <E> E call(E e) {

        return e;

    }

}

3.在类中泛型的使用格式

a.新建Test3，在main中测试类中泛型格式

public class Test3 {

    // 泛型类,在类上自定义泛型，实在创建对象实现确定,没指定为object类型
    // 在泛型类中不能作用于静态方法，需要自定义。
    public static void main(String[] args) {

        Integer[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
        Utils<Integer> utils = new Utils<Integer>();//确定类型
        utils.recerse(arr);
        utils.toString(arr);

        Character[] ch = { 'a', 'b', 'c', 'd', 'e', 'f' };
        Utils<Character> utils2 = new Utils<>();
        utils2.toString(ch);
        utils2.recerse(ch);
        utils2.toString(ch);

        String[]str={"ab","cd","e"};
        System.out.println(Utils.getSize(str));


        new Teacher().getName("Hello ,world !");//执行到实参时候确定


    }

}
//泛型在类上表现形式一
class Teacher{

    public <T> void getName(T t) {
        System.out.println("在类中封装的泛型方法！");
    }

}
//泛型在类上表现形式二
class Utils<T> {
// 数组的反转
    public void recerse(T[] arr) {

        for (int i = 0, max = arr.length; i < max; i++, max--) {

            T tmp = arr[max - 1];
            arr[max - 1] = arr[i];
            arr[i] = tmp;

        }
    }
//输出数组
    public void toString(T[] arr) {

        StringBuffer buffer = new StringBuffer();

        for (int i = 0; i < arr.length; i++) {

            if (i == 0) {
                buffer.append("[" + arr[i] + " , ");
            } else if (i == arr.length - 1) {
                buffer.append(arr[i] + "]");
            } else {

                buffer.append(arr[i] + " , ");
            }

        }
        System.out.println(buffer);
    }
//返回数组长度
    public static <T> int getSize(T[] arr) {

        return arr.length;

    }

}

b.运行效果

4.在接口中泛型的使用格式

a.新建Test4类，在类中实现接口CallBack的时候必须指定接口类型。

public class Test4 implements CallBack<String> {

    // 泛型接口,在实现接口是指定类型，没指定为object

    public static void main(String[] args) {

        new Test4().add("qishuichixi");
        new Test4().add("yuluochanganjie");

    }

    @Override
    public void add(String t) {
        System.out.println("重要的事情说三篇！！！");
        System.out.println(t);
        System.out.println(t);
        System.out.println(t);
        System.out.println("Cheer Up !!");

    }

}


interface CallBack<T> {

    public void add(T t);

}

b.在开始没指定接口类型

public class Test4 implements CallBack {
     //CallBack is a raw type. References to generic type CallBack<T> should be parameterized
    // 泛型接口,在实现接口是指定类型，没指定为object

    public static void main(String[] args) {

        new Test4().add("qishuichixi");
        new Test4().add("yuluochanganjie");

    }



    @Override
    public void add(Object t) {
        // TODO Auto-generated method stub
        System.out.println("重要的事情说三篇！！！");
        System.out.println(t);
        System.out.println(t);
        System.out.println(t);
        System.out.println("Cheer Up !!");
    }

}

c.在开始的类也定义泛型，可以延迟决定泛型类型

public class Test4<T> implements CallBack<T> {
     //CallBack is a raw type. References to generic type CallBack<T> should be parameterized
    // 泛型接口,在实现接口是指定类型，没指定为object

    public static void main(String[] args) {

        new Test4().add("qishuichixi");
        new Test4().add("yuluochanganjie");

    }

    @Override
    public void add(T t) {
        System.out.println("重要的事情说三篇！！！");
        System.out.println(t);
        System.out.println(t);
        System.out.println(t);
        System.out.println("Cheer Up !!");

    }

}


interface CallBack<T> {

    public void add(T t);

}

d.运行结果