Java常用类

最新推荐文章于 2024-09-25 10:59:43 发布

烟花丨绿`

最新推荐文章于 2024-09-25 10:59:43 发布

阅读量48

点赞数

文章标签： java servlet jvm

本文链接：https://blog.csdn.net/qq_68060664/article/details/130126811

版权

内部类

◆ 在一个类的内部再定义一个完整的类。

◆ 成员内部类、静态内部类、局部内部类、匿名内部类。

成员内部类

//外部类
public class Outer02 {
    private String name="张三";
    private int age=12;
    //内部类
    class Inner {
        private String address="北京";
        private int phone=120;

        private String name="李四";

        public void show() {
            System.out.println(Outer02.this.name);
            System.out.println(age);
            System.out.println(address);
            System.out.println(phone);
        }
    }
}
//测试类
public class Outer02Test {
    public static void main(String[] args) {
//        Outer02 outer02 = new Outer02();
//        Outer02.Inner inner = outer02.new Inner();
//        inner.show();

        Outer02.Inner inner = new Outer02().new Inner();
        inner.show();
    }
}

静态内部类

//外部类
public class Outer03 {
    private String name = "张三";
    private int age = 12;

    //静态内部类：和外部类相同
    static class Inner {
        private String address = "上海";
        private int phone = 111;
        //静态属性
        private static int count = 1000;

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

            //调用静态内部类的属性
            System.out.println(address);
            System.out.println(phone);
            //调用静态内部类的静态属性
            System.out.println(Inner.count);
        }
    }
}
//测试类
public class Outer03Test {
    public static void main(String[] args) {
        //直接创建静态内部类对象
        Outer03.Inner inner = new Outer03.Inner();

        inner.show();
    }
}

局部内部类

//外部类
public class Outer04 {
    //外部类属性
    private String name = "王五";
    private int age = 15;

    public void show() {
        //定义局部变量
        String address = "中国";
        //final String address = "中国";

        //局部内部类：不能添加任何访问修饰符
        class Inner{
            //局部内部类的属性
            private String phone = "15008937654";
            private String email = "王五@qq.com";
            //private final static int count = 12;

            public void show2() {
                //访问外部类的属性
                System.out.println(Outer04.this.name);
                System.out.println(age);
                //访问局部内部类的属性
                System.out.println(this.phone);
                System.out.println(email);
                //访问局部变量，jdk1.7要求：变量必须是常量，jdk1.8自动添加final
                System.out.println(address);
                //变量address其实已经变成常量"中国"
                //System.out.println("中国");
            }
        }
        //创建局部内部类对象，才能访问局部内部类的方法
        Inner inner = new Inner();
        inner.show2();
    }
}
//测试类
public class Outer04Test {
    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.show();
    }
}

匿名内部类

//创建一个接口
public interface Outer05Usb {
    void service();
}
//链接接口
public class Outer05Mouse implements Outer05Usb{
    @Override
    public void service() {
        System.out.println("连接电脑成功，鼠标开始工作了...");
    }
}
//测试类
public class Outer05Test {
    public static void main(String[] args) {
        //创建接口类型的变量
//        Outer05Usb outer05Usb = new Outer05Mouse();
//        outer05Usb.service();

        //局部内部类
//        class Fan implements Outer05Usb{
//            @Override
//            public void service() {
//                System.out.println("电脑连接成功，风扇开始工作了....");
//            }
//        }
        //使用局部内部类创建对象
//        Outer05Usb outer05Usb = new Fan();
//        outer05Usb.service();

        //使用匿名内部类优化（相当于创建了一个局部内部类）
        Outer05Usb outer05Usb = new Outer05Usb() {
            @Override
            public void service() {
                System.out.println("电脑连接成功，风扇开始工作了....");
            }
        };
        outer05Usb.service();
    }
}

0bject类

◆ 所有类的直接或间接父类，可存储任何对象。

//创建一个学生类
public class ObjectStudent {
    private String name;
    private int age;

    public ObjectStudent(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;
    }

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

    //equals();方法默认比较地址值；重写equals();方法，把其改成比较属性值是否相等
    @Override
    public boolean equals(Object o) {
        //1.判断两个对象是否是同一个引用
        if (this==o) {
            return true;
        }
        //2.判断obj是否null
        if (o==null) {
            return false;
        }
        //3.判断是否是同一个类型
//        if (this.getClass()==o.getClass()) {
//
//        }
        //instanceof 判断对象是否是某种类型
        if (o instanceof ObjectStudent) {
            //4.强制类型转换
            ObjectStudent s = (ObjectStudent) o;
            //5.比较属性
            if (this.name.equals(s.getName())&&this.age==s.getAge()) {
                return true;
            }
        }
        return false;
    }

    //finalize();垃圾回收时运行的一个方法，重写成我们需要的形式
    @Override
    protected void finalize() throws Throwable {
        System.out.println(this.name+"对象被回收了");
    }
}
//测试类
public class ObjectStudentTest {
    public static void main(String[] args) {
        //getClass
        //public final Class<?> getClass() {}
        //返回引用中存储的实际对像类型
        //通常用于判断两个引用中实际存储对象的类型是否一致
        System.out.println("-----------getClass----------------");
        ObjectStudent s1 = new ObjectStudent("AAA", 20);
        ObjectStudent s2 = new ObjectStudent("bbb", 25);

        //判断s1和s2是不是同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1==class2) {
            System.out.println("s1和s2属于同一个类型");
        }else {
            System.out.println("s1和s2不属于同一个类型");
        }

        //hashCode
        //public int hashCode() {}
        //返回该对象的哈希码值
        //哈希值根据对象的地址或者字符串或数字，使用hash算法计算出来的int类型的数值
        //一般情况下相同对象返回相同哈希码值
        System.out.println("-----------hashCode----------------");
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        ObjectStudent s3=s1;
        System.out.println(s3.hashCode());

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

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

        ObjectStudent s4 = new ObjectStudent("小明",17);
        ObjectStudent s5 = new ObjectStudent("小明",17);
        System.out.println(s4.equals(s5));

        //System.gc();  回收垃圾，多创建几个垃圾，有的回收有的不回收
        //当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列
        //垃圾对象：没有有效的引用指向此对象时，为垃圾对象
        //垃圾回收：由GC销毁垃圾对象，释放数据存储空间
        //自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象
        //手动回收机制：使用System.gc(); 通知JVM执行垃圾回收
        System.out.println("-----------System.gc();----------------");
        ObjectStudent objectStudent1 = new ObjectStudent("aaa",20);
        ObjectStudent objectStudent2 = new ObjectStudent("bbb",20);
        ObjectStudent objectStudent3 = new ObjectStudent("ccc",20);
        new ObjectStudent("aaa",20);
        new ObjectStudent("bbb",20);
        new ObjectStudent("ccc",20);
        new ObjectStudent("ddd",20);
        new ObjectStudent("eee",20);
        System.gc();
        System.out.println("回收垃圾");
    }
}

包装类

◆ 基本数据类型所对应的引用数据类型，可以使0bject统一所有数据。

public class Baozhuanglei {
    public static void main(String[] args) {
        //类型转换：装箱，把基本类型转成引用类型的过程
        //基本类型
        int num = 18;
        //使用Integer类创建对象
        Integer integer1 = new Integer(num);
        Integer integer2 = Integer.valueOf(num);
        System.out.println("装箱");
        System.out.println(integer1);
        System.out.println(integer2);

        //类型转换：拆箱，把引用类型转成基本类型的过程
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println("拆箱");
        System.out.println(num2);

        //jdk1.5之后，提供自动装箱和拆箱
        int num3 = 30;
        //自动装箱
        Integer integer4 = num3;
        System.out.println("自动装箱");
        System.out.println(integer4);
        //自动拆箱
        int num4 = integer4;
        System.out.println("自动拆箱");
        System.out.println(num4);

        System.out.println("----------------基本类型和字符串之间的转换-----------------");
        //基本类型和字符串之间的转换
        //基本类型转成字符串
        int n1 = 15;
        //使用+号
        String str1 = n1 + " ";
        //使用Integer中的toString()方法
        String str2 = Integer.toString(n1);
        String str3 = Integer.toString(n1,16);//n1做对应的16进制
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);

        //字符串转成基本类型
        String str4 = "100"; //字符串转成基本类型时，只能是数字
        //String str4 = "100h";  //运行错误
        //使用Integer.parseXXX();方法
        int n2 = Integer.parseInt(str4);
        System.out.println(n2);

        //boolean字符串转成基本类型："true"--->true     非"true"--->false
        String str5 = "true";
        boolean b1 = Boolean.parseBoolean(str5);
        System.out.println(b1);

        String str6 = "asas";
        boolean b2 = Boolean.parseBoolean(str6);
        System.out.println(b2);
    }
}

public class IntegerHuanchongqu {
    public static void main(String[] args) {
        //面试题
        //Integer.valueOf()缓冲区[-128~127]
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1==integer2);//false

        Integer integer3 = 100;  //自动装箱
        //Integer integer3 = Integer.valueOf(100);
        //100在[-128~127]内
        Integer integer4 = 100;
        System.out.println(integer3==integer4);//ture

        Integer integer5 = 200;  //自动装箱
        //Integer integer5 = Integer.valueOf(200);
        //200超过[-128~127]，就会new Integer(200)出来
        Integer integer6 = 200;
        System.out.println(integer5==integer6);//false
    }
}

String类

◆ 字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享。

public class String01 {
    public static void main(String[] args) {
        String name = "Hello"; //"Hello"常量存储在字符串池中，可以共享
        name = "zhangsan"; //"zhangsan"赋值给name变量，字符串赋值时，并没有修改数据，而是重新开辟一个空间
        String name2 = "zhangsan";

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

        System.out.println("-------------字符串方法的使用1--------------");
        //字符串方法的使用
        //1、length();返回字符串的长度
        //2、charAt(int index);返回某个位置的字符
        //3、contains(String str);判断是否包含某个字符

        String str = "java是最好的编程语言java,java真香";
        System.out.println(str.length());
        System.out.println(str.charAt(2));
        System.out.println(str.contains("java"));
        System.out.println(str.contains("PHP"));

        System.out.println("-------------字符串方法的使用2--------------");
        //4、toCharArray();返回字符串对应的数组
        //5、indexOf();返回字符串首次出现的位置
        //6、lastIndexOf();返回字符串最后一次出现的位置
        System.out.println(Arrays.toString(str.toCharArray()));
        System.out.println(str.indexOf("java"));
        System.out.println(str.indexOf("java",4));
        System.out.println(str.lastIndexOf("java"));

        System.out.println("-------------字符串方法的使用3--------------");
        //7、trim();去掉字符串前后的空格
        //8、toUpperCase();//把小写转成大写  toLowerCase();把大写转成小写
        //9、endWith(str);判断是否以str结尾，startWith(str);判断是否以str开头

        String str3 = "  hello  World  ";
        System.out.println(str3.trim());
        System.out.println(str3.toUpperCase(Locale.ROOT));
        System.out.println(str3.toLowerCase(Locale.ROOT));
        String str4 = "hello.java";
        System.out.println(str4.startsWith("hello"));
        System.out.println(str4.endsWith("java"));

        System.out.println("-------------字符串方法的使用4--------------");
        //10、replace(char old,char new);用新的字符或者字符串，替换旧的字符或字符串
        //11、split();对字符串进行拆分

        System.out.println(str.replace("java","php"));
        String say = "java is the best programing language,java xiang";
        String[] arr = say.split(" ");
        System.out.println(arr.length);
        for (String string : arr) {
            System.out.println(string);
        }
        System.out.println("----------");
        String[] arr2 = say.split("[ ,]"); //中括号可以选择一起拆分" "和","
        System.out.println(arr2.length);
        for (String string : arr2) {
            System.out.println(string);
        }
        String say2 = "java is the best    programing language,,,,,java xiang";
        System.out.println("----------");
        String[] arr3 = say.split("[ ,]+"); //中括号可以选择一起拆分" "和","，"+"号则表示" "或者","可以出现多个
        System.out.println(arr3.length);
        for (String string : arr3) {
            System.out.println(string);
        }

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

        String s3 = "abc";//a：97 b：98
        String s4 = "ayz";//x：120 y：121
        System.out.println(s3.compareTo(s4));
        //用s3的首字符的Unicode字符集中的编码值减去s4的首字符的Unicode字符集中的编码值
        //如果比较的两个字符串的首字符相同，就比较下一个字符
        //比完第一个字符后面的字符就不比较了

        String s5 = "abc";
        String s6 = "abcxzy";
        System.out.println(s5.compareTo(s6)); //用s5字符串的长度减去s6字符串的长度
        //如果比较的两个字符串一个字符串是另一个字符串的开头，那就不比较位置了，比较的是长度
    }
}

public class String02 {
    public static void main(String[] args) {
        String str = "this is a text";
        //1.将str中的单词单独获取出来
        System.out.println("----1.将str中的单词单独获取出来----");
        String[] string = str.split(" ");
        for (String s : string) {
            System.out.println(s);
        }

        //2.将str中的text替换成practice
        System.out.println("----2.将str中的text替换成practice----");
        String str2 = str.replace("text","practice");
        System.out.println(str2);

        //3.在text前面插入一个easy
        System.out.println("----3.在text前面插入一个easy----");
        String str3 = str.replace("text","easy text");
        System.out.println(str3);

        //4.将每个单词的首字母变成大写
        System.out.println("----4.将每个单词的首字母变成大写----");
        for (int i = 0; i < string.length; i++) {
            //获取第一个字符
            char first = string[i].charAt(0); //获取string[]字符串类型的数组的第一个字符串的第一个字符
            //把第一个字符转成大写
            char upperfirst = Character.toUpperCase(first);  //char对应的包装类Charcter
            //把已经转成大写的第一个字符和后面的字符连接起来，形成一个新的字符串
            String news = upperfirst + string[i].substring(1); //substring();截取的作用，这里截取第一个字符串的第二个字符到最后一个（T + his）
            //直接输出新的字符串
            System.out.println(news);
        }
    }
}

public class String03 {
    public static void main(String[] args) {
        //StringBuffer sb = new 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("不错");
        System.out.println(sb.toString());

        //2.insert();添加方法，可以在任意位置添加
        sb.insert(0,"我在最前面");
        System.out.println(sb.toString());
        sb.insert(2,"哈哈哈");
        System.out.println(sb.toString());

        //3.replace();替换方法
        sb.replace(0,5,"hello");
        System.out.println(sb.toString());

        //4.delete();删除方法
        sb.delete(0,5);
        System.out.println(sb.toString());

        //清空
        sb.delete(0,sb.length());
        System.out.println(sb.length());
        
        //反转字符串，str目标字符串，str2反转之后的字符串
        String str2 = new StringBuffer(str).reverse().toString();
    }
}

/**
 * 验证StringBuilder效率高于String
 */
public class String04 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();

//        String string = "";
//        for (int i = 0; i < 99999; i++) {
//            string +=i;
//        }
//        System.out.println(string);

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 99999; i++) {
            sb.append(i);
        }
        System.out.println(sb.toString());

        long end = System.currentTimeMillis();
        System.out.println("用时："+(end - start));
    }
}

BigDecimal类

◆ 可精确计算浮点数。

public class BigDecimalTset {
    public static void main(String[] args) {
        double d1 = 1.0;
        double d2 = 0.9;
        System.out.println(d1-d2);

        double result = (1.4-0.5)/0.9;
        System.out.println(result);

        //BigDecimal：大的浮点数精确计算
        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");

        //add();加法方法
        BigDecimal n2 = bd1.add(bd2);
        System.out.println(n2);

        //subtract();减法方法
        BigDecimal n1 = bd1.subtract(bd2);
        System.out.println(n1);

        //multiply();乘法方法
        BigDecimal n3 = bd1.multiply(bd2);
        System.out.println(n3);

        //divide();除法方法 (1.4-0.5)/0.9
        BigDecimal n4 = new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"));
        System.out.println(n4);

        //divide(BigDecimal bd,int scal,RoundingMode.mode)
        //参数scal：指定精确到小数点后几位
        //参数mode：指定小数部分的取舍模式，通常采用四舍五入的模式、
        //BigDecimal.ROUND_HALF_UP：四舍五入
        BigDecimal n5 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);
        System.out.println(n5);
    }
}

Date类

◆ 特定时间

◆ 该类有很多方法过时了，但有些方法还能用

public class DateTest {
    public static void main(String[] args) {
        //1.创建Date对象
        //返回今天的时间
        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());
        //2.after before方法
        boolean b1 = date1.after(date2);
        System.out.println(b1);
        boolean b2 = date1.before(date2);
        System.out.println(b2);
        //3.compareTo(); 比较毫秒值
        int n1 = date1.compareTo(date2);
        System.out.println(n1);
        int n2 = date2.compareTo(date1);
        System.out.println(n2);
        int n3 = date2.compareTo(date2);
        System.out.println(n3);
    }
}

Calendar类

◆ Calendar提供了获取或设置各种日历字段的方法

◆ 构造方法：

protected Calendar() ：由于修饰符是protected（受保护的），所以无法直接创建该对象

public class CalendarTest {
    public static void main(String[] args) {
        //1.创建Calendar对象，构造方法是受保护的，不能直接new
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toString());
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis()); //毫秒值1970年到现在的毫秒值

        //2.获取时间信息
        //获取年
        int year = calendar.get(Calendar.YEAR);
        System.out.println(year);
        //月 返回值0-11，用的时候 "+1"
        int month = calendar.get(Calendar.MONTH);
        System.out.println(month+1);
        //日
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);
        //小时
        int hour = calendar.get(Calendar.HOUR_OF_DAY); //HOUR-12小时  HOUR_OF_DAY-24小时
        System.out.println(hour);
        //分钟
        int minute = calendar.get(Calendar.MINUTE);
        System.out.println(minute);
        //秒
        int second = calendar.get(Calendar.SECOND);
        System.out.println(second);

        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+"小时"+minute+"分"+second+"秒");

        //3.set();修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH,14); //修改的目标，修改值    这里需改天数：修改为第14天
        System.out.println(calendar2.getTime().toLocaleString());

        //4.add();修改时间
        calendar2.add(Calendar.HOUR,1); //修改的目标，修改值   这里修改小时：增加一个小时（-1减少一个小时）
        System.out.println(calendar2.getTime().toLocaleString());

        //5.补充方法
        //获取这个月份的最大天数（有多少天）
        int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max);
        System.out.println(min);
    }
}

SimpleDateFormat类

◆ 格式化时间

public class SimpleDateFormatTest {
    public static void main(String[] args) throws Exception{
        //1.创建SimpleDateFormat对象    y：年 M：月 d：日 H：小时 m：分钟 s：秒 S：毫秒
        //SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH-mm-ss-SS");
        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);
        //解析，把字符串转成日期，要解析的字符串格式要和创建的日期格式一样
        Date date2 = sdf.parse("1900/05/02 14:2:03");
        System.out.println(date2.toLocaleString());
    }
}

System类

◆ 系统类

public class SystemTest{
    public static void main(String[] args) {
        //1
        //arraycopy：数组的复制
        //src：原数组
        //srcPos：从哪个位置开始复制
        //dest：目标数组
        //destPos：目标数组的位置
        //length：复制的长度
        int[] arr = {1,25,13,45,65,8,88,41};
        System.out.println(Arrays.toString(arr));
        int[] dest1 = new int[8];
        int[] dest2 = new int[8];

        System.arraycopy(arr,0,dest1,0,8);
        for (int i = 0; i < dest1.length; i++) {
            System.out.print(dest1[i]+" ");
        }
        System.out.println();
        System.arraycopy(arr,4,dest2,0,4);
        for (int i = 0; i < dest2.length; i++) {
            System.out.print(dest2[i]+" ");
        }
        System.out.println();
        //Arrays.copyOf(); 也能复制，用的时array.copy方法

        //2
        System.out.println(System.currentTimeMillis()); //返回1970年到现在的时间（毫秒值）
        //可以用来计时
        long start = System.currentTimeMillis();
        for (int i = 0; i < 99999; i++) {
            for (int j = 0; j < 99999; j++) {
                int result = i + j;
                //System.out.println(result);
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("用时："+(end-start));

        //3
        //垃圾回收
        //System.gc(); 告诉回收垃圾器回收垃圾
        new Student("aaa",15);
        new Student("saa",15);
        new Student("aaea",15);
        Student student2 = new Student("bbb",18);
        Student student3 = new Student("ccc",22);
        System.gc();

        //4
        //退出jvm
        System.exit(0);
        System.out.println("程序结束了");
    }
}
//回收垃圾
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;
    }

    @Override
    public String toString() {
        return super.toString();
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println(name+"对象被回收了"+" "+age);
    }
}