泛型与File类心得与体会

1.泛型的理解

1.1 泛型的概念

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

1.2 泛型的引入背景

集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的 对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来 解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于 这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个 参数，这个类型参数叫做泛型。Collection，List，ArrayList 这个就 是类型参数，即泛型。

2.泛型在集合中的应用

2.1 在集合中使用泛型之前的例子

//在集合中使用泛型之前的情况：
    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        //需求：存放学生的成绩
        list.add(78);
        list.add(76);
        list.add(89);
        list.add(88);
        //问题一：类型不安全
//        list.add("Tom");

        for(Object score : list){
            //问题二：强转时，可能出现ClassCastException(类型转换错误)
            int stuScore = (Integer) score;

            System.out.println(stuScore);

        }

    }

2.2 在集合中使用泛型 例子1：

  //在集合中使用泛型的情况：以ArrayList为例 不能用基本数据类型，要使用包装类
    @Test
    public void test2(){
        ArrayList<Integer> list = new ArrayList<>();

        //需求：存放学生成绩
        list.add(120);
        list.add(112);
        list.add(105);
        list.add(112);
        //编译时就会进行类型检查，保证数据的安全

//      list.add("as");

        //方式一：
//        for (Integer score: list) {
//            //避免了强转操作
//            int stuscore = score;
//            System.out.println(stuscore);
//        }
        //方式二：
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            Integer stuscore = iterator.next();
            System.out.println(stuscore);
        }
}

2.3在集合中使用泛型 例子2：

//在集合中使用泛型的情况：以HashMap为例
    @Test
    public void  test3(){

        HashMap<String, Integer> map = new HashMap<>();

        map.put("rose",45);
        map.put("jack",45);
        map.put("jerry",45);
        map.put("bob",45);

//        map.put(123,23);
        //泛型的嵌套
        Set<Map.Entry<String, Integer>> entry = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Integer> e = iterator.next();//e是 entry类型的对象
            Integer value = e.getValue();
            String key = e.getKey();
            System.out.println(key + "--->" +value);
           
        }
    }

2.4 在集合中使用泛型总结

 集合接口或集合类在jdk5.0时都修改为带泛型的结构。
  ② 在实例化集合类时，可以指明具体的泛型类型
  ③ 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型。
    比如：add(E e)  --->实例化以后：add(Integer e)
  ④ 注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换
  ⑤ 如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型。

3.自定义泛型类、泛型接口、泛型方法

3.1 举例：

【Order.java】

public class Order<T> {
    String orderName;
    int orderId;

    //类的内部结构就可以使用类的泛型

    T orderT;

    public Order() {
        //编译不通过
//       T arr =new T[10];
        T[] arr = (T[])new  Object[10];
    }

    public Order(String orderName, int orderId, T orderT) {
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }


    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public int getOrderId() {
        return orderId;
    }

    public void setOrderId(int orderId) {
        this.orderId = orderId;
    }

    //如下的三个方法都不是泛型方法
    public T getOrderT() {
        return orderT;
    }

    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }
    //静态方法中不能使用类的泛型：
        // 静态方法随类一同加载，此时泛型还未被定义，不能使用
//    public static void show(){
//        System.out.println(orderT);
//    }
    public void show(){

        //编译不通过
//        try {
//
//        } catch (T t) {
//
//        }
    }

    //泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
    //换句话说，泛型方法所属的类是不是泛型类都没有关系。
    //泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。
    //实例化类时将泛型参数看作是一个“类”(并不是类)
    public static <E>  List<E> copyFromArrayToList(E[] arr){

        ArrayList<E> list = new ArrayList<>();

        for(E e : arr){
            list.add(e);
        }
        return list;

    }
}

【SubOrder.java】

public class SubOrder extends Order<Integer>{//SubOrder:不是泛型类

    public static <E> List<E> copyFromArrayToList(E[] arr){

        ArrayList<E> list = new ArrayList<>();

        for(E e : arr){
            list.add(e);
        }
        return list;

    }
}

实例化时，如下的代码是错误的

SuberOrder<Integer>  o = new SuberOrder<>();

【SubOrder1.java】

public class SubOrder1<T> extends Order<T> {//SubOrder1<T>:仍然是泛型类
}

【测试】

 @Test
    public void test(){
        //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
        //要求：如果大家定义了类是带泛型的，建议在实例化时要指明类的泛型。
        Order order = new Order();
        order.setOrderT(123);
        order.setOrderT("abc");

        //建议：实例化时指明类的泛型
        Order<String> order1 = new Order<>();

        order1.setOrderT("AA:hello");
    }

    @Test
    public void test2(){
        SubOrder sub1 = new SubOrder();
        //由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型。
        sub1.setOrderT(123);

        SubOrder1<String> sub2 = new SubOrder1<>();
        sub2.setOrderT("order2.....");

    }

    @Test
    public void test3(){
        ArrayList<String> list1 = null;
        ArrayList<Integer> list2 = new ArrayList<Integer>();
        //泛型不同的引用不能相互赋值。
//       list1 = list2;

        Person p1 =null;
        Person p2 =null;
        p1=p2;
    }

    //测试泛型方法
    @Test
    public void test4(){
        SubOrder1 order = new SubOrder1<String>();
        Integer[] arr = new Integer[]{1, 2, 34};
        for (Integer a:arr) {
            System.out.println(a);
        }

        //泛型方法在调用时，指明泛型参数的类型
        List<Integer> list = order.copyFromArrayToList(arr);//把数组中的数据复制到一个List集合中,并将List集合返回

        System.out.println(list);


    }

3.2 注意点：

 

3.3 应用场景举例：

【DAO.java】:定义了操作数据库中表的通用操作

                ORM思想（数据库中的表和JAVA中的类对应）【万事万物皆对象】

public class Dao<T> { //表的共性操作的DAO

    //添加一条记录
    public void add(T t){

    }

    //删除一条记录
    public boolean remove(int index){

        return false;
    }

    //修改一条记录
    public void update(int index,T t){

    }

    //查询一条记录
    public T getIndex(int index){

        return null;
    }

    //查询多条记录
    public List<T> getForList(int index){

        return null;
    }
    //泛型方法
    //举例：获取表中一共有多少条记录(返回值：Long)？获取最大的员工入职时间(返回值：date)？
    public <E> E getValue(){

        return null;
    }

}

【CustomerDAO.java】:

public class CustomerDao extends Dao<Customer>{//只能操作某一个表的DAO
}

【StudentDAO.java】:

public class StudentDao extends Dao<Student>{//只能操作某一个表的DAO
}

4.泛型在继承上的体现

    /*
    1. 泛型在继承方面的体现

      虽然类A是类B的父类，但是G<A> 和G<B>二者不具备子父类关系，二者是并列关系。

       补充：类A是类B的父类，A<G> 是 B<G> 的父类

     */
    @Test
    public void test(){

        Object obj1 = null;
        String str = null;
        obj1 = str;

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

        //编译不通过
//        Date date = new Date();
//        str = date;  类型不匹配: 将Date对象赋值给String对象

        List<Object> list1 = null;
        List<String> list2 = new ArrayList<>();
        //此时的list1和list2的类型不具有子父类关系,完全并列
        //编译不通过
//        list1 = list2;
        /*
        反证法：
        假设list1 = list2;  list1和list2指向同一个地址，对list1进行操作，list2的值应该会改变
           list1.add(123);导致混入非String的数据。出错。

         */
        show(list1);
        show1(list2);

    }



    public void show1(List<String> list){

    }

    public void show(List<Object> list){

    }
    @Test
    public void test2(){

        AbstractList<String> list1 = null;//实现了List接口
        List<String> list2 = null;
        ArrayList<String> list3 = null;

        list1 = list3;
        list2 = list3;
        list2 = list1;

        List<String> list4 = new ArrayList<>();

    }

5.通配符

5.1 通配符的使用

/*
     通配符的使用
       通配符：?

       类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是：G<?>

     */
    @Test
    public void test3(){
        List<String> list1 = null;
        List<Object> list2 = null;

        List<?> list = null;

        list = list1;
        list = list2;
        //编译通过
//              print(list1);
//              print(list2);

        ArrayList<String> list3 = new ArrayList<>();
        list3.add("as");
        list3.add("hj");
        list3.add("fd");
        list =list3;

        //添加(写入)：对于List<?>就不能向其内部添加数据。
        //除了添加null之外。
//       list.add("DD");
//       list.add('?');
        list.add(null);

        //获取(读取)：允许读取数据，读取的数据类型为Object。
        Object o = list.get(0);
        System.out.println(o);
        System.out.println(list);
    }

    public void print(List<?> list){
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println(obj);

        }
    }
   /*

5.2 涉及通配符的集合的数据的写入与读取：

 见上

5.3 有限制条件的通配符的使用

   /*
         有限制条件的通配符的使用。
         ? extends A:
    G<? extends A> 可以作为G<A>和G<B>的父类，其中B是A的子类

        ? super A:
    G<? super A> 可以作为G<A>和G<B>的父类，其中B是A的父类

     */
    @Test
    public void test4(){
        List<? extends Person> list1 = null;
        //只能接收小于等于Person的， (-00 , Person]
        List<? super Person> list2 = null;
        //只能接收大于等于Person的,  (Person ,+00)

        ArrayList<Student> list3 = new ArrayList<>();
        ArrayList<Person> list4 = new ArrayList<>();
        ArrayList<Object> list5 = new ArrayList<>();

        //子类可以赋值给父类，父类不能赋值给子类
        list1 =list3;
        list1 =list4;
//        list1 =list5;

//        list2 = list3;
        list2 = list4;
        list2 = list5;

        //读取数据：
        list1 = list3;//最大能接收到Person,所以可以用Person
        Person p = list1.get(0);
        //编译不通过
        //Student s = list1.get(0);

        list2 = list4;//最小也得接收Person,所以不能用Person
        Object obj = list2.get(0);
        编译不通过
//        Person obj = list2.get(0);

        //写入数据：
        //编译不通过
//       list1.add(new Student());

        /*
        不能接受比自身大的类
         */


        //编译通过
        list2.add(new Person());
        list2.add(new Student());


    }

6.File类

6.1 File类的理解

1. File类的一个对象，代表一个文件或一个文件目录(俗称：文件夹)
2. File类声明在java.io包下
3. File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，
    并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用IO流来完成。
4. 后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的"终点".

6.2 File的实例化

6.2.1 常用构造器

File(String filePath)
File(String parentPath,String childPath)
File(File parentFile,String childPath)

6.2.2 路径的分类

相对路径：相较于某个路径下，指明的路径。
绝对路径：包含盘符在内的文件或文件目录的路径

说明：
IDEA中：
如果大家开发使用Junit中的单元测试方法测试，相对路径即为当前Module下
如果大家使用main()测试，相对路径即为当前的Project下

Eclipse:

不管使用单元测试方法还是使用main()测试，相对路径都是当前的Project下

6.2.3 路径分隔符

windows和DOS系统:\\
unix和URL:/

6.3  File类的常用方法