[Java知识库]2021-08-03 Java学习基础第四天总结

Java第四天基础学习

1. Math
2. System
3. Object
4. Objects
5. BigDecimal
6. 包装类
7. Date
8. SimpleDateFormat
9. Calendar

Math

实现数学运算的工具类
常用方法：
1.int abs(int a ):绝对返回值
2.double ceil(doublr a):向上取整（天花板）
3.double floor(double a):向下取整（地板）
4.int round(float a):四舍五入
5.double pow(double a,double b);计算a的b次方法

package _01Math类;

/*
    目标：掌握Math类的基本使用

    Math类介绍：
        Math是数学工具类，包含执行基本数字运算的各种方法。

    Math类常用方法：
        public static int  abs(int a) : 返回绝对值
        public static double ceil(double a) : 向上取整（天花板）
        public static double floor(double a) : 向下取整（地板）
        public  static int round(float a) ：四舍五入
        public  static double pow(double a,double b) : 计算a的b次方法
 */
public class Demo1 {
    public static void main(String[] args) {
        //返回绝对值
        //public static int  abs(int a)
        int num = Math.abs(-2);
        System.out.println("num = " + num);
        System.out.println(  Math.abs(-3.14) );

        //向上取整（天花板）
        System.out.println( Math.ceil(3.004) ); //4.0
        System.out.println( Math.ceil(3.499) ); //4.0
        System.out.println( Math.ceil(3.999) ); //4.0

        //向下取整（地板）
        System.out.println(  Math.floor(3.14) );
        System.out.println(  Math.floor(3.5001) );
        System.out.println(  Math.floor(3.9999) );

        //四舍五入
        System.out.println(  Math.round(3.14) );
        System.out.println(  Math.round(3.499) );
        System.out.println(  Math.round(3.501) );
        System.out.println(  Math.round(3.999) );

        //public  static double pow(double a,double b) : 计算a的b次方 幂
        System.out.println( Math.pow(2,3) ); //8.0  2*2*2
        System.out.println( Math.pow(2,10) ); //2的10次方  1024.0

        int max = Math.max(2, 5);
        System.out.println("max = " + max);

    }
}

System

代表当前系统的类
常用方法：
1.static void exit(int status)强制退出虚拟机
2.static long currentTimeMillis();获取系统时间（毫秒值）
3.arraycopy(原数组，拷贝的开始索引，新数组，放到新数组的开始索引，拷贝个数)；拷贝数组

package _02System类;

/*
    目标：学习System类的常用方法

    System类介绍：
        System系统类，代表当前Java程序的运行平台。

?	常用方法：
        static void  exit(int status) 强制退出虚拟机
        static long  currentTimeMillis() :获取系统时间（毫秒值）
        static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 拷贝数组
 */
public class Demo1 {

    public static void main(String[] args) {
        //static void  exit(int status) 强制退出虚拟机
       /* System.out.println(1);
        System.exit(0); //退出JVM

        System.out.println(1);
        System.out.println(1);*/

        //static long  currentTimeMillis() :获取系统时间（毫秒值）
        //long time = System.currentTimeMillis();
        //System.out.println("time = " + time); //从1970年1月1日

        //计算某段代码的执行时间（帮助进行代码的优化）
        /*long start = System.currentTimeMillis();

        String s = "";
        for (int i = 0; i < 100000; i++) {
            s+=i;
        }

        long end = System.currentTimeMillis();

        System.out.println( end - start ); //2857 */


        long start = System.currentTimeMillis();

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 100000; i++) {
            sb.append(i);
        }
        String s = sb.toString();

        long end = System.currentTimeMillis();

        System.out.println( end - start ); //8

    }
}

package _02System类;

import java.util.Arrays;

public class Demo2 {
    public static void main(String[] args) {
        /*
        static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 拷贝数组

        arraycopy(原数组, 拷贝的开始索引, 新数组, 放到新数组的开始索引, 拷贝个数)
     */
        int[] arr = {1, 2, 3, 4, 5};
        int[] newArr = new int[arr.length];
        System.arraycopy(arr, 0, newArr, 0, arr.length);
        System.out.println(Arrays.toString(newArr));

        int[] arr2 = new int[10];
        //把arr的部分元素拷贝到arr2中，效果如下：[0, 0, 0, 2, 3, 4, 0, 0, 0, 0]
        System.arraycopy(arr,1,arr2,3,3);

        System.out.println(Arrays.toString(arr2));
    }
}

Object

所有java类的根类。任何类都默认或者直接继承Object
常用方法：
1.toString
得到的是对象的地址值，格式为"类全名@16进制地址值"。
一般会重写toString方法，以便打印对象中的具体数据
2.equals
默认使用==比较两个对象的地址值
如果想要比较对象的内容，需要重写该方法

package _03Object类;

/*
    目标：学习Object类的使用

    1.Object类特点

    2.Object类方法：
        public String toString()
            打印对象的地址值，输出对象名时，默认就是调用了toString方法
            如果想打印对象的成员变量的值，需要重写toString方法

        public boolean equals(Object obj)
            比较两个对象是否相等，默认比较使用==比较两个对象地址值。
            如果想比较对象的内容，需要重写该方法
 */
public class Demo1 {
    public static void main(String[] args) {

        Student s = new Student("张三",20);
        System.out.println(s); //默认打印地址 _03Object类.Student@3f3afe78
        System.out.println(s.toString()); //默认打印地址 _03Object类.Student@3f3afe78

        //ArrayList<Integer> list = new ArrayList<>();
        //list.add(1);
        //list.add(2);
        //System.out.println(list); //打印集合对象，是打印元素，所以说明ArrayList中重写了toString方法
    }
}

package _03Object类;

public class Demo2 {
    public static void main(String[] args) {

        Student s1 = new Student("柳岩" ,25);
        Student s2 = new Student("柳岩" ,25);

        System.out.println( s1.equals(s2) ); //默认比较地址，false

        //比较对象的属性值（重写类的equals方法）
    }

}
package _03Object类;

import java.util.Objects;

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

    //如果想打印对象的成员变量的值，需要重写toString方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //重写的equals方法，作用比较对象的姓名和年龄
    @Override
    public boolean equals(Object o) {
        //如果两个对象相同，返回true
        if (this == o) {
            return true;
        }

        //this.getClass() 获取对象的类型
        //如果参数为null  或者 比较的两个对象不是同一个类型，返回false
        if (o == null || this.getClass() != o.getClass()) {
            return false;
        }

        //强转
        Student student = (Student) o;

        //比较两个对象的年龄和姓名，如果都相同，返回true
        return this.age == student.age &&
                //this.name.equals(student.name); //如果this.name为null，会有空指针异常
               Objects.equals(this.name, student.name); //避免空指针异常
    }

}

Objects

equals(对象1，对象2)：
调用对象自身的equals方法，比较两个对象是否相同
好处：避免空指针异常

package _04Objects类;

import java.util.Objects;

/*
    目标：了解Objects类的基本使用

    1.Objects类介绍:
        Objects类是JDK7新增的工具类，方便对对象进行操作。

    2.常用方法：
        static boolean equals(Object a, Object b) ：避免空指针异常
        static boolean isNull(Object obj)：判断对象是否为空
 */
public class Demo1 {
    public static void main(String[] args) {

        String s1 = null;
        String s2 = null;

        System.out.println(Objects.equals(s1, s2));
        //底层还是调用参数自身的equals方法比较，但是比较前会进行非空的判断，
        //可以避免空指针异常

        if(s1!=null) {
            System.out.println(s1.equals(s2));
        }
    }
}

BigDecimal

创建对象：
构造方法创建对象：BigDecimal(String val)
静态方法创建对象：BigDecimal.valueOf（数据值）
常用方法：
相加：BigDecimal add(BigDecimal b)
相减：BigDecimal subtract(BigDecimal b)
相乘：BigDecimal multiply(BigDecimal b)
相除（能整除）:BigDecimal divide(BigDecimal b)
相除（不能整除）:public BigDecimal divide(另一个BigDecimal对象，保留位数，舍入模式)
舍入模式通常使用RoundingMode.HALF_UP，表示四舍五入

package _05BigDecimal类;


import java.math.BigDecimal;

/*
    目标：掌握BigDecimal类的加减乘除方法

    1.创建对象的方式：
            BigDecimal(String val) （推荐）
            BigDecimal(double val) 有精度问题，不要使用
            valueOf()的静态方法创建对象（推荐）
 */
public class Demo1 {
    public static void main(String[] args) {

        //计算机中，浮点数的存储无法保证所有数字都能精确存储
        //System.out.println(0.1 + 0.2); //0.30000000000000004

        //构造方法参数是字符串（推荐方式）
        BigDecimal b1 = new BigDecimal("0.1"); //相当于double  b1 = 0.1;
        System.out.println( b1 ); //0.1

        /*double d = 0.1;
        BigDecimal b2 = new BigDecimal(d); //0.1000000000000000055511151231257827021181583404541015625
        System.out.println(b2);*/

        double d = 0.1;
        BigDecimal b2 = new BigDecimal(d+"");
        System.out.println( b2 ); //0.1

        //valueOf()的静态方法
        BigDecimal b3 = BigDecimal.valueOf(d);
        System.out.println(b3);

    }
}

package _05BigDecimal类;

import java.math.BigDecimal;
import java.math.RoundingMode;

/*

    2.常用方法：
        相加：BigDecimal add(BigDecimal b)
        相减：BigDecimal subtract(BigDecimal b)
        相乘：BigDecimal multiply(BigDecimal b)
        相除：BigDecimal divide(BigDecimal b)
 */
public class Demo2 {

    public static void main(String[] args) {

        BigDecimal b1 = new BigDecimal("10");
        BigDecimal b2 = new BigDecimal("6");

        //相加
        BigDecimal result = b1.add(b2);// b1+b2
        System.out.println(result);

        //相减
        System.out.println(b1.subtract(b2)); //b1-b2
        System.out.println(b2.subtract(b1)); //b2-b1

        //相乘
        System.out.println(b1.multiply(b2)); //b1*b2

        //相除，必须是能整除，否则这个方法会报错
        //System.out.println(b1.divide(b2)); //b1/b2

        //如果不能整除，需要使用重载的方法
        //divide(除数，保留的小数位，进行舍入的模式);
        //RoundingMode.HALF_UP是四舍五入
        System.out.println(b1.divide(b2, 3, RoundingMode.HALF_UP));//四舍五入保留3位小数

    }
}

包装类

基本类型的包装类：
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
基本类型转字符串：
利用包装类提供的toString方法
字符串转基本类型：
除了Character之外，其他包装类都有parseXxx(String s)的静态方法可以将字符串转为基本类型
Integer.parseInt(“5”);
Double.parseDouble(“3.14”);

package _06包装类的应用_重点;

/*
    目标：学习包装类的应用

    八种基本类型对应的包装类：
        byte    Byte
        short   Short
        int     Integer
        long    Long
        float   Float
        double  Double
        char    Character
        boolean Boolean

    包装类的作用：
        Java的基本类型只能用于运算，而包装类能以面向对象的方式操作数据。
 */
public class Demo1 {
    public static void main(String[] args) {

    }
}

package _06包装类的应用_重点;

/*
    包装类的应用
        1.包装类作为泛型。
        2.基本类型转字符串。
        3.字符串转基本类型。（重点）
 */
public class Demo2 {
    public static void main(String[] args) {
        //2.基本类型转字符串。
        int a = 10;
        String s = Integer.toString(a);

        double d = 3.14;
        String s1 = Double.toString(d);

        //将基本类型和字符串拼接
        String s2 = a + "";

        //3.字符串转基本类型。（重点）
        String number = "10";
        //int num = number;
        int num = Integer.parseInt(number);
        System.out.println(num-5);

        double v = Double.parseDouble("5.5");
        System.out.println(v);

        boolean b = Boolean.parseBoolean("true");

        //字符串转字符
        String str = "A";
        char ch = str.charAt(0);


        //使用包装类可以访问一些封装好的数据，比如获取类型的最大和最小值
        System.out.println( Byte.MAX_VALUE );
        System.out.println( Byte.MIN_VALUE );

        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);

        //定义变量
        int i = 10;
        Integer obj = new Integer(10);

    }
}

自动

自动装箱，自动拆箱

package _07自动装箱和拆箱_了解;

/*
    目标：了解自动装箱和拆箱

    1.装箱和拆箱
        装箱：基本数据类型转换为包装类的过程。
        拆箱：包装类转换为基本数据类型的过程。

    2.自动装箱和拆箱
        自动完成基本类型和包装类的转换


 */
public class Demo1 {

    public static void main(String[] args) {

        int i = 10;
        Integer obj = i; //自动装箱，自动完成将基本类型转为引用类型  Integer.valueOf(i);

        int ii = obj;   //自动拆箱，完成将引用类型转为基本类型   obj.intValue();


        /*
        int i = 10;
		Integer obj = Integer.valueOf(i); //手动装箱
		int ii = obj.intValue();
         */

        //Double obj2 = Double.valueOf(3.4); //数字转为对象  装箱
        //double d = obj2.doubleValue(); //对象变为基本类型  拆箱

        //底层自动完成转换
        Double obj2 = 3.4;
        double d = obj2;

    }
}

package _07自动装箱和拆箱_了解;

public class Student {

    //考试成绩，默认值（null比较合理）
    double score1; //0.0
    Double score2; //null


}

class Test{
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println(s.score1);
        System.out.println(s.score2);
    }
}

Date

获取当前系统时间：
Date d = new Date();
返回当前时间的毫秒值：
getTime();

package _08Date类;


import java.util.Date;

/*
    目标：掌握Date类的基本使用

    1.Date类的作用：
        java.util.Date 代表一个精确的时间，精确到毫秒。

    2.构造方法
        Date()
        Date(long date) : 使用毫秒数创建Date对象（在1970年1月1日 00:00:00 基础上加上指定毫秒数）

    3.常用方法
        long getTime() ：获取当前时间的毫秒值
        void setTime(long  time) ：设置时间（在1970年1月1日 00:00:00基础上增加设置的毫秒值）
 */
public class Demo1 {
    public static void main(String[] args) {

        //创建Date对象
        Date d = new Date();
        System.out.println(d); //Tue Aug 03 15:06:52 CST 2021

        //使用毫秒数创建Date对象（在1970年1月1日 00:00:00 基础上加上指定毫秒数）
        //Date d2 = new Date(1000L*60);
        //System.out.println(d2); //Thu Jan 01 08:00:01 CST 1970  中国在东8区，在原来基础上加上8小时

        //long getTime() ：获取当前时间的毫秒值
        long time = d.getTime(); //System.currentTimeMillis(); 效果是一样的
        System.out.println(time);

        //void setTime(long  time) ：设置时间（在1970年1月1日 00:00:00基础上增加设置的毫秒值）
        //d.setTime(1000L);
        //System.out.println(d);
    }
}

SimpleDateFormat

日期格式化（Date转String）
formar(日期对象)
解析日期（String转Date）:
parse(字符串日期)

package _09日期格式化处理;

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

/*
    目标：能够使用SimpleDateFormat类处理日期格式。

    1.构造方法
        SimpleDateFormat()   使用默认日期模板创建对象。
        SimpleDateFormat(String pattern)  使用指定日期模板创建对象。

    2.日期格式化
        public final String format(Date date)

    3.文本解析
        public Date parse(String source)
 */
public class Demo1 {
    public static void main(String[] args)  {

        //SimpleDateFormat()   使用默认日期模板创建对象。
        SimpleDateFormat sf = new SimpleDateFormat();

        //日期格式化
        //public final String format(Date date)
        Date d = new Date();
        System.out.println(d); //Tue Aug 03 15:39:46 CST 2021

        String s = sf.format(d);
        System.out.println(s); //2021/8/3 下午3:39


    }
}

package _09日期格式化处理;

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

/*
    目标：能够使用SimpleDateFormat类处理日期格式。

    1.构造方法
        SimpleDateFormat()   使用默认日期模板创建对象。
        SimpleDateFormat(String pattern)  使用指定日期模板创建对象。

    2.日期格式化
        public final String format(Date date)

    3.文本解析
        public Date parse(String source)
 */
public class Demo2 {
    public static void main(String[] args) throws ParseException {
        //使用指定日期模板创建对象。
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");
        //SimpleDateFormat sf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        //SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        //SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日 E a HH时mm分ss秒");
        //SimpleDateFormat sf = new SimpleDateFormat("HH:mm E yyyy/MM/dd");

        //format() :时间格式化
        Date d = new Date();
        String s = sf.format(d);
        System.out.println(s); //2021-08-03 15:46:04

        //parse() :解析时间
        String sdate = "1949年10月1日";
        SimpleDateFormat sf2 = new SimpleDateFormat("yyyy年MM月dd日"); //指定和要转换的字符串一样的模板

        Date dd = sf2.parse(sdate);
        System.out.println(dd);
    }
}

package _10日期转换练习_秒杀活动;

import java.text.ParseException;
import java.text.SimpleDateFormat;

/*
    目标：使用日期转换完成需求。

需求：
    秒杀开始时间: 2020年11月11日 00:00:00
    秒杀结束时间: 2020年11月11日 00:10:00

    小贾下单并付款的时间为：
        2020年11月11日 0:03:47
    小皮单并付款的时间为：
        2020年11月11日 0:10:11

    用代码说明这两位同学有没有参加上秒杀活动?

思路：
     将字符串时间转为 Date 类型：使用SimpleDateFormat的 parse方法
     通过Date对象的getTime方法获取毫秒值
     判断付款时间是否在秒杀时间内
 */
public class Demo1 {
    public static void main(String[] args) throws ParseException {
        //创建转换模板
        SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");

        //转换字符串为Date对象
        //秒杀开始时间的毫秒
        long start = sf.parse("2020年11月11日 00:00:00").getTime();
        //秒杀结束时间的毫秒
        long end = sf.parse("2020年11月11日 00:10:00").getTime();

        //小贾的下单时间的毫秒
        long xiaoJia = sf.parse("2020年11月11日 0:03:47").getTime();

        //小皮的下单时间的毫秒
        long xiaoPi = sf.parse("2020年11月11日 0:10:11").getTime();

        //判断付款时间是否在秒杀时间内
        if(xiaoJia>=start && xiaoJia<=end){
            System.out.println("小贾秒杀成功");
        }else {
            System.out.println("小贾秒杀失败");
        }

        if(xiaoPi>=start && xiaoPi<=end){
            System.out.println("小皮秒杀成功");
        }else {
            System.out.println("小皮秒杀失败");
        }


    }
}

Calendar

创建对象：
Calendar.getInstance()
获取指定字段：
get(字段名)
设置指定字段的值：
set(字段名，字段值)
增加或减去字段的值:
add(字段名，字段值)（增加）
add(字段名，-字段值)（减去）
常见字段含义：
年：YEAR
月：MONTH（0-11表示1-12月）
日：DATE或者DAY_OF_MONTH
时：HOUR_OF_DAY(24小时)
分：MINUTE
秒：SECOND
周几：DAY_OF_WEEK(1-7表示周日-周六)

package _11Calendar类;


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

/*
    目标：学习Calendar类的常用功能

    1.创建对象:
        Calendar.getInstance();

    2.常用方法：
        get(int field) 获取指定日历字段的值
        getTime()  将Calendar转为Date对象
        getTimeInMillies() 返回该日历时间的毫秒值。

        set(int field,  int value) 设置某个日历字段的值
        set?(int year, int month, int date) 设置年,月,日

        add(int field,  int amount) 添加或减去某个日历字段的值。

    3.常用日历字段含义
        年：YEAR
        月：MONTH （0~11表示1~12月）
        日：DATE 或者 DAY_OF_MONTH
        时：HOUR_OF_DAY（24小时）
        分：MINUTE
        秒：SECOND
        周几：DAY_OF_WEEK（1~7表示周日~周六）
 */
public class Demo1 {
    public static void main(String[] args) {
        //Calendar.getInstance();
        Calendar c = Calendar.getInstance(); //获取当前系统的日历对象

        //get(int field) 获取指定日历字段的值
        int year = c.get(Calendar.YEAR);
        System.out.println("year = " + year); //年

        int month = c.get(Calendar.MONTH) + 1; //月（0~11表示1~12月）
        System.out.println("month = " + month);

        int date = c.get(Calendar.DATE); //日
        System.out.println("date = " + date);

        //c.get(Calendar.HOUR);//12小时制的时间
        int hour = c.get(Calendar.HOUR_OF_DAY);//24小时制的时间
        System.out.println("hour = " + hour);

        int minute = c.get(Calendar.MINUTE);
        System.out.println("minute = " + minute);

        int second = c.get(Calendar.SECOND);
        System.out.println("second = " + second);

        //周几：DAY_OF_WEEK（1~7表示周日~周六）
        int week = c.get(Calendar.DAY_OF_WEEK)-1;
        String[] weeks = {"星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
        System.out.println(weeks[week]);

        //getTime()  将Calendar转为Date对象
        Date d = c.getTime();
        System.out.println(d);

        //getTimeInMillies() 返回该日历时间的毫秒值。
        long mills = c.getTimeInMillis();
        System.out.println(mills);

        //获取当前系统毫秒值（3个方法）
        //System.currentTimeMillis();
        //new Date().getTime();
        //Calendar.getInstance().getTimeInMillis();

    }
}

package _11Calendar类;

import java.util.Calendar;

/*
        set(int field,  int value) 设置某个日历字段的值
        set?(int year, int month, int date) 设置年,月,日
        add(int field,  int amount) 添加或减去某个日历字段的值。
 */
public class Demo2 {
    public static void main(String[] args) {

        //set(字段名,  字段值) 设置某个日历字段的值
        //北京奥运会2008年8月8日 当天是星期几
        Calendar c = Calendar.getInstance();
        c.set(2008, 7,8);

        int week = c.get(Calendar.DAY_OF_WEEK)-1;
        String[] weeks = {"星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
        System.out.println(weeks[week]); //星期五

        //add(字段名,  字段值) 添加或减去某个日历字段的值。
        //字段值正数，往后加，负数，往前减
        //100天前是几月几号
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DATE,-100);

        int month = cal.get(Calendar.MONTH) + 1;
        int date = cal.get(Calendar.DATE);
        System.out.println(month+"月"+date+"日");


    }
}

综合练习

package _12日期综合练习_年龄天数计算;

import java.util.Calendar;

/*
    计算从出生到现在，总共过了多少天？

        将日期设置到出生当天，转为毫秒值  a
        获取当前时间的毫秒值 b
        b -a 总共到目前活了多少毫秒，转为天数
 */
public class Demo {

    public static void main(String[] args) {

        //将日期设置到出生当天
        Calendar c = Calendar.getInstance();
        //假设出生日期是1995/9/9
        c.set(1995, 8, 9);
        long birthday = c.getTimeInMillis();

        //获取当前时间的毫秒值
        long now = Calendar.getInstance().getTimeInMillis();

        //计算总共到目前活了多少毫秒，转为天数
        long days = (now - birthday) / 1000 / 60 / 60 / 24;
        System.out.println(days); //9460

    }
}

总结！！！！！

package _13总结;

/*
能够说出Object类的特点
    Object是java的根类，是所有类的父类

能够重写Object类的toString方法
    toString：默认打印对象的地址值，可以重写方法，打印对象的属性值。

能够重写Object类的equals方法
    equals：默认比较两个对象的地址值，可以重写方法，比较两个对象的属性值。
            String类的equals方法，就是重写过的方法，比较字符串的内容。

能够使用System类获取当前系统毫秒值
    System.currentTimeMillis();

能够说出BigDecimal可以解决的问题
    解决浮点数运算的精度问题
    创建对象  new BigDecimal(字符串数字)  或者  BigDecimal.valueOf(基本类型数字)

能够说出自动装箱、自动拆箱的概念
    自动装箱：基本类型转为引用类型
    自动拆箱：引用类型转为基本类型

能够将基本类型转换为对应的字符串
    int a = 10;
    String s = a+""; //方式1
    String s = Integer.toString(a); //方式2

能够将字符串转换为对应的基本类型
    String s = "10";
    int i = Integer.parseInt(s);

能够使用日期类输出当前日期
    Date d = new Date();

能够使用将日期格式化为字符串的方法
    SimpleDateFormat  sf = new SimpleDateFormat("日期模板");
    Date d = new Date();
    String s = sf.format(d);

能够使用将字符串转换成日期的方法
    SimpleDateFormat  sf = new SimpleDateFormat("日期模板");
    Date d = sf.parse("字符串日期");
 */
public class Demo {
    public static void main(String[] args) {

    }
}

思维导图：