Java笔记13 泛型

最新推荐文章于 2023-05-31 14:32:41 发布
最新推荐文章于 2023-05-31 14:32:41 发布
阅读量195 收藏
点赞数 1
分类专栏： Java笔记 文章标签： java 开发语言 java-ee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44736498/article/details/123465617
版权
本文详细介绍了Java泛型的概念、优点、使用方法，包括泛型类、泛型接口、泛型方法的声明和实例化。通过示例展示了泛型在实际编程中的应用，如在集合操作中的类型安全性和效率提升，以及自定义泛型类和接口。此外，还探讨了泛型的通配符使用和JUnit单元测试的重要性。
摘要由CSDN通过智能技术生成

13.1 泛型优点

  1. 编译时，检查添加元素的类型，提高了安全性
  2. 减少了类型转换的次数，提高了效率
    1. 不使用泛型：Dog -加入-> Object -取出-> Dog //Dog加入到ArrayList会先转成Object，在取出时，还需要转换成Dog
    2. 使用泛型：Dog -> Dog ->Dog//放入时和取出时，不需要类型转换，提高效率
  3. 不再提示编译警告

13.2 介绍

  1. 泛型又称参数化类型，是JDK5.0出现的新特性，解决数据类型的安全性问题

  2. 在类声明或实例化时只要指定好需要的具体类型即可

  3. Java 泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮

  4. 泛型的作用：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者参数类型

    public class GenericDemo {
    public static void main(String[] args) {
        Person<String> tom = new Person<String>("tom");
        System.out.println(tom.f());//tom
        tom.showType();//class java.lang.String

        Person<Integer> integerPerson = new Person<Integer>(100);
        System.out.println(integerPerson.f());//100
        integerPerson.showType();//class java.lang.Integer
    }
}
class Person<E> {
    E s;
    //E表示 s 的数据类型，该数据类型在定义Person对象时指定，
    //即在编译期间。就确定E是什么类型

    public Person(E s) {//E也可以是参数类型
        this.s = s;
    }

    public E f() {//返回类型使用E
        return s;
    }

    public void showType() {//打印s的运行类型
        System.out.println(s.getClass());
    }
}

13.3 泛型的使用

13.3.1 泛型的声明

  • 接口：interface 接口<T> {}

  • 类：class 类名<K, V> {}

比如：List、ArrayList

说明：

  1. 其中，T、K、V 不代表值，而是表示类型
  2. 任意字母都可以，常用 T 表示，是 Type 的缩写

13.3.2 泛型的实例化

要在类名后指定类型参数的值（类型），如：

  1. List<String> strList = new ArrayList<String>();
  2. Iterator<Customer> iterator = cumtomers.iterator();

13.3.3 泛型使用举例

要求：

  1. 创建 3 个学生对象
  2. 学生对象放入 HashSet 中
  3. 放入 HashMap 中，要求 key 是 String name，value 是学生对象
  4. 使用两种方式遍历
public class GenericExer01 {
    public static void main(String[] args) {
        Student tom = new Student("tom", 16);
        Student jack = new Student("jack", 15);
        Student mary = new Student("mary", 16);

        //放入HashSet
        HashSet<Student> students = new HashSet<>();
        students.add(tom);
        students.add(jack);
        students.add(mary);

        System.out.println("====HashSet使用增强for遍历====");
        for (Student student : students) {
            System.out.println("姓名：" + student.getName() + "，年龄：" + student.getAge());
        }

        System.out.println("====HashSet使用迭代器遍历====");
        Iterator<Student> studentIterator = students.iterator();
        while (studentIterator.hasNext()) {
            Student next = studentIterator.next();
            System.out.println("姓名：" + next.getName() + "，年龄：" + next.getAge());
        }

        //放入HashMap
        HashMap<String, Student> studentHashMap = new HashMap<>();
        studentHashMap.put(tom.getName(), tom);
        studentHashMap.put(jack.getName(), jack);
        studentHashMap.put(mary.getName(), mary);

        System.out.println("====HashMap使用增强for遍历====");
        Set<String> names = studentHashMap.keySet();
        for (String name : names) {
            System.out.println("姓名：" + name + "，年龄：" + studentHashMap.get(name).getAge());
        }

        System.out.println("====HashMap使用迭代器遍历====");
        Set<Map.Entry<String, Student>> entries = studentHashMap.entrySet();
        Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Student> next = iterator.next();
            System.out.println("姓名：" + next.getKey() + "，年龄：" + next.getValue().getAge());
        }
    }
}
class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

13.3.4 使用细节

  1. 接口和类都能指定泛型，如interface List<T> {}、public class HashSet<E> {}等，要注意其中的 T 、E 只能是引用类型
    1. 以下语句是否正确：
      1. List<Integer> list = new ArrayList<Integer>();//ok
      2. List<int> list2 = new ArrayList<int>(); //错误
  2. 在给泛型指定具体类型后，可以传入该类型或其子类型
  3. 泛型使用形式：
    1. List<Integer> list1 = new ArrayList<Integer>();
    2. List<Integer> list2 = new ArrayList<>();
  4. 如果我们不指定具体类型，如List list3 = new ArrayList();，默认给他指定的泛型为Object【<E> E 就是Object】

13.4 泛型练习

定义Employee类

  1. 该类包含: private成员变量name,sal,birthday,其中birthday为MyDate类的对象
  2. 为每一个属性定义getter, setter方法
  3. 重写 toString方法输出name, sal, birthday
  4. MyDate类包含: private成员变量month,day,year;并为每一个属性定义 getter, setter方法
  5. 创建该类的3个对象,并把这些对象放入ArrayList集合中(ArrayList需使用泛型来定义) ,对集合中的元素进行排序,并遍历输出
  6. 排序方式:调用ArrayList的sort方法,传入Comparator对象[使用泛型],先按照 name排序,如果name相同,则按生日日期的先后排序。【即:定制排序】
public class GenericExer02 {
    public static void main(String[] args) {
        ArrayList<Employee> employees = new ArrayList<>();
        employees.add(new Employee("tom", 6000, new MyDate(2000, 1,3)));
        employees.add(new Employee("mary", 20000, new MyDate(1995, 11,13)));
        employees.add(new Employee("jack", 4000, new MyDate(1998, 7,6)));
        employees.add(new Employee("mary", 3000, new MyDate(2001, 5,1)));

        employees.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                int nameDifference = o1.getName().compareTo(o2.getName());
                if (nameDifference != 0)
                    return nameDifference;
                else
                    return o1.getBirthday().compareTo(o2.getBirthday());
            }
        });
        for (Employee employee : employees) {
            System.out.println(employee);
        }
    }
}
class Employee {
    private String name;
    private double sal;
    private MyDate birthday;

    public Employee(String name, double sal, MyDate birthday) {
        this.name = name;
        this.sal = sal;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }

    public MyDate getBirthday() {
        return birthday;
    }

    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "姓名：" + name + ",工资：" + sal +
                ",生日：" + birthday.getYear() + "年" + birthday.getMonth() + "月"
                + birthday.getDay() + "日";
    }
}
class MyDate implements Comparable<MyDate> {
    private int year;
    private int month;
    private int day;

    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    @Override
    public int compareTo(MyDate date) {
        int yearDifference = year - date.getYear();
        if (yearDifference != 0)
            return yearDifference;

        int monthDifference = month - date.getMonth();
        if (monthDifference != 0)
            return monthDifference;

        return day - date.getDay();
    }
}

13.5 自定义泛型

13.5.1 自定义泛型类

13.5.1.1 基本语法
class 类名<T,R...> {//...表示可以有多个泛型
    成员
}
13.5.1.2 使用细节
  1. 普通成员可以使用泛型（属性、方法）
  2. 使用泛型的数组，不能初始化
  3. 静态方法中不能使用类的泛型
  4. 泛型类的泛型，是在创建对象时确定的（因为创建对象时，需要制定类型）
  5. 如果在创建对象时，没有指定类型，默认为Object
13.5.1.3 示例
public class GerenicExer03 {
    public static void main(String[] args) {
        Tiger<Double, String, Integer> g = new Tiger<>("john");
        g.setT(10.9);//ok
        //g.setT("yy");//类型不匹配
        System.out.println(g);//Tiger{name='john', r=null, m=null, t=10.9}

        Tiger g2 = new Tiger("john~~");//ok
        g2.setT("yy");//ok,T为Object，String是Object子类
        System.out.println(g2);//Tiger{name='john~~', r=null, m=null, t=yy}
    }
}

//1.Tiger 后面有泛型，所以我们把 Tiger 成为 自定义泛型类
//2.T，R，M 是泛型的标识符，一般是大写字母
//3.泛型标识符可以有多个
//4.普通成员可以使用泛型（属性、方法）
class Tiger<T, R, M> {
    String name;
    R r;//属性使用泛型
    M m;
    T t;
    //T[] ts = new T[8];//类型形参 'T' 不能直接实例化
    //因为数组在new的时候不能确定T的类型，就无法在内存中开辟空间
    //T[] ts;//ok

    //static R r2;//无法从 static 上下文引用 'generic_.Tiger.this'
    //public static void m1(M m) {}//无法从 static 上下文引用 'generic_.Tiger.this'
    //因为静态是和类相关的，在类加载时，对象还没创建，泛型还没指定类型
    //所以，如果静态属性/方法使用了泛型，JVM就无法完成初始化


    public Tiger(String name) {
        this.name = name;
    }

    public Tiger(R r, M m, T t) {
        this.r = r;
        this.m = m;
        this.t = t;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public R getR() {//返回类型使用泛型
        return r;
    }

    public void setR(R r) {//方法使用泛型
        this.r = r;
    }

    public M getM() {
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    @Override
    public String toString() {
        return "Tiger{" +
                "name='" + name + '\'' +
                ", r=" + r +
                ", m=" + m +
                ", t=" + t +
                '}';
    }
}

13.5.2 自定义泛型接口

13.5.2.1 基本语法
interface 接口名<T, R...> {
    
}
13.5.2.2 使用细节
  1. 在接口中，静态成员也不能使用泛型
  2. 泛型接口的类型，在继承接口或实现接口时确定
  3. 没有指定类型，默认为 Object
13.5.2.3 示例
public class CustomInterfaceGeneric {
}

interface IUsb<U, R> {
    int n = 10;
    //U name;// 不能这样使用

    //普通方法中，可以使用接口泛型
    R get(U u);

    void hi(R r);

    void run(R r1, R r2, U u1, U u2);

    //在JDK8中，可以在接口中，使用默认方法
    default R method(U u) {
        return null;
    }
}
//1.在继承接口 指定泛型接口的类型
interface IA extends IUsb<String, Double> {
}

//当我们去实现 IA 接口时，因为 IA 在继承 IUsb 接口时，指定了 U 为 String R 为 Double
//AA 类在实现 IUsu 接口的方法时，使用 String 替换 U, 是 Double 替换 R
class AA implements IA {

    @Override
    public Double get(String s) {
        return null;
    }

    @Override
    public void hi(Double aDouble) {

    }

    @Override
    public void run(Double r1, Double r2, String u1, String u2) {

    }
}

//2.实现接口时，直接指定泛型接口的类型
//给 U 指定 Integer 给 R 指定了 Float
//所以，当我们实现 IUsb 方法时，会使用 Integer 替换 U, 使用 Float 替换 R
class BB implements IUsb<Integer, Float> {

    @Override
    public Float get(Integer integer) {
        return null;
    }

    @Override
    public void hi(Float aFloat) {

    }

    @Override
    public void run(Float r1, Float r2, Integer u1, Integer u2) {

    }
}

//3.没有指定类型，默认为 Object
//建议直接写成 IUsb<Object,Object>
class CC implements IUsb {//等价 class CC implements IUsb<Object,Object> {

    @Override
    public Object get(Object o) {
        return null;
    }

    @Override
    public void hi(Object o) {

    }

    @Override
    public void run(Object r1, Object r2, Object u1, Object u2) {

    }
}

13.5.3 自定义泛型方法

13.5.3.1 基本语法
修饰符 <T, R...> 返回类型 方法名(参数列表) {
    
}
13.5.3.2 使用细节
  1. 泛型方法，可以定义在普通类中，也可以定义在泛型类中
  2. 当泛型方法被调用时，类型会确定
  3. public void eat(E e) {}，修饰符后没有<T, R...>，所以 eat 方法不是泛型方法，而是使用了泛型
13.5.3.3 示例
public class CustomMethodGeneric {
    public static void main(String[] args) {
        Car car = new Car();
        car.fly("宝马", 100);//当调用方法时，传入了参数，编译器就会确定类型
        //class java.lang.String
        //class java.lang.Integer

        //T -> String, R -> ArrayList
        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList(), 11.3f);
        //class java.util.ArrayList
        //class java.lang.Float
    }
}
class Car {//普通类
    public void run() {//普通方法

    }

    //1.<T, R>就是泛型
    //2.是提供给fly()使用的
    public <T, R> void fly(T t, R r) {//泛型方法
        System.out.println(t.getClass());
        System.out.println(r.getClass());
    }
}
class Fish<T, R> {//泛型类
    public void run() {//普通方法

    }
    public <U, M> void eat(U u, M m) {//泛型方法

    }
    //1.hi()方法不是泛型方法
    //2.是hi()方法使用了类声明的泛型而已
    public void hi(T t) {

    }
    //泛型方法可以使用自己声明的泛型，也可以使用类声明的泛型
    public <K> void hello(R r, K k) {
        System.out.println(r.getClass());
        System.out.println(k.getClass());
    }
}

13.6 泛型的继承和通配符

13.6.1 说明

  1. 泛型不具备继承性
    1. List<Object> list = new ArrayList<String>();对吗？错误
  2. 泛型的通配符
    1. <?>：支持任意泛型类型
    2. <? extends A>：支持 A 类及 A 类的子类，规定了泛型的上限
    3. <? super A>：支持 A 类及 A 类的父类，不限于直接父类，规定了泛型的下限

13.6.2 示例

public class GenericWildcard {
    public static void main(String[] args) {

        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<AA> list3 = new ArrayList<>();
        List<BB> list4 = new ArrayList<>();
        List<CC> list5 = new ArrayList<>();

        //如果是 List<?> c ，可以接受任意的泛型类型
        printCollection1(list1);//ok
        printCollection1(list2);//ok
        printCollection1(list3);//ok
        printCollection1(list4);//ok
        printCollection1(list5);//ok

        //List<? extends AA> c： 表示 上限，可以接受 AA 或者 AA 子类
//        printCollection2(list1);//error
//        printCollection2(list2);//error
        printCollection2(list3);//ok
        printCollection2(list4);//ok
        printCollection2(list5);//ok

        //List<? super AA> c: 支持 AA 类以及 AA 类的父类，不限于直接父类
        printCollection3(list1);//ok
//        printCollection3(list2);//error
        printCollection3(list3);//ok
//        printCollection3(list4);//error
//        printCollection3(list5);//error

    }

    //说明: List<?> 表示 任意的泛型类型都可以接受
    public static void printCollection1(List<?> c) {
        for (Object object : c) { // 通配符，取出时，就是 Object
            System.out.println(object);
        }
    }

    // ? extends AA 表示 上限，可以接受 AA 或者 AA 子类
    public static void printCollection2(List<? extends AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }

    // ? super 子类类名 AA:支持 AA 类以及 AA 类的父类，不限于直接父类，
    //规定了泛型的下限
    public static void printCollection3(List<? super AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }
}

class AA {
}

class BB extends AA {
}

class CC extends BB {
}

13.7 JUnit

13.7.1 为什么需要 JUnit

  1. 一个类有很多功能代码需要测试，为了测试，就需要写入到 main 方法中
  2. 如果有多个功能代码测试，就需要来回注销，切换很麻烦
  3. 如果可以直接运行一个方法，就方便许多，并且可以给出相关信息，就很方便

13.7.2 介绍

  1. JUnit 是一个 Java 语言的单元测试框架
  2. 多数 Java 的开发环境都已经集成了 JUnit 作为单元测试的工具

13.7.3 示例

public class JUnitTest {
    public static void main(String[] args) {
        //传统方式
        //new JUnit_().m1();
        //new JUnit_().m2();
    }
    @Test
    public void m1() {
        System.out.println("m1 方法被调用");
    }
    @Test
    public void m2() {
        System.out.println("m2 方法被调用");
    }
    @Test
    public void m3() {
        System.out.println("m3 方法被调用");
    }
}

注意：先在要测试的方法前加上@Test，会报红，鼠标放上将JUnit添加到类路径即可

在这里插入图片描述

12.8 练习

定义个泛型类DAO<T>,在其中定义一个Map成员变量,Map的键为String类型,值为T类型。

分别创建以下方法:

  1. public void save(String id,T entity):保存T类型的对象到Map成员变量中
  2. public T get(String id): 从 map中获取id 对应的对象
  3. public void update(String id,T entity):替换 map 中key为id的内容,改为 entity对象
  4. public List<T> list():返回 map 中存放的所有T对象
  5. public void delete(String id):删除指定id 对象

定义一个User类:

该类包含: private成员变量(int类型) id, age; (String类型) name.

创建DAO 类的对象,分别调用其save, get, update, list, delete 方法来操作 User 对象, 使用Junit单元测试类进行测试。

public class GenericExercise {
    public static void main(String[] args) {

    }
    @Test
    public void testList() {
        DAO<User> userDAO = new DAO<>();
        userDAO.save("1001", new User(1001,18,"tom"));
        userDAO.save("1002", new User(1002,19,"jack"));
        userDAO.save("1003", new User(1003,18,"mary"));
        userDAO.save("1004", new User(1004,17,"smith"));
        System.out.println(userDAO.list());
        userDAO.update("1001", new User(1001,20,"tim"));
        System.out.println(userDAO.get("1001"));
        userDAO.delete("1004");
        System.out.println(userDAO.list());
    }

}
class DAO<T> {
    private Map<String, T> map = new HashMap<>();

    //保存T类型的对象到Map成员变量中
    public void save(String id, T entity) {
        map.put(id, entity);
    }

    //从 map中获取id 对应的对象
    public  T get(String id) {
        return map.get(id);
    }

    //替换 map 中key为id的内容,改为 entity对象
    public void update(String id, T entity) {
        map.put(id, entity);
    }

    //返回 map 中存放的所有T对象
    public List<T> list() {
        return new ArrayList<>(map.values());
    }

    //删除指定id 对象
    public void delete(String id) {
        map.remove(id);
    }
}

class User {
    private int id;
    private int age;
    private String name;

    public User(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
Zero灵渡
关注
专栏目录
Java学习笔记 --- 泛型
乌云的博客
11-11 727
1、泛型又称参数化类型，是JDK5.0出现的新特性，解决数据类型的安全性问题2、在类声明或实例化时只要指定好需要的具体的类型即可3、Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时代码更加简洁，健壮4、泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型//该数据类型在定义Person对象的时候指定，即在编译期间就确定E是什么类型。
泛型
喜欢在细雨中散步
11-24 495
.NET Framework 的泛型 　　泛型是具有占位符（类型参数）的类、结构、接口和方法，这些占位符是类、结构、接口和方法所存储或使用的一个或多个类型的占位符。泛型集合类可以将类型参数用作它所存储的对象的类型的占位符；类型参数作为其字段的类型及其方法的参数类型出现。泛型方法可以将其类型参数用作其返回值的类型或者其某个形参的类型。 　　由于.NET Framework 泛型的类型参数之实
Java泛型
m0_46065956的博客
04-20 113
目录 1. 什么是泛型 2. 泛型的优点 3. 泛型的语法 4. 自定义泛型 4.1 自定义泛型接口 4.2 自定义泛型类 4.3 自定义泛型方法 5. 泛型的继承和通配符 1. 什么是泛型 泛型：是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，而这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口。 注...
java（泛型）
weixin_63954483的博客
06-28 546
泛型的好处：1、编译时，检查添加元素的类型，提高了安全性2、减少了类型转换的次数，提高效率概念：1、泛型又称参数化类型，解决数据类型的安全性问题2、在类声明或实例化时只要指定好需要的具体类型即可3、java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。会使代码更简洁更健壮4、泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值类型，或者是参数类型注意事项：1、E只能是引用类型，不可以是基本数据类型 2、在指定泛型具体
35.Java之泛型（泛型介绍，泛型的语法，泛型使用的注意事项和细节，自定义泛型类，自定义泛型接口，自定义泛型方法，泛型的继承和通配符）
qq_46656580的博客
01-30 1096
35.1 使用泛型的意义 使用传统集合的问题分析 不能对加入到集合 ArrayList 中的数据类型进行约束（不安全） 遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响 泛型的好处 编译时，检查添加元素的类型，提高了安全性 减少了类型转换的次数，提高效率 不使用泛型 Dog -> 加入 -> Object -> 取出 -> Dog // 放入到 ArrayList 会先转成 Object，在取出时，还需要转换成 Dog 使用泛型 Dog -&gt
java基础学习笔记之泛型
09-02
泛型是Java编程语言中的一个重要特性，首次在JDK 1.5版本中引入，它允许程序员在定义类、接口和方法时使用类型参数，从而实现了类型的安全性和代码的复用性。泛型的主要目标是增强类型安全，避免在运行时出现...
Java编程笔记13：泛型
梦幻天空
03-07 626
Java编程笔记13：泛型 图源：PHP中文网 容器中的泛型 泛型存在的理由之一是解决容器可以持有不同类型的数据的问题。 假设有一个最简单的容器： package ch13.container; import util.Fmt; class SimpleContainer { private Object content; public SimpleContainer(Object content) { this.content = content; }
Java学习笔记10 泛型 枚举
gyct123的博客
04-02 273
泛型：类型参数化。(广泛不确定的数据类型) 学习要求：会写经典泛型，看得懂代码中的泛型。 泛型的标识： T Type任意类型 E Element K Key V Value <?>表示不确定的泛型，是类型实参，？通配符来表示未知类型。 泛型的应用：泛型接口、泛型类、泛型方法 泛型接口：interface 接口名 <T> { ... } 泛型类：class 类名 <T> { ... } 泛型方法：publi...
Java强化笔记 泛型与可变参数
自学菜鸡CyanLiuCY的博客
07-29 317
1.什么是泛型 1.1 概述 JDK5引入的新特性，所操作的数据类型变成了一个参数。将原来的具体类型参数化，然后在调用时再传入具体的类型，这种参数类型用在类，方法和接口中，就成了泛型类，泛型方法，泛型接口。 1.2 泛型定义格式 <> <type1,type2> 1.3 GenericDemo的朝阳经 问题：一个Collection类对象，里面可以储存任意类型元素，在其中放入String类型元素，输出时类型强转为String，正常输出。但是当里面加入了整数型元素，再强转输出就会出现类
详解 Java 泛型
IT蜗牛的专栏
02-06 288
java
Java 泛型初步
chen3749102的专栏
06-25 388
一、什么是泛型。 泛型主要是指“在程序编码中包含类型参数的类型”。在JAVA中主要是指在定义类、接口或者方法时可以为之指定特定的类型参数。 二、泛型的主要作用。 JAVA中的泛型的主要作用可以归结为以下几点： 1、加强类型安全及减少类转换的次数；         在JAVA支持泛型以前，加入你将一个对象仍进一个集合，那么这个集合将不再记         得这个对象的类型，如果你要使
Java中泛型的使用及使用注意
yxf0448的博客
03-21 2623
优势：类型限定可以增加代码的灵活性，使其适应更多的类型。使用场景：当你需要设计一组具有通用操作的接口时，例如比较器、转换器、工厂等，这些接口可以应用于不同类型的对象，可以使用泛型接口。使用场景：当你需要设计一个通用的方法，它可以处理不同类型的参数时，可以使用泛型方法。使用场景：当你需要创建一个通用的数据结构，例如列表、栈、队列、字典等，这些结构可以处理各种类型的数据时，可以使用泛型类。使用场景：当你需要限制泛型类型参数的范围时，例如，只允许实现了某个接口或继承自某个类的类型作为参数，可以使用类型限定。
java泛型程序设计——Varargs 警告+不能实例化类型变量
PacosonSWJTU的博客
12-08 5419
【0】README0.1） 本文描述+源代码均 转自 core java volume 1， 旨在理解 java泛型程序设计 的 Varargs 警告+不能实例化类型变量 的知识；【1】 Varargs 警告1.1）一个相关问题： 向参数个数可变的方法传递一个泛型类型的实例； 1.1.1）考虑以下方法， 它的参数个数是可变的： public static<T> void addAll(Collec
java泛型数组：Type parameter ‘T‘ cannot be instantiated directly
热门推荐
eyes++的博客
02-14 1万+
今天因为需要封装一些类，使用了泛型创建数组，方法如下： T[] container = new T[capacity]; 然后编译器报错： 报错Type parameter 'T' cannot be instantiated directly，即类型参数“T”不能直接实例化。 原因就是Java的泛型是通过类型擦除(type erasure)来实现的。什么是类型擦除呢，简单来说Java在编译期间，所有的泛型信息都会被擦除掉。如在代码中定义的List和List等类型，在编译后都会变成List。JVM看到的
Java泛型的一些限制
LW的技术小筑
08-09 898
在使用Java中的泛型时，有一些限制需要我们注意，下面我为大家一一介绍: 1.类型形参不能实例化 Java泛型中不能创建类型形参的实例，即不能编写如下所示代码: public class test3<T> { T ob; test3(){ ob = new T(); } } 上述代码会报错为:Cannot instantiate the type T 2.对静态成员的限制 ...
【天地图】vue 天地图 T is not defined
最新发布
amoureux555的博客
05-31 840
【天地图】vue 天地图 T is not defined
百度地图：创建多个标注点
Ygaidi的博客
11-23 915
百度地图：创建多个标注点
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值