019Java基础之泛型

1、泛型的理解和好处

package com.francis.generic;

import java.util.ArrayList;


@SuppressWarnings({"all"})
public class Generic01 {
    public static void main(String[] args) {
        
//使用传统的方法来解决
        ArrayList arrayList = new ArrayList();
        arrayList.add(new Dog("旺财", 10));
        arrayList.add(new Dog("发财", 1));
        arrayList.add(new Dog("小黄", 5));
//假如我们的程序员，不小心，添加了一只猫
        arrayList.add(new Cat("招财猫", 8));
//遍历
        for (Object o : arrayList) {
//向下转型 Object ->Dog,如果无法转型，将会抛异常
            Dog dog = (Dog) o;
            System.out.println(dog.getName() + "-" + dog.getAge());
        }
    }
}
class Dog {
    private String name;
    private int age;
    public Dog(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;
    }
}
class Cat { //Cat 类
    private String name;
    private int age;
    public Cat(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;
    }
}

1.1、使用传统方法的问题分析

（1）不能对加入到ArrayList的数据类型进行约束。会导致例如上例中存在的类型转换异常等隐患
（2）遍历的时候，需要进行类型转换，如果集合的数据量较大，会影响程序的效率

1.2、泛型快速体验-用泛型来解决前面的问题

package com.francis.generic;

import java.util.ArrayList;


public class Generic02 {
    public static void main(String[] args) {
        
//使用传统的方法来解决===> 使用泛型
//1. 当我们 ArrayList 表示存放到 ArrayList 集合中的元素是 Dog 类型 (细节后面说...)
//2. 如果编译器发现添加的类型，不满足要求，就会报错
//3. 在遍历的时候，可以直接取出 Dog 类型而不是 Object
//4. public class ArrayList {} E 称为泛型,那么 Dog->E
        ArrayList arrayList = new ArrayList();
        arrayList.add(new Dog1("旺财", 10));
        arrayList.add(new Dog1("发财", 1));
        arrayList.add(new Dog1("小黄", 5));
//假如我们的程序员，不小心，添加了一只猫,此时相当于对元素类型做了规范，编译不通过
//arrayList.add(new Cat("招财猫", 8));
        System.out.println("===使用泛型====");
        for (Dog1 dog : arrayList) {
            System.out.println(dog.getName() + "-" + dog.getAge());
        }
    }
}

class Dog1 {
    private String name;
    private int age;
    public Dog1(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;
    }
}
class Cat1 { //Cat 类
    private String name;
    private int age;
    public Cat1(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;
    }
}

1.3、泛型的理解和好处

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

2、泛型介绍

（1）泛型又称参数化类型，是JDK5.0出现的新特性，解决数据类型的安全性问题
（2）在类声明或实例化时只要指定好具体需要的类型即可
（3）Java泛型可以保证，如果程序在编译时没有发出警告，运行时就不会发生ClassCastException，同时，代码更加简介、健壮
（4）泛型的作用：可以在类声明时通过一个表示表示类中某个属性的类型或者是某个方法的返回值类型、或者是参数类型

package com.francis.generic;


public class Generic03 {
    public static void main(String[] args) {
//注意，特别强调： E 具体的数据类型在定义 Person 对象的时候指定,即在编译期间，就确定 E 是什么类型
        Person person = new Person("你好，北京！");
        person.show(); //String

        Person person2 = new Person(100);
        person2.show();//Integer

    }
}

//泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，
// 或者是某个方法的返回值的类型，或者是参数类型
class Person {
    E s;//E 表示 s 的数据类型, 该数据类型在定义 Person 对象的时候指定,即在编译期间，就确定 E 是什么类型

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

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

    public void show() {
        System.out.println(s.getClass());//显示 s 的运行类型
    }
}

3、泛型的语法 3.1、泛型的声明

接口：
interface 接口名{}
类：
class 类名{}
比如List和ArrayList的声明

其中的T、E、F、G不代表值，而是代表类型，任何字母都可以

3.2、泛型的实例化

要在类名的后面指定类型参数的值。
比如List list = new ArrayList ();

3.3、泛型使用的注意事项和细节

（1）interface List{},public class HashSet{}等等中的T,E只能是引用类型，例如List list2 = new ArrayList()编译不通过
（2）在实例化时指定具体的泛型类型后，可以传入该类型或者其子类类型
（3）如果带有泛型的接口或类在实例化时不指定泛型类型，则默认泛型为Object

package com.francis.generic;

import java.util.ArrayList;
import java.util.List;


@SuppressWarnings({"all"})
public class GenericDetail {
    public static void main(String[] args) {
//1.给泛型指向数据类型是，要求是引用类型，不能是基本数据类型
        List list = new ArrayList(); //OK
//List list2 = new ArrayList();//错误
//2. 说明
//因为 E 指定了 A 类型, 构造器传入了 new A()
//在给泛型指定具体类型后，可以传入该类型或者其子类类型
        Pig aPig = new Pig(new A());
        aPig.f();
        Pig aPig2 = new Pig(new B());
        aPig2.f();
//3. 泛型的使用形式
        ArrayList list1 = new ArrayList();
        List list2 = new ArrayList();
//在实际开发中，我们往往简写
//编译器会进行类型推断, 推荐使用下面写法
        ArrayList list3 = new ArrayList<>();
        List list4 = new ArrayList<>();
        ArrayList pigs = new ArrayList<>();
//4. 如果是这样写 泛型默认是 Object
        ArrayList arrayList = new ArrayList();//等价 ArrayList

019Java基础之泛型

Java相关栏目本月热门文章