精华内容
下载资源
问答
  • java范型
    2021-03-16 20:20:55

    规则和限制

    1、泛型的类型参数只能是类类型(包括自定义类),不能是简单类型。

    2、同一种泛型可以对应多个版本(因为参数类型是不确定的),不同版本的泛型类实例是不兼容的。

    3、泛型的类型参数可以有多个。

    4、泛型的参数类型可以使用extends语句,例如。习惯上称为“有界类型”。

    5、泛型的参数类型还可以是通配符类型。例如Class> classType = Class.forName("java.lang.String")。

    限制泛型

    我们一般是这样定义泛型的:class Generics,实际上这里的限定类型相当于Object,这和“Object泛型”实质是一样的。什么是限制比如我们要限制T为集合接口类型。只需要这么做:class Generics,这样类中的泛型T只能是Collection接口的实现类,传入非Collection接口编译会出错。

    注意:这里的限定使用关键字extends,后面可以是类也可以是接口。但这里的extends已经不是继承的含义了,应该理解为T类型是实现Collection接口的类型,或者T是继承了XX类的类型。

    public class CollectionGen {

    private T t;

    public CollectionGen(T t) {

    this.t = t;

    }

    public T getT() {

    return t;

    }

    public void setT(T t) {

    this.t = t;

    }

    public static void main(String args[]) {

    CollectionGen genList = null;

    genList = new CollectionGen(new ArrayList());

    //以下代码不能通过编译

    //      CollectionGen genCollention = null;

    //      genCollention=new CollectionGen(new ArrayList());

    System.out.println("可以编译通过并运行!");

    }

    }

    上面的代码是可以编译通过并成功运行的。但是打开注释掉的两行就出错了,因为这么定义类型的时候,就限定了构造此类实例的时候T是确定的一个类型,这个类型实现了Collection接口。简单一句话就是:上面这种方式,定义跟实例化的类型必须完全一致。

    通配符泛型

    为了解决类型被限制死了不能动态根据实例来确定的缺点,引入了“通配符泛型”,针对上面的例子,使用通配泛型格式为 extends Collection>,“?”代表未知类型,这个类型是实现Collection接口。那么上面实现的方式可以写为:

    public static void main(String args[]) {

    Generics genList = null;

    genList = new Generics(new ArrayList());

    //以下代码可以通过编译

    Generics extends Collection> genCollention = null;

    genCollention=new Generics(new ArrayList());

    System.out.println("可以编译通过并运行!");

    }

    1、如果只指定了>,而没有extends,则默认是允许Object及其下的任何Java类了。也就是任意类。

    2、通配符泛型不单可以向下限制,如 extends Collection>,还可以向上限制,如 super Double>,表示类型只能接受Double及其上层父类类型,如Number、Object类型的实例。

    3、泛型类定义可以有多个泛型参数,中间用逗号隔开,还可以定义泛型接口,泛型方法。这些都与泛型类中泛型的使用规则类似。

    多接口限制

    虽然Java泛型简单的用 extends 统一的表示了原有的 extends 和 implements 的概念,但仍要遵循应用的体系,Java 只能继承一个类,但可以实现多个接口,所以你的某个类型需要用 extends 限定,且有多种类型的时候,只能存在一个是类,并且类写在第一位,接口列在后面,也就是:

    这里的例子仅演示了泛型方法的类型限定,对于泛型类中类型参数的限制用完全一样的规则,只是加在类声明的头部,如:

    public class Demo{

    //T类型就可以用Comparable声明的方法和Seriablizable所拥有的特性了

    }

    更多相关内容
  • 主要介绍了不同Java泛型构造函数的详解,因为对象是应用类型,对象赋值是指向同一个对象,所以如果需要保存对象某个时刻的状态,就需要构造函数来new一个新的对象。下面我们来详细了解一下吧
  • 主要介绍了Java泛型的继承和实现操作,结合实例形式分析了java泛型类的继承以及泛型接口的实现相关操作技巧,需要的朋友可以参考下
  • 下面小编就为大家带来一篇详谈Java泛型中T和问号(通配符)的区别。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要介绍了Java泛型的用法及T.class的获取过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java泛型总结

    2019-04-09 17:19:51
    深入理解java泛型,包括类名泛型的定义,方法泛型定义,泛型的返回
  • 主要介绍了Java泛型和Class类用法,结合实例形式分析了java使用泛型限制class类避免强制类型转换相关操作技巧,需要的朋友可以参考下
  • 主要介绍了Java泛型<T> T与T的使用方法详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 下面小编就为大家带来一篇浅谈Java泛型让声明方法返回子类型的方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 1泛型的类型参数只能是类类型包括自定义类不能是简单类型 2同一种泛型可以对应多个版本因为参数类型是不确定的不同版本的泛型类实例是不兼容的 3泛型的类型参数可以有多个 4泛型的参数类型可以使用extends语句例如...
  • 本文主要介绍了Java泛型的使用以及类型擦除相关的问题。具有很好的参考价值。下面跟着小编一起来看下吧
  • NULL 博文链接:https://hyzhaolt.iteye.com/blog/443661
  • Java泛型

    千次阅读 2022-01-28 14:18:46
    文章目录前言一、为什么要有泛型二、泛型的使用三、如何自定义泛型结构:泛型类、泛型接口;泛型方法。四、泛型类和泛型方法的使用情景五、泛型在继承上的体现六、通配符的使用总结 前言 提示:以下是本篇文章...
    我主要是写此文章是为了给自己做一个笔记,也方便大家阅读。


    前言


    提示:以下是本篇文章正文内容,下面案例可供参考

    一、为什么要有泛型

    在这里插入图片描述
    在这里插入图片描述

    二、泛型的使用

    1.jdk 5.0新增的特性

    2.在集合中使用泛型: 总结:
    ① 集合接口或集合类在jdk5.0时都修改为带泛型的结构。
    ② 在实例化集合类时,可以指明具体的泛型类型
    ③指明完以后,在集合类或接口中凡是定义类或接口时,内部结构(比如:方法、构造器、属性等)使用到类的泛型的位置,都指定为实例化的泛型类型。 比如:add(E e) —>实例化以后:add(Integer e)
    ④注意点:泛型的类型必须是类,不能是基本数据类型。需要用到基本数据类型的位置,拿包装类替换
    ⑤如果实例化时,没有指明泛型的类型。默认类型为java.lang.Object类型。

    3.如何自定义泛型结构:泛型类、泛型接口;泛型方法。见 GenericTest1.java

    public class GenericTest {
    
    
        //在集合中使用泛型之前的情况:
        @Test
        public void test1(){
            ArrayList list = new ArrayList();
            //需求:存放学生的成绩
            list.add(78);
            list.add(76);
            list.add(89);
            list.add(88);
            //问题一:类型不安全
    //        list.add("Tom");
    
            for(Object score : list){
                //问题二:强转时,可能出现ClassCastException
                int stuScore = (Integer) score;
    
                System.out.println(stuScore);
    
            }
    
        }
    
        //在集合中使用泛型的情况:以ArrayList为例
        @Test
        public void test2(){
           ArrayList<Integer> list =  new ArrayList<Integer>();
    
            list.add(78);
            list.add(87);
            list.add(99);
            list.add(65);
            //编译时,就会进行类型检查,保证数据的安全
    //        list.add("Tom");
    
            //方式一:
    //        for(Integer score : list){
    //            //避免了强转操作
    //            int stuScore = score;
    //
    //            System.out.println(stuScore);
    //
    //        }
            //方式二:
            Iterator<Integer> iterator = list.iterator();
            while(iterator.hasNext()){
                int stuScore = iterator.next();
                System.out.println(stuScore);
            }
    
        }
    
        //在集合中使用泛型的情况:以HashMap为例
        @Test
        public void test3(){
    //        Map<String,Integer> map = new HashMap<String,Integer>();
            //jdk7新特性:类型推断
            Map<String,Integer> map = new HashMap<>();
    
            map.put("Tom",87);
            map.put("Jerry",87);
            map.put("Jack",67);
    
    //        map.put(123,"ABC");
            //泛型的嵌套
            Set<Map.Entry<String,Integer>> entry = map.entrySet();
            Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
    
            while(iterator.hasNext()){
                Map.Entry<String, Integer> e = iterator.next();
                String key = e.getKey();
                Integer value = e.getValue();
                System.out.println(key + "----" + value);
            }
    
        }
    
    
    }
    

    三、如何自定义泛型结构:泛型类、泛型接口;泛型方法。

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    //异常类不能声明为泛型类
    //public class MyException<T> extends Exception{
    //}
    
    public class Person {
    }
    
    public class SubOrder extends Order<Integer> {//SubOrder:不是泛型类
    
    
        public static <E> List<E> copyFromArrayToList(E[] arr){
    
            ArrayList<E> list = new ArrayList<>();
    
            for(E e : arr){
                list.add(e);
            }
            return list;
    
        }
    
    
    }
    
    public class SubOrder1<T> extends Order<T> {//SubOrder1<T>:仍然是泛型类
    }
    
    /**
     * 自定义泛型类
     
     */
    public class Order<T> {
    
        String orderName;
        int orderId;
    
        //类的内部结构就可以使用类的泛型
    
        T orderT;
    
        public Order(){
            //编译不通过
    //        T[] arr = new T[10];
            //编译通过
            T[] arr = (T[]) new Object[10];
        }
    
        public Order(String orderName,int orderId,T orderT){
            this.orderName = orderName;
            this.orderId = orderId;
            this.orderT = orderT;
        }
    
        //如下的三个方法都不是泛型方法
        public T getOrderT(){
            return orderT;
        }
    
        public void setOrderT(T orderT){
            this.orderT = orderT;
        }
    
        @Override
        public String toString() {
            return "Order{" +
                    "orderName='" + orderName + '\'' +
                    ", orderId=" + orderId +
                    ", orderT=" + orderT +
                    '}';
        }
        //静态方法中不能使用类的泛型。
    //    public static void show(T orderT){
    //        System.out.println(orderT);
    //    }
    
        public void show(){
            //编译不通过
    //        try{
    //
    //
    //        }catch(T t){
    //
    //        }
    
        }
    
        //泛型方法:在方法中出现了泛型的结构,泛型参数与类的泛型参数没有任何关系。
        //换句话说,泛型方法所属的类是不是泛型类都没有关系。
        //泛型方法,可以声明为静态的。原因:泛型参数是在调用方法时确定的。并非在实例化类时确定。
        public static <E>  List<E> copyFromArrayToList(E[] arr){
    
            ArrayList<E> list = new ArrayList<>();
    
            for(E e : arr){
                list.add(e);
            }
            return list;
    
        }
    }
    
    public class GenericTest1 {
    @Test
        public void test1(){
            //如果定义了泛型类,实例化没有指明类的泛型,则认为此泛型类型为Object类型
            //要求:如果大家定义了类是带泛型的,建议在实例化时要指明类的泛型。
            Order order = new Order();
            order.setOrderT(123);
            order.setOrderT("ABC");
    
            //建议:实例化时指明类的泛型
            Order<String> order1 = new Order<String>("orderAA",1001,"order:AA");
    
            order1.setOrderT("AA:hello");
    
        }
            @Test
        public void test2(){
            SubOrder sub1 = new SubOrder();
            //由于子类在继承带泛型的父类时,指明了泛型类型。则实例化子类对象时,不再需要指明泛型。
            sub1.setOrderT(1122);
    
            SubOrder1<String> sub2 = new SubOrder1<>();
            sub2.setOrderT("order2...");
        }
        @Test
        public void test3(){
    
            ArrayList<String> list1 = null;
            ArrayList<Integer> list2 = new ArrayList<Integer>();
            //泛型不同的引用不能相互赋值。
    //        list1 = list2;
    
            Person p1 = null;
            Person p2 = null;
            p1 = p2;
    
    
        }
         //测试泛型方法
        @Test
        public void test4(){
            Order<String> order = new Order<>();
            Integer[] arr = new Integer[]{1,2,3,4};
            //泛型方法在调用时,指明泛型参数的类型。
            List<Integer> list = order.copyFromArrayToList(arr);
    
            System.out.println(list);
        }
      }
    

    四、泛型类和泛型方法的使用情景

    public class DAO<T> {//表的共性操作的DAO
    
        //添加一条记录
        public void add(T t){
    
        }
    
        //删除一条记录
        public boolean remove(int index){
    
            return false;
        }
    
        //修改一条记录
        public void update(int index,T t){
    
        }
    
        //查询一条记录
        public T getIndex(int index){
    
            return null;
        }
    
        //查询多条记录
        public List<T> getForList(int index){
    
            return null;
        }
    
        //泛型方法
        //举例:获取表中一共有多少条记录?获取最大的员工入职时间?
        public <E> E getValue(){
    
            return null;
        }
    
    }
    
    public class Student {
    }
    
    public class StudentDAO extends DAO<Student> {//只能操作某一个表的DAO
    }
    

    五、泛型在继承上的体现

    在这里插入图片描述

    public class Person {
    }
    
    public class Student extends Person {
    }
    
    public class GenericTest {
    
        /*
        1. 泛型在继承方面的体现
    
          虽然类A是类B的父类,但是G<A> 和G<B>二者不具备子父类关系,二者是并列关系。
    
           补充:类A是类B的父类,A<G> 是 B<G> 的父类
    
         */
        @Test
        public void test1(){
    
            Object obj = null;
            String str = null;
            obj = str;
    
            Object[] arr1 = null;
            String[] arr2 = null;
            arr1 = arr2;
            //编译不通过
    //        Date date = new Date();
    //        str = date;
            List<Object> list1 = null;
            List<String> list2 = new ArrayList<String>();
            //此时的list1和list2的类型不具有子父类关系
            //编译不通过
    //        list1 = list2;
            /*
            反证法:
            假设list1 = list2;
               list1.add(123);导致混入非String的数据。出错。
    
             */
    
            show(list1);
            show1(list2);
    
        }
    
    
    
        public void show1(List<String> list){
    
        }
    
        public void show(List<Object> list){
    
        }
    
        @Test
        public void test2(){
    
            AbstractList<String> list1 = null;
            List<String> list2 = null;
            ArrayList<String> list3 = null;
    
            list1 = list3;
            list2 = list3;
    
            List<String> list4 = new ArrayList<>();
    
        }
       }
    

    六、通配符的使用

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    public class GenericTest {
     @Test
        public void test3(){
            List<Object> list1 = null;
            List<String> list2 = null;
    
            List<?> list = null;
    
            list = list1;
            list = list2;
            //编译通过
    //        print(list1);
    //        print(list2);
    
    
            //
            List<String> list3 = new ArrayList<>();
            list3.add("AA");
            list3.add("BB");
            list3.add("CC");
            list = list3;
            //添加(写入):对于List<?>就不能向其内部添加数据。
            //除了添加null之外。
    //        list.add("DD");
    //        list.add('?');
    
            list.add(null);
    
            //获取(读取):允许读取数据,读取的数据类型为Object。
            Object o = list.get(0);
            System.out.println(o);
    
    
        }
    
        public void print(List<?> list){
            Iterator<?> iterator = list.iterator();
            while(iterator.hasNext()){
                Object obj = iterator.next();
                System.out.println(obj);
            }
        }
    
        /*
        3.有限制条件的通配符的使用。
            ? extends A:
                    G<? extends A> 可以作为G<A>和G<B>的父类,其中B是A的子类
    
            ? super A:
                    G<? super A> 可以作为G<A>和G<B>的父类,其中B是A的父类
    
         */
        @Test
        public void test4(){
    
            List<? extends Person> list1 = null;
            List<? super Person> list2 = null;
    
            List<Student> list3 = new ArrayList<Student>();
            List<Person> list4 = new ArrayList<Person>();
            List<Object> list5 = new ArrayList<Object>();
    
            list1 = list3;
            list1 = list4;
    //        list1 = list5;
    
    //        list2 = list3;
            list2 = list4;
            list2 = list5;
    
            //读取数据:
            list1 = list3;
            Person p = list1.get(0);
            //编译不通过
            //Student s = list1.get(0);
    
            list2 = list4;
            Object obj = list2.get(0);
            编译不通过
    //        Person obj = list2.get(0);
    
            //写入数据:
            //编译不通过
    //        list1.add(new Student());
    
            //编译通过
            list2.add(new Person());
            list2.add(new Student());
    
        }
      }
    

    总结

    我主要是写此文章是为了给自己做一个笔记,也方便大家阅读。

    展开全文
  • Java泛型和集合

    2016-04-22 16:13:15
    Java Generics and Collections 英文版,详细描述java 泛型技术
  • 你真的懂Java泛型吗?

    2020-12-22 23:48:39
    但其实Java泛型还是有挺多tricky的东西的,编译器在背后为我们做了很多事。下面我们来看看有关Java泛型容易忽视的点。  泛型不支持协变  什么是协变?举个例子。  class Fruit{}  class Apple extends Fruit...
  • java泛型

    2021-03-14 22:47:33
    泛型泛型泛型接口 泛型方法作用:提高程序健壮性,简化代码泛型的默认值是Objectjdk 要1.5以上2.泛型定义/***泛型类*首先定义一个person的实体类 Person其中A代表的就是一个泛型,调用时可以自定义数据类型*/...

    1.什么是泛型

    泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。

    泛型:泛型类      泛型接口     泛型方法

    作用:提高程序健壮性,简化代码

    泛型的默认值是Object

    jdk 要1.5以上

    2.泛型定义

    /**

    *泛型类

    *首先定义一个person的实体类 Person其中A代表的就是一个泛型,调用时可以自定义数据类型

    */

    package com.temp;

    public class Person {

    private A pname;

    private B page;

    private C psex;

    public A getPname() {

    return pname;

    }

    public void setPname(A pname) {

    this.pname = pname;

    }

    public B getPage() {

    return page;

    }

    public void setPage(B page) {

    this.page = page;

    }

    public C getPsex() {

    return psex;

    }

    public void setPsex(C psex) {

    this.psex = psex;

    }

    }

    /**

    *调用泛型类

    */

    //泛型的属性  属性的数据类型 由调用方来决定当前属性数据类型

    //integer 是int数据类型的封装类

    //Character 是char的类型的封装类

    //必定只能是类而不是基础数据类型的关键字

    Person p=new Person<>();

    p.setPname("mz");

    p.setPage(10);

    p.setPsex('男');

    /**

    *定义泛型方法

    */

    package com.temp;

    public class PresonMethod {

    public M getValue(M elenment) {

    if(elenment!=null) {

    return elenment;

    }

    return elenment;

    }

    }

    /**

    *调用泛型方法

    */

    PresonMethod pm=new PresonMethod<>();

    pm.getValue(20);

    /**

    *定义泛型接口

    */

    package com.temp;

    import java.util.List;

    /**

    * 泛型的结果实现可以在实现类中定义好 也可以在调用的地方定义

    * 接口实现接口 实现类实现类

    * 基础接口 自定义接口来扩展实现类的方法

    * @author dell

    *

    * @param

    */

    public interface IBaseFace {

    /**

    * 增加的公共方法

    * @param element

    * @return

    */

    public int addObject(M element);

    /**

    * 编辑

    * @param element

    * @return

    */

    public int editObject(M element);

    /**

    * 删除

    * @param element

    * @return

    */

    public int removeObject(M element);

    /**

    * 查询单个对象的方法

    * @param element

    * @return

    */

    public M queryObject(M element);

    /**

    * 查询多个对象的方法

    * @param element

    * @return

    */

    public List queryObjects(M element);

    /**

    * 查询并且分页

    * @param element

    * @return

    */

    public List queryObjectPage(M element);

    }

    /**

    *定义基础接口

    */

    package com.temp;

    /**

    * 可以在当前类的接口确定它的数据类型

    * @author dell

    *

    */

    public interface IpersonFace extends IBaseFace>{

    public boolean queryUserName(String uanem);

    }

    /**

    *调用泛型接口

    */

    package com.temp;

    import java.util.List;

    public class Personimpl implements IpersonFace{

    @Override

    public int addObject(Person element) {

    // TODO Auto-generated method stub

    return 0;

    }

    @Override

    public int editObject(Person element) {

    // TODO Auto-generated method stub

    return 0;

    }

    @Override

    public int removeObject(Person element) {

    // TODO Auto-generated method stub

    return 0;

    }

    @Override

    public Person queryObject(Person element) {

    // TODO Auto-generated method stub

    return null;

    }

    @Override

    public List> queryObjects(Person element) {

    // TODO Auto-generated method stub

    return null;

    }

    @Override

    public List> queryObjectPage(Person element) {

    // TODO Auto-generated method stub

    return null;

    }

    @Override

    public boolean queryUserName(String uanem) {

    // TODO Auto-generated method stub

    return false;

    }

    }

    展开全文
  • 火龙果软件工程技术中心 Java5提供泛型支持,泛型支持是开发人员多年以来所要求的特性。它代表了Java编程语言一次具有重要意义的升级。像泛型这么复杂的技术,不仅对工具供应商也对开发人员带来了挑战。本文着重...
  • Java 泛型全解析

    2020-09-07 18:24:58
    主要介绍了Java 泛型的相关资料,帮助大家更好的理解和学习Java,感兴趣的朋友可以了解下
  • Java泛型的基本应用

    2020-12-22 19:55:41
    一、泛型概述  jdk1.5版本以后出现的新特性,用于解决安全问题,是一个安全机制。  好处:  1,将运行时期的问题ClassCastException转到了编译时期。  2,避免了强制转换的麻烦。  什么时候用:  当操作...
  • Java泛型使用详细分析.pdf
  • 主要介绍了Java泛型类与泛型方法的定义,结合实例形式详细分析了java泛型类与泛型方法定义、用法及相关操作注意事项,需要的朋友可以参考下
  • Java 泛型详解

    2018-09-18 17:03:22
    Java泛型详解,Java泛型详解,Java泛型详解,Java泛型详解
  • java泛型源码Java泛型用法 步骤1 原始类型有问题。 第2步 使用泛型类型。 第三步 车库和车辆。 原始类型。 第四步 首先尝试生成车库。 木星在我的车库里。 第5步 泛型上限。 第6步 TripleGarage 步骤7 试图使用泛型...
  • Java泛型x详细知识点思维导图.xmind
  • 主要介绍了Java泛型的使用限制,结合实例形式分析了不能使用java泛型的情况以及泛型使用的相关注意事项,需要的朋友可以参考下
  • 主要介绍了Java泛型继承原理与用法,结合实例形式分析了java泛型继承的相关原理与实现技巧,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 303,145
精华内容 121,258
关键字:

java范型