基础语法
八进制
每3位二进制作为一个单元,最小数是0,最大数是7,0-7有8个数字
十六进制
每4位二进制作为一个单元,最小数是0,最大数是15
0-15有16个数字,依次用:0-9 A B C D E F
基本数据类型
类型转换
自动类型转换
类型范围小的变量,可以直接赋值给类型范围大的变量
- 小范围的类型会自动转换成大范围的类型进行运算
- 最终类型由表达式的最高类型决定
- byte、short、char是直接转换成int类型参与运算
强制类型转换
强行将类型范围大的变量、数据赋值给类型范围小的变量
数据类型 变量 = (数据类型) 变量 / 数据
运算符
运算符种类:+ - * / %
如果两个整数做除法,结果一定是整数,因为最高类型是整数System.out.println(a*1.0/b);//最高位运算相乘再除可以得小数
自增、自减
- ++、-- 。对当前变量值+1、-1
自增、自减运算符在变量前后有区别吗? - 如果单独使用放前后是没有区别的
- 非单独使用:在变量前,先进行变量自增/自减,再使用变量
- 非单独使用:在变量后,先使用变量,再进行变量自增/自减
案例
赋值运算符
作用
- 基本作用是赋值;
- += 可以实现数据得累加,把别人的数据加给自己
逻辑运算符
- 把多个条件的布尔结果放一起运算,最终返回一个布尔结果
短逻辑运算符
逻辑运算符特点
三元运算符
格式: 条件表达式 ? 值1 : 值2;
运算符优先级
API、键盘录入
- API(Application Programming Interface)应用程序编程接口
键盘录入
1、导包 import java.util.Scanner
2、抄写代码得到扫描器对象(Scanner sc = new Scanner(System.in))
3、抄写代码等待接受用户输入的数据:sc.nextInt() sc.next();
程序流程控制
分支结构
- if分支
- switch分支
if、switch分支各自适合做什么业务场景
switch分支使用注意事项
switch的穿透性
- 如果代码执行到没有写break的case块,执行完后将直接进入下一个case块执行代码(而且不会进行任何匹配),直到遇到break才跳出分支
解决什么问题?
- 存在多个case分支的功能代码是一样时,可以用穿透性把流程集中到同一处处理,这样可以简化代码
循环结构
for循环
- for循环格式和执行流程是怎样的
while循环
- while循环的格式,执行流程
- 什么时候用for循环、while循环
- for和while使用总结
do-while循环
- 先执行再判断循环条件
三种循环的区别
死循环
- 一直执行下去的方法,没有干预不会停止
嵌套循环
- 循环中又包含循环
- 特点
外部循环每循环一次,内部循环全部执行完一次
跳转关键字:break、continue
- break:跳出并结束当前所在循环的执行;
- continue:用于跳出当前循环的当此执行,进入下一次循环;
随机数:Random类
- 作用:用于在程序中获取随机数的技术
使用步骤
- 1、导包 import java.uitl.Random;
- 2、写一行代码代表获取到随机数对象 Random r = new Random();
- 3、调用随机数的功能获取0-9的随机数 int number = r.nextInt(10);
注意:
nextInt(n)功能只生成0 - n-1之间的随机数,不包含n(也可以直接定义范围r.nextInt(3 , 10))
Random生成区间随机数的技巧:减加法
猜数字游戏实现
1、生成随机数
2、使用死循环让用户直到猜到正确的
3、判断猜测数据与随机数大小(使用break跳出死循环)
数组
- 数组就是用来存储一批同种类型数据的内存区域(可以理解为容器)
数组定义方式
静态初始化数组
动态初始化组
- 定义数组的时候只确定元素的类型和数组的长度,之后再存入具体数据
写法:
- 元素默认值规则
- 两种初始化使用场景总结、注意事项说明
遍历
- 遍历:就是一个一个数据的访问
数组遍历、元素求和
快速遍历快捷方式:
变量名.fori +enter
数组案例
猜数字游戏
import java.util.Random;
import java.util.Scanner;
public class Test01 {
public static void main(String[] args){
//1、定义一个动态初始化的数组存储5个随机的1-20之间的数据
int[] arr = new int[5];
//2、动态生成5个1-20之间随机数并存入数组
Random ra = new Random();
for (int i = 0; i < arr.length; i++) {
arr[i] = ra.nextInt(20) + 1;
}
Scanner sc = new Scanner(System.in);
//3、使用一个死循环让用户进行猜测
OUT:
while(true){
System.out.println("请输入一个1-20之间的整数进行猜测");
int guessDate = sc.nextInt();
//4、遍历数组中的每个数据,看是否存数据与猜测的数据相同,相同代表猜中了,给出提示
for (int i = 0; i <arr.length; i++) {
if(guessDate == arr[i]){
System.out.println("猜中了");
break OUT;
}
}
System.out.println("没猜中,请继续");
}
//5、输出数组的全部元素,让用户看到自己确实是中了某个数据
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i] +"\t");
}
}
}
随机排名
import java.util.Random;
import java.util.Scanner;
public class Test2 {
public static void main(String[] args) {
//1、初始化一组数组,存储5个工号
int[] codes = new int[5];
//2、定义一个循环,循环5次,依次录入一个工号存入对应的位置
Scanner sc = new Scanner(System.in);
for (int i = 0; i < codes.length; i++) {
//录入工号
System.out.println("请输入第" + (i + 1) + "个员工的工号: ");
int code = sc.nextInt();
//存入到数组中去
codes[i] = code;
}
//3、遍历数组中的每个元素,然后随机一个索引出来,让该元素与随机索引位置处的元素值进行交换
Random ra = new Random();
for (int i = 0; i < codes.length; i++) {
//当前遍历的元素值:cedes[i]
//随机一个索引位置出来:codes[index]
int index = ra.nextInt(codes.length);
//定义一个临时变量存储index位置处的值
int temp = codes[index];
codes[index] = codes[i];
codes[i] = temp;
}
//4、遍历数组元素输出就是随机排名的结果
for (int i = 0; i < codes.length; i++) {
System.out.print(codes[i] + "\t");
}
}
}
冒泡排序
public class Test3 {
public static void main(String[] args) {
//1、定义一个数组,存储一些数据
int[] arr = {3,412,42,44,11};
//2、定义一个循环控制比较的轮数
for (int i = 0; i < arr.length - 1; i++) {
//3、定义一个循环控制每轮比较的次数,占位
for (int j = 0; j < arr.length - i -1; j++) {
//判断j当前位置的元素值,是否大于下一个位置,若大,则交换
if(arr[j] > arr[j + 1]){
int temp = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = temp;
}
}
}
//遍历数组输出内容
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
}
}
java内存分配介绍
- 两个数组变量指向同一个数组对象
- 数组常见问题
Debug工具
方法
- 方法是一种语法结构,它可以把一段代码封装成一个功能,以方便重复调用
方法定义格式
- 方法格式的注意点
方法的其他写法
- 方法不需要返回结果,则申明返回值类型为void;方法不需要参数,则形参列表可以不写
- 方法没有声明返回值类型,内部不能使用return返回数据
- 方法常见问题
方法案例
求和
public class Test1 {
//使用方法计算1-n得值并返回
public static void main(String[] args) {
System.out.println("1-100的和是 " + sum(100));
}
public static int sum(int n){
int sum = 0;
for (int i = 0; i <= n; i++) {
sum += i;
}
return sum;
}
}
定义方法重点关注的两点
- 方法是否需要申明返回值类型
- 方法是否需要定义形参列表
数组求最值改方法实现
public class Test2 {
public static void main(String[] args) {
//需求:通过方法求数组中的最大值
int[] ages = {21,32,53,13,24};
System.out.println("年龄最大的是+ " + maxArrayDate(ages));
}
//定义返回值类型,传入参数
public static int maxArrayDate(int[] arr) {
//找出最大值返回
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];
}
}
return max;
}
}
方法的内存原理
方法的调用流程–内存图解
- 方法没有被调用的时候,在方法区中的字节码文件中存放
- 方法被调用时,需要进入到栈内存中运行
方法的参数传递机制
基本类型的参数传递
- java的参数传递机制:值传递
引用类型的参数传递
方法的参数传递案例
打印整型数组内容
public class Test3 {
public static void main(String[] args) {
int[] numbers = {13,13,442,52};
printArray(numbers);
}
public static void printArray(int[] arr){
System.out.print("[");
if (arr != null && arr.length > 0 ){
for (int i = 0; i < arr.length; i++) {
System.out.print(i == arr.length-1 ? arr[i] : arr[i] + ",");
}
}
System.out.println("]");
}
}
从数组中查询指定元素的索引
public class Test4 {
public static void main(String[] args) {
//需求:从整型数组中查询某个数据的索引返回,不存在则返回-1
int[] arr = {32,43,52,65};
int index = index(arr, 329);
System.out.println(index);
}
public static int index(int[] code, int date){
for (int i = 0; i < code.length; i++) {
if(date == code[i]){
return i;
}
}
return -1;
}
}
比较两个数组是否一样
public class Test5 {
public static void main(String[] args) {
int[] arr1 = {32, 43, 62, 56};
int[] arr2 = {32, 543, 24, 44};
boolean b = compare(arr1, arr2);
System.out.println(b);
}
public static boolean compare(int[] arr1, int[] arr2) {
if (arr1.length == arr2.length) {
for (int i = 0; i < arr1.length; i++) {
if (arr1[i] != arr2[i]) {
return false;
}
}
return true;
}
return false;
}
}
方法重载、关键字
- 方法重载:同一个类中,出现多个方法名称相同,但是形参列表不同的,那这些方法就是重载方法
好处:相似功能业务场景:可读性好,方法名称相同提示是同一类型的功能,通过形参不同实现功能差异化的选择,这是一种专业的代码设计
- 方法重载的识别技巧
- return 关键字
- 立即跳出并结束当前方法的执行;return单独使用可以放在任何方法中。
编程案例
案例一:买飞机票
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
//1、让用户输入机票原价、月份、头等舱或经济舱
Scanner scanner = new Scanner(System.in);
System.out.println("请输入机票原价 ");
double money = scanner.nextDouble();
System.out.println("请输入月份 ");
int month = scanner.nextInt();
System.out.println("请选择经济舱或头等舱 ");
String type = scanner.next();
System.out.println("机票优惠后的价格为: " + money(money,month,type));
}
//2、定义方法接收信息,统计优惠后的价格返回
public static double money(double money, int month, String type) {
if (month >= 5 && month <= 10) {
switch (type) {
case "头等舱":
money *= 0.9;
break;
case "经济舱":
money *= 0.85;
break;
default:
System.out.println("您输入的舱位有误");
money = -1;
}
} else if (month == 11 || month == 12 && month >= 1 && month <= 4) {
switch (type) {
case "头等舱":
money *= 0.7;
break;
case "经济舱":
money *= 0.65;
break;
default:
System.out.println("您输入的舱位有误");
money = -1;
}
}else {
System.out.println("传入的月份有误");
money = -1;
}
return money;
}
}
案例二:找素数
public class Test2 {
public static void main(String[] args) {
//1、定义一个循环找到101-200之间所有元素
System.out.print("101到200之间的素数为 ");
for (int i = 101; i < 200; i++) {
//信号位:标记
boolean falg = true; //一开始认为当前数据为素数
//2、判断当前遍历的这个数是否为素数
for (int j = 2; j < 100; j++) {
if (i % j == 0 ){
falg = false;
break;
}
}
//3、根据判定的结果选择是否输出这个数据,是素数则输出
if (falg){
System.out.print( i + "\t");
}
}
}
}
输出结果
开发验证码
import java.util.Random;
public class Test4 {
public static void main(String[] args) {
String code = code(4);
System.out.println("随机验证码是 " + code);
}
//定义方法获取随机数
public static String code(int n){
//先用for循环获取,定义createCode
String createCode = "";
//获取随机数
Random ra = new Random();
for (int i = 0; i < n; i++) {
//定义随机数0、1、2分别代表大写字母、小写字母、数字
int i1 = ra.nextInt(3);
switch (i1){
case 0:
//大写字符A 65 - Z 65 + 25
char char1 = (char) (ra.nextInt(26) + 65);
createCode += char1;
break;
case 1:
//小写字符A 97 - Z 97 + 25
char char2 = (char) (ra.nextInt(26) + 97);
createCode += char2;
break;
case 2:
//数字0 - 9
int char3 = ra.nextInt(10);
createCode += char3;
break;
}
}
return createCode;
}
}
运行结果
数组元素赋值
public class Test5 {
public static void main(String[] args) {
int[] arr1 = {13,54,243,32};
int[] arr2 = new int[arr1.length];
copy(arr1,arr2);
printArray(arr1);
printArray(arr2);
}
//打印方法
public static void printArray(int[] a){
System.out.print("[");
for (int i = 0; i < a.length; i++) {
int i1 = a[i];
System.out.print(i == a.length -1 ? i1 : (i1 + "," ));
}
System.out.println("]");
}
//赋值方法
public static void copy(int[] a1,int[] a2){
for (int i = 0; i < a1.length; i++) {
a2[i] = a1[i];
}
}
}
运行结果
评委打分案例
import java.util.Scanner;
public class Test3 {
public static void main(String[] args) {
//1、定义初始化数组,存入评委打分分数
int[] scores = new int[6];
//键盘录入
Scanner scanner = new Scanner(System.in);
for (int i = 0; i < scores.length; i++) {
System.out.println("请第" + (i + 1) +"评委打分");
int score = scanner.nextInt();
//将分数存入相应数组位置
scores[i] = score;
}
//通过循环找出最大值、最小值、总值来得到去求最值后的平均分
//先定义最值、平均值变量接收数据
int max = scores[0];
int min = scores[0];
int sum = 0;
for (int i = 0; i < scores.length; i++) {
if (scores[i] > max){
max = scores[i];
}
if (scores[i] < min){
min = scores[i];
}
sum += scores[i];
}
System.out.println("最大值是 " + max + "最小值是 " + min + "平均值" + (sum - max -min)/ (scores.length - 2));
}
}
运行结果
数字加密
import java.util.Scanner;
public class Test4 {
public static void main(String[] args) {
//输入需要加密的个数
System.out.println("需要加密多少位");
Scanner scanner = new Scanner(System.in);
int length = scanner.nextInt();
//用数组存储键盘录入
int[] scores = new int[length];
for (int i1 = 0; i1 < scores.length; i1++) {
System.out.println("请输入第 " + (i1 + 1) + "位数字");
int number = scanner.nextInt();
//将录入数据存入数组
scores[i1] = number;
}
//打印录入数据
printArray(scores);
//核心加密
for (int i = 0; i < scores.length; i++) {
scores[i] = (scores[i] + 5) % 10;
}
//定义i和j进行双向递减直达碰面完成数据互换
for (int i = 0 , j = scores.length -1; i < j; i++ , j--) {
int temp = scores[j];
scores[j] = scores[i];
scores[i] = temp;
}
printArray(scores);
}
//打印方法
public static void printArray(int[] arr){
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + "," );
}
System.out.println("]");
}
}
运行结果
面向对象
设计对象、注意事项
内存机制
- 垃圾回收: 当堆内存当中的对象没有被任何变量引用时,就会被判定为内存中的垃圾
构造器
this关键字
封装
- 面向对象三大特征:封装、多态、继承
- 封装:告诉我们如何正确设计对象的属性和方法
- 封装的原则:对象代表什么,就得封装对应的数据,并提供数据对应的行为
JavaBean、案例
成员变量、局部变量区别
- 作用域 成员变量随着对象出现 局部变量在所归属的大括号中起作用
面向对象综合案例
Movie类
public class Movie {
private String name;
private double score;
private String actor;
public Movie(String name, double score, String actor) {
this.name = name;
this.score = score;
this.actor = actor;
}
public Movie() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
public String getActor() {
return actor;
}
public void setActor(String actor) {
this.actor = actor;
}
}
案例
public class SystemDemo {
public static void main(String[] args) {
Movie[] movies = new Movie[3];
movies[0] = new Movie("流浪地球",9.7,"吴京");
movies[1] = new Movie("我和我的父辈",9.8,"吴京");
movies[2] = new Movie("战狼",9.7,"吴京");
//通过for循环将数组中存储的访问并打印
for (int i = 0; i < movies.length; i++) {
//将访问到的对象赋值并打印
Movie movie = movies[i];
System.out.println("片名" + movie.getName());
System.out.println("评分" + movie.getScore());
System.out.println("演员" + movie.getActor());
System.out.println("----------");
}
}
}
输出结果
String、ArrayList
String的概述、对象创建的原理
创建字符串的两种方式
String常用API
String案例
验证码
import java.util.Random;
public class Test1 {
public static void main(String[] args) {
//1、定义可能出现的字符信息
String dates = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01233456789";
//2、循环5次,每次生成一个随机索引,再拼接返回
Random rs = new Random();
String cores = "";
for (int i = 0; i < 5; i++) {
//随机一个索引
int index = rs.nextInt(dates.length());
// public char charAt(int index) 获取某个索引位置处的字符
char c = dates.charAt(index);
cores += c;
}
System.out.println(cores);
}
}
运行结果
集合概述、ArrayList的使用
泛型概述
ArrayList集合常用方法
集合案例:遍历并删除元素
import java.util.ArrayList;
public class Test1 {
public static void main(String[] args) {
//创建integer泛型类的集合,添加数据
ArrayList<Integer> arrayList = new ArrayList<>();
arrayList.add(98);
arrayList.add(77);
arrayList.add(66);
arrayList.add(89);
arrayList.add(79);
arrayList.add(50);
arrayList.add(100);
System.out.println(arrayList);
//遍历集合,将分数低于80的移除
//遍历方式一:删除后将i自减一位
// for (int i = 0; i < arrayList.size(); i++) {
// //获取集合中的分数
// Integer integer = arrayList.get(i);
// //判断分数是否低于80,低于则移除
// if (integer < 80){
// arrayList.remove(i);
// i--;
// }
// }
//遍历方式二:从集合最后一位开始遍历
for (int i = arrayList.size() - 1; i >= 0; i--) {
Integer integer = arrayList.get(i);
//判断分数是否低于80,低于则移除
if (integer < 80){
arrayList.remove(i);
}
}
System.out.println(arrayList);
}
}
运行结果
集合案例:学生信息系统的数据搜索
学生类
public class Student {
private String studyNumber;
private String name;
private int age;
private String className;
public Student() {
}
public Student(String studyNumber, String name, int age, String className) {
this.studyNumber = studyNumber;
this.name = name;
this.age = age;
this.className = className;
}
public String getStudyNumber() {
return studyNumber;
}
public void setStudyNumber(String studyNumber) {
this.studyNumber = studyNumber;
}
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 String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
}
测试
import java.util.ArrayList;
import java.util.Scanner;
public class Test2 {
public static void main(String[] args) {
//1、定义学生类
//2、创建集合存储学生对象,创建学生对象封装学生信息
//把学生对象添加到集合中去
ArrayList<Student> students = new ArrayList<>();
students.add(new Student("20221118", "天地一号", 12, "天府"));
students.add(new Student("20221119", "天地二号", 13, "天府"));
students.add(new Student("20221120", "天地三号", 14, "天府"));
students.add(new Student("20221121", "天地四号", 15, "天府"));
//3、遍历学生信息展示
System.out.println("学生信息展示");
for (int i = 0; i < students.size(); i++) {
Student student = students.get(i);
System.out.println(student.getStudyNumber() + "\t" + student.getName()
+ "\t" + student.getAge() + "\t" + student.getClassName());
}
//4、定义方法完成按照学号的搜索
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println("请输入学号查找 ");
String s = scanner.next();
//5、调用方法查询
Student studentById = getStudentById(students, s);
//6、判断studentById是否含有学生地址
if (studentById == null) {
System.out.println("查无此人请重新输入 ");
} else {
System.out.println("您查询的学生信息如下");
System.out.println(studentById.getStudyNumber() + "\t" + studentById.getName()
+ "\t" + studentById.getAge() + "\t" + studentById.getClassName());
break;
}
}
}
/**
* 根据学生的学号查询学生对象返回
*
* @param students 存储全部学生对象的集合
* @param studyNumber 搜索的学生的学号
* @return 学生对象 | null
*/
public static Student getStudentById(ArrayList<Student> students, String studyNumber) {
//1、遍历全部学生对象
for (int i = 0; i < students.size(); i++) {
Student student = students.get(i);
//2、询问当前遍历的学生对象的学号,是否为我们要找的学号
if (student.getStudyNumber().equals(studyNumber)) {
//此学生对象即为要寻找的
return student;
}
}
return null;
}
}
运行结果
Static静态关键字
修饰成员变量
- 内存机制
修饰成员方法
Static访问注意事项
应用知识-工具类
应用知识-代码块
案例-斗地主游戏
应用知识-单例模式
- 单例模式
饿汉单例设计模式
懒汉单例模式设计
继承
继承的设计规范、内存运行原理
继承的特点
成员变量 成员方法访问特点
方法重写
子类构造器的特点
子类构造器访问父类无参构造器
this、super使用总结
语法
包
权限修饰符
final
常量
常量概述和基本作用
常量做信息标志和分类
枚举
枚举的概述
枚举的使用场景演示
抽象类
- 概述
抽象类案例
抽象类的特征、注意事项小结
抽象类的应用知识:模板方法模式
接口
接口概述、特点
接口的基本使用:被实现
接口与接口的关系:多继承
接口新增方法、注意事项
多态
多态的概述、形式
多态的优势
多态下引用数据类型的类型转换
多态综合案例
USB
/**
USB接口 == 规范
*/
public interface USB {
//接入、拔出
void connect();
void unconnect();
}
KeyBoard
/**
实现类
*/
public class KeyBoard implements USB {
private String name;
public KeyBoard(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public KeyBoard() {
}
@Override
public void connect() {
System.out.println(name + "成功连接了电脑");
}
@Override
public void unconnect() {
System.out.println(name + "成功退出了电脑");
}
/**
独有功能
*/
public void keyDown(){
System.out.println(name + "敲击了:来了,老弟~~~");
}
}
Mouse
/**
实现类
*/
public class Mouse implements USB {
private String name;
public Mouse(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Mouse() {
}
@Override
public void connect() {
System.out.println(name + "成功连接了电脑");
}
@Override
public void unconnect() {
System.out.println(name + "成功退出了电脑");
}
/**
独有功能
*/
public void dbClick(){
System.out.println(name + "双击");
}
}
Computer
public class Computer {
private String name;
public Computer() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Computer(String name) {
this.name = name;
}
public void start(){
System.out.println(name + "电脑开机了");
}
/**
* 提供安装USB设备的入口
*/
public void USBInstall(USB usb){
//多态:USB可能是KeyBoard或者Mouse
usb.connect();
//先判断再强转
if (usb instanceof KeyBoard){
((KeyBoard) usb).keyDown();
}else if (usb instanceof Mouse){
((Mouse) usb).dbClick();
}
usb.unconnect();
}
}
Test
public class Test {
public static void main(String[] args) {
//a.创建出电脑对象
Computer c = new Computer("戴尔");
c.start();
//b.创建键盘对象、鼠标对象
USB a = new KeyBoard("腹灵");
c.USBInstall(a);
USB b = new Mouse("雷蛇");
c.USBInstall(b);
}
}
代码实现
内部类
静态内部类
成员内部类
局部内部类
匿名内部类
匿名内部类常见使用形式
常用API
Object
Objects
StringBulider
Math
System
BigDecimal
日期与时间
Date
SimpleDateFormat
案例
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDate {
public static void main(String[] args) throws ParseException {
//1、把字符串时间拿到程序中来
String dateStr = "2021年08月06日 11:11:11";
//2、把字符串时间解析为日期对象:形式必须与解析时间的形式完全一致,否则运行时解析报错
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Date date = dateFormat.parse(dateStr);
//3、往后走2天14小时49分06秒
long time = date.getTime() + (2L * 24 * 60 * 60 + 14 * 60 * 60 + 49 * 60 + 6) * 1000;
//4、格式化这个时间毫秒值就是结果
System.out.println(dateFormat.format(time));
}
}
运行结果
Calendar
JDK8新增日期类
Instant
DateTimeFormatter
Duration/Period
- Duration 用于计算两个“时间”间隔
- Period 用于计算两个“日期”间隔