今天是我在乐子节学习Java的十四天哦，元旦休了三天小长假继续回来学Java哟~学习Java有半个月了，这半个月的收货颇多，从小白到大神 入门到精通，哈哈，大神有点夸张了哈 开开玩笑~~很喜欢老师讲课的方式，幽默风趣，一点也不会觉得枯燥无味，下面是今天老师讲课的内容，大家可以看看我有哪写的不对的地方，指出一起探讨一下哦！
第一章 Object类、常用API
1.1 概述
java.lang.Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。
如果一个类没有特别指定父类， 那么默认则继承自Object类。 例如：
publicclassMyClass/*extends Object*/{
// ...
}
123
1.2 toString方法
1.2.1 toString方法源码解读
public Sting toString()：返回该对象的字符串表示。
toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。Object类当中toString()方法源码如下：
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
123
源码解读： getClass().getName()返回的是对象所处包名.类名， Integer.toHexString(hashCode())返回的是十六进制的内存地址值
由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。
1.2.2 toString方法覆盖重写
如果不希望使用toString方法的默认行为，则可以对它进行覆盖重写。例如自定义的Person类：
public class Person {
private String name;
private int age;
@Override
public String toString() {
return "Person{" + "name=" + name + ", age=" + age + "}";
}
}
123456789
在IDEA中可以通过alt + Ins快捷键直接导入toString()方法进行重写，以此来输出对象的属性
注意：在我们直接使用输出语句输出对象名的时候,其实通过该对象调用了其toString()方法。如：
// 定义Person类
public class Person{
private String name;
private int age;
public Person() {
}
public Person(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;
}
// 可以使用alt + insert快捷键直接导入生成toString方法的重写
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
// 定义测试类
Person p = new Person("泰隆",18);
String s = p.toString();
System.out.println(s); // com.cqu.demo01.Object.Person@75412c2f / Person{name-泰隆 ,age-age}
// 直接打印对象的名字，实际上就是调用对象的toString方法 p = p.toString()
System.out.println(p); // com.cqu.demo01.Object.Person@75412c2f / Person{name-泰隆 ,age-age}
}
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647
1.3 equals方法
1.3.1 equals方法源码解读
public boolean equals(Object obj)意：指示其他某个对象是否与此对象“相等”。
源码如下：
public boolean equals(Object obj) {
return (this == obj);
}
123
可以看出，源码当中需要传入一个Object类型的对象，也就意味着是可以传入任何类型的对象（子类可以看做就是一个父类），包括null也可以传入，而返回值是使用的是==号来进行判断。
回顾==号的作用：当==号两边都是基本数据类型时，比较的是数据，数据只要一样，就为true，否则为false当==号两边都是引用数据类型时比较的是内存地址值，只有当内存地址值一样时，才会为true，否则为false
现有equals方法的两个缺陷：
有时，我们希望当对象内容相同时即判断为相同，此时则需要重写equals方法。
null值是无法调用任何非静态方法的，因此null值无法调用equals方法，会产生空指针异常。
注意：null == null返回的是true
针对第一个缺陷，解决方案：对equals方法进行重写
1.3.2 equals方法覆盖重写
举例：重写之前
// 定义Person类
public class Person{
private String name;
private int age;
public Person() {
}
public Person(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 class Demo02Equals {
public static void main(String[] args) {
Person p1 = new Person("泰隆",18);
Person p2 = new Person("泰隆",18);
System.out.println(p1); // com.cqu.demo01.Object.Person@75412c2f
System.out.println(p2); // com.cqu.demo01.Object.Person@282ba1e
System.out.println(p1.equals(p2)); // false
}
123456789101112131415161718192021222324252627282930313233343536373839404142
重写之后
// 定义Person类
public class Person{
private String name;
private int age;
public Person() {
}
public Person(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;
}
// 手动重写equals方法
/*@Override
public boolean equals(Object obj){
// 增加一个判断，如果传入的obj是this本身，直接返回true，提高程序效率
if(obj == this){
return true;
}
// 增加一个判断，传递的参数如果是null，直接返回false，提高程序的效率
if(obj == null){
return false;
}
// 增加一个判断，是Person类型再转换，防止出现类型转换异常ClassCastException
if(obj instanceof Person){
// 使用向下转型（强转）把Object类型强制转换为Person
Person p = (Person) obj;
// 比较两个对象的属性；一个是调用方法的this--->p1,另一个就是p(obj--->p2)
boolean b = this.name.equals(p.name) && this.age == p.age;
return b;
}
// 不是Person类型，根本不用比较，直接返回false
return false;
}*/
// 上面手写代码有一个问题在于一个null对象无法进行调用非静态方法。
// IDEA自动重写equals方法
@Override
public boolean equals(Object o) {
// 如果对象地址一样，则认为相同
if (this == o) return true;
// getClass() != o.getClass() 使用反射技术，判断o是否为Person类型 等效于 obj instanceof Person
// 如果参数为空，或者类型信息不一样，则返回false
if (o == null || getClass() != o.getClass()) return false;
// 转换为当前类型
Person person = (Person) o;
// 要求基本类型相等，并且将引用类型交给java.util.Objects类的equals静态方法取用结果
return age == person.age &&
Objects.equals(name, person.name);
}
}
// 定义测试类
public class Demo02Equals {
public static void main(String[] args) {
Person p1 = new Person("泰隆",18);
Person p2 = new Person("泰隆",18);
System.out.println(p1.equals(p2)); // true
}
}
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687
注意：
在重写equals方法时，用到了向下转型，原因在于这里隐藏着一个潜在的多态，就是Object obj = 传入的对象 = new 子类名称();而多态创建的对象无法使用子类特有的内容（属性，方法），因此要进行向下转型，来调用对象的各种属性内容进行判断。
和toString()方法一样，也可以通过alt + Ins的方式进行自动重写。
重写后的equals方法依然无法解决null的问题，null值依然无法调用重写后的equals方法
1.4 Objects类
1.4.1 Objects类当中的equals方法概述
正如刚才所说，equals方法有两个缺陷，缺陷1是可以通过重写equals方法解决。缺陷2则可以通过Objects中的equals方法来进行解决。
在刚才IDEA自动重写equals代码中，使用到了java.util.Objects类，那么这个类是什么呢？
在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。
在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。方法如下：
public static boolean equals(Object a, Object b):判断两个对象是否相等。
1.4.2 Objects类当中的equals方法源码
publicstaticbooleanequals(Objecta,Objectb) {
// 若a为null，则用==号判断
// 若a不为空，则调用对象a继承或者重写的equals方法判断
return(a==b)||(a!=null&&a.equals(b));
}
12345
1.4.3 使用Objects.equals（Object a, Object b）解决两个缺陷
// 定义Person类
public class Person{
private String name;
private int age;
public Person() {
}
public Person(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;
}
// IDEA自动重写equals方法
@Override
public boolean equals(Object o) {
// 如果对象地址一样，则认为相同
if (this == o) return true;
// getClass() != o.getClass() 使用反射技术，判断o是否为Person类型 等效于 obj instanceof Person
// 如果参数为空，或者类型信息不一样，则返回false
if (o == null || getClass() != o.getClass()) return false;
// 转换为当前类型
Person person = (Person) o;
// 要求基本类型相等，并且将引用类型交给java.util.Objects类的equals静态方法取用结果
return age == person.age &&
Objects.equals(name, person.name);
}
}
// 定义测试类
public class Demo03Objects {
public static void main(String[] args) {
String s1 = null;
String s2 = "aaa";
boolean b2 = Objects.equals(s1,s2);
System.out.println(b2); // false，解决了null值无法调用equals方法的问题（缺陷2）
Person p1 = new Person("泰隆",18);
Person p2 = new Person("泰隆",18);
// Objects.equals方法调用类内部重写的equals方法进行内容判断（解决了缺陷1）
System.out.println(Objects.equals(p1,p2)); // true
}
}
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
第二章 日期和时间类
2.1 Date类（两构造，一成员）
本节需学习四个内容：
public Date()
public Date(long date)
public long getTime()
System.currentTimeMillis()
2.1.1 概述
java.util.Date类 表示特定的瞬间，精确到毫秒。
public Date()：创建一个date对象，打印输出为当前系统时间对应的北京时间字符串
public Date(long date)：创建一个date对象，以表示自从标准时间（1970年1月1日 00:00:00，英国格林威治时间）以来经过传入参数date后的时间，打印输出为 标准时间 + 所传参数(单位是毫秒)对应的北京时间字符串
public long getTime()：把日期对象转换成自标准时间开始，所对应的时间毫秒值。
System.currentTimeMillis()：输出当前系统时间到标准时间起所经历的毫秒数
在使用println方法时，会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写，所以结果为指定格式的字符串。
public class Demo01Date {
public static void main(String[] args) {
// 返回输出的是一个Long类型的数据
System.out.println(System.currentTimeMillis()); // 1606913463711 获取当前系统一共到1970 年 1 月 1 日 00:00:00经历了多少毫秒
Date date1 = new Date();
System.out.println(date1);
Date date2 = new Date(2000); // 传入2000，单位是毫秒，也就是2秒
System.out.println(date2); // Thu Jan 01 08:00:02 CST 1970 标准时间过了2000毫秒后对应的北京时间为1970年1月1日 08:00:02
System.out.println(date2.getTime()); // 2000 对象date2到标准时间之间经过了2000毫秒
}
}
123456789101112
注意：中国属于东八区，会把时间加8个小时也就是说，标准时间对应于北京时间为1970年1月1日 08:00:00西方是0~11月，中国是1~12月
2.2 DateFormat类（一构造，两成员）
java.text.DateFormat 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在==Date对象(不是毫秒值)==与String对象之间进行来回转换。
格式化：按照指定的格式，从Date对象转换为String对象。
解析：按照指定的格式，从String对象转换为Date对象。
2.2.3 构造方法
由于DateFormat为抽象类，不能直接使用，所以需要常用的子类java.text.SimpleDateFormat。这个类需要一个模式（格式）来指定格式化或解析的标准。构造方法为：
public SimpleDateFormat(String pattern)：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat对象。参数pattern是一个字符串，代表日期时间的自定义格式。
格式规则
标识字母含义
y年
M月
d日
H小时
m分钟
s秒
更详细的格式规则，可以参考SimpleDateFormat类的API文档。
创建SimpleDateFormat对象代码如下所示:
import java.text.DateFormat;
import java.text.SimpleDateFormat;
public class Demo01{
public static void main(String[] args){
// 对应的日期格式如：2020-12-02 21:02:34
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
}
}
123456789
2.2.4 format和parse方法
前面概述说了，SimpleDateFormat是抽象类DateFormat的一个实现类，作用在于Date对象和字符串之间的标准化和解析，因此需要掌握public String format(Date date)和public Date parse(String source)两个方法，前者用于标准化，后者用于解析。
format方法
import java.text.SimpleDateFormat;
import java.util.Date;
/*
把Date对象转换成String
*/
public class Demo01{
public static void main(String[] args){
// 创建一个Date对象
Date date = new Date();
// 打印输出date对象，获取当前系统时间对应的date字符串
System.out.println(date); // Wed Dec 02 21:16:20 CST 2020
// 创建一个用于Date和String之间转换的对象SimpleDateFormat
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 调用format方法将Date对象转化为String字符串
String str = sdf.format(date);
System.out.println(str); // 2020-12-02 21:16:20
}
}
1234567891011121314151617181920
parse方法
public class demo01{
public static void main(String[] args) throws ParseException{
// 创建一个SimpleDateFormat对象，用于字符串和Date对象之间的转换
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
// 创建一个相对应格式的日期字符串
String str = "2020年12月02日 21时21分21秒";
System.out.println(str); // 2020年12月02日 21时21分21秒
// 调用parse方法将str字符串，转换为Date对象
// 注意：
// public Date parse(String source) throws ParseException
// parse方法声明了一个异常叫ParseException解析异常
// 如果字符串和构造方法中的模式不一样，那么程序就会抛出此异常
// 调用一个抛出了异常的方法，就必须要处理这个异常，要么throws继续声明抛出这一个异常，要么try...catch自己处理这个异常
Date date = sdf.parse(str);
System.out.println(date); // Wed Dec 02 21:21:21 CST 2020
}
}
12345678910111213141516171819
注意： 可以通过alt + Enter自动添加throwsParseException
2.2.3 练习
请使用日期时间相关的API，计算出一个人已经出生了多少天。
思路：
1.获取当前时间对应的毫秒值
2.获取自己出生日期对应的毫秒值
3.两个时间相减（当前时间– 出生日期）
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
public class Demo01{
public static void main(String[] args) throws ParseException {
Scanner sc = new Scanner(System.in);
System.out.println("请输入出生日期，格式为：yyyy-MM-dd");
String str = sc.next();
// 将获取的字符串解析为Date对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date dateBirthday = sdf.parse(str);
// 获取当前系统时间
Date dateNow = new Date();
// 将两个Date对象转换为距离标准时间经过的毫秒数
Long lBirthday = dateBirthday.getTime();
Long lNow = dateNow.getTime();
// 计算相差天数
long day = (lNow - lBirthday) / 24 /60 / 60 / 1000;
System.out.println(day);
}
}
123456789101112131415161718192021222324252627
2.3 Calendar类（4个成员方法）
2.3.1 Calendar类概述
java.util.Calendar是日历类，在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。日历类就是方便获取各个时间属性的。
Calendar和DateFormat一样，均为抽象类，由于语言敏感性，Calendar类在创建对象时并非直接创建，而是通过静态方法getInstance()创建，返回子类对象，如下：
public class Demo01{
public static void main(String[] args){
// 不难理解，这实际上是一个多态的写法
Calendar c = Calendar.getInstance();
System.out.println(c); // java.util.GregorianCalendar[time=1606916284780,areFieldsS.......
}
123456
注意： 这上面创建对象时，其实是用的多态写法
2.3.2 Calendar类常用成员方法
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对象，简单来说就是Calendar多态对象转换为Date对象
成员方法的参数：int field：日历的字段，可以使用Calendar类的静态成员常量获取,注意这些常量都是int类型的public static final int YEAR = 1; 年public static final int MONTH = 2; 月public static final int DATE = 5; 月中的某一天public static final int DATE_OF_MONTH = 5; 月中的某一天public static final int HOUR = 10; 时public static final int MINUTE = 12; 分public static final int SECOND = 13; 秒
Calendar类中提供很多成员常量，代表给定的日历字段
字段值含义
YEAR年
MONTH月（从0开始，可以+1使用）
DAY_OF_MONTH月中的天（几号）
HOUR时（12小时制）
HOUR_OF_DAY时（24小时制）
MINUTE分
SECOND秒
DAY_OF_WEEK周中的天（周几，周日为1，可以-1使用）
四个成员方法的代码演示如下：
import java.util.Calendar;
import java.util.Date;
// 定义测试类
public class Demo02Calendar{
public static void main(String[] args){
// demo01();
// demo02();
// demo03();
}
/*
public int get(int field):返回给定日历字段的值
参数：传递指定的日历字段(YEAR,MONTH...)
返回值：日历字段代表具体的值
*/
public static void demo01(){
// 调用Calendar的getInstance静态方法创建Calendar的实现类对象
// 这实际上是多态写法
Calendar c = Calendar.getInstance();
int year = c.get(Calendar.YEAR);
System.out.println(year); // 2020
int month = c.get(Calendar.Month);
int month = c.get(Calendar.MONTH) + 1; // 西方的月份是0~11，中国的月份是1~12
System.out.println(month); // 12
int date = c.get(Calendar.DATE);
System.out.println(date) // 4
}
/*
public void set(int field,int value)将日历字段设置为给定值
参数：
int field：传递给定的日历字段（YEAR,MONTH...）
int value：传递的字段设置的具体的值
*/
public static void demo02(){
// 调用Calendar的getInstance静态方法创建Calendar的实现类对象
// 这实际上是多态写法
Calendar c = Calendar.getInstance();
// 设置年为2050年
c.set(Calendar.YEAR,2050);
// 设置月为5月，相当于中国的6月
c.set(Calendar.MONTH,5);
// 设置日为3
c.set(Calendar.DATE,3);
// 同时设置年、月、日
c.set(2090,11,8);
int year = c.get(Calendar.YEAR);
System.out.println(year); // 2090
int month = c.get(Calendar.MONTH);
System.out.println(month); // 11 得到的是西方的月份0~11
int date = c.get(Calendar.DATE);
System.out.println(date); // 8
}
/*
public abstract void add(int field,int amount):根据日历的规则，为给定的日历字段添加或减去指定的时间量
把指定的字段增加/减少指定的值
参数：
int field:传递指定的日历字段（YEAR,MONTH...）
int amount:增加/减少的值
正数（增加）
负数（减少）
*/
public static void demo03(){
// 调用Calendar的getInstance静态方法创建Calendar的实现类对象
// 这实际上是多态写法
Calendar c = Calendar.getInstance();
// 把年增加2年
c.add(Calnedar.YEAR,2);
// 把月减少5月
c.add(Calendar.MONTH,-5);
// 把日增加2天
c.add(Calendar.DATE,2);
int year = c.get(Calendar.YEAR);
System.out.println(year); // 2022
int month = c.get(Calendar.MONTH);
System.out.println(month); // 6 得到的是西方的月份0~11
int day = c.get(Calendar.DATE);
System.out.println(day); // 6
}
/*
public Date getTime()：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。
*/
public static void demo04(){
// 使用getInstance方法获取Calendar对象
// 这实际上是多态写法，右边获取的是Calendar的子类对象
Calendar c = Calendar.getInstance();
// // getTime()方法将日历Calendar的多态对象，转换为日期Date对象
Date date = c.getTime();
System.out.println(date); // Fri Dec 04 22:10:02 CST 2020
}
}
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104
第三章 System类（两个静态方法）
java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有：
public static long currentTimeMillis()：返回以毫秒为单位的当前时间。
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。
3.1 currentTimeMillis方法
前面已经说过，currentTimeMillis方法就是获取当前系统时间与标准时间之间的毫秒差值
public class SystemDemo{
public static void main(String[] args){
// 获取当前时间毫秒值
System.out.println(System.currentTimeMillis()) // 1607091720061
// 使用Date对象的getTime方法测试
Date date = new Date();
System.out.println(date.getTime()); // 1607091720062 只相差1毫秒！
}
}
12345678910
3.2 练习
验证for循环打印数字1-9999所需要使用的时间（毫秒）
public class SystemTest1 {
public static void main(String[] args) {
long start = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
System.out.println(i);
}
long end = System.currentTimeMillis();
System.out.println("共耗时毫秒：" + (end - start)); // 共耗时毫秒：43
}
}
12345678910
3.3 arraycopy方法
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。数组的拷贝动作是系统级的，性能很高。System.arraycopy方法具有5个参数，含义分别为：
参数序号参数名称参数类型参数含义
1srcObject源数组
2srcPosint源数组索引起始位置
3destObject目标数组
4destPosint目标数组索引起始位置
5lengthint复制元素个数
练习：将src数组中前3个元素，复制到dest数组的前3个位置上复制元素前：src数组元素[1,2,3,4,5]，dest数组元素[6,7,8,9,10]复制元素后：src数组元素[1,2,3,4,5]，dest数组元素[1,2,3,9,10]