2-4-apiobject

import com.itheima.pojo.Student; 
@Override
public boolean equals(Object o) {
    //调用方法的对象和参数对象是同一个对象,直接返回true
    if (this == o) return true;
    /*
        o == null: 参数是null,直接返回false
        ||: 或者
        getClass() != o.getClass(): 调用方法的对象和参数对象不是同一个类的对象,直接返回false
        等价于: !(o instanceof Student) 判断o指向的不是Student类的对象
     */
    //if (o == null || !(o instanceof Student)) return false;
    if (o == null || getClass() != o.getClass()) return false;
    //把参数对象o强制类型转换成Student对象
    Student student = (Student) o;
    /*
        age == student.age: 调用方法的对象和参数对象的age属性相同
        &&:并且
        Objects.equals(name, student.name): 使用工具类调用静态方法equals比较调用方法的对象和参数对象的name属性相同

        age相同 并且 name也相同,才返回true,否写返回false
     */
    return age == student.age && Objects.equals(name, student.name);
} 
/*
    1.java.lang.Object类的介绍:
        是整个类的体系结构中的最顶层父类,是所有类的最终父类,它里面定义的方法,其它类都有.
        类Object是类层次结构的根类。每个类都使用Object作为超类。所有对象（包括数组）都实现这个类的方法。
    2.常用方法:
        (1)public String toString(): 返回调用方法的对象的字符串表示形式
            字符串形式： 理解位返回对象的地址值,类的全名称 + @ + 16进制的int数字
            内部源代码分析:
            public String toString() {
                return getClass().getName() + "@"
                    + Integer.toHexString(hashCode());
            }
            getClass().getName(): 获取类的全名称
            Integer.toHexString(hashCode()): 把对象的哈希值转换成16进制的int数字
        (2)重写toString方法
            目的: 返回对象的内容,而不是地址值
            快捷键: alt + insert --> toString --> 选择成员变量 --> ok
    注意:
        直接输出引用变量,输出语句(方法)内部会使用引用变量调用toString方法,
        把引用变量(对象)转换成字符串再做输出
 */
public class Demo01ToString {
    public static void main(String[] args) {

        //创建Student类的对象
        Student stu = new Student("张三", 18);

        //调用toString方法
        /*
            Student类没有覆盖重写Object类的toString方法
            结果是内存地址值: com.itheima.pojo.Student@1540e19d
            Student类覆盖重写Object类的toString方法
            结果: Student{name='张三', age=18}
         */
        String s1 = stu.toString();
        System.out.println(s1);
        System.out.println(stu.toString());
        System.out.println(stu);
    }
}  
/*
    1.java.lang.Object类的介绍:
        是整个类的体系结构中的最顶层父类,是所有类的最终父类,它里面定义的方法,其它类都有.
        类Object是类层次结构的根类。每个类都使用Object作为超类。所有对象（包括数组）都实现这个类的方法。
    2.常用方法:
        (1)public boolean equals(Object obj): 比较调用方法的对象和方法参数对象是否相等
            true: 说明相等
            false: 说明不相等
            默认比较对象的地址值,然而只要new对象的地址值就是不相同
            内部源代码分析:
            public boolean equals(Object obj) {
                return (this == obj);
            }
            this代表: 调用方法的对象
            obj代表: 调用方法时传递的参数对象
            ==: 在比较两个对象的内存地址值是否相同
        (2)重写equals方法:
            目的:比较对象的内容,而不是地址值
            快捷键: alt + insert --> equals && hashCode() --> 选择成员变量 --> ok
    3.==的使用
        (1)基本类型: 比较具体的数据值是否相同
        (2)引用类型: 比较的是内存地址值是否相同
 */
public class Demo02Equals {
    public static void main(String[] args) {
        //创建Student类的对象
        //注意: 只要new对象,内存地址就是不同的
        Student stu1 = new Student("张三", 18);
        Student stu2 = new Student("李四", 38);
        Student stu3 = new Student("张三", 18);

       /*
            Student类没有覆盖重写Object类的equals方法
            结果(比较内存地址值): false,false,false
            Student类覆盖重写Object类的equals方法
            结果(比较内容): false,true,false
         */
        System.out.println(stu1.equals(stu2));
        System.out.println(stu1.equals(stu3));
        System.out.println(stu2.equals(stu3));
        System.out.println(stu1.equals(stu1));
        System.out.println("-----------");
        String s1 = null;
        String s2 = "abc";
        //System.out.println(s1.equals(s2));//报空指针异常
        /*
            Objects工具类的静态方法equals
                作用: 比较两个对象是否相同,避免空指针异常
         */
        System.out.println(Objects.equals(s1,s2));//false: 不会报空指针异常
    }
} 
/*
    转义字符 \
    1.去掉某些字符上的特殊含义

    2.给某些字符添加特殊含义
        \t: 制表符
        \r\n: windows换行
*/
public class Demo03ZhuanYi {
    public static void main(String[] args) {
        //以字符串的方式输出 "
        System.out.println(""");

        //以字符的方式输出 '
        System.out.println(''');

        System.out.println("HellotWorld");
        System.out.println("Hello\tWorld");
        System.out.println("Hello\r\nWorld");
    }
}  
    1.java.util.Date类介绍:类 Date 表示特定的瞬间，精确到毫秒。

    2.注意:
        (1)时间原点: 1970年1月1日 0时0分0秒   认为是0毫秒
        (2)时间标准: 采用格林威治时间标准
        (3)北京时间与标准时间相差8小时

    3.构造方法:
        (1)public Date(): 把当前时间毫秒值(运行程序的此时此刻)封装成Date对象
        (2)public Date(long date): 把构造方法参数指定的毫秒值封装成Date对象

    4.常用常用方法:
        (1)public long getTime(): 返回调用方法的Date对象对应的毫秒值
        (2)public void setTime(long time): 把方法参数指定的毫秒值设置给调用方法的Date对象
*/
public class Demo02Date {
    public static void main(String[] args) {
        //创建当前时间对应的Date对象
        Date d1 = new Date();
        System.out.println(d1);
        System.out.println(d1.toString());

        //创建0毫秒对应的Date对象
        Date d2 = new Date(0L);
        //(3)北京时间与标准时间相差8小时
        System.out.println(d2);//Thu Jan 01 08:00:00 CST 1970

        //需求: 把当前时间向后推两天
        //获取当前时间的毫秒值
        long nowMillis = d1.getTime();
        //计算两天时间的毫秒值
        long twoDaysMillis = 2L * 24 * 60 * 60 * 1000;

        //重新修改当前日期Date对象的毫秒值
        d1.setTime(nowMillis + twoDaysMillis);

        System.out.println(d1);
    }
}  
/*
    java.text.DateFormat类:
    1.作用:
        用来完成Date对象和String对象之间的相互转换的

    2.常用功能
        (1)格式化(就是把Date对象转换成String对象)
            public String format(Date date): 把方法参数Date对象转换成String对象并返回
                参数:
                    Date date: 日期对象
                返回值:
                    String: 返回的是String对象

        (2)解析(就是把String对象转换成Date对象)
            public Date parse(String source): 把方法参数String对象转换成Date对象并返回
                参数:
                    String source: String对象
                返回值:
                    Date: 返回的是日期对象
    3.使用
        java.text.DateFormat是一个抽象类,不能直接new对象
        常用子类:java.text.SimpleDateFormat类
            构造方法:
                public SimpleDateFormat(String pattern)
                参数:
                    String pattern: String类型的日期格式

                    显示格式                                需要设置的日期格式
             2020年09月23日 10点43分20秒123毫秒         yyyy年MM月dd日 HH点mm分ss秒SSS毫秒
             2020-09-23 10:43:20:123                  yyyy-MM-dd HH:mm:ss:SSS

     把Date对象格式化成String对象的实现步骤
        1.创建String类型的日期格式对象patter,需要指定具体的格式
        2.创建日期格式化SimpleDateFormat类的对象sdf,构造方法参数传递日期格式对象patter
        3.创建当前毫秒值对应的日期Date对象date
        4.使用日期格式化SimpleDateFormat类的对象sdf调用format方法,传递日期对象date,
            获取指定格式的String对象
        5.打印String对象
*/
public class Demo03DateFormat {
    public static void main(String[] args) {
        //1.创建String对象pattern,代表日期的显示格式
        String pattern = "yyyy年MM月dd日 HH点mm分ss秒SSS毫秒";
        //String pattern = "yyyy-MM-dd HH:mm:ss:SSS";
        //2.创建日期格式化SimpleDateFormat类的对象
        //SimpleDateFormat sdf = new SimpleDateFormat();//不写参数,按照默认格式: 22-6-8 上午11:29
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);//指定了日期的显示格式
        //3.创建当前时间对应的Date对象
        Date date = new Date();
        //4.使用日期格式化SimpleDateFormat类的对象sdf调用format方法,传递Date对象,获取String对象
        String strDate = sdf.format(date);
        //5.输出日期结果字符串
        System.out.println(strDate);
    }
}  
/*
    把String对象解析成Date对象的实现步骤
        1.创建String类型的日期格式对象patter,需要指定具体的格式
        2.创建日期格式化SimpleDateFormat类的对象sdf,构造方法参数传递日期格式对象patter
        3.创建String对象strDate,保存指定格式的日期时间
        4.使用日期格式化SimpleDateFormat类的对象sdf调用parse方法,传递String的日期对象strDate,
            获取Date对象
        5.打印Date对象
*/
public class Demo04DateFormat {
    public static void main(String[] args) throws ParseException {
        //1.创建String对象pattern,代表日期的显示格式
        String pattern = "yyyy年MM月dd日 HH点mm分ss秒SSS毫秒";
        //String pattern = "yyyy-MM-dd HH:mm:ss:SSS";

        //2.创建日期格式化SimpleDateFormat类的对象,构造方法传递日期格式对象pattern
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);

        //3.根据步骤1中指定的格式创建String类型的日期对象strDate
        String strDate = "2022年06月08日 11点38分17秒423毫秒";

        //4.使用日期格式化SimpleDateFormat类的对象调用parse方法,传递字符串日期对象strDate,获取日期Date对象
        Date date = sdf.parse(strDate);

        //5.输出结果日期Date对象
        System.out.println(date);

    }
}  
import java.util.Calendar;

/*
    java.util.Calendar类: 日历类,内部提供了大量的与日期时间相关的信息,想要什么就那什么,非常方便
    java.util.Calendar类是一个抽象类,不能直接创建对象
        不常用子类: java.util.GregorianCalendar类 用起来太麻烦


    解决方案:
        在java.util.Calendar类的内部提供静态方法获取其子类对象
            public static Calendar getInstance(): 获取抽象类Calendar类的子类对象
            返回值类型:
                java.util.Calendar类: 是抽象类,说明方法内部必然会返回该抽象类的子类对象
*/
public class Demo03Calendar {
    public static void main(String[] args) {
        //获取Calendar类的子类对象
        Calendar cal = Calendar.getInstance();//方法内部必然返回抽象类Calendar的子类对象
        System.out.println(cal);
    }
}   
import java.util.Calendar;

/*
    Calendar类的常用方法
        public int get(int field) ：返回给定日历字段的值。
            参数:
                int field: 代表的是要获取的是哪个字段
            返回值:
                int: 代表的是获取到的字段对应的值

        public void set(int field, int value) ：将给定的日历字段设置为给定值。
            参数:
                int field: 代表的是要给哪个字段设置值
                int value: 代表的是设置的值是什么

        public abstract void add(int field, int amount) ：
            根据日历的规则，为给定的日历字段添加或减去指定的时间量。
            给指定字段增加指定的值
            参数:
                int field: 代表的是要给哪个字段增加值
                int amount: 代表的是增加的值是多少
                    正数表示增加,负数表示减少

        public Date getTime() ：把调用方法的Calendar对象转换成Date对象并返回
        public void setTime(Date date): 把调用方法传递的参数Date对象设置给调用方法的Calendar对象

        Calendar类当中的常量
        Calendar.YEAR           代表年     1
        Calendar.MONTH          代表月     2
        Calendar.DAY_OF_MONTH   代表日     5
*/
public class Demo04CalendarMethod {
    public static void main(String[] args) {
        //输出获取年的字段的值
        System.out.println(Calendar.YEAR);//1
        System.out.println(Calendar.MONTH);//2
        System.out.println(Calendar.DAY_OF_MONTH);//5
        //获取Calendar类的对象
        Calendar cal = Calendar.getInstance();

        //调用方法打印信息
        printCalendar(cal);

        //使用set方法 把日期 2022年6月8日  修改成 2025年8月5日
        //修改年
        cal.set(Calendar.YEAR,2025);
        //修改月
        cal.set(Calendar.MONTH,7);
        //修改日
        cal.set(Calendar.DAY_OF_MONTH,5);
        //调用方法打印信息
        printCalendar(cal);

        //使用add方法 把日期 2025年8月5日  修改成 2022年6月8日
        //修改年
        cal.add(Calendar.YEAR,-3);
        //修改月
        cal.add(Calendar.MONTH,-2);
        //修改日
        cal.add(Calendar.DAY_OF_MONTH,3);

        //调用方法打印信息
        printCalendar(cal);


    }

    //定义方法,打印Calendar对象的信息
    public static void printCalendar(Calendar cal) {
        //获取年
        //int year = cal.get(Calendar.YEAR);
        int year = cal.get(1);
        //获取月
        //int month = cal.get(Calendar.MONTH);//1月到12月对应的数字 0到11
        int month = cal.get(2);//1月到12月对应的数字 0到11
        //获取日
        //int day = cal.get(Calendar.DAY_OF_MONTH);
        int day = cal.get(5);
        System.out.println(year + "年" + (month + 1) + "月" + day + "日");
    }
}  
import java.util.Calendar;
import java.util.Scanner;

/*
    1.需求:Calendar类的练习_获取任意一年的二月有多少天
          如果可以搞到任意年份的3月份的第1天,把天数减1,得到的就是二月份的最后一天

    2.实现步骤:
        (1)创建键盘录入Scanner类的对象
        (2)获取键盘录入的代表年份的int数字,保存到int变量year中
        (3)获取当前日期时间的Calendar对象cal
        (4)Calendar对象cal调用方法把年份设置成year
        (5)Calendar对象cal调用方法把月份设置成3月(3月对应的数字是2)
        (6)Calendar对象cal调用方法把天数设置成1
        (7)Calendar对象cal调用方法把天数减1,之后就是2月份的最后一天
        (8)Calendar对象cal调用方法获取天数,保存到int变量days中,表示的就是二月份总共有多少天
        (9)打印int变量days的值
 */
public class Demo05CalendarTest {
    public static void main(String[] args) {
        //(1)创建键盘录入Scanner类的对象
        Scanner sc = new Scanner(System.in);
        //(2)获取键盘录入的代表年份的int数字,保存到int变量year中
        System.out.println("请输入一个整数数字(代表年份):");
        int year = sc.nextInt();
        //(3)获取当前日期时间的Calendar对象cal
        Calendar cal = Calendar.getInstance();
        //(4)Calendar对象cal调用方法把年份设置成year
        //cal.set(Calendar.YEAR, year);
        //(5)Calendar对象cal调用方法把月份设置成3月(3月对应的数字是2)
        //cal.set(Calendar.MONTH, 2);
        //(6)Calendar对象cal调用方法把天数设置成1
        //cal.set(Calendar.DAY_OF_MONTH, 1);

        cal.set(year,2,1);//直接设置年月日,不需要指定对应的字段名字

        //(7)Calendar对象cal调用方法把天数减1,之后就是2月份的最后一天
        cal.add(Calendar.DAY_OF_MONTH, -1);
        //(8)Calendar对象cal调用方法获取天数,保存到int变量days中,表示的就是二月份总共有多少天
        int days = cal.get(Calendar.DAY_OF_MONTH);
        //(9)打印int变量days的值
        System.out.println(year + "年的2月份总共有: " + days + "天");
    }
}