JAVA教程从入门到精通 Day13

最新推荐文章于 2024-09-15 19:46:31 发布

dlogcs

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量121

点赞数

文章标签： java 排序算法算法

本文链接：https://blog.csdn.net/dlogcs/article/details/123539434

版权

第五章数组

5.1 什么是数组

数组是一种用于存储多个相同类型数据的存储模型

5.2 数组的特点

引用数据类型
是定长的长度一旦确定不可改变
存储的多个数据类型相同
有序的有索引

5.3 索引

连续的内存空间中每一个小空间的序号
从0开始,每次+1
每个数组的第一个空间索引: 0
每个数组的最后一个空间索引: 数组名.length-1

5.4 数组的长度

数组名.length

5.5 操作数组中的数据

根据索引操作

数组名 [索引]

5.6 数组的定义格式

格式一：数据类型 [] 变量名（推荐使用）
**范例：**int [] arr
**解释：**定义了一个int类型的数组数组名是arr

格式二：数据类型变量名 [] （不常用）

范例： int arr[]

定义了一个int类型的变量变量名是arr数组

5.7 数组初始化方式

动态初始化
静态初始化

1、动态初始化

先创建数组后赋值

**格式：**数据类型 [] 数组名=new 数据类型[数组长度]；
**范例：**int [] arr=new int [3];
注意：

数组只创建不赋值存在默认值

整数==>0 小数==>0.0 boolean==>false

char===>空字符引用==>null

2、静态初始化

创建数组的同时赋值

**格式：**数据类型 [] 数组名=new 数据类型[]{数据1，数据2，…}
**范例：**int [] id = new int[]{1,2,3};
**简化格式：**数据类型 [] 数组名={数据1，数据2，…}
**范例：**int [] id = {1,2,3};

package wang;

public class Array {
    public static void main(String[] args) {
//        动态初始化
        int [] arr=new int [3];

//        静态初始化
        int [] arr1=new int[]{1,2,3};

//        动态初始化赋值
        arr[0]=11;
        arr[1]=12;
        arr[2]=11;

        System.out.println(arr[2]);
        System.out.println(arr1[2]);
    }
}

5.8 数组的遍历

1、普通for循环

【可以操作索引】

package wang;

public class Array {
    public static void main(String[] args) {
//        静态初始化
        int [] arr=new int[]{1,2,3};
//        普通for循环
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

2、增强for循环 | for…each

【不可以操作索引】

package wang;

public class Array {
    public static void main(String[] args) {
//        静态初始化
        int [] arr=new int[]{1,2,3};

//        增强for循环
        for (int sc:arr){
            System.out.println(sc);
        }
    }
}

5.9 二维数组

二维数组 : 数组中放数组 【了解】

声明
数据类型[][] [ ] [ ] 数组名; ===> 推荐

数据类型数组名 [ ] [ ];

数据类型[ ] 数组名[ ];

初始化 :
- 动态初始化 : 先创建数组,后赋值
  - 数据类型[ ] [ ] 数组名 = new 数据类型 [外层的二维数组的长度] [内层一维的长度];
  - 数据类型[ ] [ ] 数组名 = new 数据类型 [外层的二维数组的长度] [ ];
- 静态初始化 : 创建数组的同时赋值
  - 数据类型 [ ] [ ] 数组名 = new 数据类型[ ] [ ] {{1,2,3},{4,5},{6}…};
  - 数据类型 [ ] [ ] 数组名 = {{1,2,3},{4,5},{6}…};
操作数组中的数据:

数组名 [外层二维索引] [内层一维索引]

5.10 二维数组遍历

二维数组遍历 :
- 双重for循环嵌套
  - 普通for嵌套普通
  - 普通for嵌套增强
  - 增强for嵌套普通
  - 增强for嵌套增强

package wang;

import java.util.Arrays;

public class Array {
    public static void main(String[] args) {
        int [] [] arr=new int[][]{{1,2,3,},{5,6},{1,3}};
        //增强for嵌套增强
        for (int[] array:arr){
            for (int i:array){
                System.out.println(i);
            }
        }
         //普通for嵌套增强
        //i 作为二维数组的索引
        for(int i=0;i< arr.length;i++){
            for(int num:arr[i]){
                System.out.println(num);
            }
        }
    }
}

第六章异常

6.1 异常

程序生病了
异常体系 :

Throwable
/ \

Error Exception
/
Runtime Checked
Exception Exception

**Throwable：**Throwable类是Java语言中所有错误和异常的超类

**Error ：**错误一般为虚拟机生成并脱出的,不由程序猿管理

RuntimeException : 运行时异常
- 运行时期所产生的异常
- 一般通过增强程序健壮性的代码处理 ===> if
CheckedException : 检查时异常|编译时异常
- 发生在编译期间
- 只能通过异常处理方案处理
- 如果不处理程序无法运行
注意 :

如果一旦遇到异常,如果不处理程序无法继续向下执行

说说常见的运行时异常:

1.空指针异常 NullPointerException

2.数组索引越界异常 ArrayIndexOutOfBoundsException
  字符串索引越界异常 StringIndexOutOfBoundsException
  索引越界异常 IndexOutOfBoundsException
  
3.数学异常 ArithmeticException

4.类型转换异常 ClassCastException

5.数字转格式异常 NumberFormatException

6.2 异常处理方案

异常抛出 throws
- 把异常抛出到上一层处理
异常捕获

try {

有可能出现异常的代码段;

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (NullPointerException e) {

e.printStackTrace();

} …

catch (Exception e) { --> 接盘侠

e.printStackTrace();

} finally{

一般为资源的关闭等等

}
如果try中的代码一旦出现异常 try后面的代码不执行直接执行catch进行捕获
从上到下的判断catch,哪一个catch能够捕获当前异常对象,就执行对应catch后面的{}中的代码
如果所有的catch都不满足,这个异常最终没有处理,依旧影响执行的继续执行
一个try后面可以跟1~n个catch
catch从上到下,要求类型范围从小到大
finally : 无论try中是否遇到异常,最后都会执行finally中的代码

6.3 自定义异常

自定义的异常类型都会直接或者间接的继承自Exception
直接继承自Exception为编译时异常
继承自RuntimeException为运行时异常
throw 制造异常

public class Class003_Exception {
    public static void main(String[] args){
        User user = new User();
        user.setName("棒棒糖的爱");
        int age = 25;
        //运行时
        /*if(age>=18 && age<=150){
            user.setAge(age);
        }else{
            user.setAge(18);
        }*/

        //编译时
        try {
            user.setAge(15);
        } catch (AgeException e) {
            e.printStackTrace();
            try {
                user.setAge(18);
            } catch (AgeException ageException) {
                ageException.printStackTrace();
            }
        }

        System.out.println(user);

        System.out.println("main方法结束了...");
    }
}

//年龄不合法异常
//class AgeException extends RuntimeException{ //运行时异常
class AgeException extends Exception{ //编译时异常
    public AgeException() {
    }

    public AgeException(String message) {
        super(message);
    }
}

class User{
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public User() {

    }

    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<18 || age>150){
            //制造一个异常
            throw new AgeException(age+"不合法了...");
        }
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}