泛型与File类

为什么要使用泛型？
所谓泛型就是允许在定义类、接口时通过一个表示表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如继承或实现这个接口，用这个类型声明变量，创建对象时确定（即传入实际的类型参数，也称为类型实参））。
举例：

import java.util.*;
public class Demo2 {
    public static void main(String[] args)  {
        List list=new ArrayList();
        //需求：存放数字
        list.add(123);
        list.add(43);
        list.add(54);
        list.add(65);
        list.add(594);
        list.add(546);
        //问题一：类型不安全
        list.add("sdfa");

        for(Object score:list){
            //问题二：强转时，可能出现类型转换异常ClassCastException
            int s=(Integer) score;
            System.out.println(s);
        }
    }
}

在集合中使用泛型
泛型不能是基本数据类型，得是包装类。
以ArrayList为例：

ArrayList list=new ArrayList();
        list.add(4);
        list.add(654);
        list.add(54);
        //编译时就会进行类型检查，保证数据安全
        //list.add("sgsg");报错
        //方式一：
        for(Integer score:list){
            //避免了强转操作
            int s=score;
            System.out.println(s);
        }

        //方式二
        Iterator iterator=list.iterator();
        while (iterator.hasNext()){
            int s=iterator.next();
            System.out.println(s);
        }

以HashMap为例：

import java.util.*;
public class Demo2 {
    public static void main(String[] args)  {
        Map map=new HashMap();
        //jdk7新特性：类型推断 后面的可省略
        //Map map=new HashMap<>();
        map.put("sdd",46);
        map.put("dfgf",5);
        map.put("fdfd",8);
        //泛型的嵌套
        Set> entrySet=map.entrySet();
        Iterator> iterator=entrySet.iterator();
        while (iterator.hasNext()){
            Map.Entry entry=iterator.next();
            String key=entry.getKey();
            Integer value=entry.getValue();
            System.out.println(key+" "+value);
        }

    }
}

总结：
1.集合接口或集合类在jdk5.0时都修改为带泛型的结构。
2.在实例化集合类时，可以指明具体的泛型类型。
3.指明后，在集合类或者接口中凡是定义类或接口时，内部结构使用到类的泛型的位置都指定为实例化时指定的泛型类型。
4.注意泛型的类型必须是类，不能是基本数据类型，需要用到基本数据时，要用到其对应的包装类。
5.如果实例化时，没有指明泛型的类型，默认类型为java.lang.Object。

自定义泛型结构
自定义泛型类、泛型接口；泛型方法。

public class Demo2 {
    public static void main(String[] args)  {
        //如果定义了泛型类，实例化却没有指明类的类型，则认为此泛型类型为Object类型
        Order order=new Order();
        order.setOrderT(123);
        order.setOrderT("sdsg");
        //要求：如果定义了类是带泛型的，建议在实例化时要指明类的泛型
        Order order1=new Order<>("asg",55,"dfgd");
        order1.setOrderT("sag");
        subOrder o=new subOrder();
        o.setOrderT(10);//Integer类型

    }
}

class Order{
    String name;
    int age;
    //类的内部结构就可以使用类的泛型
    T orderT;
    protected Order(){}
    public Order(String name,int age,T orderT){
        this.name=name;
        this.age=age;
        this.orderT=orderT;
    }

    public T getOrderT() {
        return orderT;
    }
    public void setOrderT(T orderT){
        this.orderT=orderT;
    }
}
class subOrder extends Order{
    
}

若子类在继承带泛型的父类时，指明了泛型的类型，则实例化子类对象时，不再需要指明泛型。此时的子类就不是泛型类了。
若这样写：

class subOrder1 extends Order{
    
}

则此时的子类subOrder依旧是泛型类，在实例化时可以指明类的类型。
subOrder1 s=new subOrder1<>();

静态方法中不能使用类的泛型。
原因：类的泛型是在实例化的时候才确定，而静态结构的加载早于对象的创建。

在方法中出现了泛型的结构，泛型参数与类的泛型参数没有关系，换句话说，泛型方法所属的类是不是泛型都没关系。
例：

    public  List copyFormArrayToList(E[] arr){
        ArrayList list=new ArrayList<>();
        for(E e:arr){
            list.add(e);
        }
        return list;
    }

泛型方法中的泛型类型与其所在类的泛型类型无关。

import java.util.*;
public class Demo2 {
    public static void main(String[] args)  {
        Order o=new Order<>();
        Integer[] arr=new Integer[]{1,2,3,4};
        //泛型方法在调用时，指明泛型参数的类型
        List list=o.copyFormArrayToList(arr);
    }

}
class Order{
    T age;
    public  List copyFormArrayToList(E[] arr){
        ArrayList list=new ArrayList<>();
        for(E e:arr){
            list.add(e);
        }
        return list;
    }
}

泛型方法可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。

泛型在继承方面的体现
虽然类A是类B的父类，但G和G二者不具备子父类关系，二者是并列关系。

//在继承中可以这样写
        Object o=null;
        String str=null;
        o=str;//子类赋值给父类

        Object[] arr1=null;;
        String[] arr2=null;
        arr1=arr2;

        //而在泛型中：
        List