API_01

1.Object类, 所有类的父类

方法: 11个

Class getClass():

通过对象的该方法,可以获得对象对应的类的字节码对象
“haha”.getClass() -> String的字节码对象
“hi”.getClass() -> String的字节码对象

Class c1 = "haha".getClass();
        Class c2 = "hi".getClass();
        // 同种类型的对象, 对应的字节码对象都是同一个
        System.out.println(c1 == c2);

Object clone():

克隆, 复制
复制一份全新的, 属性内容一致的对象, 深克隆
复制的是引用 -> 浅克隆
调用方法的对象, 需要类实现Cloneable接口

public class CloneDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        ZiClone zi = new ZiClone();
        zi.setName("lucy");
        ZiClone clone = (ZiClone)zi.clone();

        ZiClone clone2 = zi; // 引用的赋值 -> 浅克隆

        // 默认的clone方法, 是复制一份全新的, 属性内容一致的对象 -> 深克隆
        System.out.println(clone.getName());
        System.out.println(zi == clone);
    }
}

public class ZiClone implements Cloneable {
    private String name;

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

    public String getName() {
        return name;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

wait() * 3

notify() / notifyAll() – 以上5个和线程有关

void finalize()

GC: 垃圾回收机制, 定时清理内存中
栈:方法结束, 方法栈直接释放
堆:无效对象, 等待gc回收
手动调用: System.gc()

public class FinalizeDemo {
    public static void main(String[] args) {
        ZiFinalize zi = new ZiFinalize();
        zi = null;

        System.gc(); // 手动调用垃圾回收方法
        // new ZiFinalize()对象被回收, 自动调用finalize方法
    }
}

public class ZiFinalize {
    // JDK9开始 过时了, 不推荐使用
    protected void finalize() throws Throwable {
        System.out.println("我要走了!");
    }
}

String toString(): 将对象变成字符串格式

直接打印对象时, 自动就会调用对象的toString方法
System.out.println(zi.toString()); // 简化写法
System.out.println(zi); // 简化写法
Object中默认toString的实现方式:
getClass().getName() + “@” + Integer.toHexString(hashCode());
自定义打印格式: 重写toString方法

public class ToStringDemo {
    public static void main(String[] args) {
        ZiToString zi = new ZiToString("张三", 28);
        // com.zzxx.api.Object.ZiToString@5fe5c6f
        System.out.println(zi);
        System.out.println(zi + "");
        System.out.println(zi.toString());

        // 想要打印对象时, 显示对象的属性内容 -- 重写toString方法
        System.out.println(zi);


        String str = "haha";
        // java.lang.String@abdcef
        System.out.println(str);

        System.out.println(str.hashCode());
    }
}

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

    public ZiToString() {
    }

    /*public String toString() {
        return name + "," + age;
    }*/

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

    public ZiToString(String name, int age) {
        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;
    }
}

public native int hashCode(); – 获得的是地址, 哈希码

boolean equals(Object o)
Object中默认equals的实现方式:
return (this == obj); – 比较对象的地址
当我们想要比较两个相同类型对象的属性值时, 需要重写equals
Objects.equals(name, ziEquals.name);

public class EqualsDemo {
    public static void main(String[] args) {
        ZiEquals zi1 = new ZiEquals("张三", 18);
        ZiEquals zi2 = new ZiEquals("张三", 18);

        boolean b = zi1.equals(zi2);
        System.out.println(b);

        /**
         * 1.先判断空值
         * 2.再调用对象的equals方法比较 zi1.equals(zi2)
         */
        boolean b2 = Objects.equals(zi1, zi2);
        System.out.println(b2);
    }
}

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

    public ZiEquals(String name, int age) {
        this.name = name;
        this.age = age;
    }
    /*public boolean equals(Object obj) {
        // this-ZiEquals 和 obj-Object
        // 1.this == obj, 一定相等
        if (this == obj) {
            return true;
        }
        // 2.类型不一致,一定是不等
        if (!(obj instanceof ZiEquals)) {
            return false;
        }
        // 3.类型一致,不是同一个对象,才要比较属性内容
        ZiEquals zi = (ZiEquals) obj;
        if(this.name == zi.name)
        if(this.name != null)  this.name.equals(zi.name)
        if(this.name == null && zi.name) zi.name.equals(this.name)
        return zi.age == this.age && this.name.equals(zi.name);
    }*/

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ZiEquals ziEquals = (ZiEquals) o;
        return age == ziEquals.age &&
                Objects.equals(name, ziEquals.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, 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;
    }
}

2.java.util.Date: 日期, 时间

构造方法:

// 空参构造方法 -> 当前系统时间
        Date date = new Date();
        // Tue Jul 21 11:48:57 CST 2020
        System.out.println(date);

        // 参数是long类型的构造方法
        Date date1 = new Date(0l + 30l*24*60*60*1000);

常用API:

void setTime(long time) -> 将date设置为对应毫秒值表示的时间
long getTime() -> 获得date对应的毫秒值
date1.after(date)
date1.before(date)

   Date date = new Date();
        // 将时间从date类型, 转换成了long类型所表示的毫秒值
        long time = date.getTime();
        System.currentTimeMillis();
        System.out.println("time: " + time);

        // 一个月以后的date时间
        time += 30l*24*60*60*1000;
        date.setTime(time);
        System.out.println(date);

        Date date1 = new Date(0l);
        // date1 是否在 date 的后面
        boolean b = date1.after(date);
        System.out.println(b);
        // date1 是否在 date 的前面
        boolean b2 = date1.before(date);
        System.out.println(b2);

时间计算: 计算long值

需求例如:入职时间已知, 入职十周年当月的第三周的周五

 // 1.获得万年历对象 2020-7-21
        Calendar cal = Calendar.getInstance();
        System.out.println(cal);
        // 入职10周年, 当月的第三周的周五
        cal.add(Calendar.YEAR, 10);
        cal.set(Calendar.WEEK_OF_MONTH, 3);
        cal.set(Calendar.DAY_OF_WEEK, Calendar.FRIDAY);

        // 2.将 Calendar 转换成 Date 类型, 再来打印
        Date date = cal.getTime();
        System.out.println(date);

商品过期日前面2周的周三是促销日

// 1.获得万年历对象 2020-7-21
        Calendar cal = Calendar.getInstance();
        System.out.println(cal);

        // 2) 保质期7天, 求当天是几号
//        cal.add(Calendar.DATE, 7);
//        System.out.println(cal.get(Calendar.DAY_OF_MONTH));
        // 当加的内容结果跨月\年\星期, 自动进行推算
        // 保质期48天, 求当天是几号  2020-9-7
        cal.add(Calendar.DATE, 48);
        // 到期日往前推两周
        cal.add(Calendar.WEEK_OF_MONTH, -2);
        // 要周四
        cal.set(Calendar.DAY_OF_WEEK, Calendar.THURSDAY);

单纯使用long计算,不可能完成
万年历 java.util.Calendar -> 复杂的时间推算
初始化: static Calendar getInstance();
常用API:
int get(分量字段) -> 获得字段对应的值
void set(分量字段, 值)
void add(分量字段, 值) -> 向前计算, 加负数

// 1.获得万年历对象
        Calendar cal = Calendar.getInstance();
        System.out.println(cal);

        // 2.get set add
        // 1). 获得cal对应的月份, 月份从0开始
        int month = cal.get(Calendar.MONTH);
        System.out.println("month: " + month); // 6
        // 2). 获得cal对应的年份
        int year = cal.get(Calendar.YEAR);
        System.out.println("year: " + year); // 2020
        // DATE  DAY_OF_MONTH
        // HOUR MINUTE SECOND DAY_OF_WEEK
        // HOUR_OF_DAY

        // 3) 今天时间是:2020-7-21 ->设置为2020-8-15
        cal.set(Calendar.MONTH, Calendar.AUGUST);
        cal.set(Calendar.DAY_OF_MONTH, 15);
        System.out.println(cal);

时间日历日期的转换：

 // 1.Date -> long
        Date date = new Date();
        long time = date.getTime();

        // 2.long -> Date
        date.setTime(time);
        // 如果原先没有Date对象, 可以通过long创建一个新的Date对象
        Date date2 = new Date(time);
        // --------------------------
        // 3.Calendar -> Date
        Calendar cal = Calendar.getInstance();
        Date date3 = cal.getTime();

        // 4.Date -> Calendar
        Date date4 = new Date(0);
        cal.setTime(date4);
        // --------------------
        // 5.Calendar -> long (了解)
        Calendar cal1 = Calendar.getInstance();
        long time2 = cal1.getTimeInMillis();

        // 6.long -> Calendar (了解)
        cal1.setTimeInMillis(time2 + 1000);

1.long: 简单时间计算, 7天之内
运行效率计算
2.Date: 展示时间
2020-07-21 16:47:55
2020/07/21 16:47:55
2020年07月21日 16:47:55
3.Calendar: 复杂计算
时间的展示: Date
自定义格式 java.text.DateFormat 子类 SimpleDateFormat
将日期以一定格式输出：

 // 为了显示时间 Date -> String
        Date date = new Date();
        System.out.println(date);

        // 构造SimpleDateFormat对象, 需要传参 - 格式
        // 2020-07-21  16:47:55
        // yyyy-MM-dd HH:mm:ss E
        SimpleDateFormat sf = new
                SimpleDateFormat("yyyy-MM-dd HH:mm:ss E");
        String str = sf.format(date);
        System.out.println(str);

        // ------------------------
        // 自行输入日期(String) -> Date  19980228
        String s = "19980228";
        SimpleDateFormat sf1 = new
                SimpleDateFormat("yyyyMMdd");
        Date date1 = sf1.parse(s);
        System.out.println(sf.format(date1));