java中泛型的定义格式

落日映苍穹つ 2022-07-21 01:54 53阅读 0赞

## 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.运行效果

![这里写图片描述][20160712155845267]

## 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.运行效果

![这里写图片描述][20160712184650263]

## 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.运行结果

![这里写图片描述][20160712185412269]

[20160712155845267]: /images/20220720/f748b36b885c498193baa766f02d5142.png
[20160712184650263]: /images/20220720/5b40c40d1fa44c9f873022a8cce93b72.png
[20160712185412269]: /images/20220720/dcf96c4ab8f747b9a5b1ee42d7b55170.png