小郑

Java基础

常用DOS命令

dir：列出当前目录下的文件以及文件夹
md：创建目录
rd：删除目录
cd：进入指定的目录
cd… : 退回到上一级目录
cd\ : 退回到根目录
del : 删除文件
exit : 退出命令行

文章目录

Java基础
- 常用DOS命令
一. JAVA基础知识
面向对象
异常（exception）

一. JAVA基础知识

1.1 Java语言特点:

面向对象, 健壮性, 跨平台性(不同的操作系统有不同的JVM), 核心机制(垃圾回收)

1.2 Java运行过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZaTZ7EhU-1651708047366)(G:\java 学习（尚硅谷）\尚硅谷博客\java编译过程.png)]

1.3 命令行编译和运行

命令行编译
*   javac   源文件名.java
*   java   源文件名

1.4注释

对所写的程序解释说明，增强可读性

可以调试所写的代码

1. // 单行注释

2. /* 多行注释*/

3. /** 文档注释 */

（Java特有）生成的内容可以被JavaDoc所解析（public类），

生成一套网页形式的体现的该程序的文档说明

1.5 JAVA API 文档

API文档: 针对于提供的类库如何使用,给的一个说明书

1.6 标识符

对方法,类,变量命名的字符

所有的标识符都应该以字母（A-Z 或 a-z），美元符($)，或者下划线开头(_)开头
首字符之后可以是任意字符,不能以数字开头
不能使用关键字作为变量名或方法名
标识符是大小写敏感的

1.7数据类型

1.7.1 强类型语言

变量必须先定义后才能使用

1.7.2 弱类型语言

1.7.3 基本类型语言(primitive type ) 8种

整型： byte ： 1字节 -128 ~ +127

short ： 2字节

int ： 4字节

long ： 8字节 L
浮点型： float ： 4字节 F

double ： 8字节
字符型 char 2字节通常使用 ’ ’ ，内部只能
Boolean 类型： 1位（True / false）

注意
1. byte short int 三者之间运算时结果类型为 int
2. 整型常量默认类型为int
3. 浮点型常量默认类型为double

1.7.4 引用类型（reference type）

类 (字符串)

接口

数组

1.7.5 整数拓展

进制二进制 ob 十进制八进制 0 十六进制 0x

1.7.6 浮点数拓展

最好完全使用浮点数比较

银行业务表示： BigDecimal类（数学工具类）

1.7.8 字符拓展

所有字符本质还是数字，

字符可以使用强制转换，转换为对应的字符编码（unicode）.

1.7.9 布尔类型拓展

boolean flag = true;

if(flag){} <=====> if(flag == true) {};

1.7. 10 转义字符

\t	制表符
\n	换行符

1.7.11 类型转换

小数的优先级大于整数

byte ， short ，char ， —> int —> long —-> float ——> double

运算中,不同类型的数据先转化为同一类型的数据强制转换

(类型)变量名

高——> 底

自动转换底——>高

 int i = 128;  // 128
        byte b = (byte) i;//内存溢出 -128
        System.out.println(i);
        System.out.println(b);

注意点:

不能对布尔值进行转换
不能把对象类型转换为不相干的类型
把高容量转为低容量时，强制转换
转换时可能存在内存溢出或者精度问题

1.8 变量

(内存中的一块空间)变量必须先申明再使用

Java是一种强类型语言，每个变量都必须声明类型

Java变量是程序中最基本的单元，其要素包括变量名，变量类型和作用域。

注意：

每个变量都有类型，类型可以是基本类型，也可以是引用类型
变量名必须是合法的标识符
变量申明是一个完整的语句，因此每个声明都必须以分号结束

变量的作用域

局部变量：必须先申明和赋值在方法里面构造器形参，

实例变量：从属于对象，如果不初始化则赋默认值

类变量：static 变量类型变量名；

1.9 常量

final 常量名 = 值；

常量名一般是大写

1.10 变量命名规范

所有变量，方法，类名：见名知意思
类成员变量：首字母小写和驼峰原则： monthSalary 除了第一个单词以外，后面的首字母大写 lastName
局部变量：首字母小写和驼峰原则、
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man ， GoodMan
方法名：首字母小写和驼峰原则：run() , runRun()
包名: 全部小写

1.11 运算符

算术运算符 : +，-，*，/，%（模运算），++（在前先自增，再赋值），–
赋值运算符 : =
关系运算符 : >，< , >= , <= , == , != , instanceof
逻辑运算符: &&（短路与） , ||（短路或） , !（非，取反）布尔类型变量，& , |,
位运算符 : ^, ~, >>（右移）, <<（左移），& , |,
条件运算符（三元运算符）：（条件表达式）？表达式1：表达式2

凡是使用三元运算符的地方都可以改写为if —– else—–
```
 int score = 50;
        String type = score < 60 ?"不及格":"及格";
        System.out.println(type);//不及格
```

字符串连接符

System.out.println(" "+c+d); // 1020
        System.out.println(c+d+" ");//30

1.12基本流程结构

顺序结构

由上向下运行，它是任何一个算法都离不开的基本算法结构

选择结构

if 单选择结构 if(表达式){ }

if 双选择结构 if(表达式){ }else { }

if 多选择结构 if（表达式）{ } else if （表达式） { } else if（表达式）{ }

Switch（）多选择结构

switch case : 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支

switch(){
case  变量1 ： 表达式1；
	break；
	。。。。。
 default{
	表达式N
	}
}

多个switch语句输出相同的效果可以合并

switch( ) 语句中的类型可以是：

byte，short，int ， char， String

写分支结构时，当发现可以使用switch--- case （同时，switch中的表达式取值情况不太多），又可以使用if----else

优先使用switch --- case

循环结构

循环四要素：

a.初始条件
b.循环条件  (布尔类型)
c.迭代体
d.迭代条件

while循环

while（布尔表达式）{ }

大多数情况会让循环停止下来的，写一个让表达式失效的方式结束循环

避免死循环 while(true) for(;😉

do …while 循环至少执行一次
For 循环（外层控制行数，内层控制列数）

for（初始化；布尔表达式；更新）{

方法体；

}

增强for循环

for （声明语句：表达式）{ }

声明语句：声明新的局部变量。该变量的类型必须和数组元素的类型匹配，其作用局限在循环语句块，其值与此时数组元素的值相等。

表达式：表达式是要访问的数组名，或者是返回值为数组的方法

break 与continue

其后不能加其他语句

break强制推出循环结束当前循环

continue结束某次循环结束当次循环

带标签的break 与 continue ，结束指定的某次循环

label ： for（  ）{
				for( ){   
					 break   label ;
                     }   
 				 }

1.13随机数

Math 类中

random() 方法

1.14 数组

数组是相同类型的有序集合
数组描述的是相同类型的若干个数据，按照一定的先后排列顺序组合而成

每个数组作为一个数组元素，通过下标访问（从0开始）

//变量类型   变量的名字   = 变量值
        //数组类型
        int[] array;//1.声明一个数组
        array = new int[10]; //2.创建一数组

        //3.给数组中赋值
        array[0] = 1;
        array[1] = 2;
        array[2] = 3;
        array[3] = 4;
        array[4] = 5;
        array[5] = 6;
        array[6] = 7;
        array[7] = 8;
        array[8] = 9;
        array[9] = 10;

        System.out.println(array[2]);//4.取值
        //计算所有数的和
        int sum =0;
        for (int i = 0; i < array.length; i++) {
            sum+=array[i];
        }
        System.out.println("总和为:"+sum);
    }



   int[] array = new int[10];//动态初始化    被隐式初始化，默认值：0
        int[] array01 = {10, 20, 30, 40, 50, 60, 70, 80, 90};//静态初始化，创建+赋值
        String[] name = {"张三", "李四", "王五"};
//    增强型for循环遍历数组
//        for (int value : array01
//        ) {
//            System.out.println(array01[2]);
//            System.out.println(array01);//返回元素地址
//        }

Arrays类

方法名	使用方法	返回值
equals(array1,array2 )	比较两个数组是否相等	返回Boolean类型
sort(array)	对array的元素升序排列	返回值为void
toString(array)	将一个数组array转换成字符串	返回String类型
fill(array,value)	把数组所有的元素都赋值成value	返回值为void

冒泡排序

  int[] array01 = {20, 15, 98, 45, 62, 15, 45, 78, 65, 12, 32, 174, 45};//静态初始化，创建+赋值
        //比较数组中两个相邻的元素，如果第一个比第二个大就交换位置
        //每次比较产生一个最大或最小的数
        //依次排序,直到结束
        int[] array=sort(array01);
        System.out.println(Arrays.toString(array));
    }

    public static int[] sort(int[] a) {
        int temper = 0;
        //外层循环,判断走多少次
        for (int i = 0; i < a.length-1; i++) {
            //判断两个数字的大小
            for (int j = 0; j < a.length - 1 - i; j++) {
                if (a[j + 1] > a[j]) {
                    temper = a[j ];
                    a[j] = a[j+1];
                    a[j+1] =temper;
                }
            }
        }
        return a;

15数据结构

数据间的逻辑关系：集合，一对一，一对多，多对多
数据存储结构：线性表，顺序表（比如：数组），链表，栈，队列
树形结构：二叉树
圆形结构

算法：

排序：时间复杂度，空间复杂度，稳定性

搜索（检索）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Lynx5LCa-1651708047368)(G:\java 学习（尚硅谷）\尚硅谷博客\算法五大特征.png)]

面向对象

物以类聚，分类的思维模式

对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统，但是具体到围观操作，任然需要面向过程的思路方法处理。

本质：以类的方式组织代码，以对象的组织（封装）数据

抽象

三大特征：封装，继承，多态

对象：是该类事物的具体表现，是一种具体存在

类：一系列具有相同属性和行为的事物的统称，是一个抽象的概念

类是对象的模板，对象是类的实例化

使用new关键字创建对象

使用new关键字创建对象的时候，除了分配内存空间之外，还会给创好的对象进行默认的初始化，以及对其类中的构造器的调用

方法

（首字母小写，驼峰原则）

Java方法是语句的集合，它们在一起执行一个功能

方法是解决一类问题的步骤的有序集合

方法包含于类和对象中

方法在程序中被创建，在其他地方被引用

静态方法

public static 修饰

可以使用：类名.方法名调用（和类一起加载）

非静态方法

public 修饰

使用：实例化这个类 new

对象类型对象名 = 对象值；

实例化后才存在

格式  
    修饰符    返回值类型    方法名（参数类型   参数名）{
    
    }


方法调用
     对象名.方法名(参数列表)    （new 一个对象）
    
     当方法返回一个值的时候，方法调用通常被当作一个值
    eg: int  larger = max(30,40);

方法重载

在同一个类中，有相同的函数名称，但形参不同的函数

方法重载的规则：

	1. 方法名必须相同
	2. 参数列表不同（个数不同，或类型不同，参数排列顺序不同）
	3. 方法的返回值类型可以相同，可以不同
	4. 仅仅返回值类型不同不足以成为方法的重载

可变参数

在方法声明中，在指定参数类型后加一个省略号（int… a）

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通参数都必须在它之前声明

public  void  printNum(int... a){//设置可变长参数
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+"\t");
        }
        System.out.println();
    }

递归

A方法调用A方法

递归结构包括两个部分：

递归头：什么时候不调用自己的方法，如果没用递归头，将陷入死循环

递归体：什么时候需要调用自己的方法

能不使用递归就不使用

构造器

和类名相同，没用返回值

作用：

new 本质在调用构造方法（创建对象）
初始化对象的值
一个类中多个构造器构成重载
有参构造，在实例化对象的时传递参数
默认构造器的权限和类的权限相同
、777.。

注意点：

1. 有有参构造时必须显示无参构造
2. 快捷键 ALT +Insert
3. 在一个包内，只允许一个类是公共类（public），可以没用公共类

封装

数据的隐藏，(使用权限修饰符)属性私有，隐藏内部复杂性只对外面提供简单接口

程序设计追求“高内聚，低耦合”

高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉

低耦合：仅暴露少量的方法给外部使用

属性私有使用get / set 方法 private set方法可以设置安全性判断

get获得属性，set给属性赋值

好处：

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
增加系统的可维护性

权限修饰符

–	类内部	同一个包	不同包的子类	同一个工程
private	√
缺省（空缺）	√	√
protected	√	√	√
public	√	√	√	√

JavaBean

是一种课重用的组件

表述的javaBean类：

1. 类是公共的的
1. 有一个无参的公共构造器
1. 有属性，且有对应的 get / set方法

继承 extends

多个类种存在相同的属性和行为，只有单继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模

格式
	修饰符    class    子类  extends 父类{
	
	}

子类继承了父。，类，就会拥有父类的所有非私有成员，私有属性不能直接调

在java种，所有的类，都默认之间或间接的继承Object类

super 注意点：

super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类方法或构造器中
super和this不能同时调用构造方法

调用父类的属性，方法，构造器

this 代表的对象不同

this 本身调用者的这个对象方法形参与类属性同名加this表明属性

this调用构造器：

 						1. 在类的构造器中，可以显示的使用”this(形参列表)“方式，调用本类中指定的其他构造器
 						1. 在构造器中不能太通过this调用自己
 						1. 如果一个类中有n个构造器，则最多有n-1个构造器中使用了”this（形参列表）“
 						1. 规定   this（形参列表）必须声明在首行
 						1. 构造器内部最多只能声明一个” this(形参列表) “，用来调用其他的构造器

super 代表父类对象的引用

前提：

this 没有继承也可以使用

super只能在继承下才能使用,

构造器

this(); //本类的构造

super(); //父类的构造

子类构造器中显式使用,super只能在继承下才能使用,必须声明在子类构造器的首行

this 和 super 只能二选一 ,不能同时出现

重载

必须是非static的方法，子父类之间的同名方法，子类重写父类的方法

方法名必须相同
参数列表必须相同
修饰符范围可以扩大
抛出异常，范围可以缩小，但不能扩大
子类的方法和父类的方法必须一致，方法体不同
父类的功能，子类不一定需要或者不一定满足
构造器也可以重载
重载不表示为多态性

重写

子类继承父类后,可以对父类中同名同参的方法,进士覆盖操作
重写父类的方法(私有方法不能重写)
父类被重写的方法返回值是void,则子类重写的方法返回值只能是void
父类被重写的方法的返回值类型是A类型,则子类重写的方法的返回值类型可以是A类或A类的子类
父类被重写的方法返回值是基本数据类型,则子类重写的方法的返回值类型必须是相同数据类型
重写可以表示为多态性
static方法不能重写

子类和父类中的同名同参方法,要么都是非static,或者都是static修饰

package关键字

为了更好的实现项目中类的管理,提供包的概念
使用package声明类或接口所属的包,声明在源文件的收行
包,属于标识符,遵循标识符的命名规则小写
每” . “一次代表一层文件目录

同名的包下不能命名同名的接口,类

不同包下可以

import关键字

作用:在源文件中显式的导入指定包下的类,接口

声明在包的声明和类的声明之间

如果需要导入多个结构,则并列写出即可

可以使用”Xxx .* “的方式导入Xxx包下的所有结构

如果使的类或接口是java.lang包下定义的,则可以省略import结构

如果使用类的类或接口是本包下定义的,则可以省略

如果在不同的包中使用了同名的类或接口,则必须有一个使用全类名的方式显式

import static :导入指定类或接口中的静态结构

多态

多态是方法的多态，属性没有多态

父类和子类，有联系

存在条件：

继承关系，有方法重写

，父类引用指向子类对象 Father f = new Son（）;

多态的使用:

编译看左，执行看右，只能调用父类中声明了的方法，执行子类重写了的方法

不能重写的方法：

static方法，属于类，它不属于实例
final 常量
private 方法

向上转型，子类向父类的转换

<父类名> <引用变量> = new <子类名()> Father f = new Son（）;

特点：

减少类中的代码量
提高代码的可扩展性和可维护性

使用场景：父类可以作为形参的数据类型，这样可以接收其任意类型的子类对象

多态关系中，成员变量是不涉及重写的，使用成员变量，遵守“编译看左，运行看右”

instanceof

返回布尔类型，X(引用对象) instanceof Y(类型) ，X与Y之间必须有继承关系，否则会出现编译错误

类型转换：

把子类转换为父类，向上转型，不用强制转换

把父类转换为子类，向下转型，强制转换，可能丢失方法无法调用子类的特有方法

（类型）变量名;

static静态的

修饰：属性，方法，代码块，内部类

修饰成员变量能被本类的所有对象共享

/* 
静态结构与类同生命周期
	 * 用static修饰的属性称为静态属性, VS 非静态属性(实例变量)
     * 静态属性:创建了多个对象,多个对象共用一个静态变量
     *当某个对象修改静态变量时,会导致其他对象调用此静态变量时
     * 是修改过了的
     * 静态属性可以通过"类名.属性"赋值,只加载一次,
     * 在内存中只有一份,存在方法区中
     
     * 非静态属性，先实例化对象再对属性赋值
         
 static修饰方法
 *static,修饰静态方法  可直接"类名.方法名"调用
     * 非静态方法需要实例化后才能调用方法
     
     静态方法中只能调用静态方法或属性
     非静态方法中既可以调用静态方法或属性,也可以调用非静态方法或属性
     
     注意点:
     	静态方法内,不能使用this关键字也不能使用super关键字
 */
        
         
         

public     static     final    公共的静态常量修饰符
    静态方法与类一起加载，只执行一次

如何判断是否使用static:

属性:

> 属性可以被多个对象共享的,不会随着对象的不同而不同的

方法:

> 操作静态的属性的方法通常是静态的

> 工具类的方法,习惯上声明为static的

单例设计模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zM5i5Cw4-1651708047369)(G:\java 学习（尚硅谷）\尚硅谷博客\单例设计模式.jpg)]

//饿汉式   加载时间过长   线程安全
public class SingletonTest1 {
    public static void main(String[] args) {
        Bank bank = Bank.getInstance();
        Bank bank1 = Bank.getInstance();
        System.out.println(bank == bank1);
    }
}
class  Bank{
    //私有化类的构造器
    private  Bank(){

    }
    //2.内部内创建对象
    //4.要求此对象也必须声明为静态
    private static Bank instance = new Bank();
    //3.提供公共的方法,返回类的对象
    public static Bank getInstance(){
        return  instance;
    }
}

//懒汉式   延迟创建对象   线程不安全

public class SingletonTest2 {
    public static void main(String[] args) {
        Order order = Order.getInstance();
        Order order2 = Order.getInstance();
        System.out.println(order == order2);
    }
}

class Order {
    //1.私有化构造器
    private Order() {

    }

    //2.声明当前类的对象,没有初始化
    //4.此对象也必须声明为static
    private static Order instance = null;

    //3.声明 public   static 的返回当前类对象的方法
    public static Order getInstance() {
        if (instance == null) {
            instance = new Order();
        }
        return instance;
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PMwTY9T4-1651708047369)(G:\java 学习（尚硅谷）\尚硅谷博客\单例模式应用场景.png)]

main()方法

程序的入口

main方法也是一个普通的静态方法

属性赋值先后顺序

对属性赋值的位置
*          1.默认初始化
*          2.显式初始化
*          3.构造器中初始化
*          4.有了对象以后通过"对象名.属性"初始化
*          5. 在代码块中赋值

final

修饰变量，(常量): 可以考虑赋值的位置的位置有: 显式初始化代码块中赋值(初始化) 构造器中初始化

修饰局部变量(大写) 修饰形参

修饰的类不能被继承

修饰的方法不能被重写

抽象类

  abstract（抽象的） 关键之的使用
*                      可以用来修饰类，和方法
*
*      abstract 修饰类：抽象类
*              此类不能实例化，
*              抽象类中一定有构造器，便于子类实例化时调用(涉及：子类对象实例化的全过程)
*              开发中提供抽象类得子类让子类对象实例化，完成相关的操作
*      abstract 修饰方法： 抽象方法
*                抽象方法只有方法的声明，没有方法体
*                包含抽象方法的类，一定是一个抽象类，反之抽象类中可以没有抽象方法
*                若子类重写了父类的所有点抽象方法后，此子类可以实例化
*                如子类没有重写，则也是一个抽象类，需要abstract修饰
      
      
     使用上注意点： 不能用来修饰属性，构造器等结构
      			  不能用来修饰私有方法，静态方法，final的方法

接口

接口使用interface定义
* 接口和类是并列的两个结构
* 如何定义接口：
* 定义接口中的成员: 接口中的方法是抽象方法

* 接口中不能定义构造器，接口不能实例化
* java开发中用类实现接口(implements )
* 如果实现类中覆盖了接口中的所有抽象方法，则此类可以实例化
* 如果没有覆盖所有的抽象方法，则此实现类仍为一个抽象类
* java类可以实现多个接口  
	格式 class AA extends BB  implements  aa,cc,bb,......
* 接口与接口直接按可以继承，可以多继承
* 接口的使用：
		体现多态性   
* 接口实际上可以看作是一种规范

 //全局常量
    //默认修饰符  public  static  final
 // 抽象方法
    //默认修饰符 public  abstract

内部类

成员内部类：

一方面作为外部类的成员：

1. 可以调用外部类的结构

2. 可以被static修饰
2. 可以被四种不同的权限修饰符修饰

另一方面作为一个类：

类内部可以定义属性，方法，构造器

可以被final修饰，表示此类不嫩被继承

可以被abstract 表示此类不能被实例化

注意：

如何实例化成员内部类的对象

//创建Dog实例,静态成员内部类
Person.Dog dog = new Person.Dog();
dog.show();
//创建Bird实例,非静态成员内部类
Person p = new Person();
Person.Bird bird = p.new Bird();

如何在成员内部类中区分调用外部类的结构‘
开发中局部内部的使用

Object类

是所有Java类的父类

== 与equals（）的区别

== 运算符：

可以使用在基本数据类型变量和应用类型变量中

int a = 10;
        int b = 10;
        double c = 10.0;
        char d = 10;
        char c1 = 65;
        char c2 = 'A';
        System.out.println(a == b);//true
        System.out.println(a == c);//true
        System.out.println(a == d);//true
        System.out.println(c1 == c2);//true

如果比较的是两个基本数据类型变量：比较两个变量保存的数据是否相等，（不一定类型相同）
如果比较的是两个引用数据类型变量：比较两个变量保存的

地址值

是否相等，
符号作用两边变量类型一致。

equals 是一个方法：

只能适用于引用数据类型

Object类中，equals（）的定义：（与 == 一样）

public boolean equals(Object obj) {
        return (this == obj);
    }

像String，Date，File，包装类等都重写了Object类中的equals（）方法，重写后比较的不是两个引用的地址是否相同

而是比较两个对象的”实体内容”是否相同
通常情况下自定义的类如果使用equals方法的话，通常比较两个对象的”实体内容”是否相同

就需要对Object类中的equals()方法重写
重写原则：对象的具体内容是否相同

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hGL4ZcQh-1651708047370)(G:\java 学习（尚硅谷）\尚硅谷博客\equals方法重写.jpg)]

toString（）的使用

当输出一个对象的引用的时，实际上就是调用当前对象的toString()
Object类中toString（）的定义:

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

像String，Date，File，包装类等都重写了Object类中的toString（）方法，当调用此方法时，返回对象的实体内容
自动实现

包装类的使用

基本类型	包装类（引用类型）
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double
boolean	Boolean

包装类的使用：

Java提供了8种基本数据类型的包装类，使得基本数据类型的变量具有类得特征
基本数据类型，包装类，String 三者之间的转换

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X8rd6ItY-1651708047371)(G:\java 学习（尚硅谷）\尚硅谷博客\包装类相互转换.png)]

单元测试

 1.选中当前工程，创建add libraries - Junit 4
*     2.创建Java类，进行单元测试
*          此时Java类的要求: 此类是公共的，此类提供公共的无参构造器
*     3.此类中声明单元测试的方法
*           此时的单元测试方法权限是public，没有返回值类型，没有形参
*     4. 此单元测试方法上需要声明注解：@Test  ,并在单元测试类中导包
*     5.声明好单元测试方法以后，就可以载方法体内测试相关的代码
*     6.写完以后 执行方法名

异常（exception）

检查性异常：具有代表性的检查性异常是用户或问题引用的异常，这是程序员无法预见的

运行时异常：运行时异常可能是可能被程序员避免的异常

错误Error：错误不是异常错误可以避免

在Exception分支中有一个重要的子类RuntimeException（运行时异常）

异常处理机制
	抛出异常
	捕获异常
	try{
	//控制区域   可能出现异常的代码
	}catch(捕获异常类型){
	//捕获异常，捕获多个异常时由小到大（如果没有子父类关系谁上谁下无所谓）    处理异常的方法
	}fianlly{
	//不管有没有异常都会执行。可以不要   一般方法关闭操作 一定会执行
	//像数据库连接，输入输出流，网络编程Socket等资源，JVM是不能自动的回收的，我们需要自己动手进行资源的释放
	//此时的资源释放就需要放在finally中
	}
	
	真正把异常处理掉了
	
	快捷键： 选中当前语句 + ctrl + T

throw 抛出异常一般会在方法中使用，可以作为单独语句使用

” throws +异常类型 “,写在方法声明处.指明此方法执行时可能会抛出的异常类型

一旦当方法体执行时,出现异常,仍会在异常代码处生成一个异常类的对象,此对象满足throws后的异常类型时,就会被抛出.后续的代码不再执行

必须是跟在方法参数列表的后面，不能单独使用

实际应用中的经验总结：

处理运行时异常时，采用逻辑去合理的规避同时辅助try-catch处理
在多重catch块后面，可以加一个catch（Exception）来处理可能会被遗漏的异常
对于不确定的代码，也可以加上try-catch 处理潜在的异常
尽量去处理异常，切忌只简单的调用printStackTrace（）去打印输出
具体如何处理异常，要根据具体的业务需求和异常类型去决定
尽量使用finall语句块去释放占用的资源
编译时异常要考虑异常处理

方法重写规则之一:

子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常

如果父类被重写的方法没有throws方式处理异常,则子类重写的方法也不能使用throws,

意味着若果子类重写的方法中有异常必须使用try – catch -finally

原文链接：https://blog.csdn.net/qq_53999102/article/details/124581320