java基础学习笔记(三)--Math--Random--File--枚举--异常

1. Math类
   1. math类的常用方法:
      abs 绝对值
      acos,asin,atan,cos,sin,tan 三角函数
      sqrt 平方根
      pow(double a, double b) a 的 b 次幂
      max(double a, double b) 取大值
      min(double a, double b) 取小值
      ceil(double a) 大于 a 的最小整数
      floor(double a) 小于 a 的最大整数
      random() 返回 0.0 到 1.0 的随机数
      long round(double a) double 型的数据 a 转换为 long 型（四舍五入）
      toDegrees(double angrad) 弧度->角度
      toRadians(double angdeg) 角度->弧度
2. Random类
   1. Random类的常用方法

      public class TestRandom {
          public static void main(String[] args) {
              Random random=new Random();
              //产生int型的随机数
              System.out.println(random.nextInt());
              //产生boolean型的随机数
              System.out.println(random.nextBoolean());
              //产生[0,1)double型的随机数
              System.out.println(random.nextDouble());
              //产生[0,1)float型的随机数
              System.out.println(random.nextFloat());
              //产生0-10之间的随机数
              System.out.println(random.nextInt(10));
              //产生10-30之间的随机数
              System.out.println(10+random.nextInt(20));
          }
      }

      ---

       

3. File类                File 类用来代表文件和目录。
   1. File 类的基本用法
      1. 使用File类创建文件

         /*File类用来代表文件和路径*/
         public class TestFile {
             public static void main(String[] args) throws IOException {
                 //file就代表了这个文件
                 File file=new File("d:/movies/微微一笑很倾城.mp4");
                 //file2就代表了这个目录
                 File file2=new File("d:/movies");
                 //项目的路径
                 System.out.println(System.getProperty("user.dir"));
                 File f3=new File("a.txt");//相对路径,默认放在user.dir目录下
         
                 file2.mkdir();//先创建这个目录
                 file.createNewFile();//再创建这个文件
             }
         }

      2. 使用 File 类访问文件或目录属性

         public class FileTest {
             public static void main(String[] args) throws IOException {
                 File file1=new File("f:/movies/微微一笑很倾城.mp4");
                 File file2=new File(System.getProperty("user.dir"));
                 System.out.println(System.getProperty("user.dir"));
                 file1.createNewFile();
                 System.out.println(file1.exists());//文件是否存在
                 System.out.println(file1.isDirectory());//是不是一个目录
                 System.out.println(file1.getName());//返回文件名
                 System.out.println(file1.isFile());//是不是一个文件
                 System.out.println(file1.length());//返回文件大小
                 System.out.println(file1.getPath());//文件的目录路径
                 System.out.println(new Date(file1.lastModified()));//最后一次修改时间
                 File file3=new File("f:/movies/aa/bb/cc");
                 file3.mkdir();//创建一个目录,中间某个目录缺失,则创建失败
                 file3.mkdirs();//创建多个目录,中间某个目录缺失,则创建该缺失目录
                 file3.delete();//删除文件
             }
         }

   2. 递归遍历目录结构和树状展现
      1. 使用递归算法，以树状结构展示目录树

         public class Test04 {
             public static void main(String[] args) {
                 File file=new File("f:/movies");
                 PrintFile(file,0);
             }
             static void PrintFile(File file,int level){
                 for(int i=0;i

         ---

          

4. 枚举
   1. 创建枚举类型                                                                                                                                                                    枚举类型的定义包括枚举声明和枚举体。枚举体就是放置一些常量。
      所有的枚举类型隐性地继承自 java.lang.Enum。枚举实质上还是类！而每个被枚举的成员实质就是一个枚举类型的实例，他们默认都是 public static final 修饰的。可以直接通过枚举类型名使用它们。

      enum 枚举名 { 
          枚举体（常量列表） 
      }
      
      enum Season { 
          SPRING, SUMMER, AUTUMN, WINDER 
      }

   2. 枚举的使用

      public class TestNum {
          public static void main(String[] args) {
             //枚举遍历
              for(Season season:Season.values()){
                  System.out.println(season);
              }
              //枚举用在switch中
              int a=new Random().nextInt(4);
              switch (Season.values()[a]){
                  case SPRING:
                      System.out.println("春天");
                      break;
                  case SUMMER:
                      System.out.println("夏天");
                      break;
                  case AUTUMN:
                      System.out.println("秋天");
                      break;
                  case WINTER:
                      System.out.println("冬天");
                      break;
              }
          }
      }
      enum Season{
          SPRING,SUMMER,AUTUMN,WINTER
      }

      ---

       

5. 异常
   1. 异常的概念
      异常指程序运行过程中出现的非正常现象，例如用户输入错误、除数为零、需要处理的文件不存在、数组下标越界等。在 Java 的异常处理机制中，引进了很多用来描述和处理异常的类，称为异常类。异常类定义中包含了该类异常的信息和对异常进行处理的方法。 所谓异常处理，就是指程序在出现问题时依然可以正确的执行完。  
      1. 异常的分析                                                                                                                                                             

         public static void main(String[] args) {
                 System.out.println("111");
                 int a=1/0;
                 System.out.println("222");
             }

                                                                                                                                                                                                                                                    

         public static void main(String[] args) {
                 System.out.println("step 1");
                 try{
                     int a=3/0;
                 }catch (Exception e){
                     e.printStackTrace();
                 }
                 System.out.println("step 2");
             }

                                                                                                   
      2. 异常处理
         抛出异常： 在执行一个方法时，如果发生异常，则这个方法生成 代表该异常的一个 对象 ，停止当前执行路径，并把异常对象提交给 JRE。
         捕获异常： JRE 得到该异常后，寻找相应的代码来处理该异常。JRE 在方法的调用栈中查找，从生成异常的方法开始回溯，直到找到相应的异常处理代码为止。
   2. 异常的分类
      JDK 中定义了很多异常类，这些类对应了各种各样可能出现的异常事件，所有异常对象都是派生于 Throwable 类的一个实例。如果内置的异常类不能够满足需要，还可以创建自己的异常类。
      Java 对异常进行了分类，不同类型的异常分别用不同的 Java 类表示，所有异常的根类为 java.lang.Throwable ，Throwable 下面又派生了两个子类：Error 和 Exception。Java异常类的层次结构如图
                                            
      1. ERROR
         Error 是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java 虚拟机（JVM）一般会选择线程终止。Error 表明系统 JVM 已经处于不可恢复的崩溃状态中。我们不需要管他。
      2. Exception
         Exception 是程序本身能够处理的异常，如：空指针异常（NullPointerException）、数 组 下 标 越 界 异 常 （ ArrayIndexOutOfBoundsException ） 、 类 型 转 换 异 常（ClassCastException）、算术异常（ArithmeticException ）等。 Exception 类是所有异常类的父类，其子类对应了各种各样可能出现的异常事件。
      3. RuntimeException(UnCheckedException)
         在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器（exception handler）。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适的异常处理器。
         运行时系统从发生异常的方法开始，依次回查调用栈中的方法，直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适的异常处理器，则运行时系统终止。同时，意味着 Java 程序的终止。

         class Animal{ 
         }
         class Dog extends Animal{ 
         }
         class Cat extends Animal{ 
         }
         
         public class Test5 { 
             public static void main(String[ ] args) { 
                 Animal a=new Dog(); 
                 Cat c=(Cat)a; 
             } 
         }
         
         报ClassCastException异常
         解决 ClassCastException 的典型方式： 
         public class Test5 { 
             public static void main(String[ ] args) { 
                 Animal a = new Dog(); 
                 if (a instanceof Cat) { 
                     Cat c = (Cat) a; 
                 } 
             } 
         }
         
         NullPointerException 异常 
         public class Test4 { 
             public static void main(String[ ] args) {
                  String str=null; 
                 System.out.println(str.charAt(0)); 
             } 
         }
         
         public class Test4 { 
             public static void main(String[ ] args) { 
                 String str=null; 
                 if(str!=null){ 
                     System.out.println(str.charAt(0)); 
                 } 
             } 
         }
         

      4. CheckedException 已检查异常

         所有不是 RuntimeException 的异常，统称为 Checked Exception，又被称为“已检查异常”，如 IOException、SQLException 等以及用户自定义的 Exception 异常。 这类异常在编译时就必须做出处理，否则无法通过编译。
   3. 异常的处理
      1. 捕获异常
         捕获异常是通过 3 个关键词来实现的：try-catch-finally。用 try 来执行一段程序，如果出现异常，系统抛出一个异常，可以通过它的类型来捕捉（catch）并处理它，最后一步是通过 finally 语句为异常处理提供一个统一的出口，finally 所指定的代码都要被执行（catch 语句可有多条；finally 语句最多只能有一条，根据自己的需要可有可无）
         1. try:
            try 语句指定了一段代码，该段代码就是异常捕获并处理的范围。在执行过程中，当任意一条语句产生异常时，就会跳过该条语句中后面的代码。代码中可能会产生并抛出一种或几种类型的异常对象，它后面的 catch 语句要分别对这些异常做相应的处理。一个 try 语句必须带有至少一个 catch 语句块或一个 finally 语句块 。 当异常处理的代码执行结束以后，不会回到 try 语句去执行尚未执行的代码。
         2. catch:
            每个 try 语句块可以伴随一个或多个 catch 语句，用于处理可能产生的不同类型的异常对象。
            常用方法， 这些方法均继承自 Throwable 类 。
            toString ()方法，显示异常的类名和产生异常的原因
            getMessage()方法，只显示产生异常的原因，但不显示类名。
            printStackTrace()方法，用来跟踪异常事件发生时堆栈的内容。
            catch 捕获异常时的捕获顺序：
            如果异常类之间有继承关系，在顺序安排上需注意。越是顶层的类，越放在下面，再不然就直接把多余的 catch 省略掉。 也就是先捕获子类异常再捕获父类异常。
         3. finally:
            有些语句，不管是否发生了异常，都必须要执行，那么就可以把这样的语句放到 finally 语句块中。
            通常在 finally 中关闭程序块已打开的资源，比如：关闭文件流、释放数据库连接等。
         4. try-catch-finally执行过程:
            程序首先执行可能发生异常的 try 语句块。如果 try 语句没有出现异常则执行完后跳至 finally 语句块执行；如果 try 语句出现异常，则中断执行并根据发生的异常类型跳至相应的 catch 语句块执行处理。catch 语句块可以有多个，分别捕获不同类型的异常。catch 语句块执行完后程序会继续执行 finally 语句块。 finally 语句是可选的，如果有的话，则不管是否发生异常，finally 语句都会被执行。

            即使 try 和 catch 块中存在 return 语句，finally 语句也会执行。是在执行完 finally语句后再通过 return 退出。

            finally 语句块只有一种情况是不会执行的，那就是在执行 finally 之前遇到了System.exit(0)结束程序运行。
      2. 声明异常throws子句
         当 CheckedException 产生时，不一定立刻处理它，可以再把异常 throws 出去。在方法中使用 try-catch-finally 是由这个方法来处理异常。但是在一些情况下，当前方法并不需要处理发生的异常，而是向上传递给调用它的方法处理。如果一个方法中可能产生某种异常，但是并不能确定如何处理这种异常，则应根据异常规范在方法的首部声明该方法可能抛出的异常。如果一个方法抛出多个已检查异常，就必须在方法的首部列出所有的异常，之间以逗号隔开。

         方法重写中声明异常原则：子类重写父类方法时，如果父类方法有声明异常，那么子类声明的异常范围不能超过父类声明的范围。
      3. try-with-resource 自动关闭 Closable 接口的资源

         JAVA 中，JVM 的垃圾回收机制可以对内部资源实现自动回收，给开发者带来了极大的便利。但是 JVM 对外部资源(调用了底层操作系统的资源)的引用却无法自动回收，例如数据库连接，网络连接以及输入输出 IO 流等。这些连接就需要我们手动去关闭，不然会导致外部资源泄露，连接池溢出以及文件被异常占用等。

         JDK7 之后，新增了“try-with-reasource”。编译器可以自动关闭实现了AutoClosable 接口的类， 实现类需要实现close()方法。 ”try-with-resources 声明”，将 try-catch-finally 简化为 try-catch，这其实是一种语法糖，在编译时仍然会进行转化为 try-catch-finally 语句。想用我这个语法,就必须实现了AutoClosable 接口。 编译器编译时自动补全finally的close()方法。

         public class Test03 {
             public static void main(String[] args) {
                 try(FileReader reader=new FileReader("f:/a.txt");){
                     char a=(char)reader.read();
                     char b=(char)reader.read();
                     System.out.println(a+b);
                 }catch (Exception e){
                     e.printStackTrace();
                 }
             }
         }

   4. 自定义异常

      在程序中，可能会遇到 JDK 提供的任何标准异常类都无法充分描述清楚我们想要表达的问题，这种情况下可以创建自己的异常类，即自定义异常类。

      自定义异常类只需从 Exception 类或者它的子类派生一个子类即可。

      自定义异常类如果继承 Exception 类，则为受检查异常，必须对其进行处理；如果不想处理，可以让自定义异常类继承运行时异常 RuntimeException 类。

      习惯上，自定义异常类应该包含 2 个构造器：一个是默认的构造器，另一个是带有详细信息的构造器。

      public class AgeException extends Exception {
          public AgeException() {
          }
      
          public AgeException(String message) {
              super(message);
          }
      }
      class  Person{
          private int age;
          private String name;
      
          public Person() {
          }
      
          public Person(int age, String name) {
              this.age = age;
              this.name = name;
          }
      
          public int getAge() {
              return age;
          }
      
          public void setAge(int age) throws AgeException{
              if(age<0)
                  throw new AgeException("人的年龄不应该为负数");
              this.age=age;
          }
      
          public String getName() {
              return name;
          }
      
          public void setName(String name) {
              this.name = name;
          }
      }
      
      class TestException{
          public static void main(String[] args) {
              Person person=new Person();
              try{
                  person.setAge(-1);
              }catch (AgeException e) {
                  e.printStackTrace();
              }
          }
      }

      ---

       

6. idea断点调试

   进行调试的核心是设置断点。程序执行到断点时，暂时挂起，停止执行。就像看视频按下停止一样，我们可以详细的观看停止处的每一个细节。
   1. 断点: 在行号后面单击即可增加断点 在断点上再单击即可取消断点
   2. 进入调试视图                                                                                                                                                                    step over       遇到方法跳过    若当前执行的是一个方法，则会把这个方法当做整体一步执行完,不会进入这个方法内部
      step into        遇到方法进入    若当前执行的是一个自定义方法，则会进入方法内部。JDK 内置方法不会进去
      force step into      强制进入     可以跳进任何方法，包含 JDK 内置方法                                                                           step out          跳出函数     当单步执行到子方法内时，用 step out就可以执行完子方法余下部分，并返回到上一层方法
      drop frame      删除栈帧                   删除当前栈帧。跳回到上一个栈帧                                                                          run to cursor      执行的光标处         一直执行，到光标处停止，用在循环内部时，点击一次就执行一个循环                 rerun                 重新执行程序         重新执行所有程序                                                                                                    resume              继续执行               继续执行到下一个断点或者程序结束