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):将指定日历字段增加或减少指定的值