内容来自B站 千锋Java 的视频笔记：视频入口
一、内部类
内部类概念：在一个类的内部再定义一个完整的类。
特点：
1. 编译之后可生成独立的字节码文件
2. 内部类可直接访问外部类的私有成员，而不破坏封装。
3. 可为外部类提供必要的内部功能主键。
成员内部类
- 在类的内部定义，与实例变量、实例方法同级别的类。
- 在外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。
- 当外部类、内部类存在重命属性时，会优先访问内部类属性。
- 成员内部类不能定义静态成员，但是可以定义静态常量。
代码实现:
package JavaTest;
//外部类
public class Outer {
//类型变量
private String name="张三";
private int age=20;
//内部类
class Inner{
private String adress="张家口";
private int high=180;
//当外部类、内部类存在重命属性时，会优先访问内部类属性。
private String name="李四";
//成员内部类不能定义静态成员，但是可以定义静态常量。
private static final String country="中国";
public void show(){
//打印外部类的属性
//重命时，打印外部类中的属性
System.out.println(Outer.this.name);
System.out.println(Outer.this.age);
System.out.println(name);
//System.out.println(this.name);更准确
System.out.println(age);
//打印内部类的属性
System.out.println(adress);
System.out.println(high);
}
}
}
package JavaTest;
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();//Outer.Inner：层次关系/包含关系
inner.show();
}
}
静态内部类
1. 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。
2. 能直接访问外部类的静态成员（实例成员需要实例化外部类对象）。
代码实现：
package JavaTest;
//外部类
public class Outer {
private String name="xxx";
private int age=18;
//静态内部类：和外部类同级别
//只有内部类才用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(outer.name);
System.out.println(outer.age);
//3 调用静态内部类的属性和方法
System.out.println(address);
System.out.println(phone);
//4 调用静态内部类的静态属性：通过类名访问
System.out.println(Inner.count);
}
}
}
package JavaTest;
public class OuterTest {
public static void main(String[] args){
//能直接访问外部类的静态成员（实例成员需要实例化外部类对象）。
//直接创建静态内部类对象
Outer.Inner inner = new Outer.Inner();//Outer.Inner()表示包含关系
//调用方法
inner.show();
}
}
局部内部类
- 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。
- 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final。
- 限制类的使用范围。
package JavaTest;
//外部类
public class Outer {
private String name="刘德华";
private int age=35;
public void show(){
//定义局部变量
//局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final。
final String address="深圳";
//局部内部类：注意不能加任何访问修饰符，与局部变量同级别
class Inner{
//局部内部类的属性
private String phone="13124124";
private String email="liudehua@qq.com";
// 不能有静态变量但是可以有静态常量
// private final static int age=100;
public void show2(){
//访问外部类的属性
System.out.println(Outer.this.age);
System.out.println(Outer.this.name);
//访问内部类的属性
System.out.println(this.email);
System.out.println(this.phone);
//访问局部变量,jdk1.7要求：变量必须是常量final，jdk1.8之后自动添加final
System.out.println(address);
}
}
//创建局部内部类对象
Inner inner = new Inner();
inner.show2();
}
}
package JavaTest;
public class OuterTest {
public static void main(String[] args){
Outer outer = new Outer();
//需要在show方法中创建一个局部内部类对象
//不然没有任何输出，因为show方法只写了一个局部变量
outer.show();
}
}
匿名内部类
- 没有类名的局部内部类（一切特征都与局部内部类 相同）
- 必须继承一个父类或者实现一个接口
- 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
- 优点：减少代码量
- 缺点：可读性较差
代码实现：
package JavaTest;
public class UsbTest {
public static void main(String[] args) {
//创建接口类型的变量
// Usb usb = new Mouse();
// usb.service();
// //局部内部类
// class Fan implements Usb{
// @Override
// public void service() {
// System.out.println("连接电脑成功，风扇开始工作");
// }
// }
// //使用局部内部类创建对象
// Usb usb = new Fan();
// usb.service();
//使用匿名内部类优化(相当于创建了一个局部内部类)
Usb usb = new Usb() {//Usb()：可以是接口、抽象类、父类
@Override
public void service() {
System.out.println("连接电脑成功，风扇开始工作");
}
};
usb.service();
}
}
package JavaTest;
public class Mouse implements Usb {
@Override
public void service(){
System.out.println("连接电脑成功，鼠标开始工作");
}
}
package JavaTest;
public interface Usb {
void service();
}
二、Object类
- 超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
- 任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承。
- Object类中所定义的方法，是所有对象都具备的方法。
- Object类型可以存储任何对象。
作为参数，可以接受任何对象。
作为返回值，可以返回任何对象。
三、Object类常用方法
getClass方法
- public final Class<?> getClass(){}
- 返回引用中存储的实际对象类型。
- 应用：通常用于判断两个引用中实际存储对象类型是否一致。
hashCode()方法
- public int hashCode(){}
- 返回该对象的哈希码值
- 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值
- 一般情况下相同对象返回相同的哈希码，可判断返回的对象是否相同。
toString()方法
- public String toString(){}
- 返回该对象的字符串表示（表现形式）。
- 可以根据程序需求覆盖（重写）该方法，如：展示对象各个属性值。
equals()方法
-
public boolean equals(Object obj){}
-
默认实现为（this == obj），比较两个对象地址是否相同。
-
可进行覆盖，比较两个对象的内容是否相同。
equals()方法覆盖步骤：
1. 比较两个引用是否指向同一个对象。
2. 判断obj是否为null。
3. 判断两个引用指向的实际对象类型是否一致。
4. 强制类型转换。
5. 依次比较各个属性值是否相同。
finalize()方法
- 当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。
- 垃圾对象：没有有效引用指向此对象时，为垃圾对象。
- 垃圾回收：由GC销毁垃圾对象，释放数据存储空间。
- 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。
- 手动回收机制：使用System.gc()；通知JVM执行垃圾回收。
四、包装类
什么是包装类
- 基本数据类型所对应的引用数据类型。
- Object可统一所有数据，包装类的默认值是null。
将基本类型byte从栈中保存到堆中，Byte：引用类型
类型转换与装箱、拆箱
- 装箱：把栈里面的对象放到堆里面。基本类型转换为引用类型
- 拆箱：把堆里面的对象放到栈里面。引用类型转化为基本类型
- 8钟包装类提供不同类型间的转换方式：
Number父类中提供的6个共性方法。
parseXXX()静态方法。
valueOf()静态方法。 - 注意：需保证类型兼容，否则抛出NumberFormatException异常（数字格式化异常）
代码实现：
package JavaTest;
public class Demo {
public static void main(String[] args) {
//JDK1.5之后，提供自动装箱和拆箱
int age = 30;
//自动装箱：基本类型转换为引用类型
Integer integer1 = age;
System.out.println("自动装箱");
System.out.println(integer1);
//自动拆箱：引用类型转化为基本类型
int age1=integer1;
System.out.println("自动拆箱");
System.out.println(age1);
System.out.println("----基本类型和字符串之间转换----");
//1基本类型转成字符串
int n1=255;
//1.1使用+号
String s1=n1+"";
//1.2使用Integer中的同String()方法
String s2=Integer.toString(n1,16);//f
System.out.println(s1);
System.out.println(s2);
//2字符串转成基本类型
String str="150";
//使用Integer.parseXXX();
int n2=Integer.parseInt(str);
System.out.println(n2);
//boolean字符串形式转换成基本类型，"true"--->true 非"true"--->false
String str2="true";
String str3="tree";
boolean b1 = Boolean.parseBoolean(str2);
boolean b2 = Boolean.parseBoolean(str3);
System.out.println(b1);
System.out.println(b2);
}
}
整数缓存区
- Java预先创建了256个常用的整数包装类型对象。
- 在实际应用当中，对已创建的对象进行复用。
代码实现：
package JavaTest;
public class Demo {
public static void main(String[] args) {
//面试题
//有new，就说明在堆中产生了新的对象，内存地址就不同
Integer integer1=new Integer(100);
Integer integer2=new Integer(100);
System.out.println(integer1==integer2);//false
//自动装箱，反编译知，其实是调用了Integer.valueOf方法，而它的范围：-128~127（256）
Integer integer3=100;//Integer integer3=Integer.valueOf(100);
Integer integer4=100;//Integer integer4=Integer.valueOf(100);
System.out.println(integer3==integer4);//true
//自动装箱，接上文：如果不在这个范围里，就new一个内存空间：new Integer(i)
Integer integer5=200;//Integer integer5=Integer.valueOf(200);
Integer integer6=200;//Integer integer6=Integer.valueOf(200);
System.out.println(integer5==integer6);//false
}
}
五、String类
- 字符串是常量，创建之后不可改变，不可变性。
- 字符串字面值存储在字符串池中，可以共享。
- String s = “hello”;产生一个对象，字符串池中存储。
- String s = new String(“hello”)；产生两个对象，堆、池各存储一个。
package JavaTest;
public class Demo {
public static void main(String[] args) {
String name="hello";//“hello”常量存储在字符串池中
/* 不可变性：
“zhangsan”赋值给name变量，并不是将字符串池中的hello修改为zhangsan，而是重
新开辟一个空间，存放“zhangsan”，然后将hello替换掉，栈中的name不再指向hello
而是指向zhangsan，此时hello成为一个垃圾数据*/
name="zhangsan";
String name2="zhangsan";
/*字符串的共享：
此时再定义一个name2="zhangsan"，栈中的name2就会去字符串池中找有没有zhangsan
如果有就将这个张三赋给name2,即：name、name2都指向zhangsan。
* */
//演示字符串的另一个创建方式，new String()
String str=new String("java");
/*此时堆、和池中都有一个“java”对象，栈中的str引用指向堆中的java。
实际运行中，堆中并没有java，“java”在字符串池中，这两个java其实是一个。
这种方法浪费空间
上方图解。
*/
String str2=new String("java");
System.out.println(str==str2);//比较的hash值
System.out.println(str.equals(str2));//比较的是字符串里面的数据是否相等
}
}
String常用方法
- public int length():返回字符串的长度。
- public char charAt(int index):根据下标获取字符。
- public boolean contains(String str):判断当前字符串中是否包含str。
- public char[] toCharArray():将字符串转换成数组。
- public int IndexOf(Sring str):查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1。
- public int lastIndexOf(String str):查找字符串在当前字符串中最后一次出现的下标索引。
- public String trim():去掉字符串前后的空格。
- public String toUpperCase():将小写转成大写。（代码实现中包括大小写之间的转换）
- public boolean endWith(String str):判断字符串是否以str结尾。（代码实现中包括str开始与结尾）
- public String replace(char oldChar,char newChar):将旧字符串替换成新字符串。
- public Stringp[] split(String str):根据str做拆分。
package JavaTest;
import java.util.Arrays;
public class Demo {
public static void main(String[] args) {
//字符串方法的使用
//1.length();显示/返回字符串的长度
//2.charAt(int index);显示/返回某个位置的字符
//3.contains(String str);判断是否包含某个子字符串
String content="java是世界上最好的编程语言，java真香，学习java";
System.out.println(content.length());//29
System.out.println(content.charAt(content.length()-1));//a
System.out.println(content.contains("java"));//true
System.out.println(content.contains("php"));//false
//4.toCharArray();返回字符串对应的数组
//5.indexOf();返回子字符串首次出现的位置
//6.lastIndexOf();返回子字符串最后一次出现的位置
System.out.println(Arrays.toString(content.toCharArray()));
System.out.println(content.indexOf("java"));//0
//从下标为4开始查找java首次出现的位置
System.out.println(content.indexOf("java",4));//16
System.out.println(content.lastIndexOf("java"));//25
//7.trim();去掉字符串前后的空格
//8.toUpperCase();将小写转成大写。toUpperCase();将大写转成小写。
//9.startWith(str);判断字符串是否以str开头。endWith(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
System.out.println(filename.startsWith("hello"));//true
//10.replace(char oldChar,char newChar);用新的字符或字符串替换新的字符或字符串
//11.split();对字符串进行拆分
System.out.println(content.replace("java","php"));
//php是世界上最好的编程语言，php真香，学习php
String say="java is the best programing language,java xiang";
//[]中可以填多个拆分依据：[ ,]:以空格还有逗号拆分字符串
// [ ,]+:空格和逗号可以连着出现一个或多个，然后以此为拆分依据
String[] arr=say.split("[ ,]+");
for (String string : arr) {
System.out.println(string);//遍历一下拆分结果
}
// java
// is
// the
// best
// programing
// language
// java
// xiang
//补充：equals():比较数值、compareTo()：比较大小（编码表的位置）
String s1="hello";
String s2="HELLO";
System.out.println(s1.equalsIgnoreCase(s2));//忽略大小写比较数据是否一样
}
}
String案例
已知String str = “this is a text”；
- 将str中的单词单独获取出来。
- 将str中的text替换为practice。
- 在text前面插入一个easy。
- 将每个单词的首字母改为大写。
package JavaTest;
public class Demo {
public static void main(String[] args) {
String str = "this is a text";
//1.
String[] arr = str.split(" ");
for (String string : arr) {
System.out.println(string);
}
//2.
System.out.println(str.replace("text","practice"));
//3.
System.out.println(str.replace("a ","a easy "));
//4.
for (int i = 0; i < arr.length; i++) {
//遍历字符串，并取出下标为0的字符：首字母
char first=arr[i].charAt(0);
//把取出来的首字母转换为大写
char upperfirst=Character.toUpperCase(first);
//substring(1):从下标1开始截取，substring(1，8)：截取下标1-8之间的字符
//将首字符和后面的单词拼接起来
String news=upperfirst+arr[i].substring(1);
System.out.println(news);
}
}
}
可变字符串
- StringBuffer：可变长字符串，JDK1.0提供，运行效率慢（相对于StringBuilder）、线程安全。
- StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全。
- 以上两个和String的区别：(1):效率比String高。(2):比String节省内存。
StringBuffer/StringBuilder常用方法
package JavaTest;
public class Demo {
public static void main(String[] args) {
//StringBuffer sb = new StringBuffer();
//和StringBuffer运行结果一样
StringBuilder sb = new StringBuilder();
//1 append();追加
sb.append("java世界第一");
System.out.println(sb.toString());
sb.append("java真棒");
System.out.println(sb.toString());
sb.append("java真香");
System.out.println(sb.toString());
//2 insert();添加xx到前面，添加的字符（串）的第一个字符成为第xx个
sb.insert(2,"我字是第3个字符");
System.out.println(sb.toString());
//3 replace();替换,含头不含尾：下标2-9的字符换成了9
sb.replace(2,10,"9");
System.out.println(sb.toString());
//4 delete();删除，含头不含尾：下标2的字符被删除
sb.delete(2,3);
System.out.println(sb.toString());
//清空
sb.delete(0,sb.length());
System.out.println(sb.length());
}
}
运行结果：
java世界第一
java世界第一java真棒
java世界第一java真棒java真香
ja我字是第3个字符va世界第一java真棒java真香
ja9va世界第一java真棒java真香
java世界第一java真棒java真香
0
String和StringBuilder效率对比：
package JavaTest;
public class Demo {
public static void main(String[] args) {
//开始时间
long start=System.currentTimeMillis();
String string="";//16009ms
for (int i = 0; i < 99999; i++) {
string+=i;
}
System.out.println(string);
// StringBuilder sb=new StringBuilder();//19ms
// for (int i = 0; i < 99999; i++) {
// sb.append(i);
// }
// System.out.println(sb.toString());
//结束时间
long end=System.currentTimeMillis();
System.out.println("用时："+(end-start));
}
}
六、Big Decimal类
- 位置：java.math包中。
- 作用：精确计算浮点数。
- 创建方式：BigDecimal bd=new BigDecimal(“1.0”);//如果有数据类型选择，一定要选String类型，更准确。JDK1.8，未遇到。
- 方法：
加法：BigDecimal add(BigDecimal bd)
减法：BigDecimal subtract(BigDecimal bd)
乘法：BigDecimal multiply(BigDecimal bd)
除法：BigDecimal divide(BigDecimal bd)
roundingMode：舍入模式：点此进入
代码实现：
package JavaTest;
import java.math.BigDecimal;
public class Demo {
public static void main(String[] args) {
//面试题
double result=(1.4-0.5)/0.9;
System.out.println(result);//0.9999999999999999
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 result2=bd1.subtract(bd2);//bd1-bd2
System.out.println(result2);//0.1
//加法:add
BigDecimal result3=bd1.add(bd2);
System.out.println(result3);//1.9
//乘法:multiply
BigDecimal result4=bd1.multiply(bd2);
System.out.println(result4);//0.90
//除法:divide
BigDecimal result5=new BigDecimal("1.4").subtract(new BigDecimal("0.5"))
.divide(new BigDecimal("0.9"));//(1.4-0.5)/0.9
System.out.println(result5);//1
//除不尽问题：
//BigDecimal result6=new BigDecimal("10").divide(new BigDecimal("3"));
//报错：java.lang.ArithmeticException:Non-terminating decimal expansion;no exact representable decimal result.
//解决：
//scale:保留几位小数，roundingMode：舍入模式，详细看代码上方链接。ROUND_HALF_UP：四舍五入
BigDecimal result6=new BigDecimal("20").divide(new BigDecimal("3"),3,BigDecimal.ROUND_HALF_UP);
System.out.println(result6);//6.667
}
}
七、Date类
- Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代。
- 时间单位：1秒=1000毫秒；1毫秒=1000微妙；1微秒=1000纳秒。
compareTo() 方法：点此进入
equals() 方法：点此进入
package JavaTest;
import java.util.Date;
public class Demo {
public static void main(String[] args) {
//1 创建Date对象
//今天
Date date1=new Date();
System.out.println(date1.toString());//Tue Nov 01 21:49:45 CST 2022
System.out.println(date1.toLocaleString());//过时了,2022-11-1 21:49:45
//昨天:(60*60*24*1000)一天(s)
Date date2=new Date(date1.getTime()-(60*60*24*1000));
System.out.println(date2.toLocaleString());//2022-10-31 21:49:45
//2 方法after、before
boolean b1=date1.after(date2);
System.out.println(b1);//true
boolean b2=date1.before(date2);
System.out.println(b2);//false
//比较compareTo();
int d=date2.compareTo(date1);
System.out.println(d);//-1
//比较是否相等equals()
boolean b3=date1.equals(date2);
System.out.println(b3);//false
}
}
八、Calendar类
代码实现：
getInstance()方法：点此进入
Calendar.getInstance()方法：点此进入
不仅能获取当前的时间，还能指定需要获取的时间点，在项目应用中达到定时的作用。
package JavaTest;
import java.util.Calendar;
import java.util.Date;
public class Demo {
public static void main(String[] args) {
//1 创建Calendar对象
Calendar calendar=Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString());//2022-11-1 22:23:52
//返回从格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000到Calendar对象表示的时间之间的毫秒数
System.out.println(calendar.getTimeInMillis());//1667312632973
//2 获取时间信息
//获取年
int year=calendar.get(Calendar.YEAR);
//获取月:从0-11
int mouth=calendar.get(Calendar.MONTH);
//获取日
int day=calendar.get(Calendar.DAY_OF_MONTH);//Calendar.Date
//获取小时
int hour=calendar.get(Calendar.HOUR_OF_DAY);//HOUR:12小时，HOUR_OF_DAY:24小时
//获取分钟
int minute=calendar.get(Calendar.MINUTE);
//获取秒
int second=calendar.get(Calendar.SECOND);
//2022年11月1日22时38分21秒
System.out.println(year+"年"+(mouth+1)+"月"+day+"日"+hour+"时"+minute+"分"+second+"秒");
//3 修改时间
Calendar calendar2=Calendar.getInstance();//获取时间
calendar2.set(Calendar.DAY_OF_MONTH,5);//set(修改的时间项.要改的时间)
System.out.println(calendar2.getTime().toLocaleString());//2022-11-5 22:38:21
//4 add方法修改时间
calendar2.add(Calendar.HOUR,1);//add(修改的时间项.要改幅度：加一小时，1；减一小时，-1)
System.out.println(calendar2.getTime().toLocaleString());//2022-11-5 23:38:21
//5 补充方法
//获得这个时间项中最大值与最小值
//DAY_OF_MONTH:以1-31之间的整数形式返回每月的第几天。
int max=calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);//本月最多几天
int min=calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
System.out.println(max);//30
System.out.println(min);//1
}
}
九、SimpleDateFormat类
代码实现：
package JavaTest;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo {
public static void main(String[] args) throws Exception{
//1 创建SimpleDateFormat对象
SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd HH-mm-ss");
//2 创建Date
Date date=new Date();
//格式化date（把日期转换成字符串）
String str=sdf.format(date);
System.out.println(str);//2022/11/01 23-10-57
//解析（把字符串转换成日期）
//由于parse方法会抛出一个未处理异常，需要在main上添加异常的方法签名
Date date2=sdf.parse("2000/04/02 01-22-33");
System.out.println(date2);//Sun Apr 02 01:22:33 CST 2000
}
}
十、System类
代码实现：
package JavaTest;
public class Demo {
public static void main(String[] args){
//1 复制数组
/* arraycopy：数组的复制
System.arraycopy(src,srcPos,dest,destPos,length)
src：源数组
srcPos：从那个位置开始复制
dest:目标数组
destPos：目标数组的位置,复制到的位置
length：复制的长度
*/
int[] arr={343,45,35,3,2,6456,7,5,54};
int[] dest=new int[8];
System.arraycopy(arr,4,dest,4,3);
for (int i = 0; i < dest.length; i++) {
System.out.println(dest[i]);
}
//Arrays.copyOf()其实也是使用了System.arraycopy()方法
//2 获取毫秒数
System.out.println(System.currentTimeMillis());
//实现程序计时器的效果
long start=System.currentTimeMillis();
for (int i = -999999999; i < 999999999; i++) {
for (int j = -999999999; j < 999999999; j++) {
int result=i*j;
}
}
long end=System.currentTimeMillis();
System.out.println("用时："+(end-start));//用时：6
//3 回收垃圾
//创建的数据没人引用=垃圾数据
new Demo1("aaa",19);
new Demo1("bbb",19);
new Demo1("ccc",19);
System.gc();//告诉垃圾回收器回收
// 回收了ccc 19
// 回收了bbb 19
// 回收了aaa 19
//4 退出jvm
System.exit(0);
System.out.println("程序结束了");//运行不出来，因为jvm已经退出
}
}
十一、总结
- 内部类：
在一个类的内部再定义一个完整得类。
成员内部类、静态内部类、局部内部类、匿名内部类。 - Object类：
所有类的直接或间接父类，可存储任何对象。 - 包装类：
基本数据类型所对应的引用数据类型，可以是Object统一所有数据。 - String类：
字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享。 - BigDecimal：
可精确计算浮点数。 - Date
特定时间 - Calendar
日历 - SimpleDateFormat
格式化时间 - System
系统类
补充：
1. 基本数据类型存储在栈中，引用类型存储在堆中，栈中存放了引用。
275
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
