常用类01（二）

最新推荐文章于 2022-09-21 23:27:37 发布

为什么暴躁

最新推荐文章于 2022-09-21 23:27:37 发布

阅读量69

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/chenguoao1999/article/details/119151423

版权

java基础专栏收录该内容

42 篇文章 2 订阅

订阅专栏

课程笔记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
    }
}

为什么暴躁

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
常用类01（二）

课程笔记Day12API的使用Object类Math类日期时间类包装类第一章 API的使用第01节基础理论1. 什么是API? API（Application Programming Interface，应用程序接口）是一些预先定义的接口（如函数、HTTP接口）。大白话解释：别人给你写好的类、接口、方法、变量等信息，你只需要使用就可以了。2. API的作用? 例如: 我们要去开发一款美团外卖程序的后台系统。存在两个核心功能（定位、支付）定位：地图相关的操作（百度和高德
复制链接

扫一扫