javaSE基础复习之常用API
课程笔记Day12
- API的使用
- Object类
- Math类
- 日期时间类
- 包装类
第一章 API的使用
第01节 基础理论
1. 什么是API?
API（Application Programming Interface，应用程序接口）是一些预先定义的接口（如函数、HTTP接口）。
大白话解释：别人给你写好的类、接口、方法、变量 等信息，你只需要使用就可以了。
2. API的作用?
例如: 我们要去开发一款美团外卖程序的后台系统。存在两个核心功能（定位、支付）
定位：地图相关的操作（百度和高德）
支付: 支付相关的操作（微信和支付宝）
问题：美团的程序员,会自己从零去开发地图和支付的操作吗?
回答: 不会的，使用别人开发出来的API接口
3. 三个角色?
以支付为例：
（1）支付宝 --> 银行对接
（2）美团 --> 支付宝
（3）大众用户 -> 美团
第02节 API用法
第01步：搜索信息
第02步：三看信息（看包、看构造方法摘要、看方法摘要）
看包
看构造方法摘要
看方法摘要
因此使用 随机数 Random 的写法是：
[1]导包 import java.util.Random;
[2]创建对象 Random r = new Random();
[3]调用方法 int num = r.nextInt(10);
第二章 Object类
第01节 理论说明
什么是Object类呢？
Object类是所有 Java类的祖宗类，任何一个类，都直接或者间接的继承了 Object类。
根据API文档，我们发现在 Object类当中，包含有11个方法，我们重点学习其中的2个方法。
| 方法API | 方法介绍 |
|---|---|
| public String toString() | 返回该对象的字符串表示形式 |
| public boolean equals(Object obj) | 指示其他某个对象是否与此对象"相等" |
| protected native Object clone() | 创建并返回此对象的一个副本 |
| protected void finalize() | 由对象的垃圾回收器调用此方法 |
第02节 toString() 方法
结论
如果我们没有重写 toString() 方法，默认情况下，打印输出对象，展示的是 地址值。
如果我们重写了 toString() 方法，打印输出对象，展示的是 重写之后的结果。
快捷键：在代码区域点击鼠标右键，选择 Gener... 找到 toString()
查看源代码快捷键
1. 搜索类的快捷键： Ctrl + N
2. 继承关系： Ctrl + H
3. 成员信息: Alt + 7
4. 查找调用过程: Ctrl + B
5. 退回到项目界面: Alt + 1
底层源码分析
第03节 equals() 方法
结论
如果我们没有重写 equals() 方法，默认情况下，底层采用的是双等号比较，比较的是地址值。
如果我们重写了 equals() 方法，比较的是对象的 属性值，也就是成员变量。
快捷键: 在代码区域点击鼠标右键，选择 Gener... 找到 hashCode And equals
底层源码分析
第04节 了解方法
clone方法
该方法返回的是当前对象的一个副本，clone的对象和母体对象，拥有相同的属性值。
这是另外的一种创建对象的方式，Object当中的此方法是 protected 我们子类重写需要写 public
所有想要使用 clone 的方法，都需要实现标识接口 java.lang.Cloneable
案例代码
public class Person implements Cloneable{
private String name;
private int age;
//需要重写方法 clone() 提升权限修饰符 public
//里面的逻辑，直接使用父类的逻辑即可。
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
finalize方法
该方法是一个回调方法，不需要我们主动的调用，是虚拟机在回收对象的过程当中，自动调用此方法。
如果我们需要在回收之前，做一个扫尾的工作，例如：资源的释放，内容的检查等，可以重写此方法。
一般情况下，我们不会重写此方法，只需要了解其调用的时机，一般出现在面试的过程当中。
第三章 Math类
第01节 理论说明
Math 类当中，包含有许多基本数学运算的方法。
其中这个方法，大多数都是 static 修饰的，因此我们在调用的过程当中，只需要使用类名称打点调用。
下面介绍一下相关的方法：
| 方法API | 方法说明 |
|---|---|
| static double PI | 比任何其他的值都更接近圆周率 |
| static double abs(double a) | 返回 double 类型的绝对值 |
| static float abs(float a) | 返回 float 类型的绝对值 |
| static long abs(long a) | 返回 long 类型的绝对值 |
| static int abs(int a) | 返回 int 类型的绝对值 |
| static double ceil(double a) | 向上取值 |
| static double floor(double a) | 向下取整 |
| static long round(double a) | 四舍五入 double 类型 |
| static int round(float a) | 四舍五入 float 类型 |
| static long pow(double a,double b) | 返回第一个参数的第二个参数次幂 |
| static double random() | 随机生成一个值，大于等于0.0 小于1.0的数据 |
第02节 快速入门
//目标：学习Math类的两个方法
public class Test01 {
public static void main(String[] args) {
//直接输出结果
System.out.println(Math.ceil(4.9999)); //5.0
System.out.println(Math.ceil(6.0000001)); //7.0
System.out.println(Math.ceil(-2.5)); //-2.0
System.out.println(Math.ceil(9.0)); //9.0
System.out.println("--------");
//直接输出结果（向下取整）
System.out.println(Math.floor(6.88)); //6.0
System.out.println(Math.floor(4.01)); //4.0
System.out.println(Math.floor(-3.0)); //-3.0
}
}
第四章 日期时间类
第01节 基础理论
只要是与时间相关的类，目前介绍三个：
（1） java.util.Date 主要是操作毫秒数
（2） java.text.SimpleDateFormat 主要是用来格式化时间
（3） java.util.Calender 日历相关的类，单独的操作时间
时间原点的概念
计算机的时间原点: 1970年1月1日 00:00:00 格林威治时间。（东一区的时间）
如果按照北京时间计算： 1970年1月1日 08:00:00 北京时间。（东八区时间）
1秒钟 = 1000毫秒
第02节 Date类
理论说明
在项目当中，常常会涉及到时间相关的内容，Java里面只要与时间相关的信息，都会涉及到 Date 类。
关于 Date类，主要是来自于 java.util.Date
构造方法
1. 无参数构造方法
A. 格式:
public Date()
B. 描述:
无参数构造方法，获取的是当前的系统时间
2. 带参数构造方法
A. 格式:
public Date(long date)
B. 描述:
带参数构造方法，传入的是毫秒值，他是在时间原点 1970年01月01日 00:00:00 基础上，增加多少毫秒。
常用方法
1. 获取毫秒值
A. 格式:
public void setTime(long time)
B. 描述:
设置此 Date对象, 以表示 1970年01月01日 00:00:00 基础上的毫秒值
2. 设置毫秒值
A. 格式:
public long getTime()
B. 描述:
获取当前对象得到的毫秒值。
案例代码
构造方法
import java.util.Date;
//目标：学习Date类的构造方法快速入门
public class Test01 {
public static void main(String[] args) {
//创建对象，采用无参数构造方法创建对象
Date d1 = new Date();
System.out.println("d1 = " + d1); //d1 = Tue Jul 27 14:15:39 IRKT 2021
//创建对象，采用带参数的构造方法创建对象
Date d2 = new Date(1000*60*60);
System.out.println("d2 = " + d2); //d2 = Thu Jan 01 08:00:00 IRKT 1970
}
}
//小结:
//1. 如果是无参数构造方法，采用的是 当前的系统时间
//2. 如果是带参数构造方法，采用的是 时间原点1970年1月1日 00:00:00 开始计算
成员方法
import java.util.Date;
//目标：学习Date类的常用方法
public class Test02 {
public static void main(String[] args) {
//采用无参数构造方法创建对象
Date dd = new Date();
System.out.println("dd = " + dd); //dd = Tue Jul 27 14:23:33 IRKT 2021
//获取到当前系统时间的毫秒值
long haoMiao1 = dd.getTime();
System.out.println("haoMiao1 = " + haoMiao1); //haoMiao1 = 1627367061992
//设置毫秒值
dd.setTime(0);
System.out.println("dd = " + dd); //dd = Thu Jan 01 08:00:00 IRKT 1970
}
}
//小结：
//两个方法： getTime() 获取毫秒数、setTime(long) 设置毫秒数，以时间原点为基数
小结：
Date 类有什么作用呢？
能够实现 毫秒数和Date对象的相互转换。（毫秒数是一个整数，可以进行运算 加减乘除）
第03节 SimpleDateFormat
理论基础
如果按照前面打印输出 Date对象，得到的结果是 dd = Tue Jul 27 14:32:03 IRKT 2021
在我们内心里面这种展示时间的方式是 排斥的。（看着非常不习惯）
所以为了让大家阅读更加 爽，香。就提出了 SimpleDateFormat
那么关于 SimpleDateFormat 类的使用方式：
1. 构造方法：
SimpleDateFormat()
SimpleDateFormat(String)
2. 成员方法：
String format(Date) //格式化：Date-->String
Date parse(String) //解析： String-->Date
格式规则：
| 标识字母（区分大小写） | 含义 |
|---|---|
| y | 年 |
| M | 月 |
| d | 日 |
| H | 时 |
| m | 分 |
| s | 秒 |
格式化代码
import java.text.SimpleDateFormat;
import java.util.Date;
//目标：学习SimpleDateFromat 的format方法
public class Test01 {
public static void main(String[] args) {
//创建对象
Date dd = new Date();
System.out.println("dd = " + dd); //dd = Tue Jul 27 14:42:17 IRKT 2021
//采用SimpleDateFormat来展示好看的格式
//yyyy年MM月dd日 四个小姨，两个大美眉，两个小弟弟
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
//格式化时间
String text = sdf.format(dd);
System.out.println("text = " + text); //text = 2021年07月27日 14:45:40
}
}
//小结：String format(Date) 将Date转换成为字符串，展示一种好看的格式
解析代码
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
//目标：学习SimpleDateFormat 解析操作
public class Test02 {
// throws ParseException 抛出异常。自己不处理，交给JVM系统处理
public static void main(String[] args) throws ParseException {
String time1 = "2021年7月27日15:02:16";
//请问毫秒值是多少呢?
//String -----【解析】----> Date ---> 毫秒值
//创建对象 (模式)
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
//解析时间
Date d1 = sdf.parse(time1);
System.out.println("d1 = " + d1);
System.out.println("d1.getTime() = " + d1.getTime());
}
}
//小结：parse(String) 这个方法可以完成 String 转换成为 Date对象（毫秒值）
//需要注意问题：模式和字符串必须匹配，否则会出现解析异常。
练习题
题目
计算你活了多少天？
分析
我们知道的是两个时间点:
1、当前的时间 "2021年7月27日"
2、你出生的时间 "2021年7月1日"
两者相减：
字符串不能相减，怎么办?
可以将字符串，转换成为数字。（例如毫秒值）再去运算。
代码
import java.text.ParseException;
import java.text.SimpleDateFormat;
//案例：计算你活了多少天?
public class Test03 {
public static void main(String[] args) throws ParseException {
//定义两个时间点
String birthday = "2021年7月1日";
String today = "2021年7月27日";
//将字符串转换成为毫秒
//String ----解析parse----> Date ---获取getTime---> 毫秒long
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
//获取时间
long haoMiao1 = sdf.parse(birthday).getTime();
long haoMiao2 = sdf.parse(today).getTime();
//运算时间
long dayNum = (haoMiao2 - haoMiao1) / (1000*60*60*24);
//展示结果
System.out.println("dayNum = " + dayNum);
}
}
第04节 Calendar类
基础介绍
通过日历，可以很快速，找到 年、月、日、时、分、秒 等信息，可以单独的针对于某个时间，进行 增加、减少、修改操作。
获取对象方式：
//注意：Calendar 是抽象类，不能创建对象，获取对象方式调用getInstance
Calendar cal = Calendar.getInstance();
常用API
关于常用的基础方法介绍
| 方法API | 方法说明 |
|---|---|
| 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 |
| public void setTime(Date) | 转换方法，将 Date 转换 Calendar |
获取时间
import java.util.Calendar;
//日历类Calender 获取时间
public class Test01 {
public static void main(String[] args) {
//获取对象
Calendar cal = Calendar.getInstance();
System.out.println("cal = " + cal);
//单独的获取到某个时间点
int mYear = cal.get(Calendar.YEAR);
System.out.println("mYear = " + mYear); //mYear = 2021
int mMonth = cal.get(Calendar.MONTH) + 1;
System.out.println("mMonth = " + mMonth); //mMonth = 6
int mDate = cal.get(Calendar.DATE);
System.out.println("mDate = " + mDate); //mDate = 27
int mWeek = cal.get(Calendar.DAY_OF_WEEK) - 1;
System.out.println("mWeek = " + mWeek); //mWeek = 2
int mHour = cal.get(Calendar.HOUR_OF_DAY);
System.out.println("mHour = " + mHour); //mHour = 15
int mMinute = cal.get(Calendar.MINUTE);
System.out.println("mMinute = " + mMinute); //mMinute = 47
int mSecond = cal.get(Calendar.SECOND);
System.out.println("mSecond = " + mSecond); //mSecond = 6
}
}
修改时间的方法
import java.util.Calendar;
//回到2008年08月08日，看看这一天星期几
public class Test02 {
public static void main(String[] args) {
//1. 获取Calender的对象。（当前的系统时间）
Calendar cal = Calendar.getInstance();
//2. 修改时间点，修改到 2008年08月08日
cal.set(Calendar.YEAR,2008);
cal.set(Calendar.MONTH,8-1);
cal.set(Calendar.DATE,8);
//3. 获取到这一天的星期数
int week = cal.get(Calendar.DAY_OF_WEEK) - 1;
System.out.println("week = " + week); //week = 5
}
}
增删时间的方法
import java.util.Calendar;
import java.util.Scanner;
//键盘录入一个年份，判断这一年是否是闰年
public class Test03 {
//思路: 回到某一年的3月1日，往前倒退1天，看看这一天是几号
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入年份:");
int year = sc.nextInt();
//获取日历类的对象
Calendar cal = Calendar.getInstance();
//回到这一年的3月1日
cal.set(year,3-1,1);
//往前推一天
cal.add(Calendar.DATE,-1);
//查看这一天是几号
int dayNum = cal.get(Calendar.DATE);
System.out.println("dayNum = " + dayNum);
}
}
Calender和Date的转换
import java.util.Calendar;
import java.util.Date;
//演示 Date 和 Calender的相互转换
public class Test04 {
public static void main(String[] args) {
//有参数构造方法创建的对象
Date d1 = new Date(0);
System.out.println("d1 = " + d1); //d1 = Thu Jan 01 08:00:00 IRKT 1970
//转换成为Calender的对象
Calendar cal1 = Calendar.getInstance();
cal1.setTime(d1);
System.out.println("cal1 = " + cal1); //YEAR=1970
System.out.println("===============");
//给你的是Calender 转换成为Date
Calendar cal2 = Calendar.getInstance();
Date d2 = cal2.getTime();
System.out.println("d2 = " + d2); //d2 = Tue Jul 27 16:32:59 IRKT 2021
System.out.println(d2.getTime()); //1627374815737
long time = cal2.getTime().getTime();
System.out.println("time = " + time); //time = 1627374857071
}
}
第05节 三者转换
三者转换的目的是为了干嘛呢?
1、Date日期类：桥梁，可以转换毫秒值 运算
2、SimpleDateFormat 格式化类： 展示出来一种好看的字符串格式
3、Calender 日历类： 单独操作某个时间的时候，增、删、改、查
第五章 包装类
第01节 基础理论
基本数据类型，他们都有取值范围。
int 的取值范围在 21亿，应该是 2的31次方。
这里可以使用包装类。例如: Integer.MAX_VALUE
常见基本数据类型的包装类
| 基本类型 | 对应的包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
第02节 类型转换
数据类型的转换，String和基本数据类型的转换。
说明：后期我们常用的数据是字符串 String。他在网络传输当中，使用非常多。
说明
1. 基本数据类型 ---> String
int num = 520;
String ss = "" + num;
2. String ----> 基本数据类型
String ss = "1314";
int num = Integer.parseInt(ss);
代码
import java.util.Scanner;
//练习：键盘录入一个数据，增加100在展示出来
public class Test02 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请录入数据:");
String sss = sc.next();
//转换成为int类型，增加100
System.out.println(Integer.parseInt(sss) + 100);
}
}
第03节 装箱拆箱
理论
装箱：将基本数据类型，变成包装类的过程。 int ---> Integer
拆箱：将包装类，转换成为基本数据类型的过程。 Integer --> int
在JDK5版本之后，上述的过程，都是自动完成的。分为：自动装箱和自动拆箱
案例
public class Test03 {
public static void main(String[] args) {
//创建对象
Integer one = new Integer(10);
Integer two = new Integer(20);
//输出结果
System.out.println(one + two); //30
//这里为什么不是地址值呢?
//因为存在自动拆箱。
/*
Integer one = new Integer(10);
Integer two = new Integer(20);
one + two ---> 识别正在进行运算，加法运算。
one --> 由Integer的对象，自动拆箱成为 int xx = 10;
two --> 由Integer的对象，自动拆箱成为 int yy = 20;
完成 one + two 相当于是 xx + yy = 30
*/
Integer three = 40;
System.out.println("three = " + three); //three = 40
}
}
经典案例题：求任何年任何月的日历
package com.blb.test01;
import java.util.Calendar;
import java.util.Scanner;
public class test03 {
public static void main(String[] args) {
Calendar calendar=Calendar.getInstance();
Scanner in = new Scanner(System.in);
System.out.println("请输入年份：");
int year = in.nextInt();
System.out.println("请输入月份：");
int month = in.nextInt();
calendar.set(year,month,1);//输入的7月份1号
calendar.add(Calendar.DATE,-1);//输入的7月份，其实是8月1号，向前推了一天也就是7月31日
int dayNum=calendar.get(calendar.DATE);//这就是7月份的最后一天
System.out.println("dayNum = " + dayNum);
calendar.set(year,month-1,1);//重新赋值改为2021月7月份
int Week=calendar.get(Calendar.DAY_OF_WEEK)-1;//拿到7月1号的星期号，星期几就空几个
System.out.println("Week = " + Week);
showCalendar(calendar.get(Calendar.DAY_OF_WEEK),dayNum,Week);//calendar.getActualMaximum(Calendar.DAY_OF_MONTH)
}
public static void showCalendar(int day , int daySize,int week){
System.out.println("日\t一\t二\t三\t四\t五\t六\t");
for(int i=0;i<week;i++ ){
System.out.print(" \t");
}
for(int j=1;j<=daySize;j++){
System.out.print(j+"\t");
if((j+day-1) % 7 == 0){
System.out.println();
}
}
}
}