Java SE07_常用类笔记
常用类
1 内部类
成员内部类、静态内部类、局部内部类、匿名内部类
概念：在一个类的内部再定义一个完整的类
特点：
- 编译之后可生成独立的字节码文件
- 内部类可直接访问外部类私有成员，而不破坏封装
- 可为外部类提供必要的内部功能组件
Body$Header.class Body.class
// 身体
class Body{
// 头部
class Header{
// 也会生成class文件
}
}
1.1 成员内部类
- 在类的内部定义，与实例变量、实例方法同级别的类
- 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
- 当外部类、内部类存在重名属性时，会优先访问内部类属性
- 成员内部类里不能定义静态成员、可以包含静态常量(final)
//外部类
public class Outer {
//实例变量
private String name = "张三";
private int age = 20;
//内部类
class Inner{
private String address="北京";
private String phone = "110";
//属性和外部类的属性名字相同时，默认访问内部类的，除非使用Outer.this.
private String name = "李四";
// private static String country = "中国";//成员内部内不能包括静态成员
// private static final String country = "中国";//但是可以包括静态常量
//方法
public void show(){
//打印外部类的属性 Outer.this.
System.out.println("打印外部类的属性:");
System.out.println(Outer.this.name);//使用这种会更加明确
System.out.println(age);
//打印内部类的属性
System.out.println("打印内部类的属性:");
System.out.println(this.name);//使用这种会更加明确
System.out.println(address);
System.out.println(phone);
}
}
}
public class OuterTest {
//测试类
public static void main(String[] args) {
// 1.创建外部类对象
Outer outer = new Outer();
// 2.创建内部类对象
Outer.Inner inner = outer.new Inner();
//一步到位
// Outer.Inner inner = new Outer().new Inner();
inner.show();
}
}
1.2 静态内部类
- 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员
//外部类
public class Outer {
//实例变量
private String name = "xxx";
private int age = 18;
//静态内部类，和外部类相同，只有内部类可以通过static修饰，外部类不可以用static修饰
static class Inner{
private String address="上海";
private String phone="111";
//静态成员
private static int count = 1000;
public void show(){
//调用外部类的属性
//1.先创建外部类对象
Outer outer = new Outer();
//2.调用外部类对象的属性
//打印外部类的属性
System.out.println("打印外部类的属性:");
System.out.println(outer.name);
System.out.println(outer.age);
//调用静态内部类的属性和方法
//打印静态内部类的属性
System.out.println("打印静态内部类的属性:");
System.out.println(address);
System.out.println(phone);
//调用静态内部类的静态属性
System.out.println(Inner.count);
}
}
}
public class OuterTest {
//测试类
public static void main(String[] args) {
//直接创建静态内部类对象
Outer.Inner inner = new Outer.Inner();
inner.show();
}
}
1.3 局部内部类
- 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法
- 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final
- 限制类的使用范围
//外部类
public class Outer {
//实例变量
private String name = "程序员";
private int age = 22;
public void show(){
//定义局部变量
String address = "深圳";
//局部内部类：注意不能加任何访问修饰符
class Inner{
//局部内部类的属性
private String email="158@qq.com";
private String phone="1588888888";
//属性和外部类的属性名字相同时，默认访问内部类的，除非使用Outer.this.
private int age = 33;
//静态成员
private int count = 1000;
public void show2() {
//打印外部类的属性
System.out.println("打印外部类的属性:");
System.out.println(Outer.this.name);//使用这种会更加明确
System.out.println(Outer.this.age); //22
//打印局部内部类的属性
System.out.println("打印局部内部类的属性:");
System.out.println(age); //33 如果内部类无age则为22
System.out.println(this.phone);//使用这种会更加明确
System.out.println(email);
//打印局部变量(不能修改)，jdk1.7要求变量必须为常量，jdk1.8之后自动添加final
System.out.println("打印局部变量的属性:");
System.out.println(address);
}
}
//创建局部内部类对象
Inner inner = new Inner();
inner.show2();
}
}
public class OuterTest {
//测试类
public static void main(String[] args) {
Outer out = new Outer();
out.show();
}
}
1.4 匿名内部类
- 没有类名的局部内部类（一切特征都与局部内部类相同）
- 必须继承一个父类或者实现一个接口
- 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
- 优点：减少代码量
- 缺点可读性较差
//使用匿名内部类优化（相当于创建了一个局部类）
Usb usb = new Usb(){ //Usb为一个接口，也可以是Monuse（实现了Usb的一个方法），不会影响到Monuse里的方法
@Override
public void service() {
System.out.println("连接电脑成功，风扇开始工作了...");
}
};
usb.service();
2 Object类
- 超类、基类，所有类的直接或间接父类，位于继承树的最顶层
- 任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承
- Object类中所定义的方法，是所有对象都具备的方法
- Object类型可以存储任何对象
- 作为参数，可接受任何对象
- 作为返回值，可返回任何对象
2.1 getClass()方法
- 返回引用中存储的实际对象类型
- 应用：通常用于判断两个引用中实际存储对象类型是否一致
- 返回Class类型
//判断s1和s2是不是同一个类型，getClass返回 class类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
if(class1.equals(class2)){
System.out.println("s1和s2属于同一个对象");
}else {
System.out.println("s1和s2不属于同一个对象");
}
2.2 hashCode()方法
- 返回该对象的哈希码值
- 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的值
- 一般情况下相同对象返回相同哈希码
- 返回int类型
s1.hashCode();
s2.hashCode();
// 自然不同
Student s3 = s1; // 此时s3的hashCode与s1相同
2.3 toString()方法
- 返回该对象的字符串表示（表现形式）
- 可以根据程序需求覆盖该方法，如：展示对象各个属性值
- 返回String类型
//toString方法
System.out.println(s1.toString());//Object的toString直接打印包+类名+哈希值
System.out.println(s2.toString());//重写的toString直接打印该类的具体信息
2.4 equals()方法
- 默认实现为(this == obj), 比较两个对象地址是否相同
- 可进行覆盖，比较两个对象的内容是否相同
- 返回boolean类型
equals()方法覆盖步骤
- 比较两个引用是否指向同一个对象。
- 判断obj是否为nul1。
- 判断两个引用指向的实际对象类型是否一致。
- 强制类型转换。
- 依次比较各个属性值是否相同。
//4.equals方法：判断两个对象值是否相等
System.out.println(s1.equals(s2));//false
System.out.println(s1.equals(s3));//true
Student s4 = new Student("小明", 17);
Student s5 = new Student("小明", 17);
System.out.println(s4.equals(s5));//true
//重写equals方法
@Override
public boolean equals(Object o) {
//1.判断两个对象是否是同一个引用
if (this == o) return true;
//2.判断o是否为空
//3.判断是否是同一个类型（getClass()）（也可以 o instanceof Student）
//instanceof判断对象是否是某种类型
if (o == null || getClass() != o.getClass()) return false;
//4.强制类型转换
Student student = (Student) o;
//5.比较属性
return age == student.age &&
name.equals(student.name);
}
2.5 finalize()方法
- 当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列
- 垃圾对象：没有有效引用指向此对象时，为垃圾对象
- 垃圾回收：由gc销毁垃圾对象，释放数据存储空间
- 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象
- 手动回收机制：使用System.gc();通知JVM执行垃圾回收
//finalize回收垃圾
new Student("小明", 17);
System.gc();
System.out.println("回收垃圾");
//会打印回收垃圾 小明对象被回收了...
//重写finalize方法
@Override
protected void finalize() throws Throwable {
System.out.println(this.name+"对象被回收了...");
}
3 包装类
- 基本数据类型所对应的引用数据类型
- Object 可统一所有数据，包装类的默认值是null
| 类型 | 包装类 | 字节位数 |
|---|---|---|
| byte | Byte | 8位，-128~127 |
| boolean | Boolean | 1位，默认false |
| short | Short | 16位，-32768~32767 |
| char | Character | 16位，存储Unicode码 |
| int | Integer | 32位 |
| long | Long | 64位 |
| float | Float | 32位 |
| double | Double | 64位 |
3.1 类型转换与装箱、拆箱
- 8种包装类提供不用类型间的转换方式
- Number父类中提供的6个共性方法
parseXXX( )静态方法valueOf( )静态方法
- 注意：需保证类型兼容，否则抛出NumberFormatException异常
public static void main(String[] args) {
//类型转换：装箱:基本类型 -> 引用类型, 基本类型转成引用类型的过程
//基本类型
int num1 = 10;
//第一种：使用Integer类创建对象
Integer integer1 = new Integer(num1);
//第二种：使用Integer类valueOf方法
Integer integer2 = Integer.valueOf(num1);
//类型转换，拆箱，引用类型转成基本数据类型
Integer integer3 = new Integer(100);
int num2 = integer3.intValue();
//从jdk1.5之后，提供自动装箱和拆箱
int age = 18;
//自动装箱
Integer integer4 = age;
//自动拆箱
int age2 = integer4;
//基本类型和字符串之间的转换
//1.基本类型 -> 字符串
int n1 = 100;
//1.1 使用+号
String s1 = n1+"";
//1.2 使用Integer中的toString方法
String s2 = Integer.toString(n1);//Integer.toString(n1, radix); radix表示的是进制数
//2.字符串 -> 基本类型
String str = "150";
//使用Integer.parsXXX()
int n2 = Integer.parseInt(str);
//3.boolean -> 基本类型,"true"->true,非"true"->false
String str2 = "true";
String str3 = "ture";
System.out.println(Boolean.parseBoolean(str2));//true
System.out.println(Boolean.parseBoolean(str3));//false
}
3.2 整数缓冲区
- Java预先创建了256个常用的证书包装类型对象
- 在实际应用当中，对已创建的对象进行复用
public static void main(String[] args) {
//面试题
Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
//==比较的是地址，equals比较的是值
System.out.println(integer1 == integer2);//false
System.out.println(integer1.equals(integer2));//true
Integer integer3 = 100;//自动装箱，Integer.ValueOf
Integer integer4 = 100;
//IntegerCache缓存区数组 [-128, 127],在缓冲区的地址相同所以为true
System.out.println(integer3 == integer4);//true
Integer integer5 = 200;
Integer integer6 = 200;
//因为缓存区数组 [-128, 127],超过之后不能进入缓冲区，没在缓冲区的就需要new Integer,地址不同所以为false
System.out.println(integer5 == integer6);//false
Integer integer7 = Integer.valueOf("200");//只有int类型的可以自动装箱，其他的需要手动装箱
Integer integer8 = Integer.valueOf("200");
System.out.println(integer7 == integer8);//false
}
4 String类
- 字符串是常量，创建之后不可改变
- 字符串字面值存储在字符串池中，可以共享
String s = "Hello";产生一个对象，在字符串常量池中存储String s = new String("Hello");产生两个对象，堆、池各一个
4.1 常用方法
public static void main(String[] args) {
//字符串方法的使用
//1.length(); 返回字符串长度
//2.charAt(int index); 返回某个位置的字符
//3.contains(String str); 判断是否包含某个字符串
String content = "java是最好的语言,java No.1,java最好";
System.out.println(content.length());//27 字符串长度
System.out.println(content.charAt(0));//j 返回第一个位置的字符
System.out.println(content.charAt(content.length()-1));//好 返回最后一个位置的字符
System.out.println(content.contains("java"));//true 判断是否包含'java'
System.out.println(content.contains("php"));//false 判断是否包含'php'
//4.toCharArray(); 返回字符串对应数组
//5.indexOf(); 返回子字符串首次出现的位置
//6.lastIndexOf(); 返回字符串最后一次出现的位置
System.out.println(Arrays.toString(content.toCharArray()));//[j, a, v, a, 是, 最, 好, 的, 语, 言, ,, j, a, v, a, , N, o, ., 1]
System.out.println(content.indexOf("java"));//0 第一个出现的下标
System.out.println(content.indexOf("java", 4));// 从索引4开始找 返回11
System.out.println(content.lastIndexOf("java"));//21，最后一个出现的下标
//7.trim(); //去掉字符串前后空格
//8.toUpperCase(); toLowerCase(); 转换大小写
//9.endWith(str); startWith(str); 判断是否以str 结尾、开头
String content2 = " Hello World ";
System.out.println(content2.trim());//Hello World 去掉前后空格
System.out.println(content2.toUpperCase());// HELLO WORLD 转大写
System.out.println(content2.toLowerCase());// hello world 转小写
String filename = "hello.java";
System.out.println(filename.endsWith(".java"));//true 判断是否以.java结尾
System.out.println(filename.startsWith("hello"));//true 判断是否以hello开头
//10.replace(char old, char new); 用心的字符或字符串替换旧的字符或字符串
//11.split(); 对字符串拆分
//content="java是最好的语言,java No.1,java最好"
System.out.println(content.replace("java", "php"));//php是最好的语言,php No.1,php最好
String say = "java is the best programing language";
String[] s = say.split(" ");//split("[ ,]+")可以以空格和逗号一起分割，+号代表可以出现多个（贪婪匹配）
System.out.println(s.length);//6 切割后的数组长度
for (String str : s){
System.out.print(str+"\t");//java is the best programing language
}
System.out.println();
//补充两个equals/compareTo();比较大小
//equalsIgnoreCase忽略大写写进行比较
String s1 = "hello";
String s2 = "HELLO";
System.out.println(s1.equals(s2));//false 比较值
System.out.println(s1.equalsIgnoreCase(s2));//true 忽略大小写比较
String s3 = "abc";//97
String s4 = "xyz";//120
//compareTo(); 两字符不同时比较字符字典序的ascii码相减
//字符相同时比较长度 返回差值
System.out.println(s3.compareTo(s4));//-23
}
4.2 案例演示
已知String str = "this is a text"，需求：
- 将str中的单词单独获取
- 将str中的text替换成practice
- 在text前面插入一个easy
- 将每个单词的首字母改为大写
public static void main(String[] args) {
String str = "this is a text";
//1. 将str中的单词单独获取
String[] arr = str.split(" ");
for(String s : arr) {
System.out.print(s+"\t");//this is a text
}
System.out.println();
//2. 将str中的text替换成practice
String str2 = str.replace("text", "practice");
System.out.println(str2);//this is a practice
//3. 在text前面插入一个easy
String str3 = str.replace("text", "easy text");
System.out.println(str3);//this is a easy text
//4. 将每个单词的首字母改为大写
for(int i = 0; i < arr.length; i++) {
char first = arr[i].charAt(0);
//把第一个字符转成大写
char upperfirst = Character.toUpperCase(first);
//拼接 substring():从1开始截取,可以有结束的位置
arr[i] = upperfirst+arr[i].substring(1);
System.out.print(arr[i]+"\t");//This Is A Text
}
}
4.3 可变字符串
- StringBuffer：jkd1.0提供，可变长字符串，运行效率慢、线程安全。
- StringBuilder：jkd5.0提供，可变长字符串、运行快、线程不安全。
- StringBuilder更快，StringBuffer线程更安全（一般使用StringBuffer比较好）
效率都比String高且节省内存，单线程使用StringBuilder。
public static void main(String[] args) {
//StringBuffer和StringBuilder 用法一致
StringBuffer sb = new StringBuffer();
// StringBuilder sb = new StringBuilder();
//1.append(); 追加
sb.append("java世界第一");
System.out.println(sb.toString());//java世界第一
//2.insert(); 添加、插入
sb.insert(0,"start");//指定位置插入
System.out.println(sb.toString());//startjava世界第一
//3.replace(); 替换
sb.replace(0, 5, "hello");//左闭右开
System.out.println(sb.toString());//hellojava世界第一
//4. delete(); 删除
sb.delete(0, 5);//左闭右开
System.out.println(sb.toString());//java世界第一
//5.reverse(); 字符反转
sb.reverse();
System.out.println(sb.toString());//一第界世avaj
//6. 清空 sb.delete(0, sb.length())
sb.delete(0, sb.length());
System.out.println(sb.length());//0 清空之后的长度
}
5 BigDecimal类
- 位置
java.math包中 - 作用 精确计算浮点数
- Double是近似值存储，在某些实际应用中需要精确运算，Double类型不符合要求，所以需要借助BigDecimal。
public static void main(String[] args) {
double d1 = 1.0;
double d2 = 0.9;
System.out.println(d1 - d2);//0.09999999999999998
//BigDecimal 大的浮点数精确计算
BigDecimal bd1 = new BigDecimal("1.0");//用字符窜
BigDecimal bd2 = new BigDecimal("0.9");
//减法：subtract()
BigDecimal r1 = bd1.subtract(bd2);
System.out.println(r1);//0.1
//加法：add()
BigDecimal r2 = bd1.add(bd2);
System.out.println(r2);//1.9
//乘法：multiply()
BigDecimal r3 = bd1.multiply(bd2);
System.out.println(r3);//0.90
//除法：divide()
//divide(BigDecimal divisor, int scale, int roundingMode) scale:保留位数,roundingMode:小数取舍模式
//BigDecimal.ROUND_HALF_DOWN 四舍五入
//不设置scale和roundingMode除不尽时会报异常
BigDecimal r4 = new BigDecimal("1.4")
.subtract(new BigDecimal("0.5"))
.divide(new BigDecimal("0.9"));//(1.4-0.5)/0.9
System.out.println(r4);//1
//除不尽时 2的地方填保留位数 后面保留类型为四舍五入
BigDecimal r5 = new BigDecimal("20").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_DOWN);
System.out.println(r5);//6.67
}
6 日期类
6.1 Date类
Date表示特定的瞬间，精确到毫秒（ms）。在jkd1.1开始，Date类中的大部分方法都已经被Calendar类中的方法所取代。
时间单位：s（秒），ms（毫秒），μs（微秒），ns（纳秒）
- 1s = 1,000ms
- 1ms = 1,000μs
- 1μs = 1,000ns
public static void main(String[] args) {
//1.创建Date对象 java.util包下的
Date date1 = new Date();//当前时间
System.out.println(date1);//Mon May 23 00:00:00 CST 2022
System.out.println(date1.toLocaleString());//2022-5-23 00:00:00 已过时 但也能用
//昨天的时间
Date date2 = new Date(date1.getTime()-(60*60*24*1000));
System.out.println(date2.toLocaleString());//2022-5-22 00:00:00
//2.方法after before
//b1的时候是否在b2之后
boolean b1 = date1.after(date2);
//b1的时候是否在b2之前
boolean b2 = date1.before(date2);
System.out.println(b1);//true
System.out.println(b2);//false
//比较compareTo(); 比较的是毫米值 今天的时间毫秒值比昨天的毫秒值多
int d = date1.compareTo(date2);
System.out.println(d);//1 多的为1 少的为 -1
//比较是否相等 equals()
boolean b3 = date1.equals(date2);
System.out.println(b3);//false
}
6.2 Calendar类
- Calendar提供了获取或设置各种日历字段的方法
- 构造方法
protected Calendar();由于是protected 所以无法直接创建 - 其他方法
| 方法名 | 说明 |
|---|---|
| static Calendar getInstance() | 使用默认时区和区域获取日历 |
| void set(int year, int month, int date, int hourofday, int minute, int second) | 设置日历的年、月、日、时、分、秒 |
| int get(int field) | 返回给定日历字段的值。字段比如年、月、日 |
| void setTime(Date date) | 用给定的date设置此日历时间 Date -> Calendar |
| Date getTime() | 返回一个date表示此日历的时间 Calendar -> Date |
| void add(int field, int amount) | 按照日历的规则，给指定字段添加或减少时间量 |
| long getTimeInMilles() | 毫秒为单位返回该日历的时间值 |
public static void main(String[] args) {
//1.创建Calendar类
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString());//2022-5-23 00:00:00
//2.获取时间的信息
//获取年
int year = calendar.get(Calendar.YEAR);
//获取月（从0-11）
int month = calendar.get(Calendar.MONTH);
//获取日(两个都可以)
int day1 = calendar.get(Calendar.DAY_OF_MONTH);
int day2 = calendar.get(Calendar.DATE);
//小时
int hour1 = calendar.get(Calendar.HOUR_OF_DAY);//12小时
int hour2 = calendar.get(Calendar.HOUR);//24小时
//分钟
int minute = calendar.get(Calendar.MINUTE);
//秒
int second = calendar.get(Calendar.SECOND);
//3.修改时间
Calendar calendar2 = Calendar.getInstance();
calendar2.set(calendar.DAY_OF_MONTH,22);//设置日数为22
System.out.println(calendar2.getTime().toLocaleString());//2022-5-22 00:00:00
//4.add()方法修改时间
calendar2.add(Calendar.HOUR,1);//添加1小时时间 第二个参数amount属性为正+，为负-
System.out.println(calendar2.getTime().toLocaleString());//2022-5-22 01:00:00
//5.补充方法
int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);//该数最大天数
int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);//该数最小天数
System.out.println("max="+max+" min="+min);//max=31 min=1
}
6.3 SimpleDateFormat类
- SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
- 进行格式化（日期→文本）、解析（文本→日期）
- 常用的时间模式字母
| 字母 | 日期或时间 | 示例 |
|---|---|---|
| y | 年 | 2019 |
| M | 年中月份 | 08 |
| d | 月中天数 | 10 |
| H | 一天中小时（0-23） | 22 |
| m | 分钟 | 16 |
| s | 秒 | 59 |
| S | 毫秒 | 356 |
public static void main(String[] args) throws Exception {
//1.创建SimpleDateFormat对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd");
//2.创建Date对象
Date date = new Date();
//3.格式化date（日期—>字符串）
String str = sdf.format(date);
System.out.println(str);//2022年05月23日 00:00:00
//解析（字符串—>日期）
Date date2 = sdf2.parse("1970/01/02");//parse有异常，需要抛出Exception异常
System.out.println(date2.toLocaleString());//1970-1-2 0:00:00
//踩坑记录：parse的参数必须符合sdf的格式，否则会报异常
}
7 System类
主要用于获取系统的属性数据和其他操作，构造方法私有的
| 方法名 | 说明 |
|---|---|
| static void arraycopy(...) | 复制数组 |
| static long currentTimeMillis(); | 获取当前系统时间，返回毫秒值 |
| static void gc(); | 建议jvm赶快启动垃圾回收期器回收垃圾 |
| static void exit(int status); | 退出jvm 如果参数是0表示正常退出jvm 非0表示异常退出 |
public static void main(String[] args) {
//1.arraycopy(src,srcPos,dest,destPos,length) 数组的复制
//src:原数组 srcPos:从哪个位置开始复制(以0开始) dest:目标数组 destPos:目标数组的位置 length:复制的长度
int[] arr = {20, 18, 15, 8};
int[] dest1 = new int[4];
int[] dest2 = new int[4];
System.arraycopy(arr, 0, dest1, 0, dest1.length);
System.arraycopy(arr, 2, dest2, 2, 2);
for (int i = 0; i < dest1.length; i++) {
System.out.print(dest1[i]+" ");//20 18 15 8
}
System.out.println();
for (int i = 0; i < dest2.length; i++) {
System.out.print(dest2[i]+" ");//0 0 15 8
}
//2.Arrays.copyOf(original, newLength) Arrays工具类也是用的arraycopy来实现
System.out.println();
int[] ints = Arrays.copyOf(arr, 2);
for (int i = 0; i < ints.length; i++) {
System.out.print(ints[i]+" ");//20 18
}
//3.System.currentTimeMillis() 自1970年1月1日零点到目前计算这一刻所经历的的毫秒数
//返回值为long型，因为int已经存不下了
long time = System.currentTimeMillis();
System.out.println(time);//一串数字
//4.System.gc();告诉垃圾回收器回收
//5.System.exit(0); 退出jvm,后面的代码不执行
}
总结
内部类：
- 在一个类的内部再定义一个完整的类。
- 成员内部类、静态内部类、局部内部类、匿名内部类。
Object类：
- 所有类的直接或间接父类，可存储任何对象。
包装类：
- 基本数据类型所对应的引用数据类型，可以使0bject统一所有数据。
String类：
- 字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享。
BigDecimal：
- 可精确计算浮点数。
Date：
- 特定时间
Calendar：
- 日历，Date过期的方法可使用Calendar里面的方法
SimpleDateFormat：
- 格式化时间
System：
- 系统类
· 阿里巴巴 QwQ-32B真的超越了 DeepSeek R-1吗？
· 10年+ .NET Coder 心语 ── 封装的思维：从隐藏、稳定开始理解其本质意义
· 【设计模式】告别冗长if-else语句：使用策略模式优化代码结构
· 字符编码：从基础到乱码解决
· 提示词工程——AI应用必不可少的技术