一、异常二、常用类库3、可变字符串0712

一、异常

什么是异常？异常就是程序在编译或运行期间发生的意外情况

报错：写代码报错和运行后报错

​ 写代码报错：1.不符合规范 2.变量名写错 3.导错包 4.少写括号 5.多写括号 6.没写分号结束…

​ 运行后报错：1.输入数字的时候输入的字母会有格式化异常 2.空对象使用了方法空指针异常 3.数组使用了不存在的下标…

Exception/RuntimeException/Error

• Exception属于编译期异常处理，必须要处理
• RuntimeException属于运行时异常处理，不必须处理，一般调整代码可以解决
• Error是错误，比如一直递归造成的内存溢出等等，这些错误会造成程序崩溃，运行期间不能处理

使用开发工具，编码时会自动编译javac，如果有编译期异常，会报红

1、异常的解决

throws抛出异常，没有解决，一旦发生异常，程序会中止

/**
 * 测试编译期异常
 */
public class Demo01 {
    public static void main(String[] args) throws ParseException {

        //简单日期格式化类
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日");

        //创建Date日期对象
        Date d = new Date();
        
        //格式化
        String s = simpleDateFormat.format(d);
        System.out.println("s = " + s);

        //将字符串解析为Date对象
        Date d1 = null;
        d1 = simpleDateFormat.parse("2025年07月12日");//编译期异常
        d1 = simpleDateFormat.parse("2025-07-12");//编译期异常(解析异常，因为解析的字符串不符合格式)
        System.out.println("d1 = " + d1);
        System.out.println("--程序结束..");
    }
}

try-catch捕获异常

/**
 * 测试编译期异常
 *  捕获异常
 */
public class Demo02 {
    public static void main(String[] args) {

        //简单日期格式化类
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日");

        //创建Date日期对象
        Date d = new Date();
        
        //格式化
        String s = simpleDateFormat.format(d);
        System.out.println("s = " + s);

        //将字符串解析为Date对象
        Date d1 = null;
        try {
            System.out.println(1);
            //d1 = simpleDateFormat.parse("2025-07-12");//编译期异常(解析异常，因为解析的字符串不符合格式)
            d1 = simpleDateFormat.parse("2025年07月12日");//编译期异常(解析异常，因为解析的字符串不符合格式)
            System.out.println(2);
        } catch (ParseException e) {
            System.out.println(3);
            //e.printStackTrace();
        } finally {//无论try语句块是否发生异常，最终都会执行
            System.out.println(4);
        }
        System.out.println(5);
        System.out.println("d1 = " + d1);
        System.out.println("--程序结束..");
    }
}

2、自定义异常

编译期自定义异常：extends Exception

运行时自定义异常：extends RuntimeException

ATM取款，余额不足

银行卡类

/**
 * 银行卡
 *  账号，有密码
 *  余额
 */
public class Account {
    private String accountNum; //卡号
    private String pwd; //密码
    private double balance; //余额

    //构造器
    public Account() {
    }
    public Account(String accountNum, String pwd, double balance) {
        this.accountNum = accountNum;
        this.pwd = pwd;
        this.balance = balance;
    }

    //get和set省略...
}

ATM取款机类

/**
 * 自动取款机
 *  插卡
 *  纸币
 *
 *  输入密码
 *  可以取款
 */
public class ATM {
    private Account account; //卡槽
    private double balance; //取款机的纸币余额
	private int flag; //如果等于1表示密码登录成功，等于0表示密码错误
    
    /**
     * 输入密码
     */
    public void inputPwd(){
        System.out.println("-->请输入卡密码...");
        String pwd = new Scanner(System.in).next();
        //判断密码是否正确（跟卡槽里的卡判断）
        if(pwd.equals(this.account.getPwd())){
            System.out.println("-->提示：密码正确..");
            flag=1;
        }else{
            System.out.println("-->警告：密码错误");
            flag=0;
        }
    }

    /**
     * 取款
     */
    public void withdrawMoney(){
        //先判断是否密码已正确登录
        if(flag==0){
            System.out.println("-->请先登录！！");
            return;
        }
        
        System.out.println("-->请输入取款金额...");
        int money = new Scanner(System.in).nextInt();
        //判断卡里的钱是否足够
        if(money<=this.account.getBalance()){
            System.out.println("-->提示：正在出纸币..");
            //判断ATM是否有足够纸币
            if(money<=this.balance){
                System.out.println("-->提示：请取走您的纸币..");
                this.account.setBalance(this.account.getBalance()-money);
                this.setBalance(this.getBalance()-money);
                System.out.println("-->取款"+money);
                System.out.println("-->您的银行卡账号余额："+this.account.getBalance());
                System.out.println("-->ATM剩余纸币："+this.getBalance());
            }else{
                System.out.println("-->提示：ATM纸币不足，请联系工作人..");
            }
        }else{
            System.out.println("-->警告：余额不足！！！替换为异常处理");
        }
    }

    //构造器
    public ATM() {
    }
    public ATM(double balance) {
        this.balance = balance;
    }
	//get和set省略
}

测试ATM取款

/**
 * 测试使用ATM
 */
public class Test {
    public static void main(String[] args) {
        //创建ATM取款机对象
        ATM atm = new ATM(5000);//取款机只有5000纸币

        //创建银行卡账号
        Account account = new Account("10101100", "123456", 200);

        //模拟取款
        //第一步：插卡
        atm.setAccount(account);

        //第二步：输入密码
        atm.inputPwd();

        //第三步：取款
        atm.withdrawMoney();

        //第四步：退卡
        atm.setAccount(null);

    }
}

问题：卡余额和ATM纸币数量变量

自定义异常类：编译期异常

/**
 * 自定义异常类：余额不足异常
 */
public class BalanceNotEnoughException extends Exception{
    public BalanceNotEnoughException() {
        super("余额不足！！取款失败！！");//调用父类构造器
    }
}

自定义异常类：运行时异常

/**
 * 自定义异常类：余额不足异常
 */
public class BalanceNotEnoughException extends RuntimeException{
    public BalanceNotEnoughException() {
        super("余额不足！！取款失败！！");//调用父类构造器
    }
}

二、常用类库

系统类有一些是final修饰

• 被final修饰的变量：常量，一旦赋值不改变
• 被final修饰的方法：最终的方法，不能被重写
• 被final修饰的类：最终的类，不能被继承

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

1、Object

万类之祖：所有的类都间接或直接的继承了Object类（所有的类都有一个共同形态：Object类型）

从[jdk1.8中文版.CHM]帮助文档查看

java.lang包：这个包下放置是常用的类，系统做了设置，无需导包，可以直接使用

equals()比较对象是否是同一个

​ 我们使用的最多是String类的equals方法比较两个字符串值是否一样

​ String类的equals方法来自于Object类（String重写了Object类的equals方法）

    //底层源码，其实底层用==比较
    public boolean equals(Object obj) {
        return (this == obj);
    }

​ ==

​ 一般用于比较基本数据类型的值是否相同

​ 如果用于比较引用数据类型（不常用），比较的是是否是同一个对象

    //重写从Object类继承的equals()方法（改写比较的规则）
    public boolean equals(Object o){
        //不比较对象是否是同一个，只要账号和密码相同就返回true
        Account acc = (Account) o;//向下转型
        //this 和 参数acc对象比较
        boolean f=false;
        if(this.getAccountNum().equals(acc.getAccountNum()) && this.getPwd().equals(acc.getPwd())){
            f=true;
        }
        return f;
    }

​ equals

​ 重写后才有自己的规则，如果不重写，仍然是底层==比较

​ 子类可以改写比较的规则

hashCode()返回对象在堆内存的位置

//hashCode()返回内存地址
System.out.println("acc1的哈希码："+acc1.hashCode());
System.out.println("acc1："+acc1);//对象首地址com.baidu.demo04.Account@1b6d3586
System.out.println(Integer.toHexString(acc1.hashCode()));//1b6d3586 转换为16进制

acc1的哈希码：460141958

toString()重写打印对象的值

//Object类的toString()方法的源码
public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

//这两行是一样的，不写toString()调用，默认也有
System.out.println("acc1："+acc1);
System.out.println("acc1："+acc1.toString());

也可以重写toString()方法，打印输出自己想显示的数据

例子

/**
 * 杯子类
 */
public class Cup {
    private String cupName;

    public String getCupName() {
        return cupName;
    }

    public void setCupName(String cupName) {
        this.cupName = cupName;
    }

    public Cup() {
    }
    public Cup(String cupName) {
        this.cupName = cupName;
    }

    @Override
    public String toString() {
        return cupName ;
    }
}

/**
 * 测试杯子类
 */
public class CupTest {
    public static void main(String[] args) {
        //创建Cup对象
        Cup c1 = new Cup("水晶杯");
        Cup c2 = new Cup("玻璃杯");

        System.out.println("c1 = " + c1);//com.baidu.demo04.Cup@1b6d3586
        System.out.println("c2 = " + c2);//com.baidu.demo04.Cup@4554617c

        String s1 = new String("字符串1");
        String s2 = new String("字符串2");
        System.out.println("s1 = " + s1);
        System.out.println("s2 = " + s2);
    }
}

c1 = 水晶杯
c2 = 玻璃杯
s1 = 字符串1
s2 = 字符串2

2、String

是字符串常量，一旦创建不可改变

//源码
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

被final修饰，String类不能被继承

字符串值本质存在private final char value[];

用法和使用：参考JDK1.8API中文文档

3、可变字符串

String：字符串常量，一旦创建不可改变，线程不安全

StringBuffer：可变字符串，创建仍然可以改变，线程安全（数据在多个线程中同步）

StringBuilder：可变字符串，创建仍然可以改变，线程不安全（数据在多个线程中不同步）

用法和使用：参考JDK1.8API中文文档

4、包装类

包装类是为了将八种基本数据类型转为引用类型的形态

基本 包装类

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

基本数据可以和包装类自动转换：

​ 装箱（基本数据->包装类对象）和拆箱（包装类对象->基本数据）