异常处理以及数组的基本知识
Throwable
Error
这类不需要程序员关注，一般是由虚拟机生成并脱出的
Exception
异常
RuntimeException：运行时异常，运行期间发生的异常，编译时没有问题，可以通过增强程序的健壮性来处理 if…else
常见的运行时异常：
空指针异常NullpointerException：当对象无法正常存在使用，会发生空指针异常
类型转换异常ClassCastException：intansceof可以解决
数组下标越界
数组长度负数异常
数学异常ArithmeticException
数字转换异常NumberFormatException
什么是异常
程序无法正常执行完毕
异常的分类
运行期间|编译期间
异常的不同分类的特点：
异常的处理
throws 异常抛出 抛给上一层处理，当前不处理
try…catch 异常捕获
try{
可能会出现异常的代码;
}catch(NullPointerException e){ //捕获空指针类型的对象,或者多态
如果出现这个异常,执行的代码...
}catch(FileNotFoundException e){
如果出现这个异常,执行的代码...
}....
catch(Exception e){
任意类型的异常都可以捕获
}finally{
无论try中是否出现异常,都会执行finally中的代码
}
try中一旦遇到异常，try后面的代码不会继续执行，直接找对应的catch，如果存在多个catch，从上到下依次判断。
一个try后面可以跟1至多个catch，至少有一个
如果出现多个catch，捕获异常类型的范围要从小到大
public class Abnormal {
public static void main(String[] args) {
//try中一旦遇到异常try中后面的代码都不会执行
try {
System.out.println(5/0);
System.out.println(Integer.valueOf("123a"));
InputStream is=new FileInputStream("E:\\test\\code");
}catch(ArithmeticException e) {
System.out.println(e.getMessage());
e.printStackTrace();
}catch(FileNotFoundException e) {
e.printStackTrace();
}catch (Exception e) {
// TODO: handle exception
System.out.println("异常处理");
}finally {
System.out.println("一般资源的关系都要放在finally中");
}
System.out.println("main方法结束");
}
}
自定义异常
直接或者间接的继承自Exception
运行时异常：继承RuntimeException
编译时异常：Exception或者某一个编译时异常的子类
public class CustomException {
public static void main(String[] args) {
Student stu=new Student();
stu.setName("小强");
// try {
// stu.setAge(-18);
// } catch (AgeException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
int age=15;
if(age>0 && age<100) {
stu.setAge(age);
}else {
stu.setAge(18);
}
stu.setWeight(50);
System.out.println(stu);
}
}
//class AgeException extends Exception{//编译时异常
class AgeException extends RuntimeException{//运行时异常
public AgeException() {
// TODO Auto-generated constructor stub
}
public AgeException(String str) {
super(str);
}
}
class Student{
private String name;
private int age;
private double weight;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) throws AgeException {
if(age>0 && age<100) {
this.age = age;
}else {
throw new AgeException(age+"不合法");
}
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", weight=" + weight + "]";
}
}
数组
变量：存储单个数据
数组：存储多个数据
在内存中是一段连续的内存空间
相同数据类型数据的有序集合
数组的特点
- 数组时一个容器，是一个引用数据类型，在堆中
- 数组中的所有数据要求数据类型相同
- 长度一旦确定不可改变
- 有序，根据序号使用（索引|下标）
创建数组
1.数组的声明
数据类型 变量名；
数据类型[] 数组名;
数据类型 数组名[]; 不推荐
数据类型：数组中所有数据的数据类型
[] 数组
数组名：标识符
2.初始化
动态初始化：创建的时候不确定数组中的数据值，可以先创建，后续确定了数据值的时候再赋值
数据类型[] 数组名 = new 数据类型[长度];
默认值：
整形 0
小数 0.0
boolean false|true
char ' '
引用数据类型 null
静态初始化：创建数组的同时赋值
数据类型[] 数组名 = new 数据类型[]{值1,值2...};
数据类型[] 数组名 = {值1,值2...};
根据索引操作数组中的数据
数组名[下标|索引]：定位数组中指定索引位置的空间，就可以赋值|获取值
数组：1 2 3 4 5 6转置之后的数组：6 5 4 3 2 1（冒泡排序）
public class ArrayTest02 {
public static void main(String[] args) {
int[] arr=new int[] {1,2,3,4,5,6};
array(arr);
}
public static void array(int arr[]) {
for(int i=0;i<arr.length;i++) {
int num=0;
for(int j=i+1;j<arr.length;j++) {
if(arr[i]<arr[j]) {
num=arr[i];
arr[i]=arr[j];
arr[j]=num;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
数组中最后一个数据的索引
数组名.length-1
属性
数组名.length 这个数组的数据的个数
数组的遍历
数组的遍历:依次的拿出数据的中每一个数据操作
1.for普通for循环
2.增强for循环:for..each
for(数据类型 变量名 : 数组名|容器名){
变量名 ->代表数组中的从前到后的每一个数据
}
public class TestArray {
public static void main(String[] args) {
// TODO Auto-generated method stub
//定义
int[] arr=new int[10];
System.out.println("--------普通for---------");
for(int i=0;i<arr.length;i++) {
//赋值
arr[i]=i;
//打印
System.out.print(arr[i]);
}
System.out.println("\n-------增强for--------");
for(int j : arr){
System.out.print(arr[j]);
}
}
}
Arrays 包含了很多操作数组的方法,是一个静态工厂
常用方法:
Arrays.toString(数组) 把数组中的内容以字符串的形式返回
Arrays.equals(arr1, arr2) 比较两个数组内容是否相等
--从索引为0的位置开始
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 fill(int[] a, int fromIndex, int toIndex, int val)
static void sort(int[] a) 对指定的 int 型数组按数字升序进行排序。
static int binarySearch(int[] a, int key) 查找数据出现的索引 返回值: -插入点 - 1
使用前提:先升序排序
import java.util.Arrays;
public class TestArrayCommon {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr= {3,2,1,4,5,6,7,8,9};
int[] arr1= {3,2,1,4,5,6,7,8,9};
System.out.println(arr==arr1);
System.out.println(Arrays.equals(arr,arr1));
System.out.println((Arrays.toString(Arrays.copyOf(arr, 3))));
System.out.println((Arrays.toString(Arrays.copyOfRange(arr,1,3))));
Arrays.fill(arr1,9);
System.out.println(Arrays.toString(arr1));
Arrays.fill(arr,1,5,8);
System.out.println(Arrays.toString(arr));
//排序默认升序
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
//当超出数组长度时返回负数 假如数组长度为5，用这个方法拿第10个位置的数，那么返回的负数为-10
System.out.println(Arrays.binarySearch(arr, 10));
}
}
