异常与数组

一、异常

1、常见异常

RuntimeException:运行异常，运行时期发生的异常，编译时没有问题（可以通过增强程序的健壮性来处理 if..else）

常见的运行异常：

• 空指针异常：NullPointerException 当对象无法正常存在使用，会发生空指针

• 类型转换异常：ClassCastException 可以通过instanceof

• 数学异常：ArithmeticException

• 数字转换异常：NumberFormatException

• 数组下标越界异常：ArrayIndexOutOfBoundsException

• 数组长度负数异常：NegativeArrayException

CheckedException：检查时异常|编译时异常，发生在编译期间； 

public static void main(String[] args){
            //数学异常
            System.out.println(5/0);
            //空指针异常
            String a = null;
            System.out.println(a.length());
            //找不到文件异常
            InputStream is=new FileInputStream("");
    }

2、自定义异常

直接或者间接的继承自Exception；

运行时异常：继承自RuntimeException

编译时异常：Exception或者某一个编译时异常的子类

//编译异常
public class NumException extends Exception{
    public NumException() { 
    }
    public NumException(String message) {
        super(message);
    }
}
    public void setNum(int num) throws NumException{
        if(num>=0) {
            this.num = num;
        }else {
            throw new NumException("数量小于零异常！！！");
            
        }
    }
}
public class SelfException {
    public static void main(String[] args) throws NumException {
        Animal a=new Animal();
        a.setName("Cat");
        a.setNum(-10);
        System.out.println(a);
    }
    
//运行异常
class Num extends RuntimeException{
    public Num() {
    }
    public Num(String message) {
        super(message);
    }
}
public static void main(String[] args) {
        Fruit f = new Fruit();
        f.setName("apple");
        f.setPrice(-2.34);
        System.out.println(f);
    }  
 public void setPrice(double price) {
        if(price>0) {
            this.price = price;
        }else {
            System.out.println("Num异常");
            throw new Num("异常！！！");
        }
        
    }

3、异常处理

throws ：异常抛出 抛给上一层处理,当前不处理

try..catch： 异常捕获

public static void main(String[] args) throws FileNotFoundException {
        
        try{
//          ArithmeticException
            System.out.println(5/0);
            //空指针异常
            String a = null;
            System.out.println(a.length());
            //找不到文件异常
            InputStream is=new FileInputStream("");
        }catch(ArithmeticException e) {
            System.out.println("ArithmeticException");
        }catch(NullPointerException e) {
            System.out.println("NullPointerException");
        } catch(Exception e) {
            System.out.println("Exception");
        }finally{
            System.out.println("结束。。。");
        }
    }

二、数组

1、数组

在内存中是一段连续的内存空间相同数据类型数据的有序集合；

数组：存储单个数据

变量：存储多个数据

1.数组的特点:

• 1.数组是一个容器,是一个引用数据类型,堆中

• 2.数组中的所有数据要求数据类型相同

• 3.长度一旦确定不可改变

• 4.有序 根据序号使用(索引|下标)

2.数组的声明：

• 数据类型 变量名;

• 数据类型[] 数组名;

• 数据类型 数组名[];---不推荐

  数据类型 :数组中所有数据的数据类型

  []->数组

  数组名:标识符

3.初始化

动态初始化: 创建的时候不确定数组中的数据值,可以先创建,后续确定了数据值的时候再赋值

• 数据类型[] 数组名 = new 数据类型[长度];

• 默认值:整型0 小数0.0 boolean->false char->' ' 引用数据类型null

  int[] arr=new int[10];

静态初始化: 创建数组的同时赋值

• 数据类型[] 数组名 = new 数据类型[]{值1,值2,值3...};

• 数据类型[] 数组名 ={值1,值2,值3...}; --简单,不够灵活

  int[] a=new int[] {1,7,9,11};
  int[] a={1,7,9,11,13};

4、数组遍历

1. 普通for循环

2. 增强for循环

           int[] arr=new int[10];
           //普通for
           for(int i=0;i<10;i++) {
               arr[i]=i+1;
               System.out.println(arr[i]);
           }
           //增强for
           System.out.println("---------增强for---------");
           int i=1;
           for(int ch:arr) {
               ch=i;
               i++;
               System.out.println(ch);
           }

5、数组常用方法

Arrays 包含了很多操作数组的方法,是一个静态工厂；

常用方法：

• Arrays.toString(数组) 把数组中的内容以字符串的形式返回

• Arrays.equals(arr1, arr2) 比较两个数组内容是否相等

• static int[] copyOf(int[] original, int newLength) 拷贝,截取,填充的效果

• static int[] copyOfRange(int[] original, int from, int to) 从原数组的指定位置开始拷贝,拷贝到指定to位置

• static void fill(int[] a, int val) 数组中的所有位置,使用val数值填充

• static void sort(int[] a) 对指定的 int 型数组按数字升序进行排序。

• static int binarySearch(int[] a, int key) 查找数据出现的索引 返回值:使用前提:先升序排序

   int[] arr1={1,2,3,4,5};
  int[] arr2={3,1,2,5,4};
  System.out.println(arr1==arr2);  //==比较地址
  System.out.println(Arrays.equals(arr1, arr2));//比较内容
  System.out.println(Arrays.toString(Arrays.copyOf(arr1, 3)));//拷贝[0,3)
  System.out.println(Arrays.toString(Arrays.copyOfRange(arr1, 1,3)));//截取[1,3)
  Arrays.sort(arr2);//升序排序
  System.out.println(Arrays.toString(arr1));