Java Day12

Java

day12——2023.8.21

Date类

Date类分为两个包，一个是sql包下的Date，一个是util包下的Date

sql包下的Date，一般表示毫秒值，用来连接jdbc的时候，可以直接以字符串形式获取数据库中的时间

util包下的Date，一般表示生活中的时间格式，目前学习这个Date

构造方法

Date()

分配一个 Date对象，并初始化它，以当前时间创建一个Date对象

Date(long date)

分配一个 Date对象，传入一个毫秒值，根据毫秒值来创建Date对象

         //创建日期类型 ：
        //1，无参构造
        Date date = new Date();
        System.out.println(date);

        //2,使用毫秒值
        long time = System.currentTimeMillis();
        Date date1 = new Date(time);
        System.out.println(date1);

普通方法

long getTime() 返回当前Date对象的毫秒值

void setTime(long time) 设置此 Date对象以表示1970年1月1日00:00:00 GMT后的 time毫秒的时间点。

String toString() 将此 Date对象转换为 String的形式：

String toLocaleString()

    	 System.out.println(date.getTime()); //毫秒值

        System.out.println(date.getYear()+1900);
        System.out.println(date.getMonth()+1);
        System.out.println(date.getDate());
        System.out.println(date.getDay()); //星期几
        System.out.println(date.getHours());
        System.out.println(date.getMinutes());
        System.out.println(date.getSeconds());

DateFormat类

DateFormat是日期/时间格式化子类的抽象类

将来如果需要转换时间日期格式，一般使用它的子类 SimpleDateFormat

SimpleDateFormat是一个具体的类，一般用来完成字符串日期和Date日期类型之间的格式转换

构造方法

SimpleDateFormat()

构造一个 SimpleDateFormat使用默认模式和日期格式符号为默认的 FORMAT区域设置。

SimpleDateFormat(String pattern)

使用给定模式 SimpleDateFormat并使用默认的 FORMAT语言环境的默认日期格式符号。

常用方法

String format(Date date)

将日期格式化成日期/时间字符串。

Date parse(String source)

从给定字符串的开始解析文本以生成日期。

public class DemoFormat {
    public static void main(String[] args) throws ParseException {
        //通过SimpleDateFormat完成Date和String之间的转换

        //Date->String
        //创建当前的时间对象
        Date date = new Date();
        //创建日期格式化对象
        SimpleDateFormat sdf =
                new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //调用方法
        String stringTime = sdf.format(date);
        System.out.println(stringTime);

        //String-> Date
        //声明一个字符串时间格式
        String time = "2022-07-22 10:10:10";
        Date date1 = sdf.parse(time);
        System.out.println(date1);
    }
}

计算出生天数

//让用户输入自己的生日，然后看看自己已经出生多少天了
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的生日,参考格式：1999-11-11");
//接受生日输入
String birthday = scanner.next();

//生日转为Date，然后获取时间戳(毫秒值)
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

Date date = sdf.parse(birthday);

long time = date.getTime(); //获取毫秒值

long timeNow = System.currentTimeMillis();

//计算天数
long day = (timeNow - time) /1000/60/60/24;
System.out.println("天数" + day);

日期转换工具类

//日期工具类
public class DateUtil {
    //日期转字符串方法
    // 返回值 ：String
    //参数 ：日期，格式
    public static String dateToString(Date date,String pattern){
        return new SimpleDateFormat(pattern).format(date);
    }

    //字符串转日期方法
    // 返回值 ：Date
    //参数 ：String日期，格式
    public static Date stringToDate(String date,String pattern) throws ParseException {
        return new SimpleDateFormat(pattern).parse(date);
    }
}

Calendar类

常用的日历类，提供了一些常用日期时间中的属性、以及一些转换的方法

常用方法

int get(int field) 返回给定日历字段的值。

static Calendar getInstance() 使用默认时区和区域设置获取日历对象。

String toString() 返回此日历的字符串表示形式。

public class CalendarDemo {
    public static void main(String[] args) throws ParseException {
        //Calendar类是抽象类，不能直接new，通过getInstance方法创建对象

        Calendar calendar = Calendar.getInstance();
        //传入的是Calendar类中的属性
        int year = calendar.get(Calendar.YEAR);
        //int year1 = calendar.get(1);
        System.out.println(year);
        //System.out.println(year1);

        System.out.println(calendar.get(Calendar.MONTH)+1); //月份+1
        System.out.println(calendar.get(Calendar.DATE)); //日期
        System.out.println(calendar.get(Calendar.DAY_OF_WEEK)-1); //周几获取-1
        System.out.println(calendar.get(Calendar.DAY_OF_YEAR)); //一年的第多少天
        System.out.println(calendar.get(Calendar.HOUR)); // 时
        System.out.println(calendar.get(Calendar.MINUTE)); //分
        System.out.println(calendar.get(Calendar.SECOND)); //秒

        //获取某个指定时间
        //Date date = DateUtil.stringToDate("2000-10-10", "yyyy-MM-dd");
        //calendar.setTime(date);
        //System.out.println(calendar.get(Calendar.YEAR));
        //System.out.println(calendar.get(Calendar.MONTH)+1); //月份+1
        //System.out.println(calendar.get(Calendar.DATE)); //日期
        //System.out.println(calendar.get(Calendar.DAY_OF_WEEK)-1); //周几获取-1
        //System.out.println(calendar.get(Calendar.DAY_OF_YEAR)); //一年的第多少天
        //System.out.println(calendar.get(Calendar.HOUR)); // 时
        //System.out.println(calendar.get(Calendar.MINUTE)); //分
        //System.out.println(calendar.get(Calendar.SECOND)); //秒

        //abstract void add(int field, int amount)
        //根据日历的规则，将指定的时间量添加或减去给定的日历字段。
        //获取三年前的今天

       // calendar.add(Calendar.YEAR,-3);
       // System.out.println(calendar.get(Calendar.YEAR));
       // System.out.println(calendar.get(Calendar.MONTH)+1);

        //3年后的，10天前
        calendar.add(Calendar.YEAR,3);
        calendar.add(Calendar.DATE,-10);

        System.out.println(calendar.get(Calendar.YEAR));
        System.out.println(calendar.get(Calendar.MONTH)+1);
        System.out.println(calendar.get(Calendar.DATE));
    }
}

//利用日历类，完成时间的获取
​ //在计费系统中，需要计算两个时间的时间差，比如停车时间
​ // 从 7:30 进入停车场， 8：35分离场，每15分钟收费1块钱
​ //计算我需要交费多少钱

public class CalendarDemo02 {
    public static void main(String[] args) throws ParseException {
        //利用日历类，完成时间的获取
        //在计费系统中，需要计算两个时间的时间差，比如停车时间
        // 从 7:30 进入停车场， 8：35分离场，每15分钟收费1块钱
        //计算我需要交费多少钱

        // 字符串时间对应的Date对象
        String time1 = "07:30";
        String  time2 = "08:35";
        Date startDate = DateUtil.stringToDate(time1, "HH:mm");
        Date endDate = DateUtil.stringToDate(time2, "HH:mm");
        //设置日历类的时间
        Calendar c1 = Calendar.getInstance();
        Calendar c2 = Calendar.getInstance();
        // 通过日历类分别获取到 开始时间的小时和分钟
        c1.setTime(startDate);
        int startHour = c1.get(Calendar.HOUR);
        int startMinute = c1.get(Calendar.MINUTE);
        //获取结束时间的小时和分钟
        c2.setTime(endDate);
        int endHour = c2.get(Calendar.HOUR);
        int endMinute = c2.get(Calendar.MINUTE);
        //计算总时间,计算价格

        int money = ((endHour * 60 + endMinute) - (startHour * 60 + startMinute))/15 * 1;

        System.out.println(money);

    }
}

正则表达式

指的是符合一定规则的字符串，用来约束某些信息，在编写的时候，遵守指定的规则

正则的编写规范 ：

1，字符格式

a 表示 匹配 a

[abc] 表示匹配 abc ，1次

[^abc] 表示除abc以外的 ，1次

[A-Z] 表示匹配大写字母 1次

[0-9] 表示匹配任意数字1次

[a-z] 表示匹配小写字母1次

[a-zA-Z0-9] 表示匹配大小写字母数字1次

2,次数格式

{n} 匹配指定的n次

{n,m} 匹配n到m次

{n,} 匹配最少n次，最高不限次数

? 一次或者0次

*0次或者多次

+1次或者多次

3，通配符

\转义符 ,将有特殊含义的字符转义为本来的含义

^表示以指定的内容

$表示以指定的内容结尾

\w 表示任意字符 ，相当于 [a-z_A-Z0-9]

\d 表示任意数字 ，相当于[0-9]

public class RegexDemo {
    public static void main(String[] args) {

        //测试用户输入的手机号码是否符合规范
        //声明一个手机号码的正则表达式
        String regex = "^[1][3-9]\\d{9}";
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个手机号码:");
        String phoneNum = sc.next();
        //调用方法，传入正则规则，判断是否符合
        boolean b = phoneNum.matches(regex);
        if (b){
            System.out.println("手机号符合规范");
        }else {
            System.out.println("手机号不符合规范");
        }
    }
}

public class RegexDemo02 {
    public static void main(String[] args) {

        //写一个邮箱的正则表达式   xxx@sohu.com.cn
        //String regex = "[0-9a-zA-Z]{3,16}@[0-9a-zA-Z]{2,10}(\\.[a-z]{2,3}){1,2}";
        String regex = "\\w{3,16}@\\w{2,10}(\\.\\w{2,3}){1,2}";

        Scanner sc = new Scanner(System.in);
        System.out.println("输入邮箱:");
        String s = sc.next();

        boolean b = s.matches(regex);
        if (b){
            System.out.println("符合规范");
        }else {
            System.out.println("不符合规范");
        }
    }
}

异常

概念：程序在执行的过程中，可能会出现的问题，称为异常

生活中的异常：

计划出去玩 ： 出发 -> 去公园 ->散步 -> 吃个烧烤 ->回家

出现的问题 ： 散步的时候，下雨了，只能终止计划，提前回家。这个时候，下雨，就是一种异常情况

解决方法 ： 玩之前查看天气，如果要下雨，带把雨伞 。带着雨伞 就是 可能出现异常的解决方案

程序中的异常： 程序中出现不正常的情况，跳出的提示

比如如下的例子， 正常按照提示，用户可以输入 1-3的数字，但是有些用户如果输入其他的非数字的字符，程序运行就会发生异常

public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入1-3之间的整数：");
        int i = scanner.nextInt();

        switch (i){
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            default:
                System.out.println("产生错误！");
                break;
        }
    }
}

Java中异常相关的类

为了让程序员能够很好的处理异常错误，Java专门提供了异常类 Throwable，用来处理错误及异常

异常体系结构

Thorwable 父类

–Error 子类，错误类 ，表示严重的问题，程序员一般无法解决

–Exception 子类，异常类

----RuntimeException 运行时异常，一般都是程序运行时发生的错误，通过修改代码可以防止异常的出现

----非RuntimeException 编译时异常，必须要处理，否则，程序编译不通过

异常的处理

Java中处理异常，通过5个关键字来实现： try 、catch 、 throw 、 throws 、finally

处理方案 ：

1，JVM的默认处理

把异常的名称、原因、位置等信息输出在控制台，然后终止程序运行

2，自己处理

方式1： try…catch…finally

语法： try{

​ 代码块1;

​ }catch(ExceptionType1 e){

​ 异常处理代码块1；

​ }catch(ExceptionType2 e){

​ 异常处理代码块2；

​ }finally｛

​ 最终代码块

​ ｝

如果，将来程序员写的代码，可能会发生异常，就需要将这段代码提前放在try块中。

在catch的后面，跟上将来你的代码中，可能会出现的异常类型，如果将来真的发生异常了，程序也不会因为异常而终止，只会继续跳转到catch块中继续执行其中的代码。

catch块中的代码，执行完后，会继续执行finally块中的代码

package com.iweb.airui369.day11;

import java.util.InputMismatchException;
import java.util.Scanner;

public class Demo02 {

    public static void main(String[] args) {
        try {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入被除数：");
            int num1 = scanner.nextInt();

            System.out.println("请输入除数：");
            int num2 = scanner.nextInt();

            System.out.println(num1 + "/" + num2 + "=" + num1/num2);

        }catch (InputMismatchException exception){
            System.out.println("输入的数据不符合数据类型规范！");
        }catch(ArithmeticException exception){
            System.out.println("除数不能为0！");
        }finally {
            System.out.println("程序结束，谢谢使用！！！");
        }

    }
}

try…catch…finally注意事项

1，整个语法结构中，try块是必须要写的，catch块和finally块是可选的，但是catch和finally至少得有一个，也可以同时出现

2，可以有多个catch快，如果catch的异常类型，存在父子关系，那么父类异常必须放在子类异常的后面

3，多个catch块必须位于try块后，finally块也必须位于所有的catch后面

try…catch块和 return语句的执行

1，当try块和catch中，都有return语句时，不会影响finally语句的执行

2，如果finally中，指定了return，并且是有返回值的情况，返回值可能会替换try中的return的返回值

方式2： 通过throws，将异常抛出。

把自己处理不了的异常，在方法上声明，告诉调用者，这个方法可能会有异常，需要处理

在方法上，通过throws抛出异常之后，调用者，调用后，需要怎么做？

开发的时候，调用的方法上，存在异常，需要怎么解决 ？

(idea中直接alt+enter，选择以下两个方法中的一个处理即可)

1，将异常继续向上抛；一般平时的代码测试可以用这个方式

2，使用try-catch手动捕获异常，进行处理；将来项目开发，尽量都用这种方式

public class Demo04 {


    public static void operate() throws Exception{
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入被除数:");
            int num1 = scanner.nextInt();
            System.out.println("请输入除数:");
            int num2 = scanner.nextInt();
            System.out.println(num1 + "/" + num2 + "=" + num1/num2);
            System.out.println("程序结束！");
    }
}

public class Test {
    //在方法上继续抛出异常
    public static void main(String[] args) throws Exception  {

        //手动捕获异常，并处理 或者在方法上继续抛出
        //try {
            Demo04.operate();
        //} catch (Exception e) {
        //    System.err.println("程序发生了异常！");
        //    e.printStackTrace();
        //}
    }
}

throw关键字的使用

throw一般是用来方法内部，更多的含义是声明异常

public class Student {
    private String name;
    private String gender;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) throws Exception {
        if ("男".equals(gender)|| "女".equals(gender)){
            this.gender = gender;
        }else {
            throw new Exception("性别必须是男或者是女!");
        }
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                '}';
    }
}


public class Test {
    //在方法上继续抛出异常
    public static void main(String[] args) throws Exception {


        Student s = new Student();
        s.setName("张三");
        s.setGender("妖");

        System.out.println(s);
    }
}

throws和throw的区别？

1，throws一般声明在方法体上，throw 声明在方法内部

2，throws用来声明一个方法可能抛出的所有的异常信息，表示将来异常的一种可能性，但并不一定发生异常

​ throw 则是抛出一个具体的异常类型，

3，throws通常不需要显式的捕获异常，由系统自动将异常抛给上级方法

​ throw需要用户自己捕获相关异常，然后再对其处理，最后将异常信息抛

自定义异常：

//自定义异常
public class GenderException extends Exception {
    //构造方法
    public GenderException(String message) {
        super(message);
    }
}


public class Test {
    //在方法上继续抛出异常
    public static void main(String[] args)  {

        try {
            Student s = new Student();
            s.setName("张三");
            s.setGender("妖");
            System.out.println(s);
        } catch (GenderException e) {
            //e.printStackTrace();
            System.err.println("性别输入错误");
        }
    }
}

1， == 和 equals()方法的区别

==可以用来比较基本类型和引用类型
用来比较基本类型的时候比较的是值
用来比较引用类型的时候比较的是对象的地址值
equal（）是Object的方法，一般用来比较对象是否相等

2，什么是封装以及封装的好处

封装：对象的一种隐藏技术，目的是将对象的属性和方法组织起来同时隐藏，不想把对象的属性和实现细节暴露出来，用户和其他对象看不到也不能对其进行修改，将来只有通过特定的接口去调用对象的方法，才能达到通信的目的，关键字是private
封装的好处：将设计者和用户分开，用户没法看到设计内部细节，也不能对其修改，只需要设计者提供方法来访问对象就行了。

3，什么是继承以及继承的好处

继承：多个类提取出相同的成员，定义到一个独立的类中，让当前类和独立的类产生关系，使当前类具有独立类的内容
写法：class 子类名 extends 父类名{}
继承的好处：增强代码的复用性，提高代码的维护性
让类和类之间产生关系，是学习多态的前提

4，什么是多态，多态的特点，多态的转型

多态：一个对象在不同时刻体现出来的不同状态
写法是：父类 对象名 = new 子类（）；
多态的特点：有继承或者实现关系，有方法的重写，有父类或者父接口引用指向子类对象
多态的转型：向上转型：把子类看成是父类的对象
写法：Fu f = new Zi（）；它一定是安全的
向下转型，把父类对象还原成子类对象，完成子类特有方法的调用
写法：Zi zi = （Zi）f；它不一定安全，转换的前提是父类对象必须指向子类对象

5，方法重载和重写的区别

重载是同一个类中，根据参数的类型，个数和顺序，定义多个同名但是签名不同的方法，他的方法可以有不同的返回值类型，重载经常提供相似但功能不同的操作
重写是在继承关系中，子类重新定义父类已有的方法，要求方法名，参数列表，返回类型完全相同，通过重写，子类可以改变父类方法的实现，从而实现自身特有的行为
重载是同一个类中根据参数的不同定义多个同名的方法，用于提供相似但功能不同的操作
重写是子类重新定义父类方法，用来改变自身的实现方法