JavaOOP_泛型&File！

1、泛型

在前面的集合学习中，我们都知道集合是可以放任意对象的，只要把对象存储到集合后，其就会被自动提升为Object类型，当我们取出每一个对象，进行操作前，必须采用类型转换（常出现类型转换异常：java.lang.ClassCastException）
泛型：可以在类或方法中预支的使用未知的类型
好处：
将运行时期的ClassCastException，转移到了编译时期的编译失败，避免了类型强转的麻烦
泛型是数据类型的一部分，我们将类名与泛型合并一起看做数据类型

自定义泛型类：
    修饰符 class 类名<代表泛型的变量> {  }
~~~~~~~~~~~~
public class MyGenericClass<MVP> {
    //没有MVP类型，在这里代表 未知的一种数据类型 未来传递什么就是什么类型
    private MVP mvp;
    public void setMVP(MVP mvp) {
        this.mvp = mvp;
    }
    public MVP getMVP() {
        return mvp;
    }
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
使用泛型：即什么时候确定泛型
        在创建对象的时候确定泛型
        例如：`ArrayList<String> list = new ArrayList<String>();`
~~~~~~~~~~~~
public class GenericMethodDemo {
    public static void main(String[] args) {
        // 创建对象
        MyGenericMethod mm = new MyGenericMethod();
        // 演示看方法提示
        mm.show("aaa");
        mm.show(123);
        mm.show(12.45);
    }
}

泛型方法：    
        修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }
public class MyGenericMethod {      
    public <MVP> void show(MVP mvp) {
        System.out.println(mvp.getClass());
    }
    public <MVP> MVP show2(MVP mvp) {    
        return mvp;
    }
}

泛型接口：
        修饰符 interface接口名<代表泛型的变量> {  }
public interface MyGenericInterface<E>{
    public abstract void add(E e);    
    public abstract E getE();  
}

2、Collections

Collection是针对集合操作的工具类

Collection中常用的方法：
        public static void sort(List<T> list)
                        将指定的列表按升序排序
        public static void reverse(List<?> list)
                        反转指定列表中元素的顺序
        public static void shuffle(List<?> list)
                        使用默认的随机源随机排列指定的列表
直接调用方法：
         Collections.方法名(list);

3、File类

java.io.File类是文件和目录路径名的抽象表示，主要用于文件和目录的创建，查找和删除等操作

public File(String pathname)
                        通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
public File(String parent, String child)
                        从父路径名字符串和子路径名字符串创建新的 File实例。
public File(File parent, String child)
                        从父抽象路径名和子路径名字符串创建新的 File实例。
1、一个File对象代表硬盘中实际存在的一个文件或者目录
2、无论该路径下是否存在文件或者目录，都不影响File对象的创建

获取功能方法：

public String getAbsolutePath()
                        返回此File的绝对路径名字符串。
public String getPath()
                        将此File转换为路径名字符串
public String getName()
                        返回由此File表示的文件或目录的名称。
public long length()
                        返回由此File表示的文件的长度。

绝对路径和相对路径：

绝对路径：
从盘符开始的路径，这是一个完整的路径
相对路径：
相对于项目目录的路径，这是一个便捷的路径，开发中经常使用

判断功能的方法：

public boolean exists()
                        此File表示的文件或目录是否实际存在。
public boolean isDirectory()
                        此File表示的是否为目录。
public String getName()
                        返回由此File表示的文件或目录的名称。

创建删除功能的方法：

public boolean createNewFile()
                        当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
public boolean delete()
                        删除由此File表示的文件或目录。
public boolean mkdir()
                        创建由此File表示的目录。
public boolean mkdirs()
                        创建由此File表示的目录，包括任何必需但不存在的父目录。
delete方法，如果此File表示目录，则目录必须为空才能删除。

目录的遍历：

public String[] list()
                        返回一个String数组，表示该File目录中的所有子文件或目录。
public File[] listFiles()
                        返回一个File数组，表示该File目录中的所有的子文件或目录。
调用listFiles方法的File对象，表示的必须是实际存在的目录，否则返回null，无法进行遍历。

4、递归

递归是什么？我调用我自己就是递归
指在当前方法内调用自己的这种现象
递归分为两种
直接：方法自身调用自己
间接：A方法调用B方法，B方法调用C，C方法调用A方法
1、递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出
2、在递归里虽然有限定条件，但是递归次数不能太多，否则也会发生栈内存溢出
3、构造方法，禁止递归

递归累加求和：
public class DiGuiDemo {
    public static void main(String[] args) {
        //计算1~num的和，使用递归完成
        int num = 5;
          // 调用求和的方法
        int sum = getSum(num);
          // 输出结果
        System.out.println(sum);
    }
      /*
        通过递归算法实现.
        参数列表:int 
        返回值类型: int 
      */
    public static int getSum(int num) {
          /* 
             num为1时,方法返回1,
             相当于是方法的出口,num总有是1的情况
          */
        if(num == 1){
            return 1;
        }
          /*
          num不为1时,方法返回 num +(num-1)的累和
          递归调用getSum方法
        */
        return num + getSum(num-1);
    }
}

递归求阶乘：
public class DiGuiDemo {
      //计算n的阶乘，使用递归完成
    public static void main(String[] args) {
        int n = 3;
          // 调用求阶乘的方法
        int value = getValue(n);
          // 输出结果
        System.out.println("阶乘为:"+ value);
    }
    /*
        通过递归算法实现.
        参数列表:int 
        返回值类型: int 
      */
    public static int getValue(int n) {
          // 1的阶乘为1
        if (n == 1) {
            return 1;
        }
          /*
            n不为1时,方法返回 n! = n*(n-1)!
          递归调用getValue方法
          */
        return n * getValue(n - 1);
    }
}

5、小Demo

打印多级目录：

public class DiGuiDemo2 {
    public static void main(String[] args) {
          // 创建File对象
        File dir  = new File("D:\\aaa");
          // 调用打印目录方法
        printDir(dir);
    }
    public static void  printDir(File dir) {
          // 获取子文件和目录
        File[] files = dir.listFiles();
          // 循环打印
          /*
            判断:
            当是文件时,打印绝对路径.
            当是目录时,继续调用打印目录的方法,形成递归调用.
          */
        for (File file : files) {
            // 判断
            if (file.isFile()) {
                  // 是文件,输出文件绝对路径
                System.out.println("文件名:"+ file.getAbsolutePath());
            } else {
                  // 是目录,输出目录绝对路径
                System.out.println("目录:"+file.getAbsolutePath());
                  // 继续遍历,调用printDir,形成递归
                printDir(file);
            }
        }
    }
}

文件搜索：

public class DiGuiDemo3 {
    public static void main(String[] args) {
        // 创建File对象
        File dir  = new File("D:\\aaa");
          // 调用打印目录方法
        printDir(dir);
    }
    public static void printDir(File dir) {
          // 获取子文件和目录
        File[] files = dir.listFiles();
          // 循环打印
        for (File file : files) {
            if (file.isFile()) {
                  // 是文件，判断文件名并输出文件绝对路径
                if (file.getName().endsWith(".java")) {
                    System.out.println("文件名:" + file.getAbsolutePath());
                }
            } else {
                // 是目录，继续遍历,形成递归
                printDir(file);
            }
        }
    }
}