Java基础语法合集（下篇）

最新推荐文章于 2024-09-04 15:29:36 发布
最新推荐文章于 2024-09-04 15:29:36 发布
阅读量832 收藏 18
点赞数 23
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Warsaki_/article/details/139426883
版权

文章目录

前言

该博客合集可适用于课前预习，课后复习，考前知识点复习，由于篇幅问题，因此部分知识点不会进行深度解释，例如：栈，堆，递归等概念。在未来会制作相应的博客进行深度讲解。

一、String 类

1. 字符串常用的方法

1.1 字符串构造

String 类提供的构造方式非常多，常用的就以下三种：

public static void main(String[] args) {
// 使用常量串构造
String s1 = "hello bit";
System.out.println(s1);

// 直接newString对象
String s2 = new String("hello bit");
System.out.println(s1);

// 使用字符数组进行构造
char[] array = {'h','e','l','l','o','b','i','t'};
String s3 = new String(array);
System.out.println(s1);
}

其他方法需要用到时，大家参考Java开发文档：
https://docs.oracle.com/javase/8/docs/api/index.html

注意：
1.String 是引用类型，内部并不存储字符串本身，在String类的实现源码中，String类实例变量如下：

请添加图片描述

public static void main(String[] args) {
// s1和s2引用的是不同对象 s1和s3引用的是同一对象
String s1 = new String("hello");
String s2 = new String("world");
String s3 = s1;

System.out.println(s1.length()); // 获取字符串长度---输出5
System.out.println(s1.isEmpty()); // 如果字符串长度为0，返回true，否则返回false
}

在这里插入图片描述

2.在Java中 " " 引起来的也是 String 类型对象

// 打印"hello"字符串(String对象)的长度
System.out.println("hello".length());

1.2 String对象的比较
字符串的比较是常见操作之一，比如：字符串排序。Java中总共提供了4中方式：

1. ==比较是否引用同一个对象
注意：对于内置类型，== 比较的是变量中的值；对于引用类型 == 比较的是引用中的地址。

public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 10;

// 对于基本类型变量，==比较两个变量中存储的值是否相同
System.out.println(a == b); // false
System.out.println(a == c); // true

// 对于引用类型变量，==比较两个引用变量引用的是否为同一个对象
String s1 = new String("hello");
String s2 = new String("hello");
String s3 = new String("world");
String s4 = s1;
System.out.println(s1 == s2); // false
System.out.println(s2 == s3); // false
System.out.println(s1 == s4); // true
}

2. boolean equals(Object anObject) 方法：按照字典序比较
字典序：字符大小的顺序
String类重写了父类Object中equals方法，Object中equals默认按照==比较，String重写equals方法后，按照
如下规则进行比较，比如： s1.equals(s2)

public boolean equals(Object anObject) {
// 1. 先检测this 和 anObject 是否为同一个对象比较，如果是返回true
if (this == anObject) {
return true;
}

// 2. 检测anObject是否为String类型的对象，如果是继续比较，否则返回false
if (anObject instanceof String) {
// 将anObject向下转型为String类型对象
String anotherString = (String)anObject;
int n = value.length;

// 3. this和anObject两个字符串的长度是否相同，是继续比较，否则返回false
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;

// 4. 按照字典序，从前往后逐个字符进行比较
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}

public static void main(String[] args) {
String s1 = new String("hello");
String s2 = new String("hello");
String s3 = new String("Hello");

// s1、s2、s3引用的是三个不同对象，因此==比较结果全部为false
System.out.println(s1 == s2); // false
System.out.println(s1 == s3); // false

// equals比较：String对象中的逐个字符
// 虽然s1与s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出true
// s1与s3引用的不是同一个对象，而且两个对象中内容也不同，因此输出false
System.out.println(s1.equals(s2)); // true
System.out.println(s1.equals(s3)); // false
}

3. int compareTo(String s) 方法: 按照字典序进行比较
与equals不同的是，equals 返回的是 boolean 类型，而 compareTo 返回的是 int 类型。具体比较方式：

  1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
  2. 如果前 k 个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值
public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("ac");
String s3 = new String("abc");
String s4 = new String("abcdef");
System.out.println(s1.compareTo(s2)); // 不同输出字符差值-1
System.out.println(s1.compareTo(s3)); // 相同输出 0
System.out.println(s1.compareTo(s4)); // 前k个字符完全相同，输出长度差值 -3
}

4. int compareToIgnoreCase(String str) 方法：与compareTo方式相同，但是忽略大小写比较

public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("ac");
String s3 = new String("ABc");
String s4 = new String("abcdef");
System.out.println(s1.compareToIgnoreCase(s2)); // 不同输出字符差值-1
System.out.println(s1.compareToIgnoreCase(s3)); // 相同输出 0
System.out.println(s1.compareToIgnoreCase(s4)); // 前k个字符完全相同，输出长度差值 -3
}

1.3 字符串查找
字符串查找也是字符串中非常常见的操作，String类提供的常用查找的方法：

方法功能
char charAt(int index)返回 index 位置上字符,如果 index 为负数或者越界，抛出IndexOutOfBoundsException 异常
int indexOf(int ch)返回 ch 第一次出现的位置，没有返回-1
int indexOf(int ch, int fromIndex)从 fromIndex 位置开始找 ch 第一次出现的位置，没有返回-1
int indexOf(String str)返回 str 第一次出现的位置，没有返回-1
int indexOf(String str, int fromIndex)从 fromIndex 位置开始找 str 第一次出现的位置，没有返回-1
int lastIndexOf(int ch)从后往前找，返回 ch 第一次出现的位置，没有返回 -1
int lastIndexOf(int ch, int fromIndex)从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返回-1
int lastIndexOf(String str)从后往前找，返回 str 第一次出现的位置，没有返回 -1
int lastIndexOf(String str, int fromIndex)从 fromIndex 位置开始找，从后往前找str第一次出现的位置，没有返回-1
public static void main(String[] args) {
String s = "aaabbbcccaaabbbccc";
System.out.println(s.charAt(3)); // 'b'
System.out.println(s.indexOf('c')); // 6
System.out.println(s.indexOf('c', 10)); // 15
System.out.println(s.indexOf("bbb")); // 3
System.out.println(s.indexOf("bbb", 10)); // 12
System.out.println(s.lastIndexOf('c')); // 17
System.out.println(s.lastIndexOf('c', 10)); // 8
System.out.println(s.lastIndexOf("bbb")); // 12
System.out.println(s.lastIndexOf("bbb", 10)); // 3

注意：上述方法都是实例方法。

1.4 转化

1. 数值和字符串转化

public static void main(String[] args) {
// 数字转字符串
String s1 = String.valueOf(1234);
String s2 = String.valueOf(12.34);
String s3 = String.valueOf(true);
String s4 = String.valueOf(new Student("Hanmeimei", 18));
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
System.out.println(s4);
System.out.println("=================================");
// 字符串转数字
// 注意：Integer、Double等是Java中的包装类型，这个后面会讲到
int data1 = Integer.parseInt("1234");
double data2 = Double.parseDouble("12.34");
System.out.println(data1);
System.out.println(data2);
}

2. 大小写转换

public static void main(String[] args) {
String s1 = "hello";
String s2 = "HELLO";
// 小写转大写
System.out.println(s1.toUpperCase());
// 大写转小写
System.out.println(s2.toLowerCase());
}

3. 字符串转数组

public static void main(String[] args) {
String s = "hello";
// 字符串转数组
char[] ch = s.toCharArray();
for (int i = 0; i < ch.length; i++) {
System.out.print(ch[i]);
}
System.out.println();
// 数组转字符串
String s2 = new String(ch);
System.out.println(s2);
}

4. 格式化

public static void main(String[] args) {
String s = String.format("%d-%d-%d", 2019, 9,14);
System.out.println(s);
}

1.5字符串替换
使用一个指定的新的字符串替换掉已有的字符串数据，可用的方法如下：

方法功能
String replaceAll(String regex, String replacement)替换所有的指定内容
String replaceFirst(String regex, String replacement)替换收个内容
String str = "helloworld" ;
System.out.println(str.replaceAll("l", "_"));
System.out.println(str.replaceFirst("l", "_"));

注意事项: 由于字符串是不可变对象, 替换不修改当前字符串, 而是产生一个新的字符串

1.6字符串拆分
可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串。

方法功能
String[] split(String regex)将字符串全部拆分
String[] split(String regex, int limit)将字符串以指定的格式，拆分为limit组

字符串的拆分处理：

String str = "hello world hello bit" ;
String[] result = str.split(" ") ; // 按照空格拆分
for(String s: result) {
System.out.println(s);
}

字符串的部分拆分：

String str = "hello world hello bit" ;
String[] result = str.split(" ",2) ;
for(String s: result) {
System.out.println(s);
}

拆分是特别常用的操作，一定要重点掌握，另外有些特殊字符作为分割可能无法正确切分，需要加上转义字符：
拆分 IP 地址：

String str = "192.168.1.1" ;
String[] result = str.split("\\.") ;
for(String s: result) {
System.out.println(s);
}

注意

  1. 字符 “|” , “*” , “+” 都得加上转义字符，前面加上 “\”
  2. 而如果是 “” ，那么就得写成 “\\”
  3. 如果一个字符串中有多个分隔符，可以用 “|” 作为连字符

多次拆分：

String str = "name=zhangsan&age=18" ;
String[] result = str.split("&") ;
for (int i = 0; i < result.length; i++) {
String[] temp = result[i].split("=") ;
System.out.println(temp[0]+" = "+temp[1]);
}

1.7 字符串截取
从一个完整的字符串之中截取出部分内容，可用如下方法：

方法功能
String substring(int beginIndex)从指定索引截取到结尾
String substring(int beginIndex, int endIndex)截取部分内容

1.8 其它操作方法

方法功能
String trim()去掉字符串中的左右空格,保留中间空格
String toUpperCase()字符串转大写
String toLowerCase()字符串转小写

trim() 方法的使用示例：

String str = " hello world " ;
System.out.println("["+str+"]");
System.out.println("["+str.trim()+"]");
//trim 会去掉字符串开头和结尾的空白字符(空格, 换行, 制表符等)

大小写转换：

String str = " hello%$$%@#$%world 哈哈哈 " ;
System.out.println(str.toUpperCase());
System.out.println(str.toLowerCase());
//这两个函数只转换字母

1.9 字符串的不可变性
String是一种不可变对象. 字符串中的内容是不可改变。字符串不可被修改，是因为：
1.String类在设计时就是不可改变的，String类实现描述中已经说明了
请添加图片描述

String类中的字符实际保存在内部维护的value字符数组中，该图还可以看出：
1.String类被final修饰，表明该类不能被继承
2. value被修饰被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中的内容可以修改

final修饰类表明该类不想被继承，final修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象中的内容是可以修改的。

public static void main(String[] args) {
final int array[] = {1,2,3,4,5};
array[0] = 100;
System.out.println(Arrays.toString(array));
// array = new int[]{4,5,6}; // 编译报错：Error:(19, 9) java: 无法为最终变量array分配值
}

为什么 String 要设计成不可变的？

  1. 方便实现字符串对象池. 如果 String 可变, 那么对象池就需要考虑写时拷贝的问题了
  2. 不可变对象是线程安全的
    3.不可变对象更方便缓存 hash code, 作为 key 时可以更高效的保存到 HashMap 中

1.10 字符串修改

注意：尽量避免直接对String类型对象进行修改，因为String类是不能修改的，所有的修改都会创建新对象，效率非常低下。

使用字符串拼接：

public static void main(String[] args) {
String s = "hello";
s += " world";
System.out.println(s); // 输出：hello world
}

这种方式不推荐使用，因为其效率非常低，中间创建了好多临时对象。
在这里插入图片描述

2. StringBuilder和StringBuffer

2.1 StringBuilder的介绍
于String的不可更改特性，为了方便字符串的修改，Java中又提供StringBuilder和StringBuffer类。这两个类大部分功能是相同的，这里介绍 StringBuilder常用的一些方法，其它需要用到了大家可参阅开发文档 https://docs.oracle.com/javase/8/docs/api/

方法说明
StringBuff append(String str)在尾部追加，相当于String的+=，可以追加：boolean、char、char[]、double、float、int、long、Object、String、StringBuff的变量
char charAt(int index)获取index位置的字符
int length()获取字符串的长度
void ensureCapacity(int mininmumCapacity)扩容
void setCharAt(int index,char ch)将index位置的字符设置为ch
int indexOf(String str)返回str第一次出现的位置
int indexOf(String str, int fromIndex)从fromIndex位置开始查找str第一次出现的位置
int lastIndexOf(String str)返回最后一次出现str的位置
int lastIndexOf(String str,int fromIndex)从fromIndex位置开始找str最后一次出现的位置
StringBuff insert(intoffset, String str)在offset位置插入：八种基类类型 & String类型 & Object类型数据
StringBuffer deleteCharAt(int index)删除index位置字符
StringBuffer delete(int start, int end)删除[start, end)区间内的字符
StringBuffer replace(int start, int end, String str)将[start, end)位置的字符替换为str
String substring(int start)从start开始一直到末尾的字符以String的方式返回
String substring(int start，int end)将[start, end)范围内的字符以String的方式返回
StringBuffer reverse()反转字符串
String toString()将所有字符按照String的方式返回
public static void main(String[]args){
StringBuildersb1=new StringBuilder("hello");    	  StringBuildersb2=sb1;
    //追加：即尾插-->字符、字符串、整形数字
    
sb1.append(' '); // hello
sb1.append("world"); // hello world
sb1.append(123); // hello world123
System.out.println(sb1); // hello world123
System.out.println(sb1 == sb2); // true
System.out.println(sb1.charAt(0)); // 获取0号位上的字符 h
System.out.println(sb1.length()); // 获取字符串的有效长度14
System.out.println(sb1.capacity()); // 获取底层数组的总大小
sb1.setCharAt(0, 'H'); // 设置任意位置的字符 Hello world123
sb1.insert(0, "Hello world!!!"); // Hello world!!!Hello world123
System.out.println(sb1);
System.out.println(sb1.indexOf("Hello")); // 获取Hello第一次出现的位置
System.out.println(sb1.lastIndexOf("hello")); // 获取hello最后一次出现的位置
sb1.deleteCharAt(0); // 删除首字符
sb1.delete(0,5); // 删除[0, 5)范围内的字符

String str = sb1.substring(0, 5); // 截取[0, 5)区间中的字符以String的方式返回
System.out.println(str);
sb1.reverse(); // 字符串逆转
str = sb1.toString(); // 将StringBuffer以String的方式返回
System.out.println(str);
}

从上述例子可以看出：String 和 StringBuilder 最大的区别在于 String的内容无法修改，而 StringBuilder 的内容可以修改。频繁修改字符串的情况考虑使用 StringBuilder

注意：String和StringBuilder类不能直接转换。如果要想互相转换，可以采用如下原则:

  • String 变为 StringBuilder: 利用 StringBuilder 的构造方法或append() 方法
  • StringBuilder 变为 String: 调用 toString() 方法

二、认识异常

1. 异常的概念与体系结构

1.1 异常的概念
在Java中，将程序执行过程中发生的不正常行为称为异常。比如之前写代码时经常遇到的：

  1. 算数异常
System.out.println(10 / 0);
// 执行结果

Exception in thread "main" java.lang.ArithmeticException: / by zero
  1. 数组越界异常
int[] arr = {1, 2, 3};
System.out.println(arr[100]);

// 执行结果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100
  1. 空指针异常
int[] arr = null;
System.out.println(arr.length);

// 执行结果
Exception in thread "main" java.lang.NullPointerException

从上述过程中可以看到，Java中不同类型的异常，都有与其对应的类进行描述


1.2 异常的体系结构
异常种类繁多，为了对不同异常或者错误进行很好的分类管理，Java内部维护了一个异常的体系结构：
在这里插入图片描述
从上图中可以看到：

  1. Throwable：是异常体系的顶层类，其派生出两个重要的子类, Error 和 Exception
  2. Error：指的是Java虚拟机无法解决的严重问题，比如：JVM的内部错误、资源耗尽等，典型代表：StackOverflowError 和OutOfMemoryError，一旦发生回力乏术
  3. Exception：异常产生后程序员可以通过代码进行处理，使程序继续执行。比如：感冒、发烧。我们平时所说的异常就是Exception

1.3 异常的分类
异常可能在编译时发生，也可能在程序运行时发生，根据发生的时机不同，可以将异常分为：

  1. 编译时异常
    在程序编译期间发生的异常，称为编译时异常，也称为受检查异常(Checked Exception)
public class Person {
private String name;
private String gender;
int age;

// 想要让该类支持深拷贝，覆写Object类的clone方法即可
@Override
public Person clone() {
return (Person)super.clone();
}
}

//编译时报错：
//Error:(17, 35) java: 未报告的异常错误java.lang.CloneNotSupportedException; 必须对其进行捕获或声明以便抛出
  1. 运行时异常
    在程序执行期间发生的异常，称为运行时异常，也称为非受检查异常(Unchecked Exception)
    RunTimeException 以及其子类对应的异常，都称为运行时异常。比如：NullPointerExceptionArrayIndexOutOfBoundsException、ArithmeticException
    注意：编译时出现的语法性错误，不能称之为异常。例如将 System.out.println 拼写错了, 写成了system.out.println. 此时编译过程中就会出错, 这是 “编译期” 出错。而运行时指的是程序已经编译通过得到 class 文件了, 再由 JVM 执行过程中出现的错误.

2. 异常的处理

2.1 异常的抛出
在编写程序时，如果程序中出现错误，此时就需要将错误的信息告知给调用者，比如：参数检测
在Java中，可以借助 throw 关键字，抛出一个指定的异常对象，将错误信息告知给调用者。具体语法如下：

throw new XXXException("异常产生的原因");

例如：实现一个获取数组中任意位置元素的方法

public static int getElement(int[] array, int index){
if(null == array){
throw new NullPointerException("传递的数组为null");
}
if(index < 0 || index >= array.length){
throw new ArrayIndexOutOfBoundsException("传递的数组下标越界");
}
return array[index];
}
public static void main(String[] args) {
int[] array = {1,2,3};
getElement(array, 3);
}

注意：

  1. throw 必须写在方法体内部
  2. 抛出的对象必须是 Exception 或者 Exception 的子类对象
  3. 如果抛出的是 RunTimeException 或者 RunTimeException 的子类，则可以不用处理，直接交给JVM来处理
  4. 如果抛出的是编译时异常，用户必须处理，否则无法通过编译
  5. 异常一旦抛出，其后的代码就不会执行

2.2 异常的捕获
异常的捕获，也就是异常的具体处理方式，主要有两种：异常声明throws 以及 try-catch 捕获处理

2.2.1 异常声明throws
处在方法声明时参数列表之后，当方法中抛出编译时异常，用户不想处理该异常，此时就可以借助 throws 将异常抛给方法的调用者来处理。即当前方法不处理异常，提醒方法的调用者处理异常。

语法格式：
修饰符 返回值类型 方法名(参数列表) throws 异常类型1，异常类型2...{
}

例如：加载指定的配置文件config.ini

public class Config {
File file;
/*
FileNotFoundException : 编译时异常，表明文件不存在
此处不处理，也没有能力处理，应该将错误信息报告给调用者，让调用者检查文件名字是否给错误了
*/
public void OpenConfig(String filename) throws FileNotFoundException{
if(filename.equals("config.ini")){
throw new FileNotFoundException("配置文件名字不对");
}

// 打开文件
}
public void readConfig(){
}
}

注意：

  1. throws 必须跟在方法的参数列表之后
  2. 声明的异常必须是 Exception 或者 Exception 的子类
  3. 方法内部如果抛出了多个异常，throws 之后必须跟多个异常类型，之间用逗号隔开，如果抛出多个异常类型具有父子关系，直接声明父类即可。
public class Config {
File file;
// public void OpenConfig(String filename) throws IOException,FileNotFoundException{
// FileNotFoundException 继承自 IOException
public void OpenConfig(String filename) throws IOException{
if(filename.endsWith(".ini")){
throw new IOException("文件不是.ini文件");
}

if(filename.equals("config.ini")){
throw new FileNotFoundException("配置文件名字不对");
}

// 打开文件
}

public void readConfig(){
}
}
  1. 调用声明抛出异常的方法时，调用者必须对该异常进行处理，或者继续使用 throws 抛出
public static void main(String[] args) throws IOException {
Config config = new Config();
config.openConfig("config.ini");
}

2.2.2 try-catch捕获并处理
throws 对异常并没有真正处理，而是将异常报告给抛出异常方法的调用者，由调用者处理。如果真正要对异常进行处理，就需要 try-catch

try{
// 将可能出现异常的代码放在这里
}catch(要捕获的异常类型 e){
// 如果try中的代码抛出异常了，此处catch捕获时异常类型与try中抛出的异常类型一致时，或者是try中抛出异常的基类
时，就会被捕获到
// 对异常就可以正常处理，处理完成后，跳出try-catch结构，继续执行后序代码
}[catch(异常类型 e){
// 对异常进行处理
}finally{
// 此处代码一定会被执行到
}]
// 后序代码
// 当异常被捕获到时，异常就被处理了，这里的后序代码一定会执行
// 如果捕获了，由于捕获时类型不对，那就没有捕获到，这里的代码就不会被执行

//注意：
//1. []中表示可选项，可以添加，也可以不用添加
//2. try中的代码可能会抛出异常，也可能不会

例如：读取配置文件，如果配置文件名字不是指定名字，抛出异常，调用者进行异常处理

public class Config {
File file;
public void openConfig(String filename) throws FileNotFoundException{
if(!filename.equals("config.ini")){
throw new FileNotFoundException("配置文件名字不对");
}

// 打开文件
}

public void readConfig(){
}

public static void main(String[] args) {
Config config = new Config();
try {
config.openConfig("config.txt");
System.out.println("文件打开成功");
} catch (IOException e) {
// 异常的处理方式
//System.out.println(e.getMessage()); // 只打印异常信息
//System.out.println(e); // 打印异常类型：异常信息
e.printStackTrace(); // 打印信息最全面
}

// 一旦异常被捕获处理了，此处的代码会执行
System.out.println("异常如果被处理了，这里的代码也可以执行");
}
}

注意：

  1. try 块内抛出异常位置之后的代码将不会被执行
  2. 如果抛出异常类型与 catch 时异常类型不匹配，即异常不会被成功捕获，也就不会被处理，继续往外抛，直到 JVM 收到后中断程序----异常是按照类型来捕获的
  3. try 中可能会抛出多个不同的异常对象，则必须用多个catch来捕获----即多种异常，多次捕获
  4. 如果多个异常的处理方式是完全相同的，可以写成:
    catch (ArrayIndexOutOfBoundsException | NullPointerException e) { ... }
  5. 可以通过一个 catch 捕获所有的异常，即多个异常，一次捕获(不推荐)
    由于 Exception 类是所有异常类的父类. 因此可以用这个类型表示捕捉所有异常

2.2.3 finally
在写程序时，有些特定的代码，不论程序是否发生异常，都需要执行，比如程序中打开的资源：网络连接、数据库连接、IO流等，在程序正常或者异常退出时，必须要对资源进进行回收。另外，因为异常会引发程序的跳转，可能导致有些语句执行不到，finally就是用来解决这个问题的

语法格式：
try{
// 可能会发生异常的代码
}catch(异常类型 e){
// 对捕获到的异常进行处理
}finally{
// 此处的语句无论是否发生异常，都会被执行到
}
// 如果没有抛出异常，或者异常被捕获处理了，这里的代码也会执行

3. 自定义异常类

Java 中虽然已经内置了丰富的异常类, 但是并不能完全表示实际开发中所遇到的一些异常，此时就需要维护符合我们实际情况的异常结构

例如：实现一个用户登陆功能

public class LogIn {
private String userName = "admin";
private String password = "123456";

public static void loginInfo(String userName, String password) {
if (!userName.equals(userName)) {
}

if (!password.equals(password)) {
}

System.out.println("登陆成功");
}

public static void main(String[] args) {
loginInfo("admin", "123456");
}
}

此时我们在处理用户名密码错误的时候可能就需要抛出两种异常. 我们可以基于已有的异常类进行扩展(继承), 创建和我们业务相关的异常类

具体方式：

  1. 自定义异常类，然后继承自 Exception 或者 RunTimeException
  2. 实现一个带有 String 类型参数的构造方法，参数含义：出现异常的原因
class UserNameException extends Exception {
public UserNameException(String message) {
super(message);
}
}

class PasswordException extends Exception {
public PasswordException(String message) {
super(message);
}
}

此时我们的 login 代码可以写成：

public class LogIn {
private String userName = "admin";
private String password = "123456";
public static void loginInfo(String userName, String password)
throws UserNameException,PasswordException{
if (!userName.equals(userName)) {
throw new UserNameException("用户名错误！");
}
if (!password.equals(password)) {
throw new PasswordException("用户名错误！");
}
System.out.println("登陆成功");
}

public static void main(String[] args) {
try {
loginInfo("admin", "123456");
} catch (UserNameException e) {
e.printStackTrace();
} catch (PasswordException e) {
e.printStackTrace();
}
}
}

注意事项

  • 自定义异常通常会继承自 Exception 或者 RuntimeException
  • 继承自 Exception 的异常默认是受查异常
  • 继承自 RuntimeException 的异常默认是非受查异常
Warsaki_
关注
  • 23
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Java基础篇 | Java基础语法
分享思想，留下痕迹。
05-31 1万+
Java以前自学过一写，现在工作了，时间太久有一些知识都遗忘了，今天开始就更新Java了，想着把之前的Java基础知识捡起来；从最基础的开始，打好Java基础，便于以后复习。也欢迎大家跟我一起复习。Java中，字面量指的是在程序中直接使用的数据，字面量是Java中最基本的表达式，不需要进行计算或转换，直接使用即可。基本数据类型整数类型：包括byteshortint和long四种类型，用于表示整数。浮点类型：包括float和double两种类型，用于表示带小数点的数值。boolean。
Java入门之~Java基础语法
Ara-追着风跑
03-12 7171
Java入门之基础语法篇，收藏学起来
Java语法基础，看这篇就够了
重庆崽儿李锅锅的博客
01-21 4037
基本概念、基础语法、常用容器及对应方法
java_java基础语法
JiuMeilove的博客
04-23 2万+
首先我们要知道，在计算机中，数据是用其二进制补码形式来存储的，过程如下：首先130会被当成int类型存储，int是4个字节32位，也就是0000 0000 0000 0000 0000 0000 1000 0010，转成byte类型会丢弃高三字节部分，也就是1000 0010，因为正数的源码，补码，反码相同，所以130的补码还是1000 0010，将其转换成源码：补码（1000 0010）->反码（1000 0001）->原码（1111 1110）为-126，所以最后的转换结果就是-126。
Java面试总结-基础语法篇
HenryLei的博客
08-28 3万+
一. JDK、JRE、JVM有什么区别？   首先需要了解这三者的定义： JDK：Java Development Kit（Java 开发工具包）的简称，提供了 Java 的开发环境和运行环境； JRE：Java Runtime Environment（Java 运行环境）的简称，为 Java 的运行提供了所需环境； JVM：Java Virtual Machine（Java虚拟机）的简称，...
Java基础知识总结（2021版）
热门推荐
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
Java基础语法及其经验总结
weixin_53202763的博客
01-03 1万+
Java语法基础序言Java语言Java为什么要有语法计算机语言，应该做什么，我们要学什么，为什么去学？Java基本数据类型java运算符及其优先级Java循环语句以及选择执行语句循环语句：do...while、while和fordo...while循环while循环for循环 序言 这是一篇可以让你快速进入学习语言基础的文章。绝对算得上是难得的宝藏。 Java语言 Java语言，是一门计算机高级语言。所谓高级，就是说，不是对计算机底层进行操作的语言，而是对计算机软件或程序进行设计和开发的语言。 Java为
Java语法基础篇选择题练习
YING—country的博客
09-23 7932
Java语法基础篇Java选择题练习：数组（牛客网）Java选择题练习：运算符（牛客网）Java选择题练习：常量变量（牛客网）Java选择题练习：循环（牛客网）Java选择题练习：函数（牛客网） Java选择题练习：数组（牛客网） 1.假设一个 list初始化为{2，9，5，4，8，1}。 在第一轮冒泡排序后，list变成了（）? 正确答案: D A 2, 9, 5, 4, 8, 1 B 2, 9, 5, 4, 1, 8 C 2, 5, 9, 4, 8, 1 D 2, 5, 4, 8, 1, 9 解
JAVA基础（面试篇）
对博客内容有任何疑问，欢迎私信我
10-25 3920
一、JAVA基础 1、什么是面向对象？ 封装、继承、多态 2、对异常有什么看法？一般会如何做处理？（finally会用来做什么，关闭流的时候会放在哪个地方？） 异常是程序在编译或者运行的时候出现问题的显相； Throwable是所有Error（非程序问题，首要解决目标以及性能调优）和Exception（程序问题，且可处理可调式）的父类； 手动处理异常，可提升程序的健壮性； 3、JAVA中堆和栈的区别，说下java的内存机制。（引用类型能打印出来么？当打印一个String申明的变量时，打印出来的是什么？.
java大数据培训学校全套教材）java基础语法入门
06-15
前面青少年java的第一篇的基础学习，本课程更加专业细致讲述变量，判?断，循环，数组，子函数，排序和9个大作业，让已有一点青少年中专基?础的人迅速提高，进入到大学专业在校生计算机的入门水平，以备下一步?进一步...
C与Java基础语法对比实用PPT学习教案.pptx
10-06
《C与Java基础语法对比分析》 在编程领域，C语言和Java都是非常重要的编程语言，它们各有特色，但在基础语法上有许多相似之处，同时也存在一些显著的区别。本篇将对比分析C语言和Java的基础语法特性。 首先，让...
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 3229
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
okhttp，retrofit,rxjava 是如何配合工作的 作用分别是什么
最新发布
追梦的鱼儿
09-04 275
OkHttp、Retrofit 和 RxJava 是 Android 开发中常用的三种库，它们各自有不同的作用，并且可以很好地配合工作来实现网络请求和响应的处理。
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1228
浅析synchronized锁升级的原理与实现
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 779
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
《深入理解 Java 中的适配器模式》
面团到油条的成长日记
08-29 7294
在软件开发的广阔领域中，不同接口之间不匹配的问题时常像个棘手的难题困扰着开发者。而适配器模式就像是一位得力的助手，专门用来解决这类问题。它的关键作用在于把一个类的接口有效地转化为客户端所期望的另一种接口，让原本因接口不相符而不能一起工作的两个类可以共同协作，学习本文希望你能有所收获
深度解读并发安全集合的原理及源码
DougLiang的博客
09-01 1344
本节主要介绍J.U.C包中的几种并发安全集合：ConcurrentHashMap,ConcurrentLinkedQueue,和ConcurrentLinkedDeque。所谓并发安全集合，相对于普通集合来说，能够保证在多线程环境下向集合中添加数据时的线程安全性。主要讲ConcurrentHashMap在实现线程安全性方面对性能和安全性的合理平衡。
JavaWeb（基于SpringBoot开发）全总结（1）
2302_81420820的博客
09-02 982
再到spring boot中去设置，当我们遇到报错不要紧，我们直接再复制我们在DG上面写的sql语句，到idea那个数据库那里再运行一次，2.由于使用不同开发工具开发出来的略有不同，导致不能够互通，所以国际规定，使用maven创建的项目为统一标准结构，也就是下图所示的结构。还有我们写的案例里面的mapper层写的sql语句的新增，删除，等等操作，都是基于mybatis来实现的。例如：传入的是路径参数，json格式的参数等等，根据不同的参数我们使用不同的注解。
Java基础语法：变量与常量详解
"Java基础语法Part3，包括变量、常量和var关键字的使用以及变量的作用范围" 在Java编程语言中，基础知识是非常重要的，尤其是在学习过程中。本篇笔记主要介绍了Java中的变量、常量和一个现代特性——var关键字，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值