java常用类中的Obje类和日期时间类

最新推荐文章于 2022-05-30 20:52:38 发布
最新推荐文章于 2022-05-30 20:52:38 发布
阅读量928 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq1305730611/article/details/106960234
版权

Object类

概述

object类是java.lang.object,包下的类，是java语言的根类（最顶层），即所有类的父类。它描述的所有方法子类都可以使用。在实例化对象是最终找到的父类就是object类；

1.object:java.lang.Object
2.类Object是类层次结构的根(最顶层)。每个类都有Object一个超类（父类）。
  所有对象（包括数组）都实现此类的方法。


import com.commonClass.Object.toString.Person;

        import java.util.Random;
        import java.util.Scanner;
        import java.util.stream.DoubleStream;

public class Application {
    public static void main(String[] args) {
        //person类是默认继承Object类的，我们可以使用Object类中的toString方法；
        Person person1 = new Person("浩鑫",13);
        Person person2 = new Person("Andy",13);

toString()方法

  1. 作用：打印对象的信息
  2. 重写前：打印的包名、类名@地址值
package com.commonClass.Object.toString;

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

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

    public Person() {
    }

package com.commonClass;

1.object:java.lang.Object
2.类Object是类层次结构的根(最顶层)。每个类都有Object一个超类（父类）。
  所有对象（包括数组）都实现此类的方法。
import com.commonClass.Object.toString.Person;

        import java.util.Random;
        import java.util.Scanner;
        import java.util.stream.DoubleStream;

public class Application {
    public static void main(String[] args) {
        //person类是默认继承Object类的，我们可以使用Object类中的toString方法；
        Person person1 = new Person("浩鑫",13);
        Person person2 = new Person("Andy",13);
        //调用toString方法
        String s1=person1.toString();
        String s2=person2.toString();
        //直接调用打印对象，事实上就是默认调用了toString方法
        System.out.println(s1.toString());//com.commonClass.Object.toString.Person@1b6d3586
        System.out.println(s2);//com.commonClass.Object.toString.Person@4554617c
        //直接调用toString方法，其实就是打印对象的地址和直接打印对象没有区别
        System.out.println(person1);//com.commonClass.Object.toString.Person@1b6d3586
        System.out.println(person2);//com.commonClass.Object.toString.Person@4554617c
  1. 重写后：打印的是对象的属性值
package com.commonClass.Object.toString;

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

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

    public Person() {
    }

   //重写toString方法可以使用快捷键：Alt+insert 选中toString 方法
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

}

package com.commonClass;

1.object:java.lang.Object
2.类Object是类层次结构的根(最顶层)。每个类都有Object一个超类（父类）。
  所有对象（包括数组）都实现此类的方法。
import com.commonClass.Object.toString.Person;

        import java.util.Random;
        import java.util.Scanner;
        import java.util.stream.DoubleStream;

public class Application {
    public static void main(String[] args) {
                //重写了toString方法后再重新输出
        System.out.println(person1);//person={name=浩鑫,age=13}
        System.out.println(person2);//person={name=Andy,age=13}

        看一个类是否重写了toString方法，就直接打印这个类实例化的对象名字
            如果没有重写，打印出来的就是对象的地址（默认方法）
            如果重写了，那么就是按照重写的方式打印

        System.out.println(new Random().ints());//没有重写toString方法

        System.out.println(new Scanner(System.in));//重写toString方法


    }
}

equals()方法

  1. 作用:比较两个对象
  2. 重写前：比较两个对象的地址值
package com.commonClass.Object.equals;

import java.util.Objects;
import java.util.Random;

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

    public Person() {
    }

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


package com.commonClass;

1.object:java.lang.Object
2.类Object是类层次结构的根(最顶层)。每个类都有Object一个超类（父类）。
  所有对象（包括数组）都实现此类的方法。


import com.commonClass.Object.equals.Person;

        import java.util.Random;

public class Application {
    public static void main(String[] args) {
        /*person类是默认继承Object类的，我们可以使用Object类中的equals方法；
          比较两个对象是否相等
          object类equals方法的源码：
           public boolean equals(Object obj) {
              return (this == obj);
           }
             参数：
                 Object obj： 可以传递任意的对象
             方法体：
                 ==：比较运算符，返回的是一个布尔值，不是true 就是 false
                 基本数据类型：比较的是值
                 引用数据类型：比较的是地址值
*/
        Person person1 = new Person();
        Object person2 = new Person();
        Random r = new Random();
        //通过boolean进行比较，比较的是对象的地址值
        boolean tese=(person1==person2);//false
        System.out.println(tese);
        //通过调用equals方法进行比较
        //直接使用对象进行比较，比较的是对象的地址值，要通过方法重写比较两者的属性值
        person1=person2;
        System.out.println(person1.equals(person2));//true
  1. 重写方法后：比较的是对象的属性值
package com.commonClass.Object.equals;

import java.util.Objects;
import java.util.Random;

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

    public Person() {
    }

    public Person(String name, int age) {
       this.name = name;
        this.age = age;
    }
    /*
    Object类中的equals方法默认比较的是对象的地址值，没有意义
    我们需要重写equals方法，来比较两个对象的属性值
    问题：
       Object类隐含了一个多态。
       多态的弊端：无法使用子类特有的方法和属性
       解决方法：使用向下转型（类型的强制转换）
     */


    @Override

    public boolean equals(Object obj) {
        //增加一个判断，当传递进来的参数为this时，直接返回true
        if(obj==this){
            return true;
        }
        //增加一个判断，当传递进来的参数为null时，直接返回false
        if(obj==null){
            return false;
        }
        //使用instanceof关键字，判断传递进来的参数和本类，是否存在父子类的关系
        if(obj instanceof Person){
            Person person=(Person)obj;
            //使用try-catch,避免当出现当this.name=null是，出现空指针异常
            try {
                return this.age==person.age && this.name.equals(person.name);
            } catch (Exception e) {
                //出现空指针异常时，让person.name与null进行比较
                return this.age==person.age && person.name==null;
            }
        }
        //当传递进来的参数与本类无父子关系，直接防护false
        return false;
    }


//可以使用快捷键Alt+insert 添加equalt方法

    @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);
    }


}  

public class Application {
    public static void main(String[] args) {
        Person person1 = new Person();
        Object person2 = new Person();
         System.out.println(person1.equals(person2));//false
        }

Objects类中的equals()方法

  • 作用：比较两个对象，家里一些健壮性的判断
package com.commonClass.Object.Objects;

import java.util.Objects;

public class Test {
    //定义一个测试类
    private String name;

    public String getName() {
        return name;
    }

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

package com.commonClass;
/*
1.object:java.lang.Object
2.类Object是类层次结构的根(最顶层)。每个类都有Object一个超类（父类）。
  所有对象（包括数组）都实现此类的方法。
*/

import com.commonClass.Object.Objects.Test;

        import java.util.Objects;
//objects是JDK7添加的一个工具类，里面的方法都为静态方法，我们可以直接调用

public class Application {
    public static void main(String[] args) {
        Test test1 = new Test();
        Test test2 = new Test();
        test1.setName(null);
        test2.setName("浩鑫");
        /*调用方法的对象为null时，使用Object中的equals方法会出现NullPointerException（空指针异常）
        //所以，我们可以使用Objects中的equals方法来避免出现异常
        //System.out.println(test1.getName().equals(test2.getName()));

        1.Objects类中的equals方法是空指针安全的，是允许空指针的
        2，源码：   public static boolean equals(Object a, Object b) {
                   return (a == b) || (a != null && a.equals(b));
                   }
        3.Objects类中的equals方法是直接传入两个对象进行比较
*/
        System.out.println(Objects.equals(test1.getName(), test2.getName()));

    }
}

日期时间类

Date类

  • java.util.Date 表示特定的瞬间，精确到毫秒。
  • 常用的方法有：
    1. Date() 无参构造方法：获取当前系统的日期和时间
    2. Date(long date) 有参构造方法：将毫秒值转化为日期
    3. getTime() 成员方法：将日期转换为毫秒值
package com.commonClass.Date.date;
/*
1.java.util.Date:表示日期与时间
2.该类Date表示特定的时间瞬间，精度为毫秒。
3.1000毫秒=1秒
4.毫秒值的作用：可以对日期和日期进行计算，例如：从2020-1-1到2025-6-24中间一共有多少天、
5.计算时：可以先把日期转换成毫秒，计算完毕后，再毫秒转换为日期
6.毫秒值是一个long类型的值
7.把日期转换为毫秒：当前日期为 2020-6-24
                 默认的时间原点（0毫秒）：1970年1月1日 00；00；00（英国格林威治标准时间）
                 注意点：中国属于东八区：默认的实际原点要增加8小时 1970年1月1日 08；00；00
8.把毫秒转换为日期：1天=24*60*60=86400秒=86400*1000=86400000L毫秒

 */

import javax.xml.soap.DetailEntry;
import java.util.Date;

public class Demo01 {
  public void date1(){
      /*
      Date类的空构造方法
      Date():获取当前系统的日期和时间
       */
      System.out.println(new Date());
  }
  public void date2(){
      /*
      Date类带参数的构造方法
      Date(long date):传递一个毫秒值，把毫秒化为Date日期
       */
      System.out.println(new Date(1592982995640L));
  }
  public void date3(){
      /*
      Date类的成员方法
      long getTime()：把日期转换为毫秒值（相当于：System.currntTimeMillis()）
       */
      System.out.println(new Date().getTime());
  }

}

import com.commonClass.Date.date.Demo01;

public class Application {
    public static void main(String[] args) {
        //System.out.println(System.currentTimeMillis());//获取当前系统的时间到时间原点的毫秒值
        //获取当前系统的时间
        new Demo01().date1();//Wed Jun 24 14:56:29 GMT+08:00 2020
        //将输入的毫秒值转换为日期
        new Demo01().date2();//Wed Jun 24 15:16:35 GMT+08:00 2020
        //获取当前系统的毫秒值
        new Demo01().date3();//1592982875531

    }
}

DateFormat类

  1. java.text.Format. 它是一个抽象类，是日期/时间格式化的子类
  2. 抽象类不能被实例化，我们需要借助DateFormat的子类：SimpleDateFormat去调用DateFormat中的方法
  3. 常用的方法有：
    • format()方法：将日期（Date对象）格式化为文本（字符串）
    • parse()方法：将文本（字符串）解析为日期（Date对象）

SimpleDateFormat类

SimpleDateFormat:java.text.SimpleDateFormat exdents DateFoemat
构造方法：SimpleDateFormat(String pattern)：使用给定的模式和默认Format语言环境的默认日期格式符号构造。
   参数：String pattern
   模式：区分大小写的
        y-->年
        M-->月
        d-->日
        H-->时
        m-->分
        s-->秒
        对应的书写模式："yyyy-MM-dd HH:mm:ss"  "yyyy年MM月dd日 HH时mm分ss秒"
        注意点：书写的模式中，字母是不能改变的，且区分大小写，连接字母之间的符号是可以改变的

package com.commonClass.Date.dateFormat;
/*
java.text.DateFormat:是日期/时间格式化子类的抽象类
作用：格式化（日期-->文本），解析（文本-->日期）
成员方法：
       String  format(Date date)：把传递进来的Date对象格式化，转换成符合文本规范的字符串
       Date    parse(String source)：把传递进来的字符串解析，转换成Date对象
DateFormat是一个抽象类，无法直接使用new关键字来实例化使用，可以使用DateFormat的子类 SimpleDateFormat

 */

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

public class Demo01 {
/*
使用DateFormat中的format方法，把日期格式化为文本
使用步骤：
1.实例化SimpleDateFormat，将要实现的文本格式传递进去
2.调用format方法，将传进去的Date对象转换为规范的文本格式
 */
public void dateFormat1(){
        System.out.println(new SimpleDateFormat("yyyy,MM,dd HH:mm:ss").format(new Date()));
    }
/*
使用DateFormat中的parse方法，把文本解析为日期
1.实例化SimpleDateFormat，将要实现的文本格式传递进去
2.调用parse方法，将传进去规范的字符串转换为规范的Date对象
注意：parse方法中声明了一个异常，如果要使用parse方法需要在方法中捕获（try-catch）异常
     或者在方法外throws,继续向外抛出
 */
    public void dateFormat2(){
        try {
            Date parse1 = new SimpleDateFormat("yyyy-MM-dd").parse("2020-01-01");
            Date parse2 = new SimpleDateFormat("yyyy-MM-dd").parse("2025-06-24");
            System.out.println(parse1);
            System.out.println(parse2);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

}

package com.commonClass;

import com.commonClass.Date.dateFormat.Demo01;

public class Application {
    public static void main(String[] args) {
        new Demo01().dateFormat1();//2020,06,24 17:10:31
        new Demo01().dateFormat2();//Wed Jan 01 00:00:00 GMT+08:00 2020
                                   //Tue Jun 24 00:00:00 GMT+08:00 2025


    }
}

package com.commonClass.Date.test;

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

/*
练习题：
请使用日期相关的API计算一个人出生了多少天
 */
public class Demo01 {
    public long date(){
        boolean flag=true;
        long count=0;
        long result=0;
        while (flag) {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入出生日期,输入格式为：yyyy-MM-dd");
            flag=false;
            try {
                long parse = new SimpleDateFormat("yyyy-MM-dd").parse(scanner.nextLine()).getTime();
                count=parse;
            } catch (ParseException e) {
                System.out.println("输入格式错误，请重新输入");
                flag=true;
            }

        }
        long time = new Date().getTime();

        if(time-count>0){
            long sun=time-count;
            result=sun/(24*60*60*1000);
        }else{
            return 0;
        }

        return result;
    }
}

package com.commonClass;

import com.commonClass.Date.test.Demo01;


public class Application {
    public static void main(String[] args) {
        System.out.println(new Demo01().date());


    }

}

Calendar类

  1. java.util.Calendar：Calendar类是一个抽象类,是是日历类
  2. 我们通过Calendar的静态方法getInstance()去实例化Calendar
  3. 我们常用的方法有：
    • int get（int field）：返回给定日历的值
    • void set（int field int value）：将给定的日历字段设置成给定的值
    • void add（int field int amount）:给日历字段添加或减去指定的值
    • Date geiTime():将日历对象转换为日期对象
package com.commonClass.Date.calendar;
/*
java.util.calendar
Calendar是一个抽象类，里面提供了很多操作日历字段的方法
Calendar不能实例化对象
getInstance()静态方法，返回值就是一个Calendar
Calendar instance = Calendar.getInstance();
 */
/*
成员方法的参数：
        ins field:日历类的字段，可以使用Calendar的静态成员变量获取
        public static final int YEAR=1; 年
        public static final int MONTH=2;月
        public static final int DATE=5; 月中的某一天
        public static final int DAY_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;

public class Demo01 {
    public void calendar1(){
        Calendar instance = Calendar.getInstance();
        System.out.println(instance);
    }
    /*
    成员方法：
    int    get(int field):返回给定日历字段的值。
    参数：通过Calendar的静态成员变量获取
     */
    public void calendar2(){
        Calendar instance = Calendar.getInstance();
        System.out.print(instance.get(Calendar.YEAR)+"年");
        System.out.print(instance.get(Calendar.MONTH)+1+"月");//西方的月份0-11，
        System.out.print(instance.get(Calendar.DATE)+"日");
        //System.out.print(instance.get(Calendar.DAY_OF_MONTH));
        System.out.print("\t"+instance.get(Calendar.HOUR)+"时");
        System.out.print(instance.get(Calendar.MINUTE)+"分");
        System.out.println(instance.get(Calendar.SECOND)+"秒");

    }
    /*
    成员方法
    void   set(int field, int value)：将给定的日历字段设置为给定的值。
    参数：int field:通过Calendar的静态成员变量获取
         int value:为给定日历字段设置的值
     */
    public void calendar3(){
        Calendar instance = Calendar.getInstance();
        instance.set(Calendar.YEAR,1994);
        instance.set(Calendar.MONTH,9);
        instance.set(Calendar.DATE,9);
        //可以同时设置YEAR_MONTH_DATE,使用set()重载的方法
        instance.set(2020,6,25);
        System.out.print(instance.get(Calendar.YEAR)+"年");
        System.out.print(instance.get(Calendar.MONTH)+"月");
        System.out.println(instance.get(Calendar.DATE)+"日");
    }
    /*
    成员方法：
    abstract void  add(int field, int amount)：给定的日历字段中添加或减去指定的时间量
    参数：int field:通过Calendar的静态成员变量获取
         int amount:要添加到该字段的日期或时间量
         正数：增加值
         负数：减少值
     */
    public void calendar4(){
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.YEAR,5);
        instance.add(Calendar.MONTH,1);
        instance.add(Calendar.DATE,-5);
        System.out.print(instance.get(Calendar.YEAR)+"年");
        System.out.print(instance.get(Calendar.MONTH)+"月");
        System.out.println(instance.get(Calendar.DATE)+"日");
    }
    /*
    成员方法：
    Date   getTime()：返回一个Date表示此Calendar时间值的对象
    把日历对象转换为日期对象
     */
    public void calendar5(){
        Calendar instance = Calendar.getInstance();
        System.out.println(instance.getTime());

    }
}

package com.commonClass;

import com.commonClass.Date.calendar.Demo01;


public class Application {
    public static void main(String[] args) {
        new Demo01().calendar1();
        new Demo01().calendar2();//2020年6月25日  1时36分54秒
        new Demo01().calendar3();//2020年6月25日
        new Demo01().calendar4();//2025年6月20日
        new Demo01().calendar5();//Thu Jun 25 03:16:46 GMT+08:00 2020


    }
}
Andy鑫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Objec通用方法
weixin_45827700的博客
12-20 209
Object的方法
java 中 String format 和Math类实例详解
08-30
Java 中 String format 和 Math 类实例详解 Java 中的 String format 和 Math 类是两个非常重要的类，它们提供了许多有用的方法来处理字符串和数学运算。在这里，我们将详细介绍 String format 和 Math 类的实例...
object转化为时间类型
05-15
在C#中如何将object转化为时间类型
Object类及Objects类
ijwddd的专栏
06-03 1万+
Object类java.lang.Object 类是java语言中的根类,所有类的父类. 特点:  如果一个类没有指定父类,那么默认继承Object类(所有类的爹)在API文档中,Object类里面共有11个方法:常用的方法:1. public String toString()   返回该对象的字符串,默认为:类全名+@+内存地址值.(类全名 = 包名 + 类名)   重写toString()方...
java之进阶语法（Object类及日期时间类）
对于写代码这件事，我是业余的。
03-04 519
一、关于Object类 （一）概述 java.lang.object类是java语言的根类，即是所有类的父类。 若一个类没有指定父类，那么默认继承自Object类 object类常用的方法有以下： - public String toString() 返回该对象的字符串表示。通常，toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。 直接打印对象的名字，调用的其实就是toString方法。toString方法
#Python3中类Class和对象obje
weixin_43097301的博客
10-27 530
Python3中类Class 类 是什么 类是一个抽象的概念，泛指很多相似的个体组成的，具有共同特征的事物。 比如类是一个车 ，这车就包括各种车型 什么是对象 类里面的具体的一个事物。 比如 五菱神车S（过弯秒掉GTR的梗还记忆犹新） ，他是车这个类的具体化， 先有类，才有对象 def eating(): print("吃草") def walking(): print...
java运行常用类rt.jar下载
04-10
这些类涵盖了输入/输出、网络通信、集合框架、字符串处理、异常处理、多线程、反射、日期时间等多个领域，几乎涵盖了Java开发的各个方面。对于Java开发者来说，理解并熟练使用`rt.jar`中的类是非常重要的基础技能。 ...
java常用工具类
01-31
Java内置的日期时间API（如`java.util.Date`和`java.util.Calendar`）在处理日期和时间时较为复杂。为了简化操作，`java.time`包引入了新的API，如`LocalDate`、`LocalTime`和`LocalDateTime`。此外，`java.text....
java中的十个大类总结
09-04
9. **`java.util.Date`**：处理日期和时间的类，尽管在Java 8之后`java.time`包提供了更先进的API，但`Date`仍然被广泛使用，尤其是在老版本的代码中。它提供了获取当前日期、比较日期以及格式化日期的方法。 10. *...
java常用工具类之Excel操作类及依赖包下载
09-04
Java中的Excel操作主要依赖于Apache POI库，这是一个强大的API，允许开发者在Java应用程序中创建、修改和显示Microsoft Office格式的文件，特别是Excel文件。在上述的`ExcelUtil.java`类中，我们可以看到如何利用...
常用类-Object类
XHW0901的博客
05-30 5654
一、Object类简介 1.Object类：位于javalang包中的类（java.lang包中的内容自动导入）； 2.Object是每个类的父类，直接父类或者是间接的父类； 3.Object类型的引用可以存储任意类型的对象； 4.Ovject类中的方法是每个类都默认的功能方法。 二、常用方法 1. getclass()：被final修饰，允许子类继承，不允许覆盖 ...
Object类型
zy_remarkable的博客
06-08 3549
Object类型：       是所有引用类型的父类，在引用类型的顶端。       它的引用变量可以指向任何类型的一个对象     Object obj = "aaaa";            obj = new int[3];            obj = new Scanner(System.in);    面试题：怎么使用数组存一些类型不同的数据        用Obj...
先有Object还是先有Class
hyly_zhard的博客
05-01 209
原文转自：https://www.zhihu.com/question/30301819/answer/47539163
python的class(类)中的object是什么意思?
耶律大石的博客
11-10 2万+
python程序类的写法中有的直接在class后价格名称，有的却在标识符后加一个括号，里面再嫁一个object，这是什么意思呢？如下图 原来 object是继承的意思，面向对象语言中都有这样一种特性。继承，指一个对象直接使用另一对象的属性和方法。 用代码说明写object和不写object有什么区别？ # -.- coding:utf-8 -.- # __author__ = 'zhengton...
Object类的方法
空之境界
12-05 6万+
前言Java语言不同于C++语言，是一种单根继承结构语言，也就是说，Java中所有的类都有一个共同的祖先。这个祖先就是Object类。object类的结构 如图可知，Object类有12个成员方法，按照用途可以分为以下几种 1，构造函数 2，hashCode和equale函数用来判断对象是否相同, 3，wait(),wait(long),wait(long,int),notify(),not
Java——Object类(toString和equal)及日期时间类
weixin_44840572的博客
12-03 474
根据JDK源代码及Object类的API文档，Object类当中包含的方法有11个。这次我们主要学习其中的2个： public String toString()：返回该对象的字符串表示。 public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。 toString方法 public String toString()：返回该对象的字符串表示。...
谈谈System.currentTimeMillis()
qq_26236193的博客
02-12 3万+
谈谈获取系统时间，以及和服务端交互时的时间校验 背景 最近玩旅行青蛙，偶然发现在没有网络情况下，还是可以正常的收三叶草以及在商店买东西。这时候就觉得这个好像是一个单机游戏，那么三叶草收割刷新的逻辑是客户端自己算的咯。然后在联想到时间，java里面一般都是用System.currentTimeMillis()这个比较高效的方法获取时间戳，再format成固定格式的时间。 带着好奇心...
Java中的常用类——Object类
java面试笔试
07-09 3979
嗨~各位小伙伴大家好呀~这两天一直在想一个问题接下来该写点什么？看看自己公众号的调性追热点又追不上文笔还不好~只能写点教程文章这个样子~所以小伙伴们准备好和小编一起捋一遍...
由system.currentTimeMillis() 获得当前的时间
热门推荐
mywebstudy的专栏
07-31 21万+
System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。 currentTimeMillis方法 public static long currentTimeMillis() 该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。 可以直接把这个方
Java基础知识-day01【Object类、常用API】.pdf
最新发布
10-26
"Java基础知识-day01【Object类、常用API】是一份针对Java初学者的课程资料，主要讲解了Object类的基础概念和常用API。Object类作为所有类的根类，提供了两个核心方法：toString()和equals()。toString()方法用于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值