泛型

一，泛型

　　1，泛型的理解和好处

　　　　看一个需求

　　　　1）请编写一个程序，在ArrayList中，添加3个Dog对象

　　　　2）Dog对象含有name和age,并输出name和age(要求使用getXXX())

　　　　　用传统方法解决-------》 引出泛型

　　　　　　

public class ArraysList01 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(new Dog("小黄",20));
        arrayList.add(new Dog("小李",18));
        arrayList.add(new Dog("小张",16));
        //假如程序员添加一个猫类对象，会出现bug
        arrayList.add(new Cat("招财",25));
        for (Object o : arrayList){
            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{
    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) 不能加入到集合ArrayList中的数据类型进行约束 （不安全）

　　　　2）遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响

　2，使用泛型，快速解决上面的问题

　　　　

public class Generic01 {
    public static void main(String[] args) {
        //1.  当我们 ArrayList<Dog>  表示存放到 ArrayList  集合中的元素是 Dog 类型 )
        //2.  如果编译器发现添加的类型，不满足要求，就会报错
        //3.  在遍历的时候，可以直接取出 Dog  类型而不是 Object
        //4. public class ArrayList<E> {} E 称为泛型,那么 Dog->E
        ArrayList<Dog> arrayList = new ArrayList<>();
        arrayList.add(new Dog("小花",10));
        arrayList.add(new Dog("小黄",11));
        for (Dog dog : arrayList){
            System.out.println(dog.getName() + dog.getAge());
        }
    }
}

 

　3，泛型的好处

　　　　　　

 

 　4，泛型的介绍

　　　　泛（广泛）型（类型） =》 Integer  , String ,Dog               泛型是可以表示数据类型的一种数据类型

　　　　1）泛型又城参数化列表，是Jdk5.0出现的新特性，解决数据类型的安全性问题

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

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

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

　　　　　　

public class Generic02 {
    public static void main(String[] args) {
        Person<String> stringPerson = new Person<>("好好学java");
    }
}
class Person<E>{
    E s;//E 表示 s 的数据类型,  该数据类型在定义 Person对象的时候指定, 即在编译期间，就确定 E 是什么类型
    public Person(E s){  //E 也可以是参数类型
        this.s= s;
    }
    public E f(){   //返回类型使用 E
        return s;
    }
}

 

二， 泛型的语法及使用

　　1，泛型的声明

　　　　interface接口<T>{}  和 class类 <K ,V>{}             比如： List    和  ArrayList

　　　　说明：

　　　　1）其中，T, K,  V不代表值，而是表示类型

　　　　2）任意字母都可以，常用T表示 ，是 Type的缩写

　　2，泛型的实例化

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

　　　　　　1）List<String> strList = new ArrayList<String>();

　　　　　　2) Iterator<Customer> iterator = customers.iterator();　

　 3,  泛型使用的注意事项和细节

　　　　1， interfact  List <T> { }   ,   public  class  HashSet <E>{ }....等等

　　　　　说明 ： T  ,E  只能是引用数据类型   ，看看下面语句是否正确？

　　　　　　List < Integer>  list =  new   Arraylist < Integer> ();    正确

　　　　　　List<int> list2 = new Arraylist<int>() ;   错误原因是基本数据类型

　　　　2，再给泛型指定具体类型后，可以传入该类型或者其子类类型

　　　　3，泛型的使用形式

　　　　　　List<Integer> list1 = new ArrayList<Integer>();

　　　　　　List<Integer> list2 = new ArrayList<>():

　　　　4, 如果我们这样写  List<> list3 = new ArrayList<>(): 默认给它的泛型是<E>  E就是Object 

三，自定义泛型

　　1，自定义泛型类

　　　　1，基本语法：

　　　　　　　class 类名< T, R...>{ // .表示可以有多个泛型

　　　　　　　　　　成员

　　　　　　　}

　　　　　注意细节：

　　　　　　1）普通成员可以使用泛型（属性， 方法）

　　　　　　2）使用泛型的数组，不能初始化

　　　　　　3）静态方法中不能使用类的泛型

　　　　　　4）泛型类的类型，实在创建对象时确定的（因为创建对象时，需要指定确定类型）

　　　　　　5）如果在创建对象时，没有指定类型，默认为Object

　　2, 自定义泛型接口

　　　　　基本语法：

　　　　　　interfact  接口名<T, R...>{   }

　　　　　注意事项

　　　　　1）接口中，静态成员也不能使用泛型（这个和泛型类的规定一样）

　　　　　2） 泛型接口中的类型，在继承接口或者实现接口时确定

　　　　　3） 没有指定类型，默认为Object

　　3, 自定义泛型方法

　　　　修饰符 <T, R...> 返回类型  方法名（参数列表）{ }

　　　　注意细节

　　　　1）泛型方法，可以定义在普通类中，也可以定义在泛型类中

　　　　2）当泛型方法被调用时，类型会确认

　　　　3）public  void  eat(E e) {}    ,修饰符后没有< T ,R...> eat方法不是泛型方法，而是使用了泛型

　　4，泛型的继承和通配符