一、Object类

超类、基类，所有类的直接或者间接父类，位于继承树的最顶层。

任何类，如果没有写 extends 显示继承某个类，都直接默认继承 Object 类，否则为间接继承。

Object 类中所定义的方法，是所有对象都具备的方法。

Object 类型可以存储任何对象：

作为参数，可以接受任何对象
作为返回值，可以返回任何对象

1.getClass() 方法

public final Class<?> getClass(){
}

返回引用中存储的实际对象类型。

例如：判断两数据类型是否相同↓↓↓

Student类:

package com.scaaner;
public class Student {
    private String name;
    private int age;
    //无参构造器
    public Student(){

    }
    //有参构造器
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

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

方法类Demo1：

package com.scaaner;
public class Demo1 {
    public static void main(String[] args) {
        Student s1 = new Student("A",22);
        Student s2 = new Student("B",12);
        //判断s1和s2是否为同一类型
        Class<? extends Student> class1 = s1.getClass();
        Class<? extends Student> class2 = s2.getClass();
        if(class1 == class2){
            System.out.println("s1和s2是同一类型");
        }else{
            System.out.println("s1和s2不是同一类型");
        }
    }
}

输出结果：
在这里插入图片描述

2.hashCode()方法

public int hashCode() {
}

返回该对象的哈希码值。

哈希值根据对象的地址或字符串或数字使用hash算法计算出的int类型的数值。

一般情况下，相同对象返回相同哈希码。

同用Student类

在这里插入图片描述

3.toString()方法

public String toString(){
}

返回该对象的字符串表示（表现形式）

可以根据程序要求覆盖（重写）该方法，如：展示对象各个属性值。

同用Student类

（1）直接调用：

在这里插入图片描述

（2）重写

在这里插入图片描述

4.equals()方法

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

默认实现为（this == obj），比较两个对象地址是否相同。

可进行覆盖，比较两个对象的内容是否相同。

（1）姓名和年龄不同，输出为false

在这里插入图片描述

（2）姓名和年龄相同，为什么输出还为false？

在这里插入图片描述

因为在栈中所占地址不同，即使数据相同，也还是会显示false。

那要怎样才能为true呢？

对equals方法进行重写，比较两个对象的内容是否相同。

equals()方法覆盖步骤：
比较两个引用是否指向同一个对象。
判断obj是否为null。
判断两个引用指向的实际对象类型是否一致。
强制类型转换。
依次比较各个属性值是否相同。

（3）姓名和年龄相同，输出为true

在Student类中对equals方法进行重写，比较两个对象的内容是否相同。

在这里插入图片描述

5.finalize(）方法

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。

垃圾对象：没有有效引用指向此对象时，为垃圾对象。
垃圾回收：有GC销毁垃圾对象，释放数据存储空间。
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。
手动回收机制：使用System.gc()；通知JVM执行垃圾回收。

在Student类中重写finalize方法：

在这里插入图片描述

在测试类中写：

在这里插入图片描述

二、包装类

Object可统一所有数据，包装类的默认值是null。

基本数据类型对应的包装类：
在这里插入图片描述

1.基本类型和包装类型的转换、装箱与拆箱

栈中存放基本数据类型
堆中存放引用数据类型

装箱：栈中的数据放到堆中（基本类型–>引用类型）
拆箱：堆中的对象拿到栈中（引用类型–>基本类型）

具体请看示例↓↓↓

package com.scaaner;
public class Demo1 {
    public static void main(String[] args) {
        //JDK1.5之前
        //类型转换：装箱   基本类型转引用类型过程
        //基本类型
        int num1 = 10;
        //使用Integer类创建对象
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);
        System.out.println(
                "装箱"
        );
        System.out.println(integer1);
        System.out.println(integer2);

        //类型转换：拆箱   引用类型转基本类型过程
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println("拆箱");
        System.out.println(num2);


        //JDK1.5之后   自动装箱  拆箱
        int age = 30;
        //自动装箱
        Integer integer4 = age;
        System.out.println("自动装箱"+"\n"+integer4);
        //自动拆箱
        int age1 = integer4;
        System.out.println("自动拆箱"+"\n"+age1);
    }
}

2.基本类型和字符串的转换

（1）基本类型转字符串

详看注释↓↓↓

在这里插入图片描述

（2）字符串转基本类型

详看注释↓↓↓

在这里插入图片描述

（3）boolean字符串形式转成基本类型

" true " ----> true
非" true " ----> false

详看注释↓↓↓

在这里插入图片描述

注意：

需保证类型兼容，否则抛出NumberFormatException异常。

附加：Integer缓冲区

Java预先创建了256个常用的整数包装类型对象。

在这里插入图片描述

代码↓↓↓

import com.sun.org.apache.xpath.internal.operations.Bool;

public class Demo1 {
    public static void main(String[] args) {
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1 == integer2);   //false
        //为基本类型，所以放进一个数，就存进去占堆中一个空间


        Integer integer3 = 100;  //自动装箱为引用类型
        //即使用Integer integer3 = Integer.valueOf（100）;的方法
        Integer integer4 = 100;
        System.out.println("------------");
        System.out.println(integer3==integer4);//true
        //指的是在堆中的一个（-128~127）之间的空间，100都只指向的是同一个位置


        Integer integer5 = 200;
        Integer integer6 = 200;
        System.out.println("------------");
        System.out.println(integer5==integer6);  //false
        //在堆中的一个（-128~127）之间的空间，超出这个范围就在堆里开辟个新空间
    }

三、String类

1.不变字符串

字符串是常量，创建之后不可改变

字符串字面值存储在字符串池中，可以共享。

方法一：

产生一个对象，字符串池中存储。

String s = “Hello”;


public class Demo1 {
    public static void main(String[] args) {
        String name = "hello";    //"hello"常量存储在字符串池中
        name = "zhangsan";        //并没有修改数据，而是重新开辟了一个空间，将name指向zhangsan
        String name2 = "zhangsan";  //在字符串池中寻找对象  匹配；如果没有则重新开辟新的空间
    }
}

方法二：（浪费空间）

产生两个对象，堆、池各存储一个。

String s = new String("Hello");

String的常用方法详见：String的几种常见方法

2.可变长字符串

效率比String高，比String节省内存

（1）StringBuffer

JDK1.0提供，用于多线程，运行效率慢、线程安全。

（2）StringBuilder

JDK5.0提供，用于单线程，运行效率快，线程不安全。

在这里插入图片描述
StringBuffer 和 StringBuilder 用法相同。

为什么StringBuffer和StringBuilder比String的效率高？
代码验证↓↓↓

在这里插入图片描述

四、BigDecimal类

先看图↓↓↓

在这里插入图片描述

double 是属于近似值存储，所以得出结果也是近似值，但误差很小。

就要使用 BigDecimal 来精确计算。

位置：java.math 包中
作用：精确计算浮点数
创建方式：BigDecimal bd = new BigDecimal(“1.0”);

加减乘除
add 加
subtract 减
multiply 乘
divide 除

除法比较特殊不能直接用：

divide(BigDecimal bd , int scal , RoundingMode mode)

参数scal：指定精确到小数点后几位。
参数mode：指定小数部分的取舍模式，通常采用四舍五入的模式。取值为BigDecimal.ROUND_HALF_UP。

public class Demo1 {
    public static void main(String[] args) {
        double d1 = 1.0;
        double d2 = 0.9;
        System.out.println(d1-d2);
        double result = (1.4-0.5)/0.9;
        System.out.println(result);
        System.out.println("-----------------");
        BigDecimal bd1 = new BigDecimal("1.0");  //后边为字符串类型
        BigDecimal bd2 = new BigDecimal("0.9");
        System.out.println(bd1.subtract(bd2));   //不能直接用运算法则   减法
        System.out.println(bd1.add(bd2));    //加法
        System.out.println(bd1.multiply(bd2));  // 乘法
        BigDecimal bd3 = new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"));  //除法
        System.out.println(bd3);
        System.out.println("----------------");
        //BigDecimal bd4 = new BigDecimal("10").divide(new BigDecimal("3")); //除不尽  会报错
        BigDecimal bd4 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);//表示四舍五入保留2位小数
        System.out.println(bd4);
    }
}

五、Date类

Date 表示特定的瞬间，精确到毫秒。Date 类中的大部分方法都已经被 Calendar 类中的方法所取代。

时间单位：
1s = 1000 ms
1ms = 1000 μs
1μs = 1000 ns

import java.util.Date;

public class Demo1 {
    public static void main(String[] args) {
        //1.创建Date对象
        //今天
        Date date1 = new Date();
        System.out.println(date1.toString());
        System.out.println(date1.toLocaleString());
        //昨天
        Date date2 = new Date(date1.getTime()-(60*60*24*1000));
        System.out.println(date2.toLocaleString());
        //2.方法   after   before
        boolean b1 = date1.after(date2);
        System.out.println(b1);     //true
        boolean b2 = date1.before(date2);
        System.out.println(b2);      //false
        //比较 相差多少  compareTo();
        System.out.println(date1.compareTo(date2));
        System.out.println(date2.compareTo(date1));
        System.out.println(date1.compareTo(date1));
        //equals
        System.out.println(date1.equals(date2));
    }
}

输出结果↓↓↓：
在这里插入图片描述

六、Calendar类

Calendar 提供了获取或设置各种日历字段的方法。

构造方法：
protected Calendar() ：由于修饰符是protected ，所以无法直接创建该对象。

其他方法：
在这里插入图片描述

import java.util.Calendar;

public class Demo1 {
    public static void main(String[] args) {
        //1.创建Calendar对象
        Calendar calendar = Calendar.getInstance();//受保护，不能new
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());  //毫秒
        //2.获取时间信息
        int year = calendar.get(Calendar.YEAR);   //年
        int mouth = calendar.get(Calendar.MONTH); //月
        int day = calendar.get(Calendar.DAY_OF_MONTH);   //日
        int hour = calendar.get(Calendar.HOUR_OF_DAY);   //HOUR 12小时（hour_of_day 24小时）
        int minute = calendar.get(Calendar.MINUTE);   //分钟
        int second = calendar.get(Calendar.SECOND);  //秒
        System.out.println(year + "年" + (mouth+1) + "月"+ day + "日" + hour + ":" + minute + ":" + second);
        //3.修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH,5);
        System.out.println(calendar2.getTime().toLocaleString());
        //4. add方法修改时间
        calendar2.add(Calendar.HOUR,1);  //加1小时
        System.out.println(calendar2.getTime().toLocaleString());
        calendar2.add(Calendar.HOUR,-2);  //减2小时
        System.out.println(calendar2.getTime().toLocaleString());
        //5.获取当前时间的最大/最小值
        int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max);
        System.out.println(min);
    }
}

输出结果↓↓↓
在这里插入图片描述

七、SimpleDateFormat类

SimpleDateFormat 是一个以与语言环境相关的方式来格式化和解析日期的具体类。

进行格式化（日期一> 文本）、解析（文本一>日期）。

常用的时间模式字母：
在这里插入图片描述

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

public class Demo1 {
    public static void main(String[] args) throws ParseException {
        //1.创建SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //2.创建Date
        Date date = new Date();
        //格式化date（把日期转为时间字符串）
        String str = sdf.format(date);  //format格式化
        System.out.println(str);
        //解析（把时间字符串转为日期）
        Date date1 = sdf.parse("2022/04/23");
        System.out.println(date1);
    }
}

八、System类

System 系统类，主要用于获取系统的属性数据和其他操作，构造方法是私有的，静态的。

在这里插入图片描述

public class Demo1 {
    public static void main(String[] args){
        //1.arraycopy,数组的复制
        int[] arr = {20,23,17,9,34};
        int[] dest = new int[5];
        System.arraycopy(arr,1,dest,0,4);
        //System.arraycopy(源数组，从哪个位置开始复制，目标数组，目标数组的位置，复制的长度);

        for (int i = 0; i < arr.length; i++) {
            System.out.println(dest[i]);
        }
        //2.currentTimeMillis    获取当前系统时间
        long start = System.currentTimeMillis();
        for (int i = 0; i < 999999999; i++) {
            for (int i1 = 99999; i1 > 0; i1--) {
                int result = i+i1;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("用时："+ (end-start)+"ms");

        new Student("A",12);
        new Student("B",2);
        //3.垃圾回收系统   System.gc
        System.gc();
        //4.退出JVM
        System.exit(0);   //已经退出，后续程序不会再执行
        System.out.println("程序结束！");
    }
}