龙哥网

龙哥网

Java学习(Object类的方法(toString ,equals)Objectsl类equals方法,Date类,Calendar类)
2022-03-01

2022/1/9

一.Object类。
java.lang.Object类是所有类的超类。
1.toString方法

package ln.javatest.day10.demo01;
/*
java.lang,object 类
类Object是类层次结构的根(最顶层)类。每个类都是用Object作为父类。
所有对象(包括数组)都实现这个类的方法。
*/

import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

public class Demo01ToString {
    public static void main(String[] args) {
        /*
        Person类默认冀继承Object类,所以我们可以使用Object类中的toString方法
        String toString() 返回该对象的字符串表示
        */
        Person p = new Person("王嘉尔",20);
        String s = p.toString();
        System.out.println(s);
        //ln.javatest.day10.demo01.Person@282ba1e
        //abc
        //Person{name = 王嘉尔,age = 20}
        //直接打印对象的名字,其实就是调用对象的toString方法 p = p.toString()
        System.out.println(p);
        //ln.javatest.day10.demo01.Person@282ba1e
        //abc
        //Person{name = 王嘉尔,age = 20}

        /*看一个类是否重写了toString方法,直接打印这个类对一个对象的名字即可
        如果没有重写toString方法,那么打印的就是对象的地址值(默认)
        如果重写了toString方法,那么就按照重写的方式打印
         */
        Random r = new Random();
        System.out.println(r);
        //打印的地址值 java.util.Random@36d64342
        Scanner sc = new Scanner(System.in);
        System.out.println(sc);
        //打印的不是地址值,说明重写了toStringjava.util.Scanner[delimiters=\p{javaWhitespace}+]
        ArrayList<Integer> list = new ArrayList<>() ;
        list.add(1);
        list.add(2);
        System.out.println(list);
        //[1, 2] 重写了toString

    }
}
package ln.javatest.day10.demo01;

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    /*
   直接打印对象的地址值没有意义,需要重写Object类的toString方法
   直接打印对象的属性(name,age)
    */

    /*@Override
    public String toString() {
       // return "abc";
        return "Person{name = "+name+",age = "+age+"}";
    }*/

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

    public Person() {
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

2.equals方法

package ln.javatest.day10.demo01;

import java.util.Objects;

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    /*
   直接打印对象的地址值没有意义,需要重写Object类的toString方法
   直接打印对象的属性(name,age)
    */

    /*@Override
    public String toString() {
       // return "abc";
        return "Person{name = "+name+",age = "+age+"}";
    }*/
    /*
    //Getter、Setter位置有可以直接帮我们重写的
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    */
    /*
        Object类的equals方法默认比较的是两个对象的地址值,没有意义
        所以我们需要重写equals方法,比较两个对象的属性值
        对象的属性值一样,返回true否则false
        问题:
            隐含一个多态
            Object obj = p2 = new Person(“王嘉尔”,20);
            多台弊端:无法使用子类特有的内容(属性,方法)
            解决:可以使用向下转型(强转)把Object类转型为Person
    */

    /*@Override
    public boolean equals(Object obj) {
        //增加一个判断,传递的参数obj是this本身,知己额返回true,提高程序效率
        if(obj == this){
            return true;
        }
        //增加一个判断,传递的参数obj是null,直接返回false,提高程序的效率
        if(obj == null){
            return false;
        }
        *//*
        为了解决类型转换异常,是Person类型在转换,
        *//*
        //instanceof 判断obj能不能向下转型称为Person
        if(obj instanceof Person){
            //使用向下转型(强转)把Object类转型为Person
            Person p = (Person)obj;
            //比较两个对象的属性;一个是调用方法的this(p1),一个就是p(obj=p2)
            //equals比较的是字符串,数据只能用==比较
            boolean b = this.name.equals(p.name) && this.age == p.age;
            return b;
        }
        //不是Person类型直接返回false
        return false;

    }*/
    //Getter、Setter位置有可以直接帮我们重写的


    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        //getClass() != o.getClass()使用反射技术,判断o是否能读Person
        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 Person() {
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
package ln.javatest.day10.demo01;
/*
java.lang,object 类
类Object是类层次结构的根(最顶层)类。每个类都是用Object作为父类。
所有对象(包括数组)都实现这个类的方法。
*/

import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

public class Demo01ToString {
    public static void main(String[] args) {
        /*
        Person类默认冀继承Object类,所以我们可以使用Object类中的toString方法
        String toString() 返回该对象的字符串表示
        */
        Person p = new Person("王嘉尔",20);
        String s = p.toString();
        System.out.println(s);
        //ln.javatest.day10.demo01.Person@282ba1e
        //abc
        //Person{name = 王嘉尔,age = 20}
        //直接打印对象的名字,其实就是调用对象的toString方法 p = p.toString()
        System.out.println(p);
        //ln.javatest.day10.demo01.Person@282ba1e
        //abc
        //Person{name = 王嘉尔,age = 20}

        /*看一个类是否重写了toString方法,直接打印这个类对一个对象的名字即可
        如果没有重写toString方法,那么打印的就是对象的地址值(默认)
        如果重写了toString方法,那么就按照重写的方式打印
         */
        Random r = new Random();
        System.out.println(r);
        //打印的地址值 java.util.Random@36d64342
        Scanner sc = new Scanner(System.in);
        System.out.println(sc);
        //打印的不是地址值,说明重写了toStringjava.util.Scanner[delimiters=\p{javaWhitespace}+]
        ArrayList<Integer> list = new ArrayList<>() ;
        list.add(1);
        list.add(2);
        System.out.println(list);
        //[1, 2] 重写了toString

    }
}
package ln.javatest.day10.demo01;

import java.util.Random;

public class Demo02equals {
    public static void main(String[] args) {
         /*
        Person类默认冀继承Object类,所以我们可以使用Object类中的equals方法
        boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”
        Object类的equals方法的源码:
            public boolean equals(Object obj)
                return (this == obj);
             }
             参数:
                Object obj:可以传递任意对象
             方法体:
                ==:比较运算符,返回到就是一个布尔值true,false
                基本数据类型:比较的是值
                引用数据类型:比较的是两个对象的地址值
             this是谁?哪个对象调用的方法,方法中的this就是哪个对象;p1调用的那就是p1.
             obj是谁?传递过出来的参数p2
             this==obj --> p1==p2


        */
        Person p1 = new Person("王嘉尔",18);
        Person p2 = new Person("易烊千玺",20);
        //在此之前要先把toString方法注释,否则打印的就是数据值
        System.out.println("p1:"+ p1);
        System.out.println("p2:"+ p2);
        //p1:ln.javatest.day10.demo01.Person@45c8e616
        //p2:ln.javatest.day10.demo01.Person@4cdbe50f
        //赋值地址
        //p1 = p2;
        Random r =  new Random();
        //random也是Object类,所以可以被传递,但Random不能转换为Person
        //报错类型转换异常
        boolean b1 = p1.equals(r);
        //上面这句传递成功,在向下转型时出错,不能向下转型称为Person,
        boolean b = p1.equals(p2);
        System.out.println(b1); //false
        System.out.println(b); //没赋值前false  赋值后true //false
    }

}

二.Objects类
1.equals方法

package ln.javatest.day10.demo01;

import java.util.Objects;

public class Demo03Objects {
    public static void main(String[] args) {
        String s1 = "null";
        String s2 = "abc";
        //boolean b = s1.equals(s2);//出现了空指针异常
        //System.out.println(b);
        /*
        Objects类的equals方法:对两个对象进行比较,防止空指针异常。
        */
        boolean b2 = Objects.equals(s1,s2);
        System.out.println(b2);  //false
    }

}

总结:Object类和Objects类

一、Object类
1.Object类介绍
        Object类是所有类的父类,每个类都会直接或者间接的继承该类
        该类中提供了一些非常常用的方法!

2.toString()方法:
        1)直接打印输出一个String类型变量对象,默认调用对象toString方法,所以打印对象的内容。
        2)直接打印输出一个类的对象,默认也调用对象toString方法,但是打印的是对象的地址。           为什么会出现上面的情况:String类中,系统帮我们重写了toString方法,而下面那个类中没           有重写toString方法。
        作用:打印对象的信息
        重写前:打印的是包名类名@地址值
        重写后:打印的是对象当中的属性值

3.equals方法:  s1.equals(s2)
        1)String类中有重写
        2)别的类要自己重写
        作用:用来比较两个对象
        重写前:比较对象地址值
        重写后:比较对象属性值

二、Objects类
1.equals方法:  Objects.equals(s1,s2)
作用也是比较两个对象是否相同,但是它可以解决NUll指针异常的问题,可以解决有空字符串比较的问题。
        

三、日期时间类
1.Date类的构造方法和成员方法

package ln.javatest.day10.demo02;
/*
java.lang.Date:表示日期和时间的类
类 Date 表示特定的瞬间,精确到毫秒
毫秒:千分之一秒
特定的瞬间:一个时间点,一刹那时间
20122-08-08 09 :55:33 :333 瞬间
毫秒的作用:可以对时间和日期进行计算
把日期转换为毫秒:
System.currentTimeMillis();//获取当前系统日期毫秒
    当前日期:2022-02-02
    时间原点(0毫秒):1970年1月1日 00:00:00
    //中国  :1970年1月1日 08:00:00
    就是计算当前日期到时间原点之间一共经历了多少毫秒


*/

import java.util.Date;

public class Demo01Date {
    public static void main(String[] args) {
        demo01();
        demo02();
        demo03();
    }

    /*
    Date类的空参数构造方法:
    Date();获取的局势当前系统的日期和时间
     */
    private static void demo01(){
        Date date = new Date();
        System.out.println(date);
        //Sun Jan 09 11:31:35 CST 2022
    }
    /*
    Date类的带参数构造方法:
    Date(long date);传递毫秒值,把毫秒转换为Date
     */
    private static void demo02(){
        Date date1 = new Date(0L);
        System.out.println(date1);
        //Thu Jan 01 08:00:00 CST 1970
        Date date2 = new Date(15678L);
        System.out.println(date2);
        //Thu Jan 01 08:00:15 CST 1970
        Date date3 = new Date(date2.getTime());
        System.out.println(date3);
        //Thu Jan 01 08:00:15 CST 1970
    }
    /*
    Date类的成员方法:
    long getTime();把日期转换为毫秒
    相当于:System.currentTimeMillis();
     */
    private static void demo03(){
        Date date2 = new Date();
        long time = date2.getTime();
        System.out.println(time);
        //1641699580228
    }
}

2.DateFormat和SimpleFormat类介绍
DateFormat是一个子类它的父类是Format类,同时他也是一个抽象类,SimpleFormat是DateFormat的子类,所以要用SimpleFormat来实现DateFormat。

package ln.javatest.day10.demo02;
/*
java.text,DateFormat:是日期/时间格式化子类的抽象类
作用:可以对日期和我们日常看的日期文本进行相互转换。
成员方法:
    String format(Date date):按照指定的模式,把Date日期格式化为符合模式的字符串。
    Date parse(String source) 把符合模式的字符串,解析为Date日期
DateFormat类是一个抽象类,无法直接创建对象进行使用,可以使用DateFormat的子类

java.text.SimpleDateFormat extends DateFormat
构造方法:
    SimpleDateFormat(String pattern)用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
    参数:
        String pattern:传递指定的模式
    模式:区分大小写
        y   年
        M   月
        d   日
        H   时
        m   分
        s   秒
    写对应的模式,会把模式替换为对应的日期和时间:
        “yyyy-MM-dd HH:mm:ss"
        "yyyy年MM月dd日 HH时mm分ss秒“
    注意事项:
    模式中的字母不能更改,连接模式的符号可以改变

*/

public class Demo02Date {
}

3.DateFormat和SimpleFormat类的使用

package ln.javatest.day10.demo02;
/*
java.lang.Date:表示日期和时间的类
类 Date 表示特定的瞬间,精确到毫秒
毫秒:千分之一秒
特定的瞬间:一个时间点,一刹那时间
20122-08-08 09 :55:33 :333 瞬间
毫秒的作用:可以对时间和日期进行计算
把日期转换为毫秒:
System.currentTimeMillis();//获取当前系统日期毫秒
    当前日期:2022-02-02
    时间原点(0毫秒):1970年1月1日 00:00:00
    就是计算当前日期到时间原点之间一共经历了多少毫秒


*/

import java.util.Date;

public class Demo01Date {
    public static void main(String[] args) {
        demo01();
        demo02();
        demo03();
    }

    /*
    Date类的空参数构造方法:
    Date();获取的局势当前系统的日期和时间
     */
    private static void demo01(){
        Date date = new Date();
        System.out.println(date);
        //Sun Jan 09 11:31:35 CST 2022
    }
    /*
    Date类的带参数构造方法:
    Date(long date);传递毫秒值,把毫秒转换为Date
     */
    private static void demo02(){
        Date date1 = new Date(0L);
        System.out.println(date1);
        //Thu Jan 01 08:00:00 CST 1970
        Date date2 = new Date(15678L);
        System.out.println(date2);
        //Thu Jan 01 08:00:15 CST 1970
        Date date3 = new Date(date2.getTime());
        System.out.println(date3);
        //Thu Jan 01 08:00:15 CST 1970
    }
    /*
    Date类的成员方法:
    long getTime();把日期转换为毫秒
    相当于:System.currentTimeMillis();
     */
    private static void demo03(){
        Date date2 = new Date();
        long time = date2.getTime();
        System.out.println(time);
        //1641699580228
    }
}

4.DateFormat类的format方法和parse方法

package ln.javatest.day10.demo02;
/*
java.text,DateFormat:是日期/时间格式化子类的抽象类
作用:可以对日期和我们日常看的日期文本进行相互转换。
成员方法:
    String format(Date date):按照指定的模式,把Date日期格式化为符合模式的字符串。
    Date parse(String source) 把符合模式的字符串,解析为Date日期
DateFormat类是一个抽象类,无法直接创建对象进行使用,可以使用DateFormat的子类

java.text.SimpleDateFormat extends DateFormat
构造方法:
    SimpleDateFormat(String pattern)用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
    参数:
        String pattern:传递指定的模式
    模式:区分大小写
        y   年
        M   月
        d   日
        H   时
        m   分
        s   秒
    写对应的模式,会把模式替换为对应的日期和时间:
        “yyyy-MM-dd HH:mm:ss"
        "yyyy年MM月dd日 HH时mm分ss秒“
    注意事项:
    模式中的字母不能更改,连接模式的符号可以改变

*/

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo02Date {
    public static void main(String[] args) throws ParseException {
        demo01();
        demo02();
    }
    /*
     使用DateFormat类中的format方法,把日期格式化为文本
     String format(Date date):按照指定的模式,把Date日期格式化为符合模式的字符串。
     使用步骤:
        1.创建SimpleDateFormat对象,构造方法中传递指定的模式
        2.调用SimpleDateFormat对象中的方法,按照构造方法中指定的模式,把Date日期格式化为符合模式的字符串(文本)
    */
    private static void demo01(){
        //1.创建SimpleDateFormat对象,构造方法中传递指定的模式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //2.调用SimpleDateFormat对象中的方法format,按照构造方法中指定的模式,把Date日期格式化为符合模式的字符串(文本)
        Date date = new Date(); //获取当前系统时间和日期
        String text = sdf.format(date);  //转换为指定格式的文本字符串
        System.out.println(date); //Sun Jan 09 12:20:05 CST 2022
        System.out.println(text); //2022-01-09 12:20:05
    }

    /*
     使用DateFormat类中的parse方法,把文本解析为日期
     Date parse(String source):按照指定的模式,把Date日期格式化为符合模式的字符串。
     使用步骤:
        1.创建SimpleDateFormat对象,构造方法中传递指定的模式
        2.调用SimpleDateFormat对象中的方法,按照构造方法中指定的模式,把Date日期格式化为符合模式的字符串(文本)
     注意:
        public Date parse(String source) throws ParseException
        parse方法声明了一个异常叫ParseException解析异常
        如果字符串和构造方法中的模式不一样,那么程序就会抛出异常。
        调用一个抛出了异常的放,就必须去处理这个异常,要么throws继续声明抛出这个异常,要么try...catch自己处理这个异常


    */
    private static void demo02() throws ParseException {
        //1.创建SimpleDateFormat对象,构造方法中传递指定的模式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //2.调用SimpleDateFormat对象中的方法parse,把符合构造方法中的模式的字符串,解析为Date日期。
        Date date = sdf.parse("2008-12-22 12:20:22");  //这里面的时间字符串必须和上面指定的模式要一样
        System.out.println(date);  //Mon Dec 22 12:20:22 CST 2008

    }

}

5.练习

package ln.javatest.day10.demo02;
/*
    练习:
        请使用日期时间相关的API,计算出一个人已经出生了多少天。
    分析:
        1.使用Scanner类中的方法next获取出生日期
        2.使用DateFormat类中的方法parse,把字符串的出生日期解析为Data格式。
        3.把Date格式的出生日期转换为毫秒值
        4.获取当前的日期,转换为毫秒值
        5.使用当前日期的毫秒值减去出生日期的毫秒值
        6.把毫秒值的插值转换为天(s/1000/60/60/24)
*/

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class Demo02Test {
    public static void main(String[] args) throws ParseException {
        // 1.使用Scanner类中的方法next获取出生日期
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的出生日期:格式为yyyy-MM-dd");
        String birth = sc.next();
        //使用DateFormat类中的方法parse,把字符串的出生日期解析为Data格式。
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date birthDate = sdf.parse(birth);
        //3.把Date格式的出生日期转换为毫秒值
        long birthDateTime = birthDate.getTime();
        //4.获取当前的日期,转换为毫秒值
        //Date(); 获取当前系统时间
        long todayTime = new Date().getTime();
        //5.使用当前日期的毫秒值减去出生日期的毫秒值
        long time = todayTime - birthDateTime;
        //6.把毫秒值的插值转换为天(s/1000/60/60/24)
        System.out.println(time/100/60/60/24);
        //请输入您的出生日期:格式为yyyy-MM-dd
        //2000-07-06
        //78576
    }
}

四、Calendar类

package ln.javatest.day10.demo03;
/*
    java.util.Calendar类
    Calendar是一个抽象类,里面提供了很多操作日历的字段的方法(YEAR、MONTH、DAY_OF_MONTH、HOUR )
    Calendar类无法直接创建对象使用,里面有一个静态方法叫getInstance(),该方法返回了Calendar类的子类对象
    static Calendar.getInstance() //使用默认时区和语言环境获得一个日历。
*/

import java.util.Calendar;

public class Dem01Calendar {
    public static void main(String[] args) {
        //多态,返回的是一个Calendar类的子类对象
        Calendar c = Calendar.getInstance();
        System.out.println(c);
        //java.util.GregorianCalendar[time=1641713743435,areFieldsSet=true
        //输出不是地址,说明重写了toString类
    }
}

2.Calendar类常用成员方法

package ln.javatest.day10.demo03;
/*
Calendar类的成员方法:
    public int get(int field):返回给定的日历字段设置为给定值。
    public void set(int field,int value):将给定的日历字段设置为给定值
    public abstract void add(int field ,int amount):根据日历的规则,为给定的日历字段添加或减去指定的时间量。
    public Date getTime():返回一个表示此Calendar时间值(从历元到现在的毫秒偏移量)的Date对象。
成员方法的参数:
    int field:日历类的字段,可以使用calendar类的静态成员变量获取
    public static final int Year = 1;           年
    public static final int MONTH = 2;          月
    public static final int DATE = 5;           月中的某一天
    public static final int DATE_OF_MONTH = 5;  月中的某一天
    public static final int HOUR = 10;          时
    public static final int MINUTE = 12;        分
    public static final int SECOND = 13;        秒
*/

import java.util.Calendar;
import java.util.Date;

public class Demo02Calender {
    public static void main(String[] args) {
         demo01();
         demo02();
         demo03();
         demo04();
    }
    /*
    public int get(int field):返回给定的日历字段设置为给定值。
    参数:传递指定的日历字段(YEAR,MONTH...)
    返回值:日历字段代表具体的值
    */
    private static void demo01(){
        //使用getInstance方法获取Calendar对象
        //获取一个日历
        Calendar c = Calendar.getInstance();
        //获取年,返回给定日历的Year
        int year = c.get(Calendar.YEAR);
        System.out.println(year); //2022
        //获取月
        int month = c.get(Calendar.MONTH);
        System.out.println(month); //0 西方0-11,东方1-12
        int date = c.get(Calendar.DATE);
        System.out.println(date);  //9

    }
    /*
     public void set(int field,int value):将给定的日历字段设置为给定值
    参数:
        int field:传递指定的日历字段(YEAR,MONTH...)
        int value:传递的字段设置的具体的值
    */
    private static void demo02(){
        //使用getInstance方法获取Calendar对象
        //获取一个日历
        Calendar c1 = Calendar.getInstance();
        //设置年为9999
        c1.set(Calendar.YEAR,9999);
        int year1 = c1.get(Calendar.YEAR);
        System.out.println(year1);  //9999
        //同时设置年月日可以使用set重载方法
        c1.set(8888,8,8);
        int year2 = c1.get(Calendar.YEAR);
        int month1 = c1.get(Calendar.MONTH);
        int date1 = c1.get(Calendar.DATE);
        System.out.println(year2);  //8888
        System.out.println(month1); //8
        System.out.println(date1); //8
    }
    /*
   public abstract void add(int field ,int amount):根据日历的规则,为给定的日历字段添加或减去指定的时间量.
    参数:
        int field:传递指定的日历字段(YEAR,MONTH...)
        int amount:增加或者减少的值
            正数:增加
            复数:减少
    */
    private static void demo03(){
        //使用getInstance方法获取Calendar对象
        //获取一个日历
        Calendar c2 = Calendar.getInstance();
        //把年增加2年
        c2.add(Calendar.YEAR,2);
        int year = c2.get(Calendar.YEAR);
        System.out.println(year); //2024
        //把月减少3个月
        c2.add(Calendar.MONTH,-3);
        int month = c2.get(Calendar.MONTH);
        System.out.println(month); //9
    }
    /*
   public Date getTime():返回一个表示此Calendar时间值(从历元到现在的毫秒偏移量)的Date对象。
    把日历对象转换为日期对象
    */
    private static void demo04(){
        //使用getInstance方法获取Calendar对象
        //获取一个日历
        Calendar c3 = Calendar.getInstance();
        //把年增加2年
        Date date = c3.getTime();
        System.out.println(date); //Sun Jan 09 16:30:56 CST 2022
    }
}

总结:时间日期相关类总结
一、Date类
        1)构造方法:
                Date():根据当前系统的时间创建日期对象
                Date(long time):根据穿日的毫秒值创建日期对象
        2)成员方法:
                long getTime():获取当前日期对象的毫秒值时间
                String tolocaleString():根据本地格式转换日期对象

package ln.javatest.day10.demo03;

import java.util.Date;

public class Test01 {
    public static void main(String[] args) {
        //空参构造函数
        Date d = new Date();
        Date d1 = new Date(3000L);
        System.out.println(d); //Sun Jan 09 16:42:56 CST 2022
        System.out.println(d.toLocaleString()); //2022年1月9日 下午4:42:56
        System.out.println(d1);  //197-1-1 8:00:03
    }
}

二、DateFormat类和SimpleDateFormat类
(DateFormat是个抽象类,SimpleFormat是DateFormat类的子类,来实现它)
        1)构造方法
                SimpleDateFormat(String s):根据指定模板创建日期格式化对象。
        2)成员方法
                String format(Date d):根据指定格式格式化日期对象
                Date parse(String s):根据指定格式解析字符串

package ln.javatest.day10.demo03;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test01 {
    public static void main(String[] args) throws ParseException {
        //空参构造函数
        Date d = new Date();
        System.out.println(d); //Sun Jan 09 16:42:56 CST 2022
        System.out.println(d.toLocaleString()); //2022年1月9日 下午4:42:56
        //创建日期格式化对象
        SimpleDateFormat sdf = new SimpleDateFormat("YYYY年MM月dd日 HH:mm:ss");
        String str = sdf.format(d);
        System.out.println(str);  //2022年01月09日 16:54:20
        //注意 :这下面的时间格式要和上面SimpleDateFormat指定的模板格式一样,否则报错
        String str1 = "2088年03月07日 07:07:07";
        Date date = sdf.parse(str1);
        System.out.println(date); //Sun Dec 28 07:07:07 CST 2087


    }
}

三、Calendar类
        1)创建对象方式:
                Calendar c = Calendar.getInstance():获取日历类对象

        2)成员方法:
                int get(int n): 获取指定日历字段信息
                void set(int n,int value):将指定日历字段设置为指定的值
                void add(int n,int value):将指定日历字段增加或减少指定的值

免责声明
本站部分资源来源于互联网 如有侵权 请联系站长删除
龙哥网是优质的互联网科技创业资源_行业项目分享_网络知识引流变现方法的平台为广大网友提供学习互联网相关知识_内容变现的方法。