10Java常用类

最新推荐文章于 2023-04-06 14:49:42 发布

weiruia

最新推荐文章于 2023-04-06 14:49:42 发布

阅读量118

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/weiruia/article/details/114377431

版权

Java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

Java常用类

内部类

成员内部类
静态内部类
- static
局部内部类
匿名内部类

public class Demo01 {
    private String name = "weirui";
    class Header{
        public void show(){
            System.out.println(name);//内部类访问外部类的私有成员
        }

    }
}

概念：在一个类的内部再定义一个完整的类

特点：

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

成员内部类

再类的内部定义，与实例变量、实例方法同级别的类
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象

public class Test {
    public static void main(String[] args) {
//        //创建外部类对象
//        Demo01 demo01 = new Demo01();
//        //创建内部类对象
//        Demo01.Inner inner = demo01.new Inner();
        
        //一步到位
        Demo01.Inner inner = new Demo01().new Inner();
        inner.show();
    }
}

当外部类，内部类存在重名属性时，会优先访问内部类属性

public class Demo01 {
    private String name = "weirui";
    private int age = 20;

    class Inner {
        private String adderss = "beijing";
        //会优先访问内部类
        private String name = "ye";
        //打印外部类的属性，内部类属性和外部类的属性名字相同，Demo01.this
        public void show() {
            //重名访问外部类属性
            System.out.println(Demo01.this.name);
            //打印外部类属性
            System.out.println(name);//内部类访问外部类的私有成员
            //打印内部类属性
            System.out.println(adderss);
        }

    }
}

成员内部类不能定义静态成员、但是可以包含静态常量 static final

静态内部类

不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员
只有内部类，才可以使用 static 修饰

//外部类
public class Demo02 {
    private String name = "qqq";
    private int age = 11;

    //静态内部类，和外部类相同
    static class Inner{
        private String address = "wei";
        //静态成员
        private static int count = 100;

        public void show(){
            //调用外部类的属性
            //1.先创建外部类对象
            Demo02 demo02 = new Demo02();
            //2.调用外部类对象的属性
            System.out.println(demo02.name);
            System.out.println(demo02.age);
            //3.调用静态内部类的属性和方法
            System.out.println(this.address);
            //4.调用静态内部类的静态属性
            System.out.println(Inner.count);
        }
    }

}

public class Test {
    public static void main(String[] args) {

        //直接创建静态内部类对象
        Demo02.Inner inner = new Demo02.Inner();//包含关系
        //调用方法
        inner.show();
    }
}

局部内部类

定义在外部类方法中、作用范围和创建对象范围仅限于当前方法
局部内部类不包含静态常量 static 但是可以包含 final 静态常量
局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final
限制类的使用范围

//外部类
public class Demo03 {
    private String name = "weirui";
    private int age = 88;

    public void show(){
        //定义局部变量
        String address = "yyy";
        //局部内部类： 注意不能加任何访问修饰符
        class Inner{
            //局部内部类的属性
            private String email = "464@w";
            public void show1(){
                //访问外部类的属性
                System.out.println(Demo03.this.name);
                System.out.println(Demo03.this.age);
                //访问内部类的属性
                System.out.println(this.email);
                // 访问局部变量，JDK1.7要求:变量必须是常量final jdk1.8自动添加 final
                System.out.println(address);
            } 

        }
        // 创建局部内部类对象 调用内部方法
        Inner inner = new Inner();
        inner.show1();
    }


}

public class Test {
    public static void main(String[] args) {

        Demo03 demo03 = new Demo03();
        //创建外部类 调用内部方法
        demo03.show();
    }
}

匿名内部类

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

public class Test {
    public static void main(String[] args) {

//        //创建接口类型的变量
//        Demo04 demo04 = new Demo05();
//        demo04.service();
//        //局部内部类 实现接口
//        class Fun implements Demo04{
//            @Override
//            public void service() {
//                System.out.println("连接电脑，fun起来");
//            }
//        }
//        //使用局部内部类创建对象
//        Demo04 demo004 = new Fun();
//        demo004.service();
//
        //使用匿名内部类 (相当于创建了一个局部内部类)
        Demo04 demo004 = new Demo04() {
            @Override
            public void service() {
                System.out.println("连接电脑，fun起来，匿名");
            }
        };
        demo004.service();


    }
}

public class Demo05 implements Demo04{
    @Override
    public void service() {
        System.out.println("连接成功");
    }
}

//接口
public interface Demo04 {
    //服务
    void service();
}

Object类

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

Object类常用方法

getClass（）方法

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

public class Test {
    public static void main(String[] args) {

        Student s1 = new Student("aaa",20);
        Student s2 = new Student("bbb",50);
        //判断s1 和 s2是不是同一类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1 == class2){
            System.out.println("类型相同");
        }else {
            System.out.println("类型不同");
        }

    }
}

hashCode（）方法

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

public class Test {
    public static void main(String[] args) {

        Student s1 = new Student("aaa",20);
        Student s2 = new Student("bbb",50);
        System.out.println(s1.hashCode());//356573597
        System.out.println(s2.hashCode());//1735600054
        Student s3=s1;
        System.out.println(s3.hashCode());//356573597

    }
}

toString()方法

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

public class Test {
    public static void main(String[] args) {

        Student s1 = new Student("aaa",20);
        Student s2 = new Student("bbb",50);
        //toString 方法
        System.out.println(s1.toString());//com.normalclass.Student@1540e19d
        System.out.println("--------------");
        System.out.println(s2.toString());//com.normalclass.Student@677327b6
        //包 + 哈希值
        //重写方法

    }
}

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

equals() 方法

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

equals（）方法覆盖步骤

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

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

@Override
public int hashCode() {
    return Objects.hash(name, age);
}

public class Test {
    public static void main(String[] args) {

        Student s1 = new Student("aaa",20);
        Student s2 = new Student("bbb",50);
        Student s3 = new Student("xiaoming",17);
        Student s4 = new Student("xiaoming",17);
        //equals 方法，判断两个对象是否相等
        System.out.println(s1.equals(s2));//false
        System.out.println(s3.equals(s4));//false  对象地址还是不一样
        // 判断 参数相同的判断  equals 可以重写


    }
}

finalize()方法

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

public class Test {
    public static void main(String[] args) {

//        Student s1 = new Student("aaa",20);
//        Student s2 = new Student("bbb",50);
//        Student s3 = new Student("xiaoming",17);
//        Student s4 = new Student("xiaoming",17);
        new Student("aaa", 20);
        new Student("bbb", 50);
        new Student("xiaoming", 17);
        new Student("xiaoming", 17);
        //回收垃圾
        System.gc();
        System.out.println("回收垃圾");
//        xiaoming回收了
//        xiaoming回收了
//        bbb回收了
//        aaa回收了


    }
}

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

包装类

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

基本数据类型	包装类型
byte	Byte
b	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

类型转换与装箱，拆箱

public class Demo06 {
    public static void main(String[] args) {
        int num = 10;
        //JDK1.5 之前
        //类型转换： 装箱，基本类型转成引用类型的过程
        // 基本类型
        //使用 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 age = 60;
        //自动装箱
        Integer integer4 = age;
        System.out.println("自动装箱");
        System.out.println(integer4);
        //自动拆箱
        int age2 = integer4;
        System.out.println("自动拆箱");
        System.out.println(age2);
    }
}

8种包装类提供不同类型间的转换形式
- Number父类种提供六个共性方法
- parseXXX（）静态方法
- valueOf() 静态方法

public class Demo06 {
    public static void main(String[] args) {
        //基本类型和字符串之间转换
        //1. 基本类型转换成字符串
        int n1 = 15;
        //1.1 使用 + 号
        String s1 = n1 + "";
        //1.2 使用Integer 的toString()方法
        String s2 = Integer.toString(n1, 16);
        System.out.println(Integer.toHexString(n1));
        System.out.println(s1);
        System.out.println(s2);

        //字符串转成基本类型
        String str = "150";
        //使用Integer.parseXXX();
        int n2 = Integer.parseInt(str);//字符串转数字
        System.out.println(n2);

        //boolean字符串形式壮成基本类型 “true”->true 非"true"->
        String str2 = "true";
        boolean b1 = Boolean.parseBoolean(str2);
        System.out.println(b1);

    }
}

注意：需要保证类型兼容，否则抛出NumberFormatExeption 异常

整数缓冲区

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

String 类

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

public class Demo08 {
    public static void main(String[] args) {
         String name = "hello";//hello 常量存储再字符串池中
        name = "zhangsan"; // 赋给 name  给字符串赋值时，没有修改数据，而是重新开辟空间
        String name2 = "zhangsan";  // 指向字符串池中 同一个 字符串

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

    }
}

常用方法

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

//length() 返回字符串的长度
//charAt(int index) 返回某个位置的字符
//contains(String str) 判断是否包含某个字符串
String content = "java the best language";
System.out.println(content.length()); //22 一个空格也是一个字符
System.out.println(content.charAt(10));//某个位置的字符
System.out.println(content.contains("java"));

public char[] toCharArray(): 将字符串转换为数组
public int indexOf (String str): 查找str 首次出现的下标，存在，则返回该下标；不存在，则返回-1
public int lastIndexOf(String str): 查找字符串在当前字符串中最后一次出现的下标索引

//toCharArray(): 将字符串转换为数组
//indexOf (String str): 查找str 首次出现的下标
//lastIndexOf(String str): 查找字符串在当前字符串中最后一次出现的下标索引
System.out.println(Arrays.toString(content.toCharArray()));
System.out.println(content.indexOf("java",5));
System.out.println(content.lastIndexOf("java"));

public String trim() 去掉字符串前后的空格
public String toUpperCase() 将小写转成大写
public boolean endWith(String str) 判断字符串是否以str 结尾

//trim() 去掉字符串前后的空格
//toUpperCase() 将小写转成大写 toLowerCase()将大写转成小写
//endWith(String str) 判断字符串是否以str 结尾
//starWith(String str) 判断字符串是否以str 开头
String content2 = " hello world ";
System.out.println(content2.trim());
System.out.println(content2.toUpperCase());
System.out.println(content2.toLowerCase());
String filename = "hello.java";
System.out.println(filename.endsWith("java"));//true
System.out.println(filename.startsWith("hello"));//true

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

//equals()\compareTo() 比较大小、比较大小
System.out.println("*********************");
String ss = "hello";
String sa = "Hello";
System.out.println(ss.equals(sa)); // false
System.out.println(ss.equalsIgnoreCase(sa)); // true  忽略大小写比较
//compare() 比较编码的位置
String s3 = "abc";
String s4 = "qwe";
System.out.println(s3.compareTo(s4));  //s3 的首字母 减去 s4 首字母

String s5 = "abc";
String s6 = "abcdefg";
//如果字符一样 比较字符的长度，前面的字符串长度减去后面字符串的长度
System.out.println(s5.compareTo(s6));  //-4
System.out.println(s6.compareTo(s5));  //4

String 实例

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

public class Demo09 {
    public static void main(String[] args) {
        String str = "this is a text";
        String[] arr = str.split(" ");
        // 每个单词 单独输出
        for (String s : arr){
            // 遍历
            System.out.println(s);
        }

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

        // 在 text 前面 加一个 easy  将 text 替换成 easy text
        System.out.println("-----3-------");
        String str3 = str.replace("text","easy text");
        System.out.println(str3);

        // 每个单词的首字母 改为大写, 根据第一步的分割 拿到每个字母的数组
        System.out.println("-------4------");
        for (int i = 0;i<arr.length;i++){
            // 拿到每一个单词的 第一个字母
            char first =  arr[i].charAt(0);
            // 字符变大写
            char upperfirst = Character.toUpperCase(first);
            // subString 替换（开始位置，结束位置）
            String news = upperfirst + arr[i].substring(1);
            System.out.println(news);
        }

    }
}

可变字符串

StringBuffer: 可变长字符串，运行效率慢，线程安全（都比 string更快）
StringBuilder: 可变长字符串，运行效率快，线程不安全

方法和效率比较

/**
 * stringbuffer 和 stringbuilder 之间的区别
 * 区别 1. 效率比string 会更高，更节省内存
 */
public class Demo10 {
    public static void main(String[] args) {
        // stringbuffer 和 stringbuilder  功能介绍（功能相同）
        StringBuffer sb = new StringBuffer();
        // 1. append(); 追加
        sb.append("Java no.1");
        System.out.println(sb.toString());
        sb.append("java 真香");
        System.out.println(sb.toString());
        // 2. insert(); 添加
        sb.insert(0, "first");
        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());
        // 5.将字符串反转
//        sb.reverse();
//        System.out.println(sb);
        // 6. 清空 操作  0 - str.length
        sb.delete(0, sb.length());
        // 清空 整个 stringbuffer
        // 推荐使用stringbuilder

        /**
         * 验证 stringbuilder 高于 stringbuffer 的效率
         */
        // 获得一个开始时间
        long star = System.currentTimeMillis();
        String string = "";
        for (int i = 0; i < 9999; i++) {
            // 字符串拼接
            string+=i;
        }
        System.out.println(string);
        long end = System.currentTimeMillis();
        System.out.println("用时： "+ (end - star));
        //用时 421


        // stringbuilder 效率
        star = System.currentTimeMillis();
        StringBuilder sbb = new StringBuilder();
        for (int i = 0; i < 9999; i++) {
            // 字符串拼接
            sbb.append(i);
        }
        System.out.println(sbb.toString());
        end = System.currentTimeMillis();
        System.out.println("用时： "+ (end - star));
        //用时 16
    }
}

BigDecimal类

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

public class Demo11 {
    public static void main(String[] args) {
        // BigDecimal 类
        double d1 = 1.0;
        double d2 = 0.5;
        System.out.println(d1 - d2);
        //double 存储的是近似值，运算是会存在误差的
        //BigDecimal 大的浮点数精确计算
        BigDecimal bd1 = new BigDecimal("1.0"); //创建使用字符串
        BigDecimal bd2 = new BigDecimal("0.9");
        //创建使用字符串  转化后 更加准确
        //类不能直接只用运算符  对应类，使用方法运算

        //减法
        BigDecimal re1 = bd1.subtract(bd2);
        // 实现精确计算
        System.out.println(re1);

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

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

        //除法 如果结果是除不尽的话，会报告异常
        BigDecimal re4 = bd1.divide(bd2,2,BigDecimal.ROUND_HALF_UP);
        // 保留两位小数 四舍五入
        /**
         * 参数 scal 指定精确到小数点后几位
         * 参数 mode 指定小数部分的取舍模式，通常采用四舍五入的模式
         *          取值为BigDecimal.ROUND_HALF_UP
         */
        System.out.println(re4);
    }
}

Date类

过时的方法~

Date 表示特定的瞬间，精确到毫秒，Date类大部分方法都被Calendar类中的方法所取代

public class Demo12 {
    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));
        // 2.方法 after before 判断两个日期顺序，返回布尔值
        boolean f1 = date1.after(date2);
        System.out.println(f1);
        // 3. 比较 compareTo();  返回int 相差的天数
        int d = date1.compareTo(date2);
        System.out.println(d);
        
        //equals(); 比较是否相等
    }
}

Calendar类

勤查API 查看方法

Calender 提供了获取或设置各种日历字段的方法
构造方法
- protected() Calender() : 由于修饰符是protected 所以无法直接创建该对象
其他常用方法使用

public class Demo13 {
    public static void main(String[] args) {
        // 1. 创建 Calender 对象 因为受保护的，无法直接new 一个对象
        // 使用 getInstance
        Calendar calendar = Calendar.getInstance();
        // 打印时间
        System.out.println(calendar.getTime());
        System.out.println(calendar.getTimeInMillis());
        //2. 获取时间信息
        // 获取 年
        int year = calendar.get(Calendar.YEAR);
        // 月  返回的是 0-11
        int month = calendar.get(Calendar.MONTH);
        // 日
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        // 小时
        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);
        System.out.println(year + "年" + (month + 1) + "月" + day + "日" + hour + ":" + minute + ":" + second);
        //  2020年10月21日11:46:23
        //修改时间 .set
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH, 20);//修改日期
        System.out.println(calendar2.getTime().toLocaleString());

        //add 方法 修改时间
        // 增加一个小时
        calendar2.add(Calendar.HOUR,1);
        System.out.println("增加一个小时 add方法");
        System.out.println(calendar2.getTime().toLocaleString());

        // 补充方法
        // getactualmaximum 获取当月的最大天 或者 最小天
        int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        // 当月最多 31 天
        System.out.println(max);
        // 当月最少 1 天
        System.out.println(min);
    }
}

SimpleDateFormat类

SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类
进行格式化（日期-》文本）解析（文本-》日期）

字母	日期或时间	示例
y	年	2019
M	年中月份	08
d	月中天数	10
H	1天中小时数（0-23）	22
m	分钟	16
s	秒	89
S	毫秒	367

public class Demo14 {
    public static void main(String[] args) throws Exception{
        // 1. 创建一个simpledateformat 对象  pattern 指定时间格式 输出
        // simpledateformat 类似一种加工厂 将输入的时间 date 转换成指定的pattern格式输出
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH-mm-ss");
        // 2. 创建date
        Date date = new Date();
        // 格式化 date  format -> data 放入 string 存放
        // 把日期 转成 字符串
        String str = sdf.format(date);
        System.out.println(str);
        //2020年10月21日19:05:22

        // 解析（把字符串转化成日期） 没有按照给定的parse格式，会抛出异常
        Date date2 = sdf.parse("1990/05/01");
        System.out.println(date2);
    }
}

System类

System 系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的

public class Demo15 {
    public static void main(String[] args) {
        /**
         * system 类的演示 使用，方法是私有的，使用的时候不需要创建对象，直接使用
         * arraycopy 数组的复制
         *  参数： src:源数组
         *  srcPos: 从哪个位置开始复制，默认为0
         *  dest: 目标数组
         *  destPos: 目标数组的位置
         *  length: 复制的长度
         */

        int [] arr = {20,18,15,8,25,48,90,1};
        int [] dest = new int[8];
        // 可对应调整参数
        System.arraycopy(arr,0,dest,0,arr.length);
        for (int i = 0; i <dest.length ; i++) {
            System.out.println(dest[i]);
        }
        //对比 Arrays.copyof  里面的源码 就是通过 system.arrycopy实现的
        // 记录当前的时间  毫秒 计算运行的时间
        System.out.println(System.currentTimeMillis());

        // System.gc(); 告诉垃圾回收器 回收，干预对象的内存回收，三个对应情况下的垃圾回收，还是系统判断

        //退出JVM 程序正常后退出
        System.exit(0);
        //程序到这儿 就结束了 status: 参数是0 正常退出JVM 非0表示异常退出JVM
    }
}

总结

内部类
- 在一个类的内部再定义一个完整的类
- 成员内部类，静态内部类，局部内部类，匿名内部类
Object类：
- 所有类的直接或间接父类，可存储任何对象
包装类
- 基本数据类型所对应的应用数据类型，可以使Object统一所有数据
String类
- 字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享
BigDecimal：
- 可精确计算浮点数
Date
- 特定时间
Calender
- 日历
SimpleDateFormat
- 格式化时间
System
- 系统类

weiruia

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
10Java常用类

Java常用类内部类成员内部类静态内部类static局部内部类匿名内部类public class Demo01 { private String name = "weirui"; class Header{ public void show(){ System.out.println(name);//内部类访问外部类的私有成员 } }}概念：在一个类的内部再定义一个完整的类特点：编译之后可生
复制链接

扫一扫

专栏目录