java入门之异常

可变参数

作用：提高了代码的复用性，简化了开发，降低了入参的复杂度。

定义规则：在形参列表中通过type…type_names的形式定义

tips: 1. 可变参数作为形式参数，一定是当前形参的最后

2.可变参数作为形参一定只有一个

3.可变参数在一定长度上可以替代想同类型，不同个数的方法重载

package com.mage.arrays;  
  
public class Test03 {  
    public static void main(String[] args) {  
        int[] list=new int[] {2,3,4,5};  
        info("11",1,2,3,4,5);  
    }  
    public static void info(int ...arr) {  
        int sum=0;  
        for(int ar:arr) {  
            sum+=ar;  
        }  
        System.out.println(sum);  
    }  
    public static void info(String str,int...arr) {  
        int sum=0;  
        for(int ar:arr) {  
            sum+=ar;  
        }  
        System.out.println(sum);  
    }  
}  

对于重载方法：1.可变参数最后调

2.基本类型，最近最优

3.引用类型最近最优（多个重载方法参数列表中的形式参数存在继承关系，一定调用子类的重载方法）

package com.mage.arrays;  
  
public class Test04 {  
    public static void main(String[] args) {  
        fun("",null);  
        invoke(null, 1);  
    }  
    public static void fun(String str,String...strs) {  
        System.out.println("str=["+str+"],strs=["+strs+"]");  
    }  
    public static void fun(String str,Integer...ins) {  
        System.out.println("str=["+str+"],ins=["+ins+"]");  
    }  
    public static void invoke(Object obj,Object...args) {  
        System.out.println("obj=["+obj+"],args=["+args+"]");  
    }  
    public static void invoke(String str,Object obj,Object...args) {  
        System.out.println("str=["+str+"],obj=["+obj+"],args=["+args+"]");  
    }  
}  

冒泡排序及优化

最基础的冒泡排序

public static void bubbleSort01(int[] list) {  
        for(int i=0;i<list.length-1;i++) {  
            System.out.println("第"+(i+1)+"趟");  
            int temp=0;  
            for(int j=0;j<list.length-1;j++) {  
                  
                if(list[j]>list[j+1]) {  
                    temp=list[j];  
                    list[j]=list[j+1];  
                    list[j+1]=temp;  
                }  
                System.out.println("第"+(j+1)+"次:"+toString(list));  
            }  
        }  
    }  

第一次优化

public static void bubbleSort02(int[] list) {  
        for (int i = 0; i < list.length-1; i++) {  
            System.out.println("第"+(i+1)+"趟");  
            boolean flag=false;  
            for (int j = 0; j < list.length-1-i; j++) {  
                if (list[j]>list[j+1]) {  
                    int temp=list[j];  
                    list[j]=list[j+1];  
                    list[j+1]=temp;  
                    flag=true;  
                }  
                  
                System.out.println("第"+(j+1)+"次:"+toString(list));  
            }  
            if(flag==false) {  
                return;  
            }  
        }  
    }  

第二次优化

public static void bubbleSort03(int[] list) {  
        int size=list.length-1;  
        for (int i = 0; i < list.length-1; i++) {  
            System.out.println("第"+(i+1)+"趟");  
            boolean flag=false;  
            int k=0;  
            int index=1;  
            for (int j = 0; j < size; j++) {  
                if (list[j]>list[j+1]) {  
                    int temp=list[j];  
                    list[j]=list[j+1];  
                    list[j+1]=temp;  
                    flag=true;  
                    k=j;  
                }  
                System.out.println("第"+(j+1)+"次:"+toString(list));  
            }  
            size=k;  
            if(flag==false) {  
                return;  
            }  
        }  
    }  
      

二分查找

package com.mage.sort;
public class HalfSeach {
	public static void main(String[] args) {
		
		int[] list= {1,3,5,7,9,11};
		int key=5;//带查找数据
		int test=get(list, key);
		if(test==-1) {
			System.out.println("数组中没有该数据");
		}else {
			System.out.println("查找的是"+key+"位置是"+test);
		}
	}
	public static int get(int[] list,int key) {
		int low=0;
		int middle=0;
		int high=list.length-1;
		if(key<list[low]||key>list[high]||low>high) {
			System.out.println("数据有误");
		}
		while(low<=high) {
			middle=(high+low)/2;
			if(list[middle]>key) {
				high=middle-1;
			}else if(list[middle]<key) {
				low=middle+1;
			}else {
				return middle;
			}
		}
		return -1;
	}
}

异常

异常分类：检查时异常（编译时报错）和运行时异常（执行时报错）

JVM处理异常机制：1.暂停程序

​ 2.报错（异常内容，原因描述，异常行数）

解决异常的办法：1.通过if来判断确保程序没有异常，但过于繁琐，不建议使用

2.通过try-catch语句

3.通过throw，throws抛出异常

try-catch

语法结构：

try{
	有可能出现异常的代码块
}catch（声明异常1）{
	解决异常的办法
}catch（声明异常2）{
    解决异常办法
}.....{
    
}finally{
    关闭资源的代码
}

执行顺序：1.执行try块中的内容

2.如果try块出现异常，执行catch块

3.匹配catch中声明的异常信息 ，如果匹配上了，执行catch中的代码

4.不论是否匹配成功都会执行finally中的内容

5.执行后续代码

tips:1.忘记了具体的异常信息可以使用Exception去捕获异常，不要在catch中做逻辑判断。

2.在多重catch中一般会在最后一个catch语句中编写Exception来捕获未识别的异常

3.不要在第一个catch写异常父类，会屏蔽子类异常

4.代码中存在system.exit()可以让finally不执行，但一般不用

package com.mage.exception;  
  
import java.util.InputMismatchException;  
import java.util.Scanner;  
public class Test01 {  
    public static void main(String[] args) {  
        Scanner input=new Scanner(System.in);  
        System.out.println("请输入第一个数：");  
        try {  
            int num1=input.nextInt();  
            System.out.println("请输入第二个数：");  
            int num2=input.nextInt();  
            int result=num1/num2;  
            System.out.println(num1+"/"+num2+"="+result);  
        } catch (ArithmeticException e) {  
            System.out.println("输入的数据错误");  
        }catch (InputMismatchException e) {  
            System.out.println("除数不能为0");  
        }catch (Exception e) {  
            System.out.println("网络加载错误");  
        }  
        finally {  
            input.close();  
        }  
          
    }  
}      

throw-throws

1.throw声明当前代码块中可能存在的异常信息，并抛给调用者，对于调用者用try-catch捕获异常，不捕获则jvm解决，throw会是程序中断，后续代码不执行

2.throws在方法外对外抛出异常，调用者解决当前异常

throw和throws的区别：

throws抛出异常 是异常解决的一种办法定义在方法的外部 形式参数后 可以抛出多个异常通过","分割

throw 定义在方法内部，声明当前方法可能出现的异常信息 可以导致当前程序中断。

tips：1.一般会将throws和throw在一起使用，throw 声明的异常是检查时异常需要和throws一起使用

2.throws可以单独使用

package com.mage.exception;  
  
import java.io.FileNotFoundException;  
  
public class Test02 {  
    public static void main(String[] args) {  
        Student s=new Student();   
        s.setName("张三");  
        System.out.println(s);  
    }  
}  
class Student{  
    private String name;  
    private int age;  
    public Student() {  
          
    }  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name=name;  
    }  
    public int getAge() {  
        return age;  
    }  
    public void setAge(int age) throws FileNotFoundException{  
        if(age<0||age>150) {  
            throw new FileNotFoundException();  
        }  
        this.age=age;  
    }  
    @Override  
    public String toString() {  
        return "Student [name=" + name + ", age=" + age + "]";  
    }  
}    

自定义异常

jdk中提供的异常信息不满足使用

自定义异常方法：1.声明一个自定义异常类

2.继承Exception

3.编写两个构造器，一个为空构造器，一个带字符串构造器

public class AgeException extends Exception{  
    public AgeException() {  
          
    }  
// 当前异常的原因描述  
    public AgeException(String msg) {  
        super(msg);  
    }  
}