Java Se 基础系列(笔记) -- Exception && Array

Exception

1.java 异常是java提供的用于处理程序中错误(指在程序运行的过程中发生的一些异常事件)的一种机制

2.java程序的执行过程中如果发生异常事件则自动生产一个异常类对象，该对象封装了异常事件的信息并被提交给java运行时系统，这过程称为throw异常；

当java运行时系统接收到异常对象时会寻找能处理这一异常的代码并交其处理，这过程称为catch异常

 public class TestEx1 {
     public static void main(String[] args) {
         TestEx1 test = new TestEx1();

         //捕获异常
         try {
             test.m(0);
             System.out.println("a");    //不会被执行
         } catch(ArithmeticException e) {
             e.printStackTrace();
             //System.out.println(e);
         }

         //try{}里面包含可能会出错的代码，如果里面出错了，他会交给catch{}处理，不影响你之后的代码运行
         //但是如果你try{}里面有多行代码第一行，第二行，第三行，如果第二行出错了，第三行是不执行的
         //如果有finally{}，finally里面代码是处理后事的。比如说，你try里面有操作工作流的，那么如果出错了fianlly
         //可以关闭工作流对象，避免浪费资源。finally{}是必须执行的，不管是出错了，还是不出错。
         System.out.println("b");    //会被执行

     }

     //声明该方法可能抛出的异常
     public void m(int j) throws ArithmeticException {
         //手动往外抛异常
         if(j == 0) {
             throw new ArithmeticException("分母不能为0");
28         }
29     }
30 }

3.在一个try语句块中，父类异常的捕获语句不可以写在子类异常捕获语句的上面

4.重写方法需要抛出与原方法相同的异常或者不抛出

5.自定义异常：

　　-1 通过继承Exception类声明自己的异常类

　　-2 在方法的声明部分用throws语句声明该方法可能抛出的异常

　　-3 在方法适当的位置生成自定义异常的实例并用throw语句抛出

 public class TestEx3 {
     public static void main(String[] args) {
         TestEx3 t = new TestEx3();
         t.manager();
     }

     public void manager() {
         try {
             regist(-3);
         } catch(MyException e) {
             System.out.println("登记失败，出错类型码:" + e.getId());
             e.printStackTrace();
         }

         System.out.println("操作结束");
     }

     //在方法的声明部分用throws语句声明该方法可能抛出的异常
     public void regist(int num) throws MyException {
         //在方法适当的位置生成自定义异常的实例并用throw语句抛出
         if(num < 0) {
             throw new MyException("人数为负值，不合理", 3);
         }
         System.out.println("登记人数：" + num);
     }
 }

 //自定义异常，通过继承java.lang.Exception类声明自己的异常类
 class MyException extends Exception {
     private int id;

     public MyException(String message, int id) {
         super(message);
         this.id = id;
     }

     public int getId() {
         return id;
     }
 }

Array

 public class TestArr2 {
     public static void main(String[] args) {
         Date[] days = new Date[3];

         for(int i=0; i<days.length; i++) {
             days[i] = new Date(2016, 7, i+1);
         }

         for(int i=0; i<days.length; i++) {
             days[i].info();
         }
     }
 }

 class Date {
     int day;
     int month;
     int year;

     public Date(int year, int month, int day) {
         this.year = year;
         this.month = month;
         this.day = day;
     }

     public void info() {
         System.out.println("year:" + year + " month:" + month + " day:" + day);
     }
 }

例程内存分析

 public class TestArr10 {
     public static void main(String[] args) {

         int[][] arr3 = {{3, 4}, {4, 4, 5}, {1, 2}, {5, 6}};
         int[][] arr4 = new int[4][];

         System.arraycopy(arr3, 0, arr4, 0, arr3.length);
         arr4[3][0]= 100;

         for(int i=0; i<arr4.length; i++) {
             for(int j=0; j<arr4[i].length; j++) {
                 System.out.print(arr4[i][j] + " ");
             }

             System.out.println();
         }
     }
 }

内存图如下：

穿插一下选择排序

 import java.util.*;

 public class $TestArr4 {
     public static void main(String[] args) {
         int[] arr = new int[args.length];

         //将从命令行键入的9个值转换为int并赋给int数组
         for(int i=0; i<args.length; i++) {
             arr[i] = Integer.parseInt(args[i]);
         }

         sort(arr);
         print(arr);
     }

     public static void print(int[] a) {
         for(int i: a) {
             System.out.print(i + " ");
         }
     }

     public static void sort(int[] a) {
         //排序
         //Arrays.sort(arr);

         //初版.每一趟排序中进行了多次交换显得没效率
         /*for(int i=0; i<a.length; i++) {
             for(int j=i+1; j<a.length; j++) {
                 if(a[i] > a[j]) {
                     int temp = a[i];
                     a[i] = a[j];
                     a[j] = temp;
                 }
             }
         }*/

         //★改进.
         int k = 0, temp = 0;

         for(int i=0; i<a.length; i++) {
             k = i;
             for(int j=k+1; j<a.length; j++) {
                 if(a[k] > a[j]) {
                     k = j;
                 }
             }

             if(k != i) {
                 temp = a[i];
                 a[i] = a[k];
                 a[k] = temp;
             }
         }
     }
 }

简单分析一下：

改进前的方法的思路(讨论的是第一躺排序)，第一个数依次和后面的每一个元素比较大小，若第一个数小于该元素则交换位置若大于则继续和下一个数字比较，可想而知，确定最小的数并将其放置到第一位可能会有多次交换。那么，能不能把小于第一个数字的数做个标记，然后用这个标记的数和后面的继续比较，若还有更小的就标记更小的，重复上个步骤，等到全部比较完了后，再把这个标记数和第一个数交换，不就可以达到同样的目的了吗，而且就只交换了一次。这也就是改进后的排序的思路了。