本次的复习博客的内容主要是围绕着第九，十，十一章这三章的一个复习博客 复习内容从bilibili第七十二个视频至八十八个视频
第七十二个视频 异常（Exception）什么是异常
什么是异常？
比如程序运行时磁盘空间不足，网络连接中断，被装载的类不存在等等，针对这种情况，在java语言中，引入异常以异常类的形式对这些非正常情况进行封装，通过异常处理机制对程序运行时发生的各种问题进行处理
他先通过下面一个实例来表达异常的作用
代码如下
package 哔哩哔哩;
public class Example1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int result =divide(16,2);//调用divide()方法
System.out.println("x除以y等于："+result);
}
//下面的方法实现了两个整数相除
public static int divide(int x,int y) {
int result =x/y;//让整数相除
return result;
}
}结果
如果将y的参数改为0的话 代码将会报错因为0不能作为除数 报错就是异常也就是本章我们主要学习的内容
代码如下
异常中也是有着一个继承体系
如图Throwable类这个类是所有的错误异常的父类，
通过图中可以看出 Throwable有两个直接子类Error和Exception，其中Error代表程序中的错误，Exception代表程序中产生的异常
两个直接子类的详细讲解
1.Error类为错误类 他表示是java运行时产生的系统内部错误或者资源耗尽的错误，是一个仅靠修改程序本身是不能恢复执行的 只能重新改没有别的办法 如果出现了这个问题只能修改 改对了才能运行
2.Exception类称为异常类 这个异常类跟上面不一样的是上面的是出现问题了不能程序自己处理，只能程序员自己修改，异常类的不同点就是如果出现异常的话 程序会自己处理然后输出异常原因异常类的众多子类有一个特殊的RuntimeException类，该类以及子类用于运行时异常
第七十三个视频try...catch和finally
java提供了一种对异常进行处理的方式——异常捕获。异常捕获是通过使用try...catch语句
try{
//程序代码块
}catch（ExceptionType（Exception其他子类）e）{
//对ExceptionType的处理
}其中在try代码块中编写可能发生异常的java语句catch代码块中编写针对异常进行处理的代码。当try代码，当程序中发生异常，系统会将这个异常信息封装成一个异常对象，并将这个对象传递给catch代码块，catch代码快需要一个参数指明它所能够接受异常类型，这个参数必是Exception类或他的子类 通过实例讲解以上内容
代码如下
package 哔哩哔哩;
public class Example2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//下面代码定义了一个try...catch语句捕捉依次
try {
int result = divide(4,0);//调用divide方法
System.out.println(result);
}catch (Exception e) {//对异常进行处理
System.out.println("捕捉的异常为："+e.getMessage());
}
System.out.println("程序继续向下执行");
}
//下面的方法实现了两个整数相除
public static int divide(int x,int y) {
int result = x/y;//定义变量result记录两个数相处的结果
return result ;
}
}结果
第七十四个视频throws关键字
上一节中由于调用自己写的divide（）方法，因此很清楚该方法可能会发生异常，试想一下，如果去调用一个别人写的方法时，是否能知道别人写的方法是否会有异常呢？这很难判断所以针对这种情况 ，java中允许在方法的后面使用throws关键字对外声明该方法有可能发生的异常，这样调用者再调用方法时，就明确的知道该方法有异常，并且必须在程序中对异常进行处理
throws关键字声明抛出异常的语句格式如下
修饰符 返回值类型 方法名 （[参数1，参数2....]）throws ExceptionType1[,ExceptionType2.....]
throws关键字需要卸载方法声明的后面throws后面需要声明方法中发生异常的类型，通过将这种做法称为方法声明抛出一个异常
代码
package 哔哩哔哩;
public class Example3 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int result =divide(4,2);
System.out.println(result);
}
//下面的方法实现了两个整数相除 并使用throws关键字声明抛出
public static int divide(int x,int y) throws Exception {
int result =x/y;
return result;
}
}结果
第七十五个视频运行时异常和编译时异常
在实际开发中 ，经常会在程序编译时产生一些异常，而这些异常必须要进行处理，这种异常被称为编译时异常，也成为checked异常，另外还有一种异常时在程序运行时产生的，这种异常即使不编写异常处理代码，依然可以通过编译因此被称为运行时异常，也称为unchecked异常，接下来分别对两种异常进行详细的讲解
1.编译时异常
在java中Exception类中RuntimeException类及其子类都是编译时异常，编译时异常的特点时java编译器会对其进行检查如果出现异常就必须对一场进行处理否则程序无法通过编译，处理编译时期的异常有两种方法
1.1使用try...catch语句对异常进行捕获
1.2使用throws关键字声明抛出异常，调用者对其处理
2.运行时异常
RuntimeException类及其子类的都是运行时异常。运行时异常的特点时java编译器不会对其进行检查，也就是说在程序中出现这类异常时，即使没有使用tyr...carch语句捕捉或者使用throws关键字抛出，程序也能通过编译，运行时异常一般是由程序中的逻辑出现错误引起的，在程序运行时无法恢复，比如通过数组的角标访问数组的元素时，如果超过了数组的最大角标，就会发生运行时异常，代码如下所示
int[]arr =new int[5];
System.out.println(arrp[6]);
上面代码中，由于数组arr的length为5，因为数组是从0开始的所以最大角标是4，当使用arr[6]访问数组中的元素就会发生数组角标越界的异常
第七十六个视频 自定义异常
JDK中定义了大量的异常类，虽然这些异常类可以描述编程出现的大部分异常情况，但是在程序开发终有时可能需要描述程序中特有的异常情况，例如之前的divide（）方法不允许被除数为负数。为了解决的这个问题，在java中用户自定义异常。但自定义的异常类必须继承自Exception或其子类
在实际开发中，如果没有特殊的要求，自定义的异常类只需要继承Exception在构造方法中使用super（）语句调用Exception的构造方法即可。
既然定义了异常没那么该如何使用呢，这时就需要用到throw关键字throw关键字用于方法中声明抛出异常的实例对象 语法如下
throw Exception 异常对象
第七十七个视频 访问控制
在java中，针对类、成员方法和属性提供了四个 访问级别，分别是 private、default、protected、public 下面通过一张图将这四种控制级别由小到大依次列出
上图中展示了java中的四种放控制级别，具体如下
private（类访问级别）：如果类的成员被private访问控制符来修饰，则这成员只能被该类的其他成员，其他类无法直接访问，类的良好封装就是通过private关键字来实现的
default（包访问级别）如果一个类或者类的成员不适用任何访问控制符，则称它为默认访问控制级别，这个类或者类的成员只能被本包中的其他类访问
protected（子类访问级别）：如果一个类的成员被protected访问控制修饰符，那么这个成员既能被同一个包下的其他类访问，也能被不同包下该类的子类访问
public（公共访问级别）：这是一个最宽松的访问控制级别，如果一个类或者类的成员被public访问控制修饰符，那么这个类或者类的成员被所有的类访问，不管访问类与被访问类是否在同有个包中
表中的勾号用1代替
第七十八个视频 第五章javaAPI
String类StringBuffer类 System类和Runtime类
Math类与 Random类 包装类
学习目标分为三个方面
1.掌握 String类和StringBuffer类的使用
2.熟悉包装类的使用
3.了解System类Runtime类Math类和Random类的使用
4.1String类和StringBuffer类
在应用程序中经常会用到字符串，所谓字符串就是指一连串的字符，他是有多个单个字符连接而成的，如多个应为字母所组成的一个英文单子。字符串中可以包含任意字符，这些字符必须包含在一堆双引号内 ""例如"abc"在java中定义了String和StringBuffer两个类来封装字符串，并提供了一系列操作字符串的方法他们都位于java.lang包中，因此不需要导报就可以直接使用，接下来将针对String类和StringBuffer类进行详细的讲解
在操作String类之前，首先需要对String进行初始化，在java中可以通过以下两种方式初始化对象
1.使用字符串常量直接初始化一个String对象，具体如下
String str1 ="dingguojun"
使用String构造方法初始化字符串对象，String的构造方法如下所示
下面一个实例讲解初始化操作
代码
package bilibi;
public class Example01 {
//String类的初始化操作
//1字符串常量直接赋值
//2String类的构造方法
//String（）空参数的构造方法，创建一个String类对象 内容为空
//String（String a）创建一个String类对象 ，指定一个字符串内容
//Strin（char[]chs）创建一个String类对象 ，指定一个字符串作为内容
public static void main(String[] args) {
// TODO Auto-generated method stub
String str1 ="abc";
//String（）空参数的构造方法，创建一个String类对象 内容为空
String str2 =new String();
//String（String a）创建一个String类对象 ，指定一个字符串内容
String str3 =new String("abcd");
//Strin（char[]chs）创建一个String类对象 ，指定一个字符串作为内容
char[] charArray =new char[] {'e','f','c'};
String str4 =new String (charArray);
System.out.println(str1);
System.out.println("a"+str2+"b");
System.out.println(str3);
System.out.println(str4);
}
}结果
第七十九个视频String类的常见操作
String类的实际开发中的应用非常广泛，因此灵活的使用String类是非常中欧给要的接下来介绍String类的常用的一些方法如表所示
下面例题讲解获取字符串长度
代码
package bilibi;
public class Example02 {
//String的基本操作
//在程序中，需要对字符串进行一些基本操作，如获得字符串长度，获取指定位置的字符等
//public int length（）获取字符串长度
public static void main(String[] args) {
// TODO Auto-generated method stub
String s = "abcdefghijkl";
System.out.println("获取字符串长度："+s.length());
}
}结果
获取字符串中指定位置上的字符
代码
package bilibi;
public class Example02 {
//String的基本操作
//在程序中，需要对字符串进行一些基本操作，如获得字符串长度，获取指定位置的字符等
//public int length（）获取字符串长度
//public char cahrAt（int index）获取字符串中指定位置上的字符
public static void main(String[] args) {
// TODO Auto-generated method stub
String s = "abcdefghijkl";
System.out.println("获取字符串长度："+s.length());
System.out.println("获取字符串中第一个字符："+s.charAt(0));
}
}结果
还有一些基本使用操作
代码
package bilibi;
public class Example02 {
//String的基本操作
//在程序中，需要对字符串进行一些基本操作，如获得字符串长度，获取指定位置的字符等
//public int length（）获取字符串长度
//public char cahrAt（int index）获取字符串中指定位置上的字符
//public int indexOf(char ch )获取指定字符串在字符串中第一次出现的位置
//public int lastIndexOf (char ch)获取指定字符串中最后一次出现的位置
//public int indexOf(String str) 获取指定子字串中第一次出现的位置
//public int lastIndexOf(String str)获取指定子串在字符串中最后一次出现的位置
public static void main(String[] args) {
// TODO Auto-generated method stub
String s = "abcdabcdkl";
System.out.println("获取字符串长度："+s.length());
System.out.println("获取字符串中第一个字符："+s.charAt(0));
System.out.println("获取字符c第一次出现的位置"+s.indexOf('c'));
System.out.println("获取字符c最后一次出现的位置"+s.lastIndexOf('c'));
System.out.println("获取子串ab第一次出现的位置"+s.indexOf("ab"));
System.out.println("获取子串ab最后一次出现的位置"+s.lastIndexOf("ab"));
}
}结果
下面例题讲解的是将字符串转换为字符数组
代码
package bilibi;
public class Example03 {
//String类的转换操作
//程序开发中，经常需要对字符串进行转换操作，例如将字符串转换为数组的形式，将字符串进行大小写的转换
//public char[]toChatArray()将此字符串转换成字符数组
public static void main(String[] args) {
// TODO Auto-generated method stub
//声明一个字符串
String s = "abcdefg";
//将此字符串转换为字符数组
char [] charArray =s.toCharArray();
for(int i =0;i<charArray.length;i++) {
if(i==charArray.length-1) {
//数组最后一个元素直接打印元素值
System.out.println(charArray[i]);
}else {
//打印逗号
System.out.print(charArray[i]+",");
}
}
}
}结果
将指定的int值转换成字符串类型
代码
package bilibi;
public class Example03 {
//String类的转换操作
//程序开发中，经常需要对字符串进行转换操作，例如将字符串转换为数组的形式，将字符串进行大小写的转换
//public char[]toChatArray()将此字符串转换成字符数组
//public static String valueOf(int n)将指定的int值转换成字符串类型
public static void main(String[] args) {
// TODO Auto-generated method stub
//声明一个字符串
String s = "abcdefg";
//将此字符串转换为字符数组
char [] charArray =s.toCharArray();
for(int i =0;i<charArray.length;i++) {
if(i==charArray.length-1) {
//数组最后一个元素直接打印元素值
System.out.println(charArray[i]);
}else {
//打印逗号
System.out.print(charArray[i]+",");
}
}
System.out.println("将int值转换成String类型后的结果"+String.valueOf(12));
}
}结果
将字符串全部转换成大写字母
代码
package bilibi;
public class Example03 {
//String类的转换操作
//程序开发中，经常需要对字符串进行转换操作，例如将字符串转换为数组的形式，将字符串进行大小写的转换
//public char[]toChatArray()将此字符串转换成字符数组
//public static String valueOf(int n)将指定的int值转换成字符串类型
//public String toUppercase()将此字符串的字符全部换成大写字母，会返回一个新的字符串
public static void main(String[] args) {
// TODO Auto-generated method stub
//声明一个字符串
String s = "abcdefg";
//将此字符串转换为字符数组
char [] charArray =s.toCharArray();
for(int i =0;i<charArray.length;i++) {
if(i==charArray.length-1) {
//数组最后一个元素直接打印元素值
System.out.println(charArray[i]);
}else {
//打印逗号
System.out.print(charArray[i]+",");
}
}
System.out.println("将int值转换成String类型后的结果"+String.valueOf(12));
System.out.println("将字符串转换成大写字母后的结果"+s.toUpperCase());
}
}结果
程序开发中，用户输入数据时经常会有一些错误和空格，这时可以使用String类的replace（）和trim（）方法进行字符串的替换和去除空格的操作，接下来通过一个实例来学习这两种方法
代码
package bilibi;
public class Example04 {
//String类的替换与去除空格的操作
//程序开发中，用户输入数据时经常会有一些空格和错误，这时可以使用String类的replace()和trim（）方法，进行字符串的替换和去除空格操作
//public String replace（String oldStr，String newStr）
//将原有i字符串中的oldStr字符串内容有newStr字符串所替换，返回一个新的字符串
//public String trim（）返回一个新字符串，它去除了原有字符串的两端空格
public static void main(String[] args) {
// TODO Auto-generated method stub
//声明一个字符串
String s="itcast";
String s2="i t c a s t ";
//替换操作
System.out.println("将it替换成cn.it之后的结果"+s.replace("it", "cn.it"));
//去除空格操作
System.out.println("去除左右空格的结果："+s2.trim());
System.out.println("去除全部空格后的结果"+s2.replace(" ",""));
}
}结果
操作字符串时，经常需要都字符串进行一些判断，如判断字符串是否以指定的字符串开始，结束，是否包含指定的字符串，字符串是否包含指定的字符串，字符串是否为空等等，在String类中针对字符串的判断提供操作提供很多方法
代码
package bilibi;
//String类的判断操作
//操作字符串时，经常需要对字符串进行一些判断，如果判断字符串是否以指定的字符串开始，结束，是否包含指定的字符串，字符串是否为空等。
//public boolean startsWith (String str)判断字符串是否以给定字符串str开头
//public boolean endWith（String str）判断字符串是否以给定字符串str结尾
//public boolean contains（String str）判断字符串是否包含给定的字符串str
//public boolean isEmpty（）判断字符串内容是否为空
//public boolean equals（String str）判断字符串与给定字符串str的是否相等
public class Example05 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//声明一个字符串
String s ="String";
String s2 ="String";
System.out.println("判断字符串是否以str开通："+s.startsWith("str"));
System.out.println("判断字符串是否以ng结尾："+s.endsWith("ng"));
System.out.println("判断字符串是否包含tri："+s.contains("tri"));
System.out.println("判断当前字符串内容是否为空"+s.isEmpty());
System.out.println("判断两个字符串的内容是否相同"+s.equals(s2));
}
}结果
在String类中针对字符串的截取和分割操作提供了两个方法，其中systring（）方法用于截取字符串的一部分，split（）方法可以将字符进行分割，通过以下案例讲解使用方法
代码
package bilibi;
//String类的截取和分割
//在String类中针对字符串的截取和分割操作提供了两种方法
//其中。substring（）方法用于截取字符串的一部分
//split（）方法可以将字符串按照某个字符进行分割
//public String substring（int start）返回一个新的字符串，他从原有字符串指定位置开始截取，到字符串的末尾结束
public String substring（int start，int end ）返回一个他从原有的字符串指定位置开始截取，到指定位置结束
//public String []split (String regex)按照指定的字符串进行分割返回一个字符串数组
public class Example06 {
public static void main(String[] args) {
// TODO Auto-generated method stub
String s ="羽毛球-篮球-乒乓球";
//截取操作
System.out.println("从第5个字符开始截取到末尾的结果："+s.substring(4));
System.out.println("从第五个字符开始截取到第六个字符结束的结果："+s.substring(4,6));//前含后不含
//分割操作
System.out.println("打印分割后的每个字符串内容");
String [] strArray =s.split("-");
for(int i =0;i<strArray.length;i++) {
//羽毛球，篮球，乒乓球
if(i==strArray.length-1) {
System.out.println(strArray[i]);
}else{
//打印逗号
System.out.print(strArray[i]+",");
}
}
}
}结果
String在获取某个字符时，会用到字符的索引当访问字符时，如果字符的索引不存在则会发生字符串角标越界异常
代码
package bilibi;
//String 类的异常演示
//String的字符串在获取某个字符，会用到字符的索引，当访问字符串中的字符时
//如果字符的索引不存在，则会发生字符角标越界异常
public class Example07 {
public static void main(String[] args) {
// TODO Auto-generated method stub
String s =("abcde12345");
System.out.println(s.charAt(10));
}
}结果
StringBuffer类
由于字符事是常量，因此一旦创建，其内容和长度是不可改变的。如果需要对一个字符串进行修改，则只能创建新的字符事。为了便于对字符串进行修改，在JDK中提供了一个StringBuffer类(也称字符事缓冲区)，StringBuffer和String类最大的区别在于它的内容和长度都是可以改变的。StringBuffer类似一个字符容器，当在其中添加或副除字符时，并不会产生新的StringBuffcr对象
针对添加和删除字符的操作，StringBuffer类提供了一系列的方法，具体如下表所示
/*
* stringbuffer的构造方法
* public stringBuffer（）空参数构造方法
* public stringBuffer(string data)创建带有内容的字符串缓冲区
*
* stringbuffer类的常用方法
* public stringBuffer append(string str)向字符串缓冲区的末尾添加数据，返回当前的stringBuffer对象自身
* public stringBuffer insert（int index，string str）向字符串缓冲区指定位置上，插入指定数据
* public stringBuffer delete(int start,int end)删除字符串缓冲区指定范围内的数据
* public stringBuffer deleteCharAt(int index)删除字符串缓冲区内指定位置上的数据
* public int length（）获取字符串缓冲区的长度
* public stringBuffer replace（int start，int end,string str)替换字符串缓冲区指定范围内的字符串
* public stringBuffer setcharAt(int index,char ch)替换字符串缓冲区指定位置上的字符
* public stringBuffer reverse()字符串缓冲区数据翻转方法
*/
public class Test1{
public static void main(String[] args) {
System.out.println("1、添加----------------");
add();
System.out.println("2、删除----------------");
remove();
System.out.println("3、修改----------------");
alter();
}
public static void add() {
//定义一个字符串缓冲区
StringBuffer sb=new StringBuffer();
//向缓冲区的末尾添加指定字符串
sb.append("abcdefg");
System.out.println("append添加数据后的结果："+sb);
//向缓冲区指定位置插入字符串
sb.insert(2, "123");
System.out.println("插入数据后的结果:"+sb);
}
public static void remove() {
//定义一个字符串缓冲区对象
StringBuffer sb=new StringBuffer("abcdefg");
//删除字符串缓冲区指定范围内的数据
sb.delete(1, 5);//不包含结尾位置元素
System.out.println("删除指定范围数据后的结果："+sb);
//删除字符串缓冲区指定位置上的字符
sb.deleteCharAt(2);
System.out.println("删除指定位置数据后的结果："+sb);
//清除字符串缓冲区
sb.delete(0, sb.length());
System.out.println("清除缓冲区数据后的结果："+sb);
}
public static void alter() {
//定义一个字符串缓冲区对象
StringBuffer sb=new StringBuffer("abcdef");
//修改指定位置的字符
sb.setCharAt(1, 'p');
System.out.println("修改指定位置数据后的结果"+sb);
//修改指定范围内的数据
sb.replace(1, 3, "qq");
System.out.println("替换指定范围内字符串的结果"+sb);
//字符串缓冲区数据翻转
System.out.println("字符串缓冲区数据翻转后的结果"+sb.reverse());
}
} 结果
案例
/*
* 记录一个子串在整串中出现的次数
* 思路：
* 1.定义一个整串，定义一个子串
* 2.获取子串在整串中出现的次数
*/
public class Test1{
public static void main(String[] args) {
//1.定义一个整串，定义一个子串
String str = "nbaernbatnbaynbauinbapnba";//整串
String key = "nba";//子串
//2.获取子串在整串中出现的次数
int count = getKeyStringCount(str,key);
System.out.println("count="+count);
}
//获取子串在整串中出现的次数
public static int getKeyStringCount(String str, String key) {
//定义计数器，用来记录出现的次数
int count = 0;
//如果整串中不包含子串，则直接返回count
if(!str.contains(key)) {
return count;
}
//定义变量，用来记录key出现的位置
int index = 0;
/*
* 1.查找子串在整串中出现的位置
* 2.将出现的位置记录在index变量中
*/
while((index = str.indexOf(key)) != -1) {
//子串出现次数累加
count++;
//截取整串，从子串出现的位置后面开始，到整串末尾
str = str.substring(index + key.length());
}
return count;
}
}结果
1791
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
