Java 泛型

柔情只为你懂 2024-03-27 16:59 4阅读 0赞

### 泛型 ###

#### 泛型深入 ####

**泛型**：jdk5新特性，可以在编译阶段约束操作的数据类型，并进行检查  
**泛型的格式**：<数据类型>  
**注意**：泛型只能支持引用数据类型

#### 泛型的好处： ####

*  统一数据类型
 *  把运行时期的问题提前到了编译期间，避免开了强制类型转换可能出现的异常，因为在编译阶段类型就能确定下来  
    扩展知识点：Java中的泛型是伪泛型  
    java文件（是有泛型的）–泛型的擦除–class文件（没有泛型，都是Object强转）

#### 泛型的细节 ####

*  泛型中不能写基本数据类型
 *  指定泛型的具体类型后，传入数据时，可以传入该类型或者其子类类型
 *  如果不写泛型，类型默认是Object

### 泛型可以在很多地方进行定义 ###

#### 类后面（泛型类） ####

格式：修饰符 class 类名<类型>{}
    举例：public class ArrayList<E>{} 创建该类对象时，E就确定类型
    此处E可以理解为变量，但不是用来记录数据的，而是记录数据类型的
    	可以写成：T(type)  、E(element)  、K(key)  、V(value)

**使用场景**：当一个类中，每个变量的数据类型不确定时，就可以定义带有泛型的类

package com.mygenerics;
    
    import java.util.Arrays;
    
    public class MyArrayList <E>{
        
    
        Object[] obj = new Object[10];
        int size;
    
        public boolean add(E e){
        
            obj[size] = e;
            size++;
            return true;
        }
    
        public E get(int index){
        
            return (E)obj[index];
        }
    
        @Override
        public String toString () {
        
            return Arrays.toString (obj);
        }
    }

package com.mygenerics;
    
    public class GenericsDemo02 {
        
        public static void main (String[] args) {
        
            MyArrayList<String> list = new MyArrayList<> ();
    
            list.add ("aaa");
            list.add ("bbb");
            list.add ("ccc");
            list.add ("ddd");
    
            System.out.println (list);
    
            MyArrayList<Integer> list2 = new MyArrayList<> ();
    
            list2.add (1);
            list2.add (3);
            list2.add (2);
            list2.add (4);
    
            int get = list2.get (1);
            System.out.println (get);
    
            System.out.println (list2);
        }
    }

#### 方法上面（泛型方法） ####

此时泛型写的什么类型，那么就只能传递什么类型的数据
     弊端：
        利用泛型方法有个小弊端，此时它可以接受任意的数据类型

#### 接口上面（泛型接口） ####

### 泛型通配符 ###

？表示不确定的类型
        它可以进行类型的限定
        ？Extends E 表示可以传递E或者E 的所有的子类类型
        ？ super E ：表示可以传递E或者E所有的父类类型
     应用场景：
        1. 如果我们在定义类、方法、接口的时候，如果类型不确定，姐可以定义泛型类、泛型方法、泛型接口
        2. 如果类型不确定，但是能知道只能传递某个继承体系中的，就可以使用泛型通配符
     泛型的通配符
        关键点：可以限定类的范围

package com.mygenerics;
    
    import java.util.ArrayList;
    
    public class GenericsDemo04 {
        
        public static void main (String[] args) {
        
    
            /*
                需求：定义一个方法，形参是一个集合，但是集合中的数据类型不确定
             */
    
            //创建集合的对象
            ArrayList<Ye> list1 = new ArrayList<> ();
            ArrayList<Fu> list2 = new ArrayList<> ();
            ArrayList<Zi> list3 = new ArrayList<> ();
    
            ArrayList<Student2> list4 = new ArrayList<> ();
    
            //调用method方法
            method(list1);
            method(list2);
            method(list3);
            method (list4);
        }
        /**
        此时泛型写的什么类型，那么就只能传递什么类型的数据
         弊端：
            利用泛型方法有个小弊端，此时它可以接受任意的数据类型
    
         希望：虽然不确定类型，但是只希望他传递 Ye Fu Zi
    
         此时我们就可以使用泛型的通配符
            ？表示不确定的类型
            它可以进行类型的限定
            ？Extends E 表示可以传递E或者E 的所有的子类类型
            ？ super E ：表示可以传递E或者E所有的父类类型
    
         应用场景：
            1. 如果我们在定义类、方法、接口的时候，如果类型不确定，姐可以定义泛型类、泛型方法、泛型接口
            2. 如果类型不确定，但是能知道只能传递某个继承体系中的，就可以使用泛型通配符
         泛型的通配符
            关键点：可以限定类的范围
    
        */
        public static<E> void method(ArrayList<? extends Ye> list){
        
    
        }
    }
    class Ye{
        
    
    }
    
    class Fu extends Ye {
         }
    
    class Zi extends Fu {
        
    
    }
    class Student2{
        }

### 综合练习 ###

![在这里插入图片描述][975ed319e60e4b4694165d840e7fe92c.png]

package com.mygenerics.test;
    
    import java.util.Objects;
    
    public abstract class Animal {
        
        private String name;
        private int age;
    
        public abstract void eat();
    
        public Animal () {
        
        }
    
        public Animal (String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    
        public String getName () {
        
            return name;
        }
    
        public void setName (String name) {
        
            this.name = name;
        }
    
        public int getAge () {
        
            return age;
        }
    
        public void setAge (int age) {
        
            this.age = age;
        }
    
        @Override
        public String toString () {
        
            return "Animal{" + "name='" + name + '\'' + ", age=" + age + '}';
        }
        
    
        @Override
        public int hashCode () {
        
            return Objects.hash (name, age);
        }
    }

package com.mygenerics.test;
    
    public abstract class Cat extends Animal{
        
    }

package com.mygenerics.test;
    
    public class Persian extends Cat{
        
        @Override
        public void eat () {
        
            System.out.println ("一只叫做"+getName ()+"的"+getAge ()+"岁波斯猫，正在吃小饼干");
        }
    }

package com.mygenerics.test;
    
    public class Civet extends Cat{
        
        @Override
        public void eat () {
        
            System.out.println ("一只叫做"+getName ()+"的"+getAge ()+"岁狸花猫，正在吃鱼");
        }
    }

package com.mygenerics.test;
    
    public abstract class Dog extends Animal{
        
    }

package com.mygenerics.test;
    
    
    public class Teddy extends Dog {
        
        @Override
        public void eat () {
        
            System.out.println ("一只叫做"+getName ()+"的"+getAge ()+"岁泰迪，正在吃骨头，边吃边蹭");
        }
    }

package com.mygenerics.test;
    
    public class Husky extends Dog{
        
        @Override
        public void eat () {
        
            System.out.println ("一只叫做"+getName ()+"的"+getAge ()+"岁哈士奇，正在吃骨头，边吃边拆家");
        }
    }

package com.mygenerics.test;
    
    import java.util.ArrayList;
    
    public class Test {
        
        public static void main (String[] args) {
        
    
            ArrayList<Persian> list1 = new ArrayList<> ();
            ArrayList<Civet> list2 = new ArrayList<> ();
            ArrayList<Husky> list3 = new ArrayList<> ();
            ArrayList<Teddy> list4 = new ArrayList<> ();
    
            keepPet (list1);
            keepPet (list2);
            keepPet (list3);
            keepPet (list4);
        }
    
    
         //该方法能养所有的动物，但是不能传递其他类型
        public static void keepPet(ArrayList<? extends Animal> list){
        
            //遍历集合，调用动物的eat() 方法
        }
    
        /**
         * 该方法能养所有的猫，但是不能养狗
         * public static void keepPet(ArrayList<? extends Cat> list){
    
        }*/
        /**
         * 该方法能养所有的狗，但是不能养猫
         * public static void keepPet(ArrayList<? extends Dog> list){
    
        }*/
    }

### 总结 ###

![在这里插入图片描述][f66b3bfe3d6c49fbb922f9804804f366.png]  
![在这里插入图片描述][9b8bf7e8c22a4f69809a22b49a8a6b45.png]

[975ed319e60e4b4694165d840e7fe92c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/42b7a2a181fe427d9c924ac3f3009bbe.png
[f66b3bfe3d6c49fbb922f9804804f366.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/aaf2424c3c4348828b7334ee7566e94a.png
[9b8bf7e8c22a4f69809a22b49a8a6b45.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/f25b7c0e0a91487591d4af905925b284.png