Java入门-10、Object类认识与使用、Date类以及包装类

本文链接：https://blog.youkuaiyun.com/NeverFG/article/details/99301259

Object类

1、认识与了解Object类（顶级父类）

java.lang.Object 类是Java语言中的根类，即所有类的父类。
它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。
如果一个类没有特别指定父类，那么默认则继承自Object类

2、根据JDK源代码及Object类的API文档

比较常见的两种方法：

public String toString();返回对象字符串表示
public boolean equals(Object obj);判断该对象与其他对象内容是否相同

toString方法：

如果一个类没有重写Object类中的toString方法，则调用默认的Object类的toString方法，返回一个地址值

如果重写了toString方法，则直接调用重写后的toString方法


public class Student {
private String name;
private int age;
@Override
//重写后的
public String toString() {
return "Student{" + "name='" + name + '\'' + ", age=" + age + '}';
}

}

equals方法：

不重写Object类中的equals方法，则默认调用Object类中的equals方法，比较地址值

重写Object类的equals方法，则直接调用的是重写后的equals方法

import java.util.Objects;
public class Student {
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;
// 转换为当前类型  向下转型
Student stu = (Student) o;
// 要求基本类型相等，并且将引用类型交给java.util.Objects类的equals静态方法取用结果
return age == stu.age && Objects.equals(name, stu.name);
}
}

Date类

java.util.Date

类Date表示特定的瞬间，精确到毫秒

作用：表示时间测试代码的运行效率

获取毫秒 : System.currentTimeMillis()

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

        long start = System.currentTimeMillis();
        for(int i=0;i<1000;i++){
            System.out.println("HelloWorld!");
        }

        long end =System.currentTimeMillis();

        long time =end -start;
        System.out.println("耗时"+time+"毫秒");
    }
}

import java.util.Date;

public class Test {
    public static void main(String[] args) {
        //Date的使用  获取当前时间
        Date date =new Date();
        System.out.println(date);

        //根据毫秒值获取时间
        Date date1 = new Date(10000000L);
        System.out.println(date1);

        //将日期对象转换成对应的毫秒值
        long time = date.getTime();
        System.out.println(time);
        Date date2 = new Date(time);
        System.out.println(date2);

        method();
    }

    private static void method() {
        Date date =new Date();
        //把方法参数给定的毫秒值设置给日期对象
        date.setTime(123456789L);
        System.out.println(date);

    }
}

Dateformat类（日期格式化）

java.text.DateFormat

public class Test {
    public static void main(String[] args) throws ParseException {

        //将当前日期转换为字符串
        DateFormat df = new SimpleDateFormat("yyyy‐MM‐dd"); 
        String s = df.format(new Date());
        System.out.println(s);
       
        //将字符串转换为日期对象
        DateFormat format = new SimpleDateFormat("yyyy/MM/dd");
        Date d = format.parse("1949/10/01");
        System.out.println(d);
    }
}

Calendar类（详情参照java-api文档）

Calendar 为抽象类，不能直接创建对象，而是通过静态方法创建，返回子类对象

Calendar 静态方法

public static Calendar getInstance() ：获得一个日历

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 对象。

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

public class Test {
    public static void main(String[] args) throws ParseException {

        // 创建Calendar对象
        Calendar cal = Calendar.getInstance();
        System.out.println(cal);//显示日历字段
        // 获取年
        int year = cal.get(Calendar.YEAR);
        //设置年份为2020年
        cal.set(Calendar.YEAR, 2030); //将年份修改为2000
        cal.add(Calendar.YEAR, -30);
        //将日历对象转换为日期对象
        Date d = cal.getTime();
        System.out.println(d);
    }
}

Math类（详情参照java-api文档）

/*
    Math:数学类
         特点:所有的方法都是静态的
*/


public class Test {
    public static void main(String[] args){
//        public static int   max(int a,int b)返回两个int值中的较大值
        System.out.println(Math.max(10,20));
//        public   static int min(int a,int b)返回两个int值中的较小值
        System.out.println(Math.min(10,20));
//        public static int   abs(int a)返回参数的绝对值
        System.out.println(Math.abs(-20));
//        public static double ceil(double a)返回大于或等于参数的最小double值，等于一个整数
        System.out.println(Math.ceil(13.14));
//        public static double floor(double a)返回小于或等于参数的最大double值，等于一个整数
        System.out.println(Math.floor(3.14));
//        public   static int round(float a)按照四舍五入返回最接近参数的int
        System.out.println(Math.round(4.5));
    }
}

包装类：

包装类就是基本数据类型的引用类型

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

装箱与拆箱

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

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

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

public class Test {
    public static void main(String[] args) {
        //装箱：
        Integer integer = new Integer(4);//将基本数据类型装箱，转成包装类对象
        int num = integer.intValue();//拆箱，包装类转成基本数据类型


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

String 转换成基本类型

常见方法：（详情参照java-api文档）

public static int parseInt(String s) ：将字符串参数转换为对应的 int 基本类型。

public static double parseDouble(String s) ：将字符串参数转换为对应的 double 基本类型。

public class Test {
    public static void main(String[] args) {
        String s ="100";
        Integer i = Integer.parseInt(s);
        System.out.println(i);

        String s1="10.01";
        Double d =Double.parseDouble(s1);
        System.out.println(d);
    }
}