java常用类的使用

常用类

内部类

什么是内部类

• 在一个类的内部在定义一个类
  class outer{
  	class inner{
  	
  	}
  }
  

特点

1.编译之后可生成独立的字节码文件
2.内部类可以直接访问外部类的私有成员，而不破坏封装
3.可为外部类提供必要的内部功能组件

成员内部类

1.在类的内部定义，与实例变量，实例方法同级别的类
2.外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
3.当外部类，内部类存在重名属性时，会优先访问内部类属性
4.成员内部类不能定义静态成员

package InnerClass.Demo02;

public class Application {
    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();
    }
}

package InnerClass.Demo02;
//外部类
public class Outer {
    //变量
    private String name="张三";
    private int age=10;
    //private,public等修饰符也可以修饰类
    //内部类
    class Inner{
        private String address="北京";
        private String phone="999";
        //同名内部类属性
        private String name="李四";
        private int age=20;

        //成员内部类不能定义静态成员 , 但可以包含静态常量final

        private static final String cry="中国";

        //打印
        public void show(){
            //打印外部类
            //当外部类，内部类存在重名属性时，会优先访问内部类属性 如果想访问同名外部类属性
            System.out.println(Outer.this.name);
            System.out.println(age);
            //打印内部类
            System.out.println(address);
            System.out.println(phone);
        }


    }
}

静态内部类

不依赖外部类对象，可直接创建或通过类名访问

package InnerClass.Demo03;

public class TestOuter {
    public static void main(String[] args) {
        //直接创建静态内部类对象
        //Outer.Inner 表示包含关系
        Outer.Inner inner = new Outer.Inner();
        inner.show();
    }
}

package InnerClass.Demo03;
//外部类
public class Outer {
    private String name="张三";
    private int age=10;
    //静态内部类 和外部类级别相同
    static  class Inner{
        private String address="北京";
        private String phone="111";
        //可以包含静态成员
        private static int count=10000;

        public void show(){
            //调用外部类属性
            //首先创建外部类对象
            Outer Outer=new Outer();
            System.out.println(Outer.name);
            System.out.println(Outer.age);

            //调用内部类属性
            System.out.println(address);
            System.out.println(phone);

            //调用静态内部类的静态属性
            System.out.println(Inner.count);
        }
    }
}

局部内部类

1.定义在外部类方法中，作用范围和创建对象范围仅限于当前方法
2.局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰符为final
3.限制类的使用范围（仅限当前方法）

匿名内部类

1.没有类名的局部内部类（一切特征都与局部内部类相同）
2.必须继承一个父类或者实现一个接口
3.定义类，实现类，创建对象的语法合并，只能创建一个该类的对象
优点：减少代码量
缺点：可读性差

package InnerClass.Demo05;
//接口
public interface USB {
    //服务方法
    void service();
}

package InnerClass.Demo05;

public class Mouse implements USB{
    @Override
    public void service() {
        System.out.println("这是鼠标");
    }
}

package InnerClass.Demo05;

public class TestUsb {
    public static void main(String[] args) {
        //创建接口类型的变量
//        USB usb = new Mouse();
//        usb.service();

        //局部内部类
//        class Fan implements USB{
//
//            @Override
//            public void service() {
//                System.out.println("这是Fan");
//            }
//        }

        //使用局部内部类创建对象
//        USB fan = new Fan();
//        fan.service();

        //使用匿名内部类优化
        USB fan = new USB(){
            @Override
            public void service() {
                System.out.println("这是Fan");
            }
        };
        fan.service();
    }
}

Object类

.超类，基类，所有类的直接或间接父类，位于继承树的最顶层
.任何类,如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承
.object类中所定义的方法，是所有对象都具备的方法
.object类型可以存储任何对象
	。作为参数，可接受任何对象
	。作为返回值，可返回任何对象

getClass

public final Class<?> getClass(){}
.返回引用中存储的实际对象类型
.应用：通常用于判断两个引用中实际存储的对象类型是否一致

package Object.getClass;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }
}

package Object.getClass;

public class TestStudent {
    public static void main(String[] args) {
        Student a1 = new Student("aaa", 20);
        Student a2 = new Student("bbb", 22);

        //判断a1和a2是不是一个类型
        if (a1.getClass()==a2.getClass()){
            System.out.println("类型统一");
        }else {
            System.out.println("类型不一致");
        }
        Class class1=a2.getClass();
        System.out.println(a1.getClass());
        System.out.println(class1);

    }
}

hashCode

.public int hashCode(){}
.返回该对象的哈希值
.哈希值根据对象的地址或者字符串或者数组使用hash算法计算出来的int类型数值
.一般情况下相同对象返回相同的hash值

package Object.hashCode;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }
}

package Object.hashCode;

public class TestStudent {
    public static void main(String[] args) {
        Student a1 = new Student("aaa", 20);
        Student a2 = new Student("bbb", 22);

        //判断a1和a2是不是一个类型
        if (a1.getClass()==a2.getClass()){
            System.out.println("类型统一");
        }else {
            System.out.println("类型不一致");
        }
        //getClass 方法
        Class class1=a2.getClass();
        System.out.println(a1.getClass());
        System.out.println(class1);
        System.out.println("===========================================");
        //hashCode 方法
        System.out.println(a1.hashCode());
        System.out.println(a2.hashCode());
        Student a3=a1;
        System.out.println(a3.hashCode());

    }
}

toString

.public String toString(){}
.返回该对象的字符串表示（表现形式）
.可以根据程序需求覆盖该方法，如：展示对象各个属性值

package Object.toString;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }
//重写toString方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package Object.toString;

public class TestStudent {
    public static void main(String[] args) {
        Student a1 = new Student("aaa", 20);
        Student a2 = new Student("bbb", 22);

        //判断a1和a2是不是一个类型
        if (a1.getClass()==a2.getClass()){
            System.out.println("类型统一");
        }else {
            System.out.println("类型不一致");
        }
        //getClass 方法
        Class class1=a2.getClass();
        System.out.println(a1.getClass());
        System.out.println(class1);
        System.out.println("===========================================");
        //hashCode 方法
        System.out.println(a1.hashCode());
        System.out.println(a2.hashCode());
        Student a3=a1;
        System.out.println(a3.hashCode());
        System.out.println("===========================================");
        //toString 方法
        System.out.println(a1.toString());
        System.out.println(a2.toString());
    }
}

equals

.public boolean equals(Object obj){}
.默认实现为（this==obj），比较两个对象地址是否相同
.可进行覆盖，比较两个对象的内容是否相同

equals()方法覆盖步骤

.比较两个引用是否指向同一个对象
.判断obj是否为null
.判断两个引用指向的实际对象类型是否一致
.强制类型转换
.依次比较各个属性值是否相同

package Object.equals;

import java.util.Objects;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }
//重写toString方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
//重写equals方法

    @Override
    public boolean equals(Object o) {
        //比较两个引用是否指向同一个对象
        if (this == o) return true;
        //判断obj是否为null
        //判断两个引用指向的实际对象类型是否一致
        if (o == null || getClass() != o.getClass()) return false;
        //强制类型转换
        Student student = (Student) o;
        //依次比较各个属性值是否相同
        return age == student.age && Objects.equals(name, student.name);
    }


}

package Object.equals;

public class TestStudent {
    public static void main(String[] args) {
        Student a1 = new Student("aaa", 20);
        Student a2 = new Student("bbb", 22);

        //判断a1和a2是不是一个类型
        if (a1.getClass()==a2.getClass()){
            System.out.println("类型统一");
        }else {
            System.out.println("类型不一致");
        }
        //getClass 方法
        Class class1=a2.getClass();
        System.out.println(a1.getClass());
        System.out.println(class1);
        System.out.println("===========================================");
        //hashCode 方法
        System.out.println(a1.hashCode());
        System.out.println(a2.hashCode());

        Student a3=a1;

        System.out.println(a3.hashCode());
        System.out.println("===========================================");
        //toString 方法
        System.out.println(a1.toString());
        System.out.println(a2.toString());
        //euqals 方法 判断两个对象是否相等
        System.out.println("===========================================");
        System.out.println(a1.equals(a2));
        System.out.println(a1.equals(a3));

        Student a4 = new Student("aaa", 20);
        Student a5 = new Student("aaa", 20);
        System.out.println(a4.equals(a5));

    }
}

finalize()

.当对象被判定为垃圾对象时，由jvm自动调用此方法，用以标记垃圾对象，进入回收队列
.垃圾对象：没有有效引用指向此对象时，为垃圾对象
.垃圾回收：由GC销毁垃圾对象，释放数据存储空间
.自动回收机制：jvm的内存耗尽，一次性回收所有垃圾对象
.手动回收机制：使用System.gc();通知jvm进行垃圾回收

此方法已被删除

包装类

什么是包装类？

.基本数据类型所对应的引用数据类型
.Object可统一所有数据，包装类的默认值是null

类型转换与装箱，拆箱

栈--->堆（装箱）
堆--->栈（拆箱）
.8种包装类提供了不同类型间的转换方式：
	.Number父类中提供的6个共性方法
	.parseXXX()静态方法
	.valueOf
类型要兼容

基本类型的转换

package Packaging;

public class Demo01 {
    public static void main(String[] args) {
        //int a=10;


        //类型转换 装箱 基本类型转为引用类型的过程（栈--->堆）
        //基本类型（基栈）
        int num=18;
        //使用Integer类创建对象
        //Integer integer=new Integer(num);//构造函数Integer(int)在第9版后已弃用
        Integer integer=Integer.valueOf(num);
        System.out.println("装箱："+integer);

        //拆箱 引用类型转换为基本类型（堆---->栈）
        Integer integer1=Integer.valueOf(1001);
        int i = integer1.intValue();
        System.out.println("拆箱："+i);

        //JDK1.5以后提供了自动拆箱装箱
        int age=21;
        //自动装箱
        Integer integer2=age;
        int age1=integer2;

        System.out.println("=================================");
        //基本类型和字符串之间的转换
        //基本类型转换为字符串
        int n1=100;
        //使用+
        String s1=n1+"";
        System.out.println(s1);
        //使用Integer中的toString方法
        String s2 = Integer.toString(n1);
        System.out.println(s2);
        //字符串转基本类型
        String s3="100";
        int i1 = Integer.parseInt(s3);
        System.out.println(i1);
        //boolean字符串形式转成基本类型   “true”会转成true其余则是false
        String s4="tue";
        boolean b1=Boolean.parseBoolean(s4);
        System.out.println(b1);
    }
}

整数缓冲区

.java预先创建了256个常用的整数包装类型对象
.在实际应用当中，对已创建的对象进行复用

package Packaging;

public class Demo02 {
    public static void main(String[] args) {
        //面试题

        //内存地址不相同 堆里面的地址不同
        Integer integer1=new Integer(100);
        Integer integer2=new Integer(100);
        System.out.println(integer1==integer2);//false

        //
        Integer integer3=100;//自动装箱
        Integer integer4=100;
        System.out.println(integer3==integer4);//true  cache缓存区里

        Integer integer5=200;
        Integer integer6=200;
        System.out.println(integer5==integer6);//false  cache缓存区里-128~127
    }
}

String类

.字符串是常量，创建之后不可改变
.字符串字面值存储在字符串池中，可以共享
.String s="hello";产生一个对象，字符池中存储
.String s=new String("hello");//产生两个对象，堆，池中各存储一个

内存分析

package String;

public class Demo01 {
    public static void main(String[] args) {
        String name="hello";//常量存在字符串池中
        name="张三";//“张三”赋值给name 给字符串赋值时，并没有修改数据只是从新开辟了空间
        String name2="张三";

        //字符串的另一种创建方式 new String();
        String str1=new String("java");
        String str2=new String("java");
        System.out.println(str1==str2);
        System.out.println(str1.equals(str2));
    }
}

常用方法

.public int length(); 返回字符串的长度
.public char charAt(int index);根据下标获取字符
.public boolean contains(String str);判断当前字符串中是否包含str

package String;

public class Demo02 {
    public static void main(String[] args) {
        //字符串方法的使用
        //.public int length(); 返回字符串的长度
        //.public char charAt(int index);根据下标获取字符
        //.public boolean contains(String str);判断当前字符串中是否包含str

        String content="java是世界上最好的编程语言";
        System.out.println(content.length());
        System.out.println(content.charAt(4));
        System.out.println(content.contains("java"));
        System.out.println(content.contains("php"));

    }
}

.public char[] toCharArray(); 将字符串转成数组
.public int indexOf(String str);查找str首次出现的下标，存在返回该下标，不存在返回-1
.public int lastIndexOf(String str);查找str最后出现的一次下标

package String;

import java.util.Arrays;

public class Demo03 {
    public static void main(String[] args) {
        //.public char[] toCharArray(); 将字符串转成数组
        //.public int indexOf(String str);查找str首次出现的下标，存在返回该下标，不存在返回-1
        //.public int lastIndexOf(String str);查找str最后出现的一次下标

        String name="java是世界上最好的语言java";
        char[] chars = name.toCharArray();
        //增强for快捷键 xxx.for
//        for (char aChar : chars) {
//            System.out.print(aChar+" ");
//        }
        System.out.println(Arrays.toString(chars));
        System.out.println(name.indexOf("j"));
        System.out.println(name.lastIndexOf("j"));
    }
}

.public String trim();去掉字符串前后的空格
.public String toUpperCase()/toLowerCase();将小写转换为大写、大写转小写
.public String endWith/startsWith(String str);判断字符串是否以str结尾，开头

package String;

import java.util.Locale;

public class Demo04 {
    public static void main(String[] args) {
        //.public String trim();去掉字符串前后的空格
        //.public String toUpperCase()/toLowerCase();将小写转换为大写、大写转小写
        //.public String endWith/startsWith(String str);判断字符串是否以str结尾，开头

        String name1=" java 是世界上最好的语言  ";
        String name2="java";
        String name3="Java";

        System.out.println(name1.trim());
        System.out.println(name3.toLowerCase());
        System.out.println(name2.toUpperCase(Locale.ROOT));
        System.out.println(name3.startsWith("J"));
        System.out.println(name3.endsWith("J"));
    }
}

.public String replace(char oldChar,char newChar);将旧字符串替换成新的
.public String[] split(String str);根据str做拆分

package String;

import java.util.Arrays;

public class Demo05 {
    public static void main(String[] args) {
        //.public String replace(char oldChar,char newChar);将旧字符串替换成新的
        //.public String[] split(String str);根据str做拆分
        String name="张三";
        System.out.println(name.replace("三","四"));
        String say="java is the best programing      language,java xiang";
//        String[] s = say.split(" ");
        String[] s = say.split("[ ,]+");// [] 选择分割 空格或者，进行分割
        System.out.println(Arrays.toString(s));

        //方法补充equals compareTo()；比较大小
        String s1="hello";
        String s2="HELLO";
        System.out.println(s1.equals(s2));
        System.out.println(s1.equalsIgnoreCase(s2));//忽略大小写

        String s3="abc";//97
        String s4="xyz";//120
        System.out.println(s3.compareTo(s4));

    }
}

案例演示

需求
 已知String str="this is a text";
 1.将str中的单词提取出来
 2.将str中的text替换为practice
 3.在text前面插入easy
 4.将每个单词的首字母改为大写

package String;

public class Case01 {
    //需求
    // 已知String str="this is a text";
    // 1.将str中的单词提取出来
    // 2.将str中的text替换为practice
    // 3.在text前面插入easy
    // 4.将每个单词的首字母改为大写
    public static void main(String[] args) {
        String str="this is a text";
        //将str中的单词提取出来
        String[] s = str.split(" ");
        for (String s1 : s) {
            System.out.println(s1);
        }
        //将str中的text替换为practice
        String replace = str.replace("text", "practice");
        System.out.println(replace);
        //在text前面插入easy
        String easy = str.replace("text", "easy text");
        System.out.println(easy);
        //将每个单词的首字母改为大写
        for (int i = 0; i <s.length ; i++) {
            char frist=s[i].charAt(0);
            //把第一个字符转成大写
            char upperfrist = Character.toUpperCase(frist);
            String news=upperfrist+s[i].substring(1);//截取
            System.out.println(news);
        }
    }
}

可变字符串

StringBuffer：可变长字符串，JDK1.0提供，运行效率慢，线程安全
StringBuilder：可变长字符串，JDK5.0提供，运行效率快，线程不安全

package String;
//StringBuffer：可变长字符串，JDK1.0提供，运行效率慢，线程安全
//StringBuilder：可变长字符串，JDK5.0提供，运行效率快，线程不安全
//和String的区别 效率高，节省内存
public class Demo06 {
    public static void main(String[] args) {
        StringBuffer stringBuffer = new StringBuffer();
        //1.append();追加
        stringBuffer.append("java世界第一");
        System.out.println(stringBuffer.toString());
        stringBuffer.append("java真香");
        System.out.println(stringBuffer.toString());
        stringBuffer.append("java不错");
        System.out.println(stringBuffer.toString());
        //2.insert() 添加
        stringBuffer.insert(0,"我在最前面");
        System.out.println(stringBuffer.toString());
        //3.replace() 替换
        stringBuffer.replace(0,5,"我是替换的");//含头不含尾原则
        System.out.println(stringBuffer.toString());
        //4.delete 删除
        stringBuffer.delete(0,5);
        System.out.println(stringBuffer.toString());
        //清空
        stringBuffer.delete(0,stringBuffer.length());
        System.out.println(stringBuffer.toString());
    }
}

package String;
//效率验证
public class Demo07 {
    public static void main(String[] args) {
        long startTime=System.currentTimeMillis();
        String s1="";
        for (int i = 0; i < 99999; i++) {
            s1+=i;
        }
        System.out.println(s1);
        long endTime=System.currentTimeMillis();
        System.out.println("用时："+(endTime-startTime));
        StringBuffer stringBuffer = new StringBuffer();
        long startTime2=System.currentTimeMillis();
        for (int i = 0; i < 99999; i++) {
            stringBuffer.append(i);
        }
        System.out.println(stringBuffer.toString());
        long endTime2=System.currentTimeMillis();

        System.out.println("用时："+(endTime2-startTime2));
    }
}

BigDecimal类

package BigDecimal;

public class Test01 {
    public static void main(String[] args) {
        //采用近似值存储
        double a=1.0;
        double b=0.9;
        System.out.println(a-b);
    }
}

.位置：java.math包中
.作用：精确计算浮点数
.创建方式BigDecimal bd=new BigDecimal("1.0");

package BigDecimal;

import java.math.BigDecimal;

public class Demo01 {
    public static void main(String[] args) {
        //BigDecimal 大的浮点数精确计算
        BigDecimal bigDecimal1 = new BigDecimal("1.0");
        BigDecimal bigDecimal2 = new BigDecimal("0.9");

        //减法
        BigDecimal subtract = bigDecimal1.subtract(bigDecimal2);
        System.out.println(subtract);
        //加法
        BigDecimal add = bigDecimal1.add(bigDecimal2);
        System.out.println(add);
        //乘法
        BigDecimal multiply = bigDecimal1.multiply(bigDecimal2);
        System.out.println(multiply);
        //除法
        BigDecimal divide = new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"));
        System.out.println(divide);
    }
}

Date类

.Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都被Calendar类中的方法所取代
.时间单位：
	1秒=1000毫秒
	1毫秒=1000微秒
	1微秒=1000纳秒

package Date;

import java.util.Date;

public class Dmeo01 {
    public static void main(String[] args) {
        Date date1 = new Date();
        System.out.println(date1.toString());
        System.out.println(date1.toLocaleString());
        Date date2 = new Date(date1.getTime()-60*60*24*1000);
        System.out.println(date2.toLocaleString());
        System.out.println(date2.before(date1));
        System.out.println(date1.after(date2));

    }
}

Calendar类

package Calendar;

import java.util.Calendar;

public class Demo01 {

    public static void main(String[] args) {
        //创建Calendar对象 因为修饰符protected受保护
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());

        //获取时间信息
        //获取年
        int year = calendar.get(calendar.YEAR);
        System.out.println(year);
        //月
        int month = calendar.get(calendar.MONTH);
        System.out.println(month);
        //日
        int day = calendar.get(calendar.DAY_OF_MONTH);
        System.out.println(day);
        //小时
        int hour=calendar.get(calendar.HOUR);
        System.out.println(hour);
        


    }
}

SimpleDateFormat类

package SimpleDateFormat;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo01 {
    public static void main(String[] args) {
        //1.创建SimpleDateFormat对象
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日HH：mm：ss");
        //2.创建Date
        Date date = new Date();
        //3.格式化
        String format = simpleDateFormat.format(date);
        System.out.println(format);

        //解析（把字符装换日期）
        SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy/MM/dd");
        Date parse = null;
        try {
            parse = simpleDateFormat2.parse("1990/05/05");
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println(parse.toLocaleString());
    }
}

System类

package System;

import java.util.Arrays;

public class Demo01 {
    public static void main(String[] args) {
        //数组复制  Arrays.copyOf其实用的就是System.arraycopy
        int[] a={12,3,4,5,7,45,7,9,7,3};
        int[] b=new int[8];
        System.arraycopy(a,0,b,0,5);
        System.out.println(Arrays.toString(b));
    }
}

package System;

public class student {
    private String naem;
    private int age;

    public student(String naem, int age) {
        this.naem = naem;
        this.age = age;
    }

    public student() {
    }

    public String getNaem() {
        return naem;
    }

    public void setNaem(String naem) {
        this.naem = naem;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "student{" +
                "naem='" + naem + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("回收了"+naem);
    }
}

package System;

public class Demo02 {
    public static void main(String[] args) {
        new student("aaa", 19);
        new student("bbb", 19);
        new student("ccc", 19);
        new student("ccc", 19);
        new student("ccc", 19);
        new student("ccc", 19);
        new student("ccc", 19);
        new student("ccc", 19);
        new student("ccc", 19);
        new student("ccc", 19);
        new student("ccc", 19);
        new student("ccc", 19);
        new student("ccc", 19);
        new student("ccc", 19);
        new student("ccc", 19);
        new student("ccc", 19);
        new student("ccc", 19);
        new student("ccc", 19);
        new student("ccc", 19);
        new student("ccc", 19);
        new student("ccc", 19);
        new student("ccc", 19);
        new student("ccc", 19);
        System.gc();
    }
}

总结（King老师）