JAVA中泛型全面理解

泛型

泛型的理解和好处

看一个需求：

1.请编写程序，在ArrayList中，添加3个Dog对象
2.Dog对象含有name 和 age ，并输出name 和 age 【要求使用getXXX()方法】

package collection_.collectionP.generic_;

import java.util.ArrayList;

/**
 * @author: 海康
 * @version: 1.0
 */
public class generic01 {
   
   
    public static void main(String[] args) {
   
   

        /**
         * 使用传统方法  引出泛型
         * 1.请编写程序，在ArrayList中，添加3个Dog对象
         * 2.Dog对象含有name 和 age ，并输出name 和 age 【要求使用getXXX()方法】
         */

        ArrayList list = new ArrayList();
        list.add(new Dog("罗*祥",40));
        list.add(new Dog("吴*凡",32));
        list.add(new Dog("于*光",40));
       
        // 遍历集合
        for (Object obj:
             list) {
   
   
            // 向下转型：
            Dog dog = (Dog) obj;
            System.out.println("这是一只狗：姓名:"+dog.getName()+"年龄:"+dog.getAge());
        }
    }
}
class Dog {
   
   
    private String name;
    private int age;

    public int getAge() {
   
   
        return age;
    }

    public void setAge(int age) {
   
   
        this.age = age;
    }

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

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

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

传统方法的问题分析：

不引入泛型有两个问题是：1.不能对数据进行安全检验 2.如果需要使用子类的特性还必须进行向下强转，对效率有影响

1. 不能对加入到集合中的ArrayyList中的数据类型进行约束【造成不安全】
2. 遍历的时候，由于返回类型是Object类型，如果需要使用子类特有方法或属性，还需要向下转型，如果集合中的数据量较大，对效率有影响

泛型快速入门：

package collection_.collectionP.generic_;

import java.util.ArrayList;

/**
 * @author: 海康
 * @version: 1.0
 */
public class generic02 {
   
   
    public static void main(String[] args) {
   
   
        ArrayList<Dog> list = new ArrayList<>();
        list.add(new Dog("罗*祥",40));
        list.add(new Dog("吴*凡",32));
        list.add(new Dog("于*光",40));

        /**
         * 加入了泛型可以解决了：
         * 编译时，检查添加元素的类型，提高了数据安全性
         * 减少了类型的转换，提高效率
         */

        for (Dog dog:
             list) {
   
   
            System.out.println(dog.getName()+"-"+dog.getAge());
        }
    }
}

泛型的好处：

1. 编译时，检查添加元素的类型，提高了安全性
2. 减少了类型转换的次数，提高效率

不使用泛型：
Dog  ---> Object --->  Dog // 放入到ArrayList会先转成Object，在取出时，还需要转换Dog

使用泛型：
Dog  ---> Dog  ---> Dog // 放入时，和取出时，不需要类型转换，提高了效率

不再提示编译警告

泛型介绍【都是引用数据类型】

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

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

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

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

泛型是作用范围是：

1.标识类中某个属性

2.某个方法返回值类型

3.参数类型

特别注意是：E类型在编译时就已经确定了，才能起到检查数据类型的作用

package collection_.collectionP.generic_;

/**
 * @author: 海康
 * @version: 1.0
 */
public class Generic03 {
   
   
    public static void main(String[] args) {
   
   
//       注意是： E 此类型是在编译期间就确定了，所以才能起到检查数据安全性
        Person<Integer> integerPerson = new Person<>(100);
        integerPerson.show();
        /**
         * 加入泛型代码相当于下面
         * class Person<Integer> {// E表示是标识某个属性的类型，即在编译期间就确定了，所以才能起到检查数据安全性
         *
         *     Integer  e;// E 此类型是在编译期间就确定了，所以才能起到检查数据安全性
         *
         *     public Person(Integer e){ // 泛型可以作为一个参数
         *         this.e = e;
         *     }
         *
         *     public Integer f(){
         *         return e;// 泛型可以作为一个返回值类型
         *     }
         *
         *     public void show() {
         *         System.out.println(e.getClass());//查看e运行类型
         *     }
         * }
         */
    }
}

/**
 * 泛型的作用是：可以在类声明时通过一个标识表示某个属性的类型，
 * 或者是某个方法返回值的类型，或者是参数类型
 * @param <E>
 */
class Person<E> {
   
   // E表示是标识某个属性的类型，即在编译期间就确定了，所以才能起到检查数据安全性

    E  e;// E 此类型是在编译期间就确定了，所以才能起到检查数据安全性

    public Person(E e){
   
    // 泛型可以作为一个参数
        this.e = e;
    }

    public E f(){
   
   
        return e;// 泛型可以作为一个返回值类型
    }

    public void show() {
   
   
        System.out.println(e.getClass()