黑马Java笔记第十三讲笔记—常用API&异常

旺仔不是程序员
138 阅读2分钟

携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第28天， 点击查看活动详情

🎨 个人介绍

👉大家好，我是：旺仔不是程序员

👉认真分享技术，记录学习过程的点滴，如果我的分享能为你带来帮助，请支持我奥🍻

👉你的支持，是我每天更新的动力。

👉赞点：👍 留言：✍ 收藏：⭐

👉个人格言：想法一步一步的落实，才是你我前进最佳选择。

1. 包装类

1.1 基本类型包装类

1 ）基本雷响包装类的作用

  1. 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据
  2. 常用的操作之一：用于基本数据类型和字符串的转换

2 ）基本类型对应的包装类

基本数据类型包装类
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
charCharacter
booleanBoolean

1.2 Integer 类

1 ）Integer 类的概述

包装一个对象中的原始类型 int 值

2 ）Integer类构造方法

方法名说明
public Integer(int value)根据int值创建一个Integer对象
public Integer(String s)根据String 值创建Integer对象
public static Integer valueOf(int i)返回表示指定的 int 值得Integer 实例
public sttaic Integer valueOf(String s)返回一个保存指定值得Integer对象String

3 ）代码实例

 public static void main(String[] args) {
     Integer i1 = new Integer(100);
     System.out.println(i1);
​
     Integer i2 = new Integer("100");
     System.out.println(i2);
     System.out.println("------------");
​
     Integer i3 = Integer.valueOf(100);
     System.out.println(i3);
​
     Integer i4 = Integer.valueOf("100");
     System.out.println(i4);
 }

1.3 Integer 和 String 类的相互转化

1 ）int 转化为 String

  1. 转化方式

    • 直接在数字后面加一个空字符串
    • 通过String类的静态方法valueOf()

  2. 代码实例

     public static void main(String[] args) {
     int number = 100;
​
     // 方式1
     String s1 = number + "";
     System.out.println(s1);
​
     System.out.println("---------");
     //方式2
     String s2 = String.valueOf(number);
     System.out.println(s2);
 }

2 ）String 转化为 int

  1. 转换方式

    • 先将字符串转化成Integer对象,调用valueOf()方法,在调用intValue();
    • 通过Integer静态方法parseInt()进行转化

  2. 代码实例

     public static void main(String[] args) {
     String s = "100";
​
     //方式1
     Integer i1 = Integer.valueOf(s);
     int i = i1.intValue();
     System.out.println(i);
​
     //方法2
     int i2 = Integer.parseInt(s);
     System.out.println(i2);
 }

1.4 案例需求

1 ）案例需求

有一个字符串：“91 27 46 38 50”，请写程序实现最终输出的结果是：“27 38 46 50 91”

2 ）代码实现

public static void main(String[] args) {
    //定义一个字符串和一个
    String s= "91 27 46 38 50";
​
    //把字符串放到一个int类型的数组中
    String[] strArray = s.split(" ");
​
    // 定义一个int 类型的数组
    int[] intArray=new int[strArray.length];
​
    for (int i = 0; i < strArray.length; i++) {
        intArray[i] = Integer.parseInt(strArray[i]);
    }
​
    //对 int数组进行排序
    Arrays.sort(intArray);
​
    //对int数组进行 拼接
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < intArray.length; i++) {
        if(i==intArray.length-1) {
            sb.append(intArray[i]);
        }else {
            sb.append(intArray[i]).append(" ");
        }
    }
​
    String result = sb.toString();
​
    System.out.println(result);
}

1.5 自动拆箱和自动装箱

1 ）自动装箱

  1. 把基本数据类型转化为对应的包装类型

2 ）自动拆箱

  1. 把包装类类型转换为对应的基本数据类型

3 ）代码实例

Integer i =100;   //自动装箱
i +=  200;   // i = i+200;  i+200 自动装箱 ； i=i+200  自动装箱

2. Date类常用方法

2.1 Date类

1 ）Date类概述

  1. Date 代表了一个特定的时间，精确到秒

2 ）Date类构造

方法名说明
public Date()分配一个Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
public Date(long date)分配一个Date对象，并将初始化为表示从标准基准时间起指定的毫秒数

3 ）代码示例

public static void main(String[] args) {
    Date d1 = new Date();
    System.out.println(d1);
​
    long date = 1000*60*60;
    Date d2 = new Date(date);
    System.out.println(d2);     
}

2.2 Date类的常用方法

1 ）常用方法

方法名说明
public long getTime()获取的是日期对象从1970年1月1日00:00:00到现在的毫秒
puiblic void setTime(long time)设置时间，给的是毫秒值

2 ）代码实例

public static void main(String[] args) {
    // 创建日期对象
    Date d = new Date();
    System.out.println(d.getTime());
​
    long time = System.currentTimeMillis();
    d.setTime(time);
    System.out.println(d);
}

2.3 SimpleDateFormat类

1 ）SimpleDateFormat 类的概述

  1. SimpleDateFormat 是一个具体得类，用于以区域设置敏感的方式格式化和解析日期

2 ）SimpleDateFormat 类构造器

方法名说明
public SimpleDateFormat()构造一个SimpleDateFormat使用给定的模式和默认的日期格式
public SimpleDateFormat(String pattern)构造一个SimpleDateFormat使用给定的模式和默认的日期格式

3 ）SimpleDateFormat类的常用方法

  1. 格式化（从Date到String)

    • public final String format (Date date) :将日期格式化成时期/时间字符串

  2. 解析（从String 到 Date)

    • public Date parse (String source ): 从给定字符串的开始解析文本以生成日期类

4 ）代码实例

public static void main(String[] args) throws ParseException {
    // 格式化(从Date到String)
    Date d = new Date();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
    String format = sdf.format(d);
    System.out.println(format);
    System.out.println("----------");
​
    //从 String 到 Date
    String ss = "2048-08-09 11:11:11";
    SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date dd = sdf2.parse(ss);
    System.out.println(dd);
}

2.4 日期工具类案例

1 ）案例需求

定义一个日期工具类（DateUtil's），包含两个方法：把日期转化为指定格式的字符串；字符串解析为指定的日期，然后定义一个测试类（DateDemo），测试日期工具类的方法

2 ）代码实现

  1. 工具类
public class DateUtiles {
    private DateUtils() {}
    /* 
    	把日期转为指定格式的字符串
    	返回值类型 ： String
    	参数： Date date ,String format
    */
    public static String dateToString (Date date,String format) {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        String s = sdf.formal(date);
        return s;
    }
    
    /* 
    	把字符串解析为指定格式日期
    	返回值类型：Date
    	参数：String s，String format
    */
    public static Date stringToDate(String s ,String format) throws ParseException {
        SimpleDateFormat sdf  = new SimpleDateFormat(format);
        Date d = new sdf,parse(s);
        return d;
    }
}
  1. 测试类
public class DateDemo {
    public static void main(String[] args) throws ParseException {
        //创建日期对象
        Date d = new Date();
        
        String s1 = DateUtils.dateToString(d,"yyyy年MM月dd日 HH:mm:ss");
        System.out.println(s1);
        
        String s2 = DateUtils.dateToString(d,"yyyy年MM月dd日");
        System.out.println(s2);
        
       String s3 = DateUtils.dateToString(d,"HH:mm:ss");
       System.out.println(s3);
       System.out.println("-------------");
        
       String s = "2048-08-09 12:12:12";
       Date dd = DateUtil.stringToDate(s,"yyyy-MM-dd HH:mm:ss");
       System.out.println(dd);
    }
}

2.5 Calendar类

1 ）Calendar 类概述

  1. Calendar 为特定瞬间与一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法
  2. Calendar 提供了一个类getInstance 用于获取这种类型的一般有用的对象，该方法返回一个Calendar对象
  3. 其日历字段已使用当前日期和时间初始化：Calendar right = Calendar.getInstance();

2 ）Calendar 类常用方法

方法名说明
public int get(int field)返回给定日历字段的值
public abstract void add(int field,int amount)根据日历字段规则，将指定的时间量添加或给定的日历字段
public final void set(int year,int mouth,int date)设置当前日历的年月日

3 ）代码实例

public static void main(String[] args) {
    // 获取日历对象
    Calendar c = Calendar.getInstance();

    int year = c.get(Calendar.YEAR);
    int month = c.get(Calendar.MONTH) + 1;
    int date = c.get(Calendar.DATE);
    System.out.println(year + "年" + month + "月" + date + "日");

    // 三年前的今天
    c.add(Calendar.YEAR,-3);
    year = c.get(Calendar.YEAR);
    month = c.get(Calendar.MONTH) + 1;
    date = c.get(Calendar.DATE);
    System.out.println(year + "年" + month + "月" + date + "日");

    //10年后的10 天前
    c.add(Calendar.YEAR,10);
    c.add(Calendar.DATE,-10);
    year = c.get(Calendar.YEAR);
    month = c.get(Calendar.MONTH) + 1;
    date = c.get(Calendar.DATE);
    System.out.println(year + "年" + month + "月" + date + "日");

    //设置当前日历的年月日
    c.set(2050,10,10);
    year = c.get(Calendar.YEAR);
    month = c.get(Calendar.MONTH) + 1;
    date = c.get(Calendar.DATE);
    System.out.println(year + "年" + month + "月" + date + "日");
}

2.6 二月天案例

1 ）案例需求

获取任意一年的二月有多少天

2 ）代码实例

 public static void main(String[] args) {
     // 键盘录入任意一个年份
     Scanner input = new Scanner(System.in);
     System.out.println("请输入一个年份");
     int year = input.nextInt();
     //设置日历对象的年、月、日

     Calendar c = Calendar.getInstance();
     //month 是从0开始的
     c.set(year,2,1);

     //3月1日往前推一天，就是2月的最后一天
     c.add(Calendar.DATE,-1);

     //获取这一天输出即可
     int date = c.get(Calendar.DATE);
     System.out.println(year +  "年的2月份有" + date + "天");
 }

3. 异常

3.1 异常（记忆）

1 ）异常的概述

  1. 异常就是程序出现不正常的情况

2 ）异常的体系结构

  1. Error：严重问题，不需要处理

  2. Exception : 称为异常类，它表示程序本身可以处理的问题

    • RuntimeException:在编译期是不检查的，出现问题后，需要我们回来修改代码
    • 非RuntimeException：编译期间就必须处理，否则程序不能通过编译，就更不能正常运行

3.2 JVM默认处理异常的方式

1 ）如果程序出现问题，我们没有做任何处理，最终JVM会做默认的处理，处理方式有如下两个步骤：

  1. 把异常的名称，错误原因及异常出现的位置等信息输出在了控制台
  2. 程序停止运行

3.3 try - catch 方式处理异常

1 ）定义格式

try {
	可能出现异常的代码;
}catch(异常类名 变量名) {
    异常的处理代码;
}

2 ）执行流程

  1. 程序从try 里面的代码开始执行
  2. 出现异常，就会转跳到对应的catch里边去执行
  3. 执行完毕后，程序还可以继续往下执行

3 ）代码实例

 public static void main(String[] args) {
     System.out.println("开始");
     method();
     System.out.println("结束");
 }

public static void method() {
    try {
        int[] arr = {1,2,3};
        System.out.println(arr[3]);
        System.out.println("这里真的能够访问到吗");
    }catch (ArrayIndexOutOfBoundsException e) {
        e.printStackTrace();
    }
}

3.4 Throwable 成员方法

1 ）常用方法

方法名说明
public String getMessage()返回throwable的详细消息字符串
public String toString()返回此可抛出的简短描述
public void printStackTrace()把异常的错误信息输出在控制台

2 ）代码实例

/** 程序入库 */
public static void main(String[] args) {
    System.out.println("开始");
    method();
    System.out.println("结束");
}

/** 描述try catch 的方法*/
public static  void method()  {
    try{
        int[] arr = {1,2,3};
        System.out.println(arr[3]);
        System.out.println("这里能访问到吗？");  // 不能
    }catch(ArrayIndexOutOfBoundsException e){
        //public void printStackTrace():把异常的错误信息输出在控制台
        e.printStackTrace();


        //public String getMessage():返回此 throwable 的详细消息字符串
        System.out.println(e.getMessage());

        //public String toString():返回此可抛出的简短描述
        System.out.println(e.toString());


    }
}

3.5 编译时异常和运行时异常的区别

1 ）编译时异常

  1. 都是Exception异常
  2. 必须显示处理，否则程序就会发生错误，无法通过编译

2 ）运行时异常

  1. 都是RuntimeException类及其子类
  2. 无需显示处理，也可以和编译时异常一样处理

3.6 throws方式处理异常

1 ）定义格式

public void 方法名() throws 异常类名{
    
}

2 ）代码实例

 public static void main(String[] args) {
     System.out.println("开始");
     try {
         method2();
     }catch(ParseException e) {
         e.printStackTrace();
     }
     System.out.println("结束");
 }

/** 编译时异常 */
private static void method2() throws ParseException {
    String s = "2048-08-09";
    SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");
    Date date = sf.parse(s);
    System.out.println(date);
}

/** 运行时异常 */
public static void method() throws ArrayIndexOutOfBoundsException {
    int[] arr = {1,2,3};
    System.out.println(arr[3]);
}

3 ）注意事项

  1. 这个throws 格式是跟在方法的括号后面的
  2. 编译时异常必须要进行处理，两种处理方案：try...catch...或者throws,如果采用throws 这种方案，将来谁调用谁处理异常
  3. 运行时异常可以不处理，出问题之后，需要我们回来修改代码

3.7 throws 和 throw的区别

1 ）throws

  1. 用在方法声明后面，跟的是异常类名
  2. 表示抛出异常，由该方法的调用者来处理
  3. 表示出现异常的一种可能性，并不一定会发生这些异常

2 ）throw

  1. 用在方法体内，跟的是异常对象名
  2. 表示抛出异常，由方法体内的语句处理
  3. 执行throw 一定抛出了某种异常

3.8自定义异常

1 ）自定义异常

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

2 ）老师类

public class Tescher {
    public void checkScore(int score) throws ScoreException {
        if(score < 0 || score >100) {
            throw new ScoreException("你给的分数有误，分数应该在0-100之间");
        }else {
            System.out.println("成绩正常");
        }
    }
}

3 ）测试类

public class Demo {
    public static void main(String[] args) {
        Scanner input = new Scanner (System.in);
        
        int score = input.nextInt();
        
        Teacher t = new Teacher();
        try {
            t.checkScore(score);
        }catch (ScoreException e) {
            e.printStrackTrace();
        }
    }
}

🎈看完了不妨给我点个赞吧，👉你的支持，是我每天更新的动力...

avatar
文章
阅读
粉丝