【Java学习】Object类、Date类

Object类

java.lang.Object
类Object是类层次结构的根(父)类
每个类都使用Object作为超(父)类
所有对象(包括数组)都实现这个类的方法

public class Demo01ToString {
    public static void main(String[] args) {
        /*
            Person类默认继承了Object类，所以可以使用Object类当中的toString方法
            String toString() 返回该对象的字符串表示。
         */
        Person person = new Person("张三",20);

        String s = person.toString();
        System.out.println(s);

        // 直接打印对象的名字，其实就是调用对象的toString
        System.out.println(person);

        //看一个类是否重写了toString方法，直接打印这个类的对象即可，如果没有重写toString 方法，那么打印的是对象的地址值
        Random r = new Random();
        System.out.println(r);
    }
}
// Person类
import java.util.Objects;

public class Person {

    private String name;
    private int age;

    public Person() {
    }

    public Person(String name,int age) {
        this.name = name;
        this.age = age;
    }

    // 直接打印对象的地址值没有意义，需要重写Object类中的toString方法
    // 打印对象的属性
//    @Override
//    public String toString() {
//        return "Person{}";
//    }
    //
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    /*
    Object类的equals方法，默认比较的是两个对象的地址值，没有意义
    我们要重写equals方法，比较两个对象的属性
    问题：
            隐含着一个多态
            多态的弊端:无法使用子类特有的内容
            Object obj = p2 = new Person();
            解决：使用向下转型把obj转换为Person
     */

   /* @Override
    public boolean equals(Object obj) {
        Person p = (Person) obj;
        boolean b = this.name == p.name && this.age == p.age;
        return b;
    }*/

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

equals方法

Person类默认继承了Object类，所以可以使用Object类的equals方法
boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”
equals方法源代码：

 public boolean equals(Object obj) {
        return this == obj;
    }

参数：
Object obj：可以传递任意的对象
== 比较运算符，返回的是一个布尔值
基本数据类型：比较的是值
引用数据类型：比较的是两个对象的地址值

Date类

Date类表示日期和时间的类
表示特定的瞬间，精确到毫秒
毫秒：千分之一秒
特定的瞬间：一个时间点，一刹那时间

毫秒值的作用：可以对时间和日期进行计算
把日期转换为毫秒；
当前的日期：
时间原点（0毫秒）：1970年1月1日 00：00：00 (英国格林威治)
就是计算当前日期到时间原点之间一共经历了多少毫秒
注意：
中国属于东八区，会把时间增加八个小时
1970 年1月1日 08:00:00
把毫秒转换为日期
1天=24 * 60 * 60 = 86400秒 = 864000000毫秒

import java.util.Date;

public class Demo02Date<Static> {
    public static void main(String[] args) {
         demo01();
         demo02();
         demo03();
    }

    /*
    getTime() 把日期转换为毫秒值
    返回自 1970 年1 月 1日 00:00:00 GMT 以来此对象表示的毫秒数
     */
    private static void demo03() {
        Date date = new Date();
        long time = date.getTime();
        System.out.println(time);

    }

    // Date 类的带参构造方法
    // Date(lang date) : 传递毫秒值，把毫秒值转换为Date日期
    private static void demo02() {
        Date date = new Date(1583676252187l);
        System.out.println(date);
    }

    // Date 类的空参数构造方法
    // Date()  获取当前系统的日期和时间
    private static void demo01() {
        Date date = new Date();
        System.out.println(date);
    }
}
        

DateFormat是日期/时间格式化为子类的抽象类
作用：格式化
成员方法
String format(Date date) 按照指定的模式，把Date日期，格式化为符合模式的字符串
Date parse(String source) 把符合模式的字符串，解析为Date日期
DateFormat类 是一个抽象类，无法直接创建对象使用，可以使用DateFormat类的子类

构造方法：
SimpleDateFormat(String pattern)
用给定的模式和默认语言环境的日期格式符号构造
模式：
（区分大小写的） y 年
M 月
d 日
H 时
m 分
s 秒
写对应的模式，会把模式替换为对应的日期和时间
“yyyy-MM-dd HH:mm:ss”
注意：
模式中的字母不能更改，连接模式的符号可以改变

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo03DateFormat {
    public static void main(String[] args) throws ParseException {

        demo01();
        demo02();
    }
    /*
    使用DateFormat类当中的方法parse，把文本解析为日期
    使用步骤：
        1.创建SimpleDateFormat对象，构造方法中传递指定的模式
        2.调用SimpleDateFormat对象中的方法parse，把符合构造方法中的字符串解析为日期
        注意：
        parse方法声明了一个异常
        如果字符串和构造方法的模式不一样，那么程序就会抛出此异常
        调用一个抛出了异常的方法，就必须处理这个异常，要么throws继续抛出异常，要么try catch自己处理
     */
    private static void demo02() throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        Date date = sdf.parse("2020年3月8日 10时22分21秒");
        System.out.println(date);
    }


    /*
    使用DateFormat类中的方法format，把日期格式化为文本
    使用步骤：
        1.创建SimpleDateFormat对象，构造方法中传递指定的模式
        2.调用SimpleDateFormat对象中的方法format，按照构造方法中指定的模式，把Date日期格式化为符合模式的字符串

     */
    private static void demo01() {

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        Date date = new Date();
        String d = sdf.format(date);
        System.out.println(date);
        System.out.println(d);
    }
}

练习：使用日期时间相关的API，计算一个人已经出生了多少天

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
public class Demo04Test {
    public static void main(String[] args) throws ParseException {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的出生日期：");
        String birthdayDateString = sc.next();

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date = sdf.parse(birthdayDateString);
        long birthdayDateTime = date.getTime();
        long todyTime = new Date().getTime();
        long time = todyTime-birthdayDateTime;
        System.out.println(time/1000/60/60/24);
    }
}