常用类
1. 枚举类
枚举类 枚举类是由一组固定的全局静态常量组成的数据类型
所有的枚举类都默认继承自java.lang.Enum 所以枚举类不能继承其他类 但是可以实现接口
枚举类不能new对象(实际使用也无需new对象)
/**
* @author WHD
* @description TODO
* @date 2024/1/15 15:34
*/
public enum Employee implements Work{
CEO("大拿",50,"001","董事长"),
CTO("刘能",45,"002","技术总监"),
MANAGER("赵四",35,"003","项目经理")
;
private String name;
private int age;
private String empNo;
private String job;
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 getEmpNo() {
return empNo;
}
public void setEmpNo(String empNo) {
this.empNo = empNo;
}
public String getJob() {
return job;
}
public void setJob(String job) {
this.job = job;
}
Employee() {
}
Employee(String name, int age, String empNo, String job) {
this.name = name;
this.age = age;
this.empNo = empNo;
this.job = job;
}
/**
* 根据传入的员工编号获取到员工对象
* @param empNo
* @return
*/
public static Employee finaEmp(String empNo){
// values()方法将当前枚举类中的所有枚举数据 保存到一个数组中
Employee[] values = Employee.values();
Employee emp = null;
for (int i = 0; i < values.length; i++) {
if(values[i].getEmpNo().equals(empNo)){
emp = values[i];
}
}
return emp;
}
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", age=" + age +
", empNo='" + empNo + '\'' +
", job='" + job + '\'' +
"} ";
}
@Override
public void doWork() {
System.out.println(getName() + "在工作");
}
}
package com.atguigu.test7;
/**
* 工作接口
*/
public interface Work {
void doWork();
}
/**
* @author WHD
* @description TODO
* @date 2024/1/15 15:41
*/
public class TestEmp {
public static void main(String[] args) {
Employee cto = Employee.CTO;
System.out.println("cto = " + cto);
Employee ceo = Employee.CEO;
System.out.println("ceo = " + ceo);
Employee manager = Employee.MANAGER;
System.out.println("manager = " + manager);
System.out.println("-----------------------------------------");
Employee employee = Employee.finaEmp("002");
employee.doWork();
}
}
2. 包装类
byte short int long float double boolean char
Byte Short Integer Long Float Double Boolean Character
包装类的构造方法
所有包装类都可将与之对应的基本数据类型作为参数，来构造它们的实例
除Character类外，其他包装类可将一个字符串作为参数构造它们的实例
使用String类型构造Number子类实例 则字符串必须可以解析为正确的数值 并且在合法的范围以内才可以
否则 将出现NumberFormatException 数字格式化异常
使用String构造Boolean实例 字母不区分大小写 内容为true 则为true 其他的 包括null 一律为false
/**
* @author WHD
* @description TODO
* @date 2024/1/15 16:03
*
* byte short int long float double boolean char
* Byte Short Integer Long Float Double Boolean Character
*
* 包装类的构造方法
* 所有包装类都可将与之对应的基本数据类型作为参数，来构造它们的实例
* 除Character类外，其他包装类可将一个字符串作为参数构造它们的实例
*
* 使用String类型构造Number子类实例 则字符串必须可以解析为正确的数值 并且在合法的范围以内才可以
* 否则 将出现NumberFormatException 数字格式化异常
*
* 使用String构造Boolean实例 字母不区分大小写 内容为true 则为true 其他的 包括null 一律为false
*
*
*/
public class TestConstructor {
public static void main(String[] args) {
Byte b1 = new Byte((byte)10);
System.out.println("b1 = " + b1);
byte b = 10;
Byte b2 = new Byte(b);
System.out.println("b2 = " + b2);
Byte b3 = new Byte("123");
System.out.println("b3 = " + b3);
System.out.println("*********************************************");
Short s1 = new Short((short)111);
System.out.println("s1 = " + s1);
Short s2 = new Short("123");
System.out.println("s2 = " + s2);
System.out.println("*********************************************");
Integer i1 = new Integer(123);
System.out.println("i1 = " + i1);
Integer i2 = new Integer("1244");
System.out.println("i2 = " + i2);
System.out.println("*********************************************");
Long l1 = new Long(123);
System.out.println("l1 = " + l1);
Long l2 = new Long("1242");
System.out.println("l2 = " + l2);
System.out.println("*********************************************");
Float f1 = new Float("3.5F");
System.out.println("f1 = " + f1);
Float f2 = new Float(3.5F);
System.out.println("f2 = " + f2);
Float f3 = new Float(3.5);
System.out.println("f3 = " + f3);
System.out.println("*********************************************");
Double d1 = new Double(3.5);
System.out.println("d1 = " + d1);
Double d2 = new Double("3.5");
System.out.println("d2 = " + d2);
System.out.println("*********************************************");
Character ch1 = new Character('A');
System.out.println("ch1 = " + ch1);
System.out.println("*********************************************");
Boolean bl1 = new Boolean(true);
System.out.println("bl1 = " + bl1);
Boolean bl2 = new Boolean(false);
System.out.println("bl2 = " + bl2);
Boolean bl3 = new Boolean("trUE");
System.out.println("bl3 = " + bl3);
Boolean bl4 = new Boolean("hello world");
System.out.println("bl4 = " + bl4);
Boolean bl5 = new Boolean(null);
System.out.println("bl5 = " + bl5);
}
}
3. 包装类转基本数据类型
包装类===》基本数据类型
xxxValue() 每个包装类都提供有这样的一个方法 用于将包装类对象 转换为基本数据类型
/**
* @author WHD
* @description TODO
* @date 2024/1/16 9:10
* 包装类===》基本数据类型
* xxxValue() 每个包装类都提供有这样的一个方法 用于将包装类对象 转换为基本数据类型
*/
public class TestXxxValue {
public static void main(String[] args) {
Byte b1 = new Byte("123");
byte b = b1.byteValue();
System.out.println("b = " + b);
System.out.println("----------------------------------------");
Short s1 = new Short("123");
short i = s1.shortValue();
System.out.println("i = " + i);
System.out.println("----------------------------------------");
Integer i1 = new Integer("1234");
int i2 = i1.intValue();
System.out.println("i2 = " + i2);
System.out.println("----------------------------------------");
Long l1 = new Long("12325");
long l = l1.longValue();
System.out.println("l = " + l);
System.out.println("----------------------------------------");
Float f1 = new Float("3.6F");
float v = f1.floatValue();
System.out.println("v = " + v);
System.out.println("----------------------------------------");
Double d1 = new Double("56798.5");
double v1 = d1.doubleValue();
System.out.println("v1 = " + v1);
System.out.println("----------------------------------------");
Boolean bl1 = new Boolean(true);
boolean b2 = bl1.booleanValue();
System.out.println("b2 = " + b2);
System.out.println("----------------------------------------");
Character ch1 = new Character('A');
char c = ch1.charValue();
System.out.println("c = " + c);
}
}
4. 基本数据类型转包装类
基本数据类型===》包装类对象
valueOf() 每个包装类都提供有这个方法 用于将基本数据类型 转换为包装类对象
/**
* @author WHD
* @description TODO
* @date 2024/1/16 9:15
* 基本数据类型===》包装类对象
* valueOf() 每个包装类都提供有这个方法 用于将基本数据类型 转换为包装类对象
*/
public class TestValueOf {
public static void main(String[] args) {
Byte aByte = Byte.valueOf((byte) 11);
System.out.println("aByte = " + aByte);
System.out.println("***********************************");
Short aShort = Short.valueOf((short) 123);
System.out.println("aShort = " + aShort);
System.out.println("***********************************");
Integer integer = Integer.valueOf(123);
System.out.println("integer = " + integer);
System.out.println("***********************************");
Long aLong = Long.valueOf(24124);
System.out.println("aLong = " + aLong);
System.out.println("***********************************");
Float aFloat = Float.valueOf(3.5F);
System.out.println("aFloat = " + aFloat);
System.out.println("***********************************");
Double aDouble = Double.valueOf(2.3);
System.out.println("aDouble = " + aDouble);
System.out.println("***********************************");
Boolean aBoolean = Boolean.valueOf(false);
System.out.println("aBoolean = " + aBoolean);
System.out.println("***********************************");
Character character = Character.valueOf('A');
System.out.println("character = " + character);
}
}
5.自动装箱和拆箱
装箱和拆箱 从JDK1.5开始 允许基本数据类型和包装类对象 混合计算 这种现象就属于自动装箱和拆箱
装箱：基本数据类型自动转换为包装类对象
拆箱：包装类对象自动转换为基本数据类型
/**
* @author WHD
* @description TODO
* @date 2024/1/16 9:19
* 装箱和拆箱 从JDK1.5开始 允许基本数据类型和包装类对象 混合计算 这种现场就属于自动装箱和拆箱
* 装箱：基本数据类型自动转换为包装类对象
* 拆箱：包装类对象自动转换为基本数据类型
*/
public class Test {
public static void main(String[] args) {
// JDK1.5之前
Integer i1 = new Integer("123");
int b = i1.intValue(); // 先调用intValue()方法 将Integer对象转换为int基本数据类型
int a = 10;
System.out.println(a + b ); // 再将int a 和 int b 进行计算
// JDK1.5以后
Integer c = new Integer("123");
int d = 10;
System.out.println(c + d); // JVM会实现 先将c调用intValue()方法
Integer numa = 100; // 自动装箱 JVM自动调用valueOf()方法
int number = numa; // 自动拆箱 JVM自动调用intValue()方法
}
}
6. 包装类面试题
回顾==和equals的区别？
==比较基本数据类型 比较值
==比较引用数据类型 比较地址
这四个包装类 Short Integer Long Character 直接使用等号赋值的方式
取值范围在byte以内，多个相同取值的包装类对象 ==比较为true
如果超出了byte的取值范围 ==比较为false
原因分析：直接使用等号赋值的方式 JVM会自动帮我们调用valueOf方法
此方法会根据插入的数据进行不同的操作
如果是在byte范围以内 则直接从缓存数组中取出对应的对象 返回
如果不是在byte范围以内 则直接new一个新的对象
为什么Integer类要这样处理？
为了节省内存空间 只要使用等号赋值 在byte范围以内 则直接从缓存数组中取出对应的元素
避免多次创建对象 浪费内存空间
如果不是在byte范围以内 则直接new新的对象
/**
* @author WHD
* @description TODO
* @date 2024/1/16 9:30
* 回顾==和equals的区别？
* ==比较基本数据类型 比较值
* ==比较引用数据类型 比较地址
*
* 这四个包装类 Short Integer Long Character 直接使用等号赋值的方式
* 取值范围在byte以内，多个相同取值的包装类对象 ==比较为true
* 如果超出了byte的取值范围 ==比较为false
*
* 原因分析：直接使用等号赋值的方式 JVM会自动帮我们调用valueOf方法
* 此方法会根据插入的数据进行不同的操作
* 如果是在byte范围以内 则直接从缓存数组中取出对应的对象 返回
* 如果不是在byte范围以内 则直接new一个新的对象
*
* 为什么Integer类要这样处理？
* 为了节省内存空间 只要使用等号赋值 在byte范围以内 则直接从缓存数组中取出对应的元素
* 避免多次创建对象 浪费内存空间
* 如果不是在byte范围以内 则直接new新的对象
*
*
*/
public class TestInterView {
public static void main(String[] args) {
Integer i1 = Integer.valueOf(100);
Integer i2 = Integer.valueOf(100);
System.out.println(i1 == i2); // true
Integer i3 = -129;
Integer i4 = -129;
System.out.println(i3 == i4); // false
Character ch1 = 100;
Character ch2 = 100;
System.out.println(ch1 == ch2);
Character ch3 = 127;
Character ch4 = 127;
System.out.println(ch3 == ch4);
}
}
7.Math类
Math类 数学工具类 此类提供的有关于数学计算的各种方法 和 两个静态常量 此类中的方法全部为静态方法
abs() 获取绝对值
max() 获取最大值
min() 获取最小值
ceil() 向上取整
floor() 向下取整
round() 四舍五入
random() 获取随机数
/**
* @author WHD
* @description TODO
* @date 2024/1/16 10:32
* Math类 数学工具类 此类提供的有关于数学计算的各种方法 和 两个静态常量 此类中的方法全部为静态方法
*
* abs() 获取绝对值
* max() 获取最大值
* min() 获取最小值
* ceil() 向上取整
* floor() 向下取整
* round() 四舍五入
* random() 获取随机数
*/
public class TestMath {
public static void main(String[] args) {
System.out.println(Math.PI);
System.out.println(Math.E);
System.out.println(Math.abs(-123));
System.out.println(Math.max(33, 66));
System.out.println(Math.min(55, 88));
System.out.println(Math.ceil(3.3));
System.out.println(Math.floor(3.9));
System.out.println(Math.round(3.5));
System.out.println((int)(Math.random() * 100));
System.out.println((int)(Math.random() * 12));
}
}
8.Random类
Random类专门用于生成随机数据的类
nextBoolean() 生成随机布尔数据
nextFloat() 生成随机float数据
nextDouble() 生成随机double数据
nextInt() 生成随机int数据
nextInt(int bound) 根据指定范围生成随机int数据
nextLong() 生成随机long类型数据
练习题：猜数字游戏 随机生成一个100以内的整数 让用户猜测 并且提示猜大了 或者 猜小了 直到猜对
打印猜了多少次
import java.util.Random;
/**
* @author WHD
* @description TODO
* @date 2024/1/16 10:42
* Random类专门用于生成随机数据的类
* nextBoolean() 生成随机布尔数据
* nextFloat() 生成随机float数据
* nextDouble() 生成随机double数据
* nextInt() 生成随机int数据
* nextInt(int bound) 根据指定范围生成随机int数据
* nextLong() 生成随机long类型数据
*
* 练习题：猜数字游戏 随机生成一个100以内的整数 让用户猜测 并且提示猜大了 或者 猜小了 直到猜对
* 打印猜了多少次
*/
public class TestRandom {
public static void main(String[] args) {
Random random = new Random();
System.out.println(random.nextBoolean());
System.out.println(random.nextFloat());
System.out.println(random.nextDouble());
System.out.println(random.nextInt());
System.out.println(random.nextInt(100));
System.out.println(random.nextLong());
}
}
9.Runtime类
Runtime 类 此类属于运行时类 每个Java应用程序都会自动创建一个此类的实例 此类不能人为的创建对象
此类提供有关于程序运行时数据的各种方法
此类使用单例模式设计 可以保证在程序运行过程中 只存在一个此类的实例
getRuntime() 获取Runtime类实例
exec() 执行本地的可执行文件
freeMemory() 获取JVM空闲内存 单位为字节
maxMemory() 获取JVM最大内存 单位为字节
totalMemory() 获取JVM总内存 单位为字节
gc() 运行垃圾回收器 当GC确认没有任何引用指向某个对象 则此对象将会被垃圾回收
exit() 退出JVM虚拟机
final finally finalize的区别？
final和finally属于关键字
finalize属于Object类中的方法
final用于修饰属性、方法、类
finally用于异常处理
finalize的作用相当于析构函数 当某个对象被回收时 将自动调用此对象的 finalize方法
import java.io.IOException;
/**
* @author WHD
* @description TODO
* @date 2024/1/16 10:51
* Runtime 类 此类属于运行时类 每个Java应用程序都会自动创建一个此类的实例 此类不能人为的创建对象
* 此类提供有关于程序运行时数据的各种方法
* 此类使用单例模式设计 可以保证在程序运行过程中 只存在一个此类的实例
*
* getRuntime() 获取Runtime类实例
* exec() 执行本地的可执行文件
* freeMemory() 获取JVM空闲内存 单位为字节
* maxMemory() 获取JVM最大内存 单位为字节
* totalMemory() 获取JVM总内存 单位为字节
* gc() 运行垃圾回收器 当GC确认没有任何引用指向某个对象 则此对象将会被垃圾回收
* exit() 退出JVM虚拟机
*
*
* final finally finalize的区别？
* final和finally属于关键字
* finalize属于Object类中的方法
*
* final用于修饰属性、方法、类
* finally用于异常处理
* finalize的作用相当于析构函数 当某个对象被回收时 将自动调用此对象的 finalize方法
*
*/
public class TestRuntime {
public static void main(String[] args) throws IOException {
Runtime runtime1 = Runtime.getRuntime();
System.out.println("空闲内存：" + runtime1.freeMemory() / 1024 / 1024);
// 默认为物理内存的 1 / 4
System.out.println("最大内存：" + runtime1.maxMemory() / 1024 / 1024);
System.out.println("总内存：" + runtime1.totalMemory() / 1024 / 1024);
runtime1.exec("D:\\funny\\10秒让整个屏幕开满玫瑰花\\点我.exe");
Student stu1 = new Student();
Student [] stus = new Student[1];
stus[0] = stu1;
stu1 = null;
runtime1.gc(); // 运行垃圾回收器
System.out.println(stu1);
runtime1.exit(13223);
}
}
class Student{
int age ;
String name;
@Override
protected void finalize() throws Throwable {
super.finalize();
System.out.println("Student对象被gc回收了");
}
}
10.System类
System类 提供了有关于获取系统信息的方法 此类不能new对象 所有的方法均为静态方法
arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 复制数组
currentTimeMillis() 获取当前系统时间毫秒数 从1970年1月1日 0点0分0秒到现在 1秒等于1000毫秒
exit(int status) 退出JVM虚拟机
gc() 运行垃圾回收器
getProperties() 获取系统相关的所有属性
getProperty(String key) 根据指定的键 获取到一个对应的值 值为具体的系统属性
import java.util.Properties;
/**
* @author WHD
* @description TODO
* @date 2024/1/16 14:06
* System类 提供了有关于获取系统信息的方法 此类不能new对象 所有的方法均为静态方法
*
* arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 复制数组
* currentTimeMillis() 获取当前系统时间毫秒数 从1970年1月1日 0点0分0秒到现在 1秒等于1000毫秒
* exit(int status) 退出JVM虚拟机
* gc() 运行垃圾回收器
* getProperties() 获取系统相关的所有属性
* getProperty(String key) 根据指定的键 获取到一个对应的值 值为具体的系统属性
*/
public class TestSystem {
public static void main(String[] args) {
System.out.println(System.currentTimeMillis());
Properties properties = System.getProperties();
properties.list(System.out);
System.out.println("*************************************");
System.out.println(System.getProperty("user.name"));
System.out.println(System.getProperty("java.version"));
System.out.println(System.getProperty("file.encoding"));
}
}
11.java.util.Date类
java.util.Date 此类属于日期类 提供了关于日期的各种操作方法
getDay() 获取一周的第几天
getDate() 获取一个月中的第几天
getYear() 获取年份 + 1900
getMonth() 获取月份 从0开始计数 所以要+1
getHours() 获取小时
getMinutes() 获取分钟
getSeconds() 获取秒钟
import java.util.Date;
/**
* @author WHD
* @description TODO
* @date 2024/1/16 14:22
* java.util.Date 此类属于日期类 提供了关于日期的各种操作方法
* getDay() 获取一周的第几天
* getDate() 获取一个月中的第几天
* getYear() 获取年份 + 1900
* getMonth() 获取月份 从0开始计数 所以要+1
* getHours() 获取小时
* getMinutes() 获取分钟
* getSeconds() 获取秒钟
*/
public class TestDate {
public static void main(String[] args) {
Date date1 = new Date();
System.out.println(date1);
System.out.println(date1.getYear() + 1900 + "年");
System.out.println(date1.getMonth() + 1 + "月");
System.out.println(date1.getDate() + "号");
System.out.println(date1.getDay() + "一周的第几天");
System.out.println(date1.getHours() + "时");
System.out.println(date1.getMinutes() + "分");
System.out.println(date1.getSeconds() + "秒");
System.out.println("**********************************");
long millis = 4578512454854L;
Date date2 = new Date(millis);
System.out.println("date2 = " + date2);
}
}
SimpleDateFormat 日期格式化类 主要提供两个功能
SimpleDateFormat() 无参构造 使用此类默认的格式处理日期以及字符串
SimpleDateFormat(String pattern) 使用指定的模板处理日期以及字符串
1.将日期转换为字符串 format()
2.将字符串解析为日期 parse()
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* @author WHD
* @description TODO
* @date 2024/1/16 14:34
* SimpleDateFormat 日期格式化类 主要提供两个功能
*
* SimpleDateFormat() 无参构造 使用此类默认的格式处理日期以及字符串
* SimpleDateFormat(String pattern) 使用指定的模板处理日期以及字符串
*
* 1.将日期转换为字符串 format()
* 2.将字符串解析为日期 parse()
*/
public class TestSimpleDateFormat {
public static void main(String[] args) throws ParseException {
Date date1 = new Date();
System.out.println("date1 = " + date1);
SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat();
String format1 = simpleDateFormat1.format(date1);
System.out.println("format1 = " + format1);
Date parse = simpleDateFormat1.parse("24-10-10 上午11:22");
System.out.println("parse = " + parse);
System.out.println("----------------------------------------------");
SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm-ss秒");
Date date2 = new Date();
String format = simpleDateFormat2.format(date2);
System.out.println("format = " + format);
Date parse1 = simpleDateFormat2.parse("2024年01月16日 14时42-31秒");
System.out.println("parse1 = " + parse1);
}
}
12.Calendar类
Calendar 日历类 提供有关日期获取以及设置的各种方法 此类不能直接new独享
需要通过getInstance()方法获取此类实例
import java.util.Calendar;
/**
* @author WHD
* @description TODO
* @date 2024/1/16 15:05
* Calendar 日历类 提供有关日期获取以及设置的各种方法 此类不能直接new独享
* 需要通过getInstance()方法获取此类实例
*/
public class TestCalendar {
public static void main(String[] args) {
Calendar instance = Calendar.getInstance();
System.out.println(instance.get(Calendar.YEAR) + "年份");
System.out.println(instance.get(Calendar.MONTH) + 1 + "月份");
System.out.println(instance.get(Calendar.DAY_OF_YEAR) + "一年的天数");
System.out.println(instance.get(Calendar.DAY_OF_WEEK) + "一周的天数");
System.out.println(instance.get(Calendar.DAY_OF_MONTH) + "一月的天数");
System.out.println(instance.get(Calendar.HOUR) + "小时");
System.out.println(instance.get(Calendar.MINUTE) + "分钟");
System.out.println(instance.get(Calendar.SECOND) + "秒钟");
}
}
13.JDK8新增的日期API
13.1 LocalDate
LocalDate 只能用于保存年月日的日期类
now() 获取当前系统时间
of() 根据参数创建一个LocalDate对象
getYear() 获取年份
getMonth() 获取月份
getDayOfYear() 获取一年的第几天
getDayOfMonth() 获取一月的第几天
getDayOfWeek() 获取一周的第几天
import sun.util.resources.LocaleData;
import java.time.LocalDate;
import java.util.Locale;
/**
* @author WHD
* @description TODO
* @date 2024/1/16 15:11
* LocalDate 只能用于保存年月日的日期类
* now() 获取当前系统时间
* of() 根据参数创建一个LocalDate对象
*
* getYear() 获取年份
* getMonth() 获取月份
* getDayOfYear() 获取一年的第几天
* getDayOfMonth() 获取一月的第几天
* getDayOfWeek() 获取一周的第几天
*/
public class TestLocalDate {
public static void main(String[] args) {
LocalDate now = LocalDate.now();
System.out.println(now);
System.out.println(now.getYear() + "年");
System.out.println(now.getMonth() + "月");
System.out.println(now.getDayOfMonth() + "日");
System.out.println(now.getDayOfYear() + "一年的天数");
System.out.println(now.getDayOfWeek() + "一周的天数");
LocalDate of = LocalDate.of(2024, 12, 31);
System.out.println("of = " + of);
}
}
13.2 LocalTime
LocalTime 只能保存时分秒的时间类
now() 获取当前系统时间
of() 根据传入的参数获取LocalTime对象
import java.time.LocalTime;
/**
* @author WHD
* @description TODO
* @date 2024/1/16 15:17
* LocalTime 只能保存时分秒的时间类
*
* now() 获取当前系统时间
* of() 根据传入的参数获取LocalTime对象
*
*/
public class TestLocalTime {
public static void main(String[] args) {
LocalTime now = LocalTime.now();
System.out.println("now = " + now);
System.out.println(now.getHour() + "时");
System.out.println(now.getMinute() + "分");
System.out.println(now.getSecond() + "秒");
System.out.println(now.getNano() + "纳秒");
LocalTime of = LocalTime.of(12, 12, 12);
System.out.println("of = " + of);
}
}
13.3 LocalDateTime
LocalDateTime 包含年月日 时分秒的日期类
of() 根据传入的参数获取LocalDateTime对象
now() 获取当前系统时间 表示的LocalDateTime对象
import java.time.LocalDateTime;
/**
* @author WHD
* @description TODO
* @date 2024/1/16 15:21
* LocalDateTime 包含年月日 时分秒的日期类
* of() 根据传入的参数获取LocalDateTime对象
* now() 获取当前系统时间 表示的LocalDateTime对象
*/
public class TestLocalDateTime {
public static void main(String[] args) {
LocalDateTime now = LocalDateTime.now();
System.out.println("now = " + now.toString());
System.out.println(now.getYear() + "年");
System.out.println(now.getMonth() + "月");
System.out.println(now.getDayOfMonth() + "日");
System.out.println(now.getDayOfYear() + "一年的天数");
System.out.println(now.getDayOfWeek() + "一周的天数");
System.out.println(now.getHour() + "时");
System.out.println(now.getMinute() + "分");
System.out.println(now.getSecond() + "秒");
System.out.println(now.getNano() + "纳秒");
LocalDateTime of = LocalDateTime.of(2008, 12, 12, 12, 12, 12);
System.out.println("of = " + of);
}
}
14.String类
String类常用方法
length() 获取字符串长度
equals() 比较字符串内容
equalsIgnoreCase() 忽略大小写比较内容
toLowerCase() 转换为小写
toUpperCase() 转换为大写
concat() 拼接字符串
indexOf(int ch) : 获取某个字符串第一次出现的位置
indexOf(String ch) : 获取某个字符串第一次出现的位置
lastIndexOf(int ch) 获取某个字符串最后一次出现的位置
lastIndexOf(String value)获取某个字符串最后一次出现的位置
substring(int index) 截取字符串
substring(int index,int endIndex) 截取字符串 包前不包后 trim() 去除字符串首尾的任何不可见的字符
split() 根据指定的条件拆分字符串 拆分后的返回值为字符串数组
charAt(int index) 返回 char指定索引处的值。
contains(CharSequence s) 判断字符串中是否包含某个字符串
endsWith(String suffix) 判断字符串是否以某个字符串结尾
startsWith(String prefix) 判断字符串是否以某个字符串开头
isEmpty() 判断字符串长度是否为0 注意不是是否为null
replace(char oldChar, char newChar) 替换字符串
replaceAll(String regex, String replacement) 支持正则表达式替换字符串
toCharArray() 将字符串转换为插入数组
15.String类相关面试题
String类相关面试题
1.String对象可变吗？
不可变，String类是一个特殊的引用数据类型 String类对象是不可变对象
任何对字符串内容的修改都会产生新的字符串对象
2.为什么String是不可变对象？
一.String类是final修饰的 表示不能有任何类继承String类 不能继承即意味着不能扩展
二.维护字符串对象的char数组是final修饰的 表示不能指向新的地址空间
三.维护字符串对象的char数组同时也使用private修饰 表示其他类都不能直接访问此数组
3.有没有方式可以修改字符串对象的内容？
有，使用反射可以修改字符串的内容
/**
* @author WHD
* @description TODO
* @date 2024/1/17 9:25
* String类相关面试题
* 1.String对象可变吗？
* 不可变，String类是一个特殊的引用数据类型 String类对象是不可变对象
* 任何对字符串内容的修改都会产生新的字符串对象
*
* 2.为什么String是不可变对象？
* 一.String类是final修饰的 表示不能有任何类继承String类 不能继承即意味着不能扩展
* 二.维护字符串对象的char数组是final修饰的 表示不能指向新的地址空间
* 三.维护字符串对象的char数组同时也使用private修饰 表示其他类都不能直接访问此数组
*
* 3.有没有方式可以修改字符串对象的内容？
* 有，使用反射可以修改字符串的内容
*
*
*/
public class TestString1 {
public static void main(String[] args) {
String str1 = "abc"; // 存在字符串常量池中
String str2 = "abc";// 存在字符串常量池中
System.out.println(str1 == str2); // true
String str3 = new String("abc");// 存在堆中
String str4 = new String("abc");// 存在堆中
System.out.println(str1 == str3); // false
System.out.println(str4 == str3); // false
System.out.println("----------------------------------------------");
// 常量 拼接 常量 会在字符串常量池中查找 创建 字符串对象
// 其他的任何情况 都在堆中创建字符串对象
String str5 = "hello";
String str6 = "he";
String str7 = "llo";
String str8 = str6 + str7; // 变量 + 变量
System.out.println(str5 == str8); // false
String str9 = "he" + "llo"; // 常量 + 常量
System.out.println(str5 == str9); // true
String str10 = str6 + "llo"; // 变量 + 常量
System.out.println(str5 == str10); // false
}
}
intern() 调用此方法表示判断当前字符串对象是否在字符串常量池中存在
如果存在 则返回该字符串对象的引用
如果不存在 则先将此字符串对象保存到常量池中 然后再返回该字符串对象的引用
intern方法的作用是为了节约内存 避免在内存中存在相同内容的字符串 浪费内存空间
/**
* @author WHD
* @description TODO
* @date 2024/1/17 9:53
* intern() 调用此方法表示判断当前字符串对象是否在字符串常量池中存在
* 如果存在 则返回该字符串对象的引用
* 如果不存在 则先将此字符串对象保存到常量池中 然后再返回该字符串对象的引用
*
* intern方法的作用是为了节约内存 避免在内存中存在相同内容的字符串 浪费内存空间
*/
public class TestString2 {
public static void main(String[] args) {
String str2 = new String("abc").intern();
String str3 = "abc";
System.out.println(str3 == str2);
}
}
16.StringBuffer和StringBuilder
String StringBuffer StringBuilder 三者的区别？
String是不可变字符串对象
StringBuffer和StringBuilder都是可变字符串对象
StringBuffer是线程安全的 JDK1.0
StringBuilder线程不安全 JDK1.5
/**
* @author WHD
* @description TODO
* @date 2024/1/17 10:31
* String StringBuffer StringBuilder 三者的区别？
* String是不可变字符串对象
* StringBuffer和StringBuilder都是可变字符串对象
*
* StringBuffer是线程安全的 JDK1.0
* StringBuilder线程不安全 JDK1.5
*/
public class TestStringBufferStringBuilder {
public static void main(String[] args) {
String condition = "电脑";
condition += "笔记本";
condition += "联想";
condition += "i9 12代";
// ……
StringBuilder sb = new StringBuilder();
sb.append(true);
sb.append(200);
sb.append(2.5);
sb.append(3.6F);
sb.append('A');
sb.append("hello world");
System.out.println("sb = " + sb);
sb.delete(0, 3);
System.out.println("sb = " + sb);
sb.deleteCharAt(0);
System.out.println("sb = " + sb);
sb.insert(3, '中');
System.out.println("sb = " + sb);
sb.replace(0, 5, "世界你好");
System.out.println("sb = " + sb);
sb.reverse();
System.out.println("sb = " + sb);
}
}
17.BigDecimal和BigInteger
BigDecimal 支持任意精度 任意长度的小数
import java.math.BigDecimal;
import java.math.RoundingMode;
/**
* @author WHD
* @description TODO
* @date 2024/1/17 10:45
* BigDecimal 支持任意精度 任意长度的小数
*/
public class TestBigDecimal {
public static void main(String[] args) {
BigDecimal bd1 = new BigDecimal("7962426526526352635204565265265.5965296526526565356526352");
BigDecimal bd2 = new BigDecimal("7265876352.987465265265");
System.out.println(bd1.add(bd2));
System.out.println(bd1.subtract(bd2));
System.out.println(bd1.multiply(bd2));
System.out.println(bd1.divide(bd2, 10, RoundingMode.HALF_UP));
}
}
BigInteger 支持任意长度的 整数
import java.math.BigInteger;
/**
* @author WHD
* @description TODO
* @date 2024/1/17 10:48
* BigInteger 支持任意长度的 整数
*/
public class TestBigInteger {
public static void main(String[] args) {
BigInteger bi1 = new BigInteger("7815745156215254105210521052");
BigInteger bi2 = new BigInteger("4787512532632021323");
System.out.println(bi1.add(bi2));
System.out.println(bi1.subtract(bi2));
System.out.println(bi1.multiply(bi2));
System.out.println(bi1.divide(bi2));
}
}
18.基本数据类型转字符串
static toString(T param) 每个包装类都提供有这样的一个方法 用于将基本数据类型转换为字符串
/**
* @author WHD
* @description TODO
* @date 2024/1/17 10:52
* static toString(T param) 每个包装类都提供有这样的一个方法 用于将基本数据类型转换为字符串
*/
public class TestToString {
public static void main(String[] args) {
int a = 100;
String b = a + "";
String s = Byte.toString((byte) 12);
System.out.println("s = " + s);
String s1 = Short.toString((short) 12);
System.out.println("s1 = " + s1);
String s2 = Integer.toString(123);
System.out.println("s2 = " + s2);
String s3 = Long.toString(124);
System.out.println("s3 = " + s3);
String s4 = Float.toString(35.5F);
System.out.println("s4 = " + s4);
String s5 = Double.toString(3.5);
System.out.println("s5 = " + s5);
String s6 = Boolean.toString(true);
System.out.println("s6 = " + s6);
String a1 = Character.toString('A');
System.out.println("a1 = " + a1);
}
}
19. 字符串转基本数据类型
static parseXxx() 每个包装类都提供有这样一个方法 用于将字符串转换为基本数据类型
/**
* @author WHD
* @description TODO
* @date 2024/1/17 10:58
* static parseXxx() 每个包装类都提供有这样一个方法 用于将字符串转换为基本数据类型
*/
public class TestParseXxx {
public static void main(String[] args) {
byte b = Byte.parseByte("123");
System.out.println("b = " + b);
short i = Short.parseShort("123");
System.out.println("i = " + i);
int i1 = Integer.parseInt("123");
System.out.println("i1 = " + i1);
long l = Long.parseLong("124");
System.out.println("l = " + l);
float v = Float.parseFloat("123.5F");
System.out.println("v = " + v);
double v1 = Double.parseDouble("2.3");
System.out.println("v1 = " + v1);
boolean trUE = Boolean.parseBoolean("trUE");
System.out.println("trUE = " + trUE);
}
}
20.内部类(了解)
成员内部类：
在类的内部定义，与实例变量、实例方法同级别的类。
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。
当外部类、内部类存在重名属性时，会优先访问内部类属性。
成员内部类不能定义静态成员。
静态内部类：
不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。
只能直接访问外部类的静态成员（实例成员需实例化外部类对象）。
局部内部类：
定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。
局部内部类访问外部类当前方法中的局部变量时，变量必须修饰为final。
限制类的使用范围。
匿名内部类：
没有类名的局部内部类（一切特征都与局部内部类相同）。
必须继承一个父类或者实现一个接口。
定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。
优点：减少代码量。
缺点：可读性较差。
为什么局部内部类和匿名内部类只能访问final变量：
内部类和外部类编译会生成两个平级的.class文件，对于在一个方法中定义的以上两种内部类，如果引用了方法中的变量，当方法执行完成之后，局部变量会被回收，但内部类中仍然引用了它，这就造成了内部类对象访问了一个不存在的变量。所以内部类会赋值局部变量的值作为内部类的成员变量，实际访问的是一份拷贝。但将局部变量复制为内部类的成员变量时，必须保证这两个变量的值是一样的，只能用final修饰，一旦赋值不允许在修改，保证了一致性。
/**
* @author WHD
* @description TODO
* @date 2024/1/17 14:37
* 匿名内部类：属于局部内部类 只不过没有名字
* 使用前提：必须实现一个接口 或者 继承一个抽象类
*/
public class Outer3 {
public static void main(String[] args) {
A a1 = new A() {
@Override
public void m1() {
System.out.println("匿名内部类的方式重写m1方法");
}
@Override
public void m2() {
System.out.println("匿名内部类的方式重写m2方法");
}
@Override
public void m3() {
System.out.println("匿名内部类的方式重写m3方法");
}
};
a1.m1();
a1.m2();
a1.m3();
B b1 = new B() {
@Override
void m1() {
System.out.println("匿名内部类的方式重写m1方法");
}
@Override
void m2() {
System.out.println("匿名内部类的方式重写m1方法");
}
@Override
void m3() {
System.out.println("匿名内部类的方式重写m1方法");
}
};
b1.m1();
b1.m2();
b1.m3();
C c1 = new C(){
@Override
public void m1() {
System.out.println("执行m1方法");
}
};
c1.m1();
}
}
interface A{
void m1();
void m2();
void m3();
}
interface C{
void m1();
}
abstract class B{
abstract void m1();
abstract void m2();
abstract void m3();
}
21.设计模式
设计模式：这个词来源与一本书 《设计模式》 这本书是由一个组合联合编写 GOF
设计模式相当于我们的前辈在长期的开发实践中总结出来的一套用于解决特定问题的方案 一共有二十三种
设计模式的七大原则：
开闭原则 对扩展开放 对修改源代码关闭
接口隔离原则 接口与接口之间相互隔离 没有关联关系 这样便于程序扩展
迪米特法则(原则) 高内聚思想体现 一个类中描述的事物 行为 应该直接与本类关联 不应该没有关联 或者 间接关联
依赖倒置原则 程序中的顶层应该依赖于抽象 而非依赖于具象
里式替换原则 程序中的父类都可以通过使用子类来代替
单一职责(原则) 一个类只描述一个事物 一个方法只描述一个行为
合成复用原则 接口的组合思想 方法的重用思想 继承的重用思想
21.1 单例模式
单例模式：单例即为单个实例 表示在JVM内存中只允许存在一个某个类的实例 这种效果可以通过单例模式实现
饿汉单例：即只要类被加载则立即创建此类对象 称之为饿汉单例
/**
* @author WHD
* @description TODO
* @date 2024/1/17 15:34
* 饿汉单例：即只要类被加载则立即创建此类对象 称之为饿汉单例
*/
public class HungrySingleton {
private static HungrySingleton instance = new HungrySingleton();
private HungrySingleton(){}
public static HungrySingleton getInstance(){
return instance;
}
}
懒汉单例：类被加载并不会创建此类实例 直到调用对应的方法才创建此类实例 因为创建对象的时机较晚 所以称之为懒汉
懒加载思想：并不会一开始就创建对象 或者 开辟空间 而是等待真正使用的时候再创建对象 或者 开辟空间
这种思想可以实现对内存更精确时机的使用。
/**
* @author WHD
* @description TODO
* @date 2024/1/17 15:29
* 单例模式：单例即为单个实例 表示在JVM内存中只允许存在一个某个类的实例 这种效果可以通过单例模式实现
*
* 懒汉单例：类被加载并不会创建此类实例 直到调用对应的方法才创建此类实例 因为创建对象的时机较晚 所以称之为
* 懒汉
* 懒加载思想：并不会一开始就创建对象 或者 开辟空间 而是等待真正使用的时候再创建对象 或者 开辟空间
* 这种思想可以实现对内存更精确时机的使用。
*/
public class LazySingleton {
private static LazySingleton instance = null;
private LazySingleton(){}
public static LazySingleton getInstance(){
if(instance == null){
instance = new LazySingleton();
}
return instance;
}
}
21.2 简单工厂模式
简单工厂模式：是用来创建对象的 我们平时new对象的操作 属于高耦合度的 后续我们学习使用了Spring框以后
将通过Spring框架提供的IOC技术创建对象 IOC(Inversion Of Control) IOC技术的核心实现就是大型的工厂
负责帮我们创建对象
/**
* @author WHD
* @description TODO
* @date 2024/1/17 15:45
*/
public abstract class Vehicle {
public abstract String getVehicleInfo();
}
class Audi extends Vehicle{
@Override
public String getVehicleInfo() {
return "A6";
}
}
class Benz extends Vehicle{
@Override
public String getVehicleInfo() {
return "S500";
}
}
class BMW extends Vehicle{
@Override
public String getVehicleInfo() {
return "740";
}
}
/**
* @author WHD
* @description TODO
* @date 2024/1/17 15:55
* 汽车工厂
*/
public class VehicleFactory {
public static Vehicle buildCar(String car){
if(car.equalsIgnoreCase("audi")){
return new Audi();
}else if(car.equalsIgnoreCase("benz")){
return new Benz();
}else if(car.equalsIgnoreCase("bmw")){
return new BMW();
}
return null;
}
}
/**
* @author WHD
* @description TODO
* @date 2024/1/17 15:45
* 简单工厂模式：是用来创建对象的 我们平时new对象的操作 属于高耦合度的 后续我们学习使用了Spring框以后
* 将通过Spring框架提供的IOC技术创建对象 IOC(Inversion Of Control) IOC技术的核心实现就是大型的工厂
* 负责帮我们创建对象
*/
public class Test {
public static void main(String[] args) {
System.out.println(VehicleFactory.buildCar("bmw").getVehicleInfo());
}
}
21.3 工厂方法模式
工厂方法模式：根据不同的产品单独创建工厂类 以实现扩展性 每添加新的产品就可以添加新的工厂
/**
* @author WHD
* @description TODO
* @date 2024/1/17 15:45
*/
public abstract class Vehicle {
public abstract String getVehicleInfo();
}
class Audi extends Vehicle{
@Override
public String getVehicleInfo() {
return "A6";
}
}
class Benz extends Vehicle{
@Override
public String getVehicleInfo() {
return "S500";
}
}
class BMW extends Vehicle{
@Override
public String getVehicleInfo() {
return "740";
}
}
class BYD extends Vehicle{
@Override
public String getVehicleInfo() {
return "汉 DMI";
}
}
/**
* 汽车工厂接口
*/
public interface VehicleFactory {
Vehicle buildCar();
}
class AudiFactory implements VehicleFactory{
@Override
public Vehicle buildCar() {
return new Audi();
}
}
class BMWFactory implements VehicleFactory{
@Override
public Vehicle buildCar() {
return new BMW();
}
}
class BenzFactory implements VehicleFactory{
@Override
public Vehicle buildCar() {
return new Benz();
}
}
class BYDFactory implements VehicleFactory{
@Override
public Vehicle buildCar() {
return new BYD();
}
}
/**
* @author WHD
* @description TODO
* @date 2024/1/17 16:06
* 工厂方法模式：根据不同的产品单独创建工厂类 以实现扩展性 每添加新的产品就可以添加新的工厂
*/
public class Test {
public static void main(String[] args) {
VehicleFactory factory = new BMWFactory();
System.out.println(factory.buildCar().getVehicleInfo());
}
}
