Object类、常用API

清疚 2022-12-14 09:07 231阅读 0赞

# 第一章 Object类 #

## 1.1 概述 ##

`java.lang.Object`类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。

如果一个类没有特别指定父类， 那么默认则继承自Object类。例如：

public class MyClass /\*extends Object\*/ \{  
      // ...  
\}

根据JDK源代码及Object类的API文档，Object类当中包含的方法有11个。今天我们主要学习其中的2个：

*  `public String toString()`：返回该对象的字符串表示。
 *  `public boolean equals(Object obj)`：指示其他某个对象是否与此对象“相等”。

## 1.2 toString方法 ##

### 方法摘要 ###

*  `public String toString()`：返回该对象的字符串表示。

toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。

由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

### 覆盖重写 ###

如果不希望使用toString方法的默认行为，则可以对它进行覆盖重写。例如自定义的Person类：

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

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

// 省略构造器与Getter Setter  
\}

## 1.3 equals方法 ##

### 方法摘要 ###

*  `public boolean equals(Object obj)`：指示其他某个对象是否与此对象“相等”。

调用成员方法equals并指定参数为另一个对象，则可以判断这两个对象是否是相同的。这里的“相同”有默认和自定义两种方式。

### 默认地址比较 ###

如果没有覆盖重写equals方法，那么Object类中默认进行`==`运算符的对象地址比较，只要不是同一个对象，结果必然为false。

### 对象内容比较 ###

如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写equals方法。例如：

public class Person \{      
    private String name;  
    private int age;  
      
    @Override  
    public boolean equals(Object o) \{  
        // 如果对象地址一样，则认为相同  
        if (this == o)  
            return true;  
        // 如果参数为空，或者类型信息不一样，则认为不同  
        if (o == null || getClass() != o.getClass())  
            return false;  
        // 转换为当前类型  
        Person person = (Person) o;  
        // 要求基本类型相等，并且将引用类型交给java.util.Objects类的equals静态方法取用结果  
        return age == person.age && Objects.equals(name, person.name);  
    \}  
\}

# 第二章 Date类 #

`java.util.Date`类 表示特定的瞬间，精确到毫秒。

继续查阅Date类的描述，发现Date拥有多个构造函数，只是部分已经过时，但是其中有未过时的构造函数可以把毫秒值转成日期对象。

*  `public Date()`：从运行程序的此时此刻到时间原点经历的毫秒值,转换成Date对象，分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
 *  `public Date(long date)`：将指定参数的毫秒值date,转换成Date对象，分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数。

简单来说：使用无参构造，可以自动设置当前系统时间的毫秒时刻；指定long类型的构造参数，可以自定义毫秒时刻。例如：

import java.util.Date;

public class Demo01Date \{  
    public static void main(String\[\] args) \{  
        // 创建日期对象，把当前的时间  
        System.out.println(new Date()); // Tue Jan 16 14:37:35 CST 2020  
        // 创建日期对象，把当前的毫秒值转成日期对象  
        System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970  
    \}  
\}

### 常用方法 ###

Date类中的多数方法已经过时，常用的方法有：

*  `public long getTime()` 把日期对象转换成对应的时间毫秒值。
 *  `public void setTime(long time)` 把方法参数给定的毫秒值设置给日期对象

public class DateDemo02 \{  
    public static void main(String\[\] args) \{  
        //创建日期对象  
        Date d = new Date();  
          
        //public long getTime():获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值  
        //System.out.println(d.getTime());  
        //System.out.println(d.getTime() \* 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");

//public void setTime(long time):设置时间，给的是毫秒值  
        //long time = 1000\*60\*60;  
        long time = System.currentTimeMillis();  
        d.setTime(time);

System.out.println(d);  
    \}  
\}

# 第三章 DateFormat类 #

`java.text.DateFormat` 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

*  **格式化**：按照指定的格式，把Date对象转换为String对象。
 *  **解析**：按照指定的格式，把String对象转换为Date对象。

### 构造方法 ###

由于DateFormat为抽象类，不能直接使用，所以需要常用的子类`java.text.SimpleDateFormat`。这个类需要一个模式（格式）来指定格式化或解析的标准。构造方法为：

*  `public SimpleDateFormat(String pattern)`：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。

参数pattern是一个字符串，代表日期时间的自定义格式。

### 格式规则 ###

常用的格式规则为：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Noa3N0YXJ0_size_16_color_FFFFFF_t_70][]

### 常用方法 ###

DateFormat类的常用方法有：

*  `public String format(Date date)`：将Date对象格式化为字符串。
 *  `public Date parse(String source)`：将字符串解析为Date对象。

//格式化：从 Date 到 String  
        Date d = new Date();  
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");  
        String s = sdf.format(d);  
        System.out.println(s);  
        System.out.println("--------");

//从 String 到 Date  
        String ss = "2048-08-09 11:11:11";  
        //ParseException  
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
        Date dd = sdf2.parse(ss);  
        System.out.println(dd);

# Math类 #

### 概述 ###

`java.lang.Math` 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

### 常用方法 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Noa3N0YXJ0_size_16_color_FFFFFF_t_70 1][]

# System #

### 概述 ###

`java.lang.System`类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作。

### 常用方法 ###

![2020101315290129.png][]

在控制台输出1-10000，计算这段代码执行了多少毫秒

public static void main(String\[\] args) \{  
           //获取当前时间毫秒值  
       System.out.println(System.currentTimeMillis());   
      //计算程序运行时间  
       long start = System.currentTimeMillis();  
        for (int i = 1; i <= 10000; i++) \{  
            System.out.println(i);  
        \}  
        long end = System.currentTimeMillis();  
        System.out.println("共耗时毫秒：" + (end - start));  
    \}

# 包装类 #

## 1.1 概述 ##

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Noa3N0YXJ0_size_16_color_FFFFFF_t_70 2][]

## 1.2 Integer类 ##

*  Integer类概述
    
    包装一个对象中的原始类型 int 的值
 *  Integer类构造方法及静态方法

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Noa3N0YXJ0_size_16_color_FFFFFF_t_70 3][]

public static void main(String\[\] args) \{  
        //public Integer(int value)：根据 int 值创建 Integer 对象(过时)  
        Integer i1 = new Integer(100);  
        System.out.println(i1);

//public Integer(String s)：根据 String 值创建 Integer 对象(过时)  
        Integer i2 = new Integer("100");  
//        Integer i2 = new Integer("abc"); //NumberFormatException  
        System.out.println(i2);  
        System.out.println("--------");

//public static Integer valueOf(int i)：返回表示指定的 int 值的 Integer 实例  
        Integer i3 = Integer.valueOf(100);  
        System.out.println(i3);

//public static Integer valueOf(String s)：返回一个保存指定值的Integer对象 String  
        Integer i4 = Integer.valueOf("100");  
        System.out.println(i4);

## 1.3 装箱与拆箱 ##

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：

*  **装箱**：从基本类型转换为对应的包装类对象。
 *  **拆箱**：从包装类对象转换为对应的基本类型。

基本数值---->包装对象

Integer i = new Integer(4);//使用构造函数函数  
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法

包装对象---->基本数值

int num = i.intValue();

## 1.4 自动装箱与自动拆箱 ##

由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如：

Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);  
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;  
//加法运算完成后，再次装箱，把基本数值转成对象。

## 1.5 基本类型与字符串之间的转换 ##

### 基本类型转换为String ###

*  转换方式
    
     *  方式一：直接在数字后加一个空字符串
     *  方式二：通过String类静态方法valueOf()
 *  示例代码

//int --- String  
        int number = 100;  
        //方式1  
        String s1 = number + "";  
        System.out.println(s1);  
        //方式2  
        //public static String valueOf(int i)  
        String s2 = String.valueOf(number);  
        System.out.println(s2);

### String转换成基本类型 ###

除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

*  `public static byte parseByte(String s)`：将字符串参数转换为对应的byte基本类型。
 *  `public static short parseShort(String s)`：将字符串参数转换为对应的short基本类型。
 *  `public static int parseInt(String s)`：将字符串参数转换为对应的int基本类型。
 *  `public static long parseLong(String s)`：将字符串参数转换为对应的long基本类型。
 *  `public static float parseFloat(String s)`：将字符串参数转换为对应的float基本类型。
 *  `public static double parseDouble(String s)`：将字符串参数转换为对应的double基本类型。
 *  `public static boolean parseBoolean(String s)`：将字符串参数转换为对应的boolean基本类型。

代码使用（仅以Integer类的静态方法parseXxx为例）如：

*  转换方式
    
     *  方式一：先将字符串数字转成Integer，再调用valueOf()方法
     *  方式二：通过Integer静态方法parseInt()进行转换
 *  示例代码

//String --- int  
        String s = "100";  
        //方式1：String --- Integer --- int  
        Integer i = Integer.valueOf(s);  
        //public int intValue()  
        int x = i.intValue();  
        System.out.println(x);  
        //方式2  
        //public static int parseInt(String s)  
        int y = Integer.parseInt(s);  
        System.out.println(y);

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Noa3N0YXJ0_size_16_color_FFFFFF_t_70]: /images/20221123/771ea898ee68418e9b1617f3122bed4c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Noa3N0YXJ0_size_16_color_FFFFFF_t_70 1]: /images/20221123/0fdc983ca38741c8b8ea5a2f81e10b9a.png
[2020101315290129.png]: /images/20221123/4b6818679f4b46d982c70e2650546c83.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Noa3N0YXJ0_size_16_color_FFFFFF_t_70 2]: /images/20221123/cffc1925090a4e54980c28f3fd3657c0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Noa3N0YXJ0_size_16_color_FFFFFF_t_70 3]: /images/20221123/c8c3fb17ffc0438baf1354fb60a4b3ea.png