1.捕获、抛出、自定义异常类
捕获
异常：就是在程序运行过程产生的错误，它会中断正在运行的程序。
Java程序的执行过程中如出现异常事件，可以生成一个异常类对象，该异常对象封装了异常事件的信息并将被提交给Java运行时系统，这个过程称为抛出（throw）异常。
当Java运行时系统接收到异常对象时，会寻找能处理这一异常的代码并把当前异常对象交给其处理，这一过程称为捕获（catch）异常。
在Java之中如果要进行异常的处理，可以使用：try、catch、finally这几个关键字来完成。
try{
//可能出现异常的代码语句
}catch (异常类型 异常对象){
//异常处理
}finally{
//无论是否出现异常都要执行的语句
}例子1（1）：
public class Demo{
public static void main(String args[]) {
System.out.println("【1】*****程序开始执行*****") ;
try {
System.out.println("【2】数学计算：" +(10 / 0)) ;
} catch (ArithmeticException e) {
System.out.println("【c】处理异常：" + e) ; //处理异常
}
System.out.println("【3】*****程序执行完毕*****") ;
}
}运行结果：
【1】*****程序开始执行*****
【c】处理异常：java.lang.ArithmeticException: / by zero
【3】*****程序执行完毕*****例子1（2）：
public class Demo{
public static void main(String args[]) {
System.out.println("【1】*****程序开始执行*****") ;
try {
System.out.println("【2】数学计算：" +(10 / 5)) ;
} catch (ArithmeticException e) {
System.out.println("【c】处理异常：" + e) ; //处理异常
}
System.out.println("【3】*****程序执行完毕*****") ;
}
}
运行结果：
【1】*****程序开始执行*****
【2】数学计算：2
【3】*****程序执行完毕*****由以上两个例子对比可以看出try-catch-finally语句块执行流程大致分为如下两种情况。
1.如果try语句块中所有语句正常执⾏完毕，程序不会进⼊catch语句块执⾏，但是finally语句块会被执⾏。
2.如果try语句块在执⾏过程中发⽣异常，程序会进⼊到catch语句块捕获异常， finally语句块也会被执⾏。
注：try-catch-finally结构中try语句块是必须存在的，catch、finally语句块为可选，但两者⾄少出现其中之⼀。
抛出
在定义一个方法时可以使用throws关键字声明，使用throws声明的方法表示此方法不处理异常，而交给方法的调用处进行处理。
使用方法
public 返回值类型 方法名称（参数列表···）throws 异常类{
//方法语句
}例子2：
class Math {
public int div (int i，int j ) throws Exception { //方法可以不处理异常
int temp=i/j;
return temp;
}
}
public class ThrowsDemo{
public static void main(String[] args){
Math m=new Math();
try{ //因为有throws,不管是否有异常，都必须处理
System.out.println("除法操作："+m.div(10,2));
}catch(Exception e){
e.printStackTrace();
}
}
}
运行结果：5
自定义异常类
在Java中已经提供了大量的异常类，但是这些异常类有时也很难满足开发者的要求，所以用户可以根据自己的需要定义自己的异常类。定义异常类只需要继承Exception类即可。
例子2：
class MyException extends Exception{
public MyException(String message){
super(message);
}
}
public class Demo {
public static void main(String[] args) throws MyException
{
int i=1 ,j = 0;
if(j ==0){
throw new MyException("除数不能为0");
}
System.out.println("i / j = "+ i/j);
}
}2.包装类、String(buffer、builder)、BigDecimal
包装类
Java提供了8种包装类Byte、Short、Integer、Long、Float、Double、Boolean、Character。包装类创建对象的方式就跟其他类一样。
基本数据类型和包装类之间的转换：
Integer num = new Integer(0); //创建一个数值为0的Integer对象
//创建包装类对象有两种方式：new关键字、valueOf()方法。
Integer num1 = new Integer(1); //基本数据类型转为包装类
Integer integer = Integer.valueOf(10);//基本数据类型转为包装类
int num2 = num1.intValue(); //包装类型转为基本数据类型
//为了方便实用，java提供了拆装箱机制（简化转换）
Integer num1 = 1; //自动装箱（基本数据类型转为包装类）
int num2 = num1; //自动拆箱（包装类型转为基本数据类型）
new关键字、valueOf()方法的区别：
Integer num3 = 10;
Integer num4 = 10;
Integer num5 = new Integer(20);
Integer num6 = new Integer(20);
Integer num7 = 128;
Integer num8 = 128;
System.out.println((num3==num4) +" "+ num3.equals(num4));
System.out.println((num5==num6) +" "+ num5.equals(num6));
System.out.println((num7==num8) +" "+ num7.equals(num8));
/*运行结果：
true true
false true
false true
*/由于num3、num4都小于等于127，它们指向的是同一个缓存的Integer对象，所以用==进行比较的结果是true；num5、num6由于使用new关键字指向的是两个不同的新对象，结果为false；num7、num8虽然是采用自动装箱的方式，但执行valueOf()方法的时候，由于不满足条件i >= IntegerCache.low && i <= IntegerCache.high，而同样新建了两个不同的新对象，结果同样是false。
equals()方法比较的是Integer对象的值，而不是像==一样比较的是对象是否是同一个对象。所以，当需要比较两个Integer对象的值是否相等时，记住要用equals()方法。用==比较的话由于缓存机制的存在，可能产生一些让人困扰的结果。
String（buffer、buider）
为了解决String字符串操作导致的内存冗余，提高效率，Java中提供了StringBuffer和StringBuilder来操作字符串，并且提供了很多方法，便于程序员开发。
StringBuffer 线程安全，效率较低 ；StringBuilder 线程不安全，效率较高。
构造方法：
StringBuffer();
创建一个未存储任何字符串信息的空StringBuffer空间，底层初始化一个16个字符char类型数组
StringBuffer(String str);
根据提供的String类型字符串创建对应的StringBuffer空间，
底层char类型数组的容量会根据str.length + 16决定，并且保存对应的str
例子：
public class Demo {
public static void main(String[] args) {
StringBuffer stringBuffer = new StringBuffer();
StringBuffer stringBuffer2 = new StringBuffer("我有东西的");
System.out.println(stringBuffer);
System.out.println(stringBuffer2.toString());
}
}
运行结果：
我有东西的
添加方法（）：
append("")：在StringBuffer和StringBuilder对象中，添加另外的数据，并且当做字符串处理。
insert(下标, "")：在StringBuffer和StringBuilder对象中，在指定的下标位置，添加其他内容，并且当做字符串处理
例子：
public class Demo {
public static void main(String[] args) {
StringBuffer stringBuffer = new StringBuffer("123456789");
stringBuffer.append("我有东西的");
System.out.println(stringBuffer);
StringBuilder stringBuilder = new StringBuilder("ABCDEFGHIJKLMN");
stringBuilder.insert(3, "---");
stringBuilder.insert(9, "===");
System.out.println(stringBuilder);
}
}
运行结果：
123456789我有东西的
ABC---DEF===GHIJKLMN
查看方法：
String toString();
将底层的char类型数组保存的字符内容转换成对应的String类型字符串返回。
int length();
返回底层char类型数组中有多少有效元素。
String substring(int begin);
从指定位置开始获取到char类型数组有效元素末尾对应的字符串，截取操作，
String substring(int begin, int end);
从指定位置begin开始到end结束，获取对应的字符串，要头不要尾。
int indexOf(String str);
指定元素字符串所在下标位置。
int lastIndexOf(String str);
指定元素字符串最后一次所在下标位置。
例子：
public class Demo3 {
public static void main(String[] args) {
StringBuffer stringBuffer = new StringBuffer("12345中国加油6789");
System.out.println(stringBuffer.indexOf("中国加油"));
System.out.println(stringBuffer.substring(5));
System.out.println(stringBuffer.substring(5, 10));
System.out.println(stringBuffer.length());
}
}
运行结果：
5
中国加油6789 //这里体现了要头不要尾
中国加油6
13修改方法：
replace(int start, int end, String str); 从指定位置start开始，到end结束，start <= n < end, 使用str替换。
例子：
public class Demo4 {
public static void main(String[] args) {
StringBuffer stringBuffer = new StringBuffer("123456789");
stringBuffer.replace(1, 5, "中国加油");
System.out.println(stringBuffer);
stringBuffer.setCharAt(6, 'A');
System.out.println(stringBuffer);
}
}
运行结果：
1中国加油6789
1中国加油6A89
删除和反序：
delete(int start, int end); 删除指定范围以内的字符。
start <= n < end deleteCharAt(int index); 删除指定下标的字符。
reverse(); 逆序。
例子：
public class Demo5 {
public static void main(String[] args) {
StringBuffer stb = new StringBuffer("123456789");
//删除指定下标范围的元素（要头不要尾）
stb.delete(1, 5);
System.out.println(stb);
//删除指定下标元素
stb.deleteCharAt(1);
System.out.println(stb);
//逆序
stb.reverse();
System.out.println(stb);
}
}
运行结果：
16789
1789
9871BigDecimal
BigDecimal是Java中用于表示任意精度数字的类，它可以表示无限长度的小数,BigDecimal 通常支持任意位数的小数部分，用来对超过16位有效位的数进行精确的运算。
构造方法：
BigDecimal(int val) //创建一个具有参数所指定整数值的对象。
BigDecimal(long val) //创建一个具有参数所指定长整数值的对象。
BigDecimal(String val) //创建一个具有参数所指定以字符串表示的数值的对象。
"加减乘除"方法示例：
import java.math.BigDecimal;
public class Test {
public static void main(String[] args){
BigDecimal b1 = new BigDecimal("1");
BigDecimal b2 = new BigDecimal("2");
BigDecimal b3 = new BigDecimal("4");
System.out.println("相加："+b1.add(b2));
System.out.println("相减："+b1.subtract(b2));
System.out.println("相乘："+b2.multiply(b3));
System.out.println("相除："+b2.divide(b3));
}
}
BigDecimal的八种舍入模式：
BigDecimal.setScale()方法用于格式化小数点
setScale(1)表示保留一位小数，默认用四舍五入方式
setScale(1,BigDecimal.ROUND_DOWN)直接删除多余的小数位，如2.35会变成2.3
setScale(1,BigDecimal.ROUND_UP)进位处理，2.35变成2.4
setScale(1,BigDecimal.ROUND_HALF_UP)四舍五入，2.35变成2.4
setScaler(1,BigDecimal.ROUND_HALF_DOWN)四舍五入，2.35变成2.3，如果是5则向下舍
setScaler(1,BigDecimal.ROUND_CEILING)接近正无穷大的舍入
setScaler(1,BigDecimal.ROUND_FLOOR)接近负无穷大的舍入，数字>0和ROUND_UP作用一样，数字<0和ROUND_DOWN作用一样
setScaler(1,BigDecimal.ROUND_HALF_EVEN)向最接近的数字舍入，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。
3.泛型简介、列表、set、map（待补充）
泛型简介
泛型是一种在编译时期类型检查的机制，它使得我们能够创建具有通用行为的类、接口和方法，以适应不同类型的数据。通过使用泛型，可以提高代码的复用性、类型安全性以及可读性。
列表
定义：List name = new ArraryList<>()
List的一些使用方法：
例子1：
List<String> person = new ArrayList<>();
person.add("jackie"); //添加
person.add("peter");
person.add("annie");
person.add("martin");
person.add("marry");
person.remove(3); //删除
person.remove("marry");
String per="";
per = person.get(1); //获取
System.out.println("per:"+per);
System.out.print("result:");
for(String pers : person)
{
System.out.print("\t"+pers);
}
输出结果：
per:peter
result: jackie peter annie
例子2：
List<String> fruits = new ArrayList<>();
fruits.add("苹果");
fruits.add("香蕉");
fruits.add("桃子");
System.out.println("fruits中包含水果:");
for(int i=0;i<fruits.size();i++)
{
System.out.println(fruits.get(i));
}
String appleString = "苹果";
System.out.printf("fruits中%s苹果\n",fruits.contains(appleString)?"包含":"不包含");
if(fruits.contains(appleString)) //方法：.contains（Object o）； 返回true或者false
System.out.println("我喜欢吃苹果");
else
System.out.println("我不喜欢吃苹果");
输出结果：
fruits中包含水果:
苹果
香蕉
桃子
fruits中包含苹果
我喜欢吃苹果
例子3：
String a = "白龙马", b = "沙和尚" , c ="八戒" , d="唐僧" , e = "悟空";
List<String> people = new ArrayList<>();
people.add(a);
people.add(b);
people.add(c);
people.set(0, d); //将替换该索引位置的值
people.add(1,e);
System.out.print("result:");
for(String s : people)
System.out.print(s+"\t");
输出结果：
result:唐僧 悟空 沙和尚 八戒
set
Set接口继承自Collection接口，并添加了一些针对无序集合的操作。它不允许重复的元素，并提供了添加、删除和检查元素是否存在的方法。在Java中，Set接口有几个常见的实现类，每个实现类都具有不同的性能和用途。
HashSet是Set接口的一个常见实现类，它基于哈希表实现，可以提供快速的插入、删除和查找操作。以下是一些常用的HashSet方法：
add(E element): 添加元素到集合中。
remove(Object element): 从集合中移除指定的元素。
contains(Object element): 检查集合中是否包含指定的元素。
size(): 返回集合中的元素个数。
例子：
import java.util.HashSet;
import java.util.Set;
public class HashSetExample {
public static void main(String[] args) {
Set<String> fruits = new HashSet<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Orange");
fruits.add("Apple"); // 重复元素，不会被添加
System.out.println("Fruits: " + fruits);
fruits.remove("Banana");
System.out.println("Fruits after removal: " + fruits);
boolean containsApple = fruits.contains("Apple");
System.out.println("Contains Apple: " + containsApple);
}
}
map
基本形式： public interface Map<K,V>
Map是一个接口，我们不能直接创建对象，可以通过多态的形式创建对象，Map中有两个
参数，一个是K表示键，一个是V表示值，且一个键有且对应一个值，Map中不能包含重复的
键，若是有重复的键添加，则会以最后一次的键为准，而其他的键会被覆盖。集合都在
java.util包下，所以需要导包。
具体实现常用的一般有两种，一是HashMap，另一个是TreeMap
import java.util.HashMap;
import java.util.Map;
public class MapTest {
public static void main(String[] args) {
Map<String,String> map=new HashMap<>();
map.put("2001", "张三");
map.put("2002", "张三");
map.put("2003", "李四");
map.put("2003", "王五");//键重复，会覆盖上一个，留下最新的
System.out.println(map);//{2003=王五, 2002=张三, 2001=张三}
}
}import java.util.HashMap;
import java.util.Map;
public class MapTest {
public static void main(String[] args) {
//创建Map集合对象
Map<String,String> map=new HashMap<>();
//增加元素
map.put("2001", "张三");
map.put("2002", "李四");
map.put("2003", "王五");
System.out.println(map);//{2003=王五, 2002=李四, 2001=张三}
//根据键删除元素
// map.remove("2001");
//System.out.println(map);//{2003=王五, 2002=李四}
//判断集合中是否包含指定的键返回boolean类型
System.out.println(map.containsKey("2001"));//true
System.out.println(map.containsKey("2004"));//false
//判断集合中是否包含指定的值返回boolean类型
System.out.println(map.containsValue("张三"));//true
System.out.println(map.containsValue("赵六"));//false
//判断集合是否为空返回boolean类型
System.out.println(map.isEmpty());//false
//得到集合的长度
System.out.println(map.size());//3
//清除所有键值对
map.clear();
System.out.println(map.isEmpty());//true，为空了
}
}注：第三部分由于时间太紧还没具体的去全面预习以及运行测试代码（QAQ）
246
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
