java内容总结 java类总结

Object类

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

• 作为参数,可接受任何对象
• 作为返回值,可返回任何对象

1. getClass()方法

• public final Class<?> 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;
    }

}

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("aaa", 20);
        Student s2 = new Student("bbb", 23);

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

    }
}

2. hashCode()方法

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

public class TestStudent {
    public static void main(String[] args) {
        //getClass方法
        Student s1 = new Student("aaa", 20);
        Student s2 = new Student("bbb", 23);

        //判断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方法
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        Student s3 = s1;
        System.out.println(s3.hashCode());

    }
}

3. toString()方法

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

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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class TestStudent {
    public static void main(String[] args) {
        //getClass方法
        Student s1 = new Student("aaa", 20);
        Student s2 = new Student("bbb", 23);

        //判断s1和s2是否为同一类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if(class1 == class2){
            System.out.println("s1和s2属于同一类型");
        }else{
            System.out.println("s1和s2不属于同一类型");
        }
        System.out.println("=============================");
        //hashCode方法
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        Student s3 = s1;
        System.out.println(s3.hashCode());

        System.out.println("=============================");
        //toString方法
        System.out.println(s1.toString());
        System.out.println(s2.toString());

    }
}

4. equals()方法

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

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

public class Student extends Object{
    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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object obj) {
        //1.判断两个对象是否是一个引用
        if(this == obj){
            return true;
        }
        //2.判断obj是否null
        if(obj == null){
            return false;
        }
        //instanceof 判断对象是否为某类型
        if(obj instanceof Student){
            //4.强制类型转换
            Student s = (Student) obj;
            //5.比较属性
            if(this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }
       return false;
    }


}

public class TestStudent {
    public static void main(String[] args) {
        //getClass方法
        Student s1 = new Student("aaa", 20);
        Student s2 = new Student("bbb", 23);
        //判断s1和s2是否为同一类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if(class1 == class2){
            System.out.println("s1和s2属于同一类型");
        }else{
            System.out.println("s1和s2不属于同一类型");
        }
        System.out.println("=============================");

        //hashCode方法
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        Student s3 = s1;
        System.out.println(s3.hashCode());
        System.out.println("=============================");

        //toString方法
        System.out.println(s1.toString());
        System.out.println(s2.toString());
        System.out.println("=============================");

        //equals方法，判断两个对象是否相等
        System.out.println(s1.equals(s2));
        Student s4 = new Student("Xiaoming",12);
        Student s5 = new Student("Xiaoming",12);
        System.out.println(s4.equals(s5));
    }
}

5. finalize()方法

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

public class Student extends Object{
    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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object obj) {
        //1.判断两个对象是否是一个引用
        if(this == obj){
            return true;
        }
        //2.判断obj是否null
        if(obj == null){
            return false;
        }
        //instanceof 判断对象是否为某类型
        if(obj instanceof Student){
            //4.强制类型转换
            Student s = (Student) obj;
            //5.比较属性
            if(this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }
       return false;
    }

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

public class TestStudent2 {

    public static void main(String[] args) {
//        Student s1 = new Student("aa",20);
//        Student s2 = new Student("bb",20);
//        Student s3 = new Student("cc",20);
//        Student s4 = new Student("dd",20);
//        Student s5 = new Student("ee",20);
        new Student("aa",20);
        new Student("bb",20);
        new Student("cc",20);
        new Student("dd",20);
        new Student("ee",20);

        //回收垃圾
        System.gc();
        System.out.println("回收垃圾");
    }
}

包装类

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

• 类型转换与装箱、拆箱

• 实例

public class Demo01 {
    public static void main(String[] args) {
//        int num = 10;
        //类型转换：装箱，基本类型转换成引用类型的过程
        //基本类型
        int num1 = 18;
        //使用Integer类创建对象
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);
        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 = 20;
        //自动装箱
        Integer integer4 = age;
        System.out.println("+++++++++++自动装箱+++++++++");
        System.out.println(integer4);
        //自动拆箱
        int age2 = integer4;
        System.out.println("++++++++++++自动拆箱+++++++++");
        System.out.println(age2);
    }
}

• 8种包装类提供不同类型间的转换方式:

• Number父类中提供的6个共性方法。
• parseXXX()静态方法。

public class Demo02 {
    //基本数据类型和字符串之间的转换
    public static void main(String[] args) {
        //1.基本类型转换成字符串
        int n1 = 255;
        //方法一：使用“+”
        String s1 = n1 + "";
        //方法二：使用Integer中的toString()方法
        String s2 = Integer.toString(n1,16);

        System.out.println("===基本类型转换成字符串===");
        System.out.println(s1);
        System.out.println(s2);

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

        //boolean字符串形式转成基本类型，“true"-->ture  非”true“-->false
        String str2 = "true";
        String str3 = "sti";
        boolean b1 = Boolean.parseBoolean(str2);
        boolean b2 = Boolean.parseBoolean(str3);
        System.out.println("===boolean字符串形式转成基本类型===");
        System.out.println(b1);
        System.out.println(b2);
        
    }
}

• valueOf()静态方法。
• 注意:需保证类型兼容,否则抛出NumberFormatException异常。

整数缓冲区

• Java预先创建了256个常用的整数包装类型对象(-128~127)。
• 在实际应用当中,对已创建的对象进行复用。

public class Demo03 {
    public static void main(String[] args) {
        //面试题
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1 == integer2);//false

        Integer integer3 = Integer.valueOf(100);//自动装箱,Integer.valueOf
        Integer integer4 = Integer.valueOf(100);
        System.out.println(integer3 == integer4);//true

        Integer integer5 = Integer.valueOf(200);//自动装箱
        Integer integer6 = Integer.valueOf(200);
        System.out.println(integer5 == integer6);//false



    }
}

String类

String

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

public class StringDemo01 {
    public static void main(String[] args) {
        String name = "hello"; //“hello”常量存储在字符串池中
        name = "zhangsan"; //"zhangsan"赋值给name，给字符串赋值时没有修改数据，而是重新开辟空间
        String name2 = "zhangsan";
        
        //演示字符串的另一种创建方式
        String str = new String("java");//浪费空间//产生两个对象，堆、池各存储一个。
        String str2 = new String("java");//浪费空间
        System.out.println(str == str2);//false
        System.out.println(str.equals(str2));//true
    }
}

String常用方法

• public int length():返回字符串的长度。
• public char charAt(int index):根据下标获取字符。
• public boolean contains(String str) :判断当前字符串中是否包含str。
• public char[] toCharArray ) :将字符串转换成数组。
• public int indexOf(String str):查找str首次出现的下标，存在，则返回该下标;不存在，则返回-1。
• public int lastIndexOf(String str):查找字符串在当前字符串中最后一次出现的下标索引。
• public String trim():去掉字符串前后的空格。
• public String toUpperCase() :将小写转成大写。
• public boolean endWith(String str):判断字符串是否以str结尾。
• public String replace(char oldChar, char newChar);将旧字符串替换成新字符串
• public String[] split(String str):根据str做拆分。

import java.util.Arrays;

public class StringDemo02 {
    public static void main(String[] args) {
        //字符串方法的使用1
        //1、length();返回字符串的长度
        //2、charAt(int index);返回某个位置的字符
        //3、contains(string str);判断是否包含某个子字符串
        System.out.println("===字符串方法的使用1===");
        String content = "javajavajava";
        System.out.println(content.length());
        System.out.println(content.charAt(0));
        System.out.println(content.contains("java"));
        System.out.println(content.contains("php"));



        //字符串方法的使用2
        //4、tocharArray();返回字符串对应的数组
        //5、 indexof();返回子字符中首次出现的位置
        //6、lastIndexof();返回字符串最后一次出现的位置
        System.out.println("===字符串方法的使用2===");
        System.out.println(Arrays.toString(content.toCharArray()));
        System.out.println(content.indexOf("av"));
        System.out.println(content.indexOf("av",3));
        System.out.println(content.lastIndexOf("va"));


        //字符串方法的使用3
        //7、trim( );去掉字符中前后的空格
        //8、toUppercase( );//把小写转成大写toLowercase();把大写转成小写
        //9、endwith( str);判断是否以str结尾,startwith(str);只断是否以str开头
        System.out.println("===字符串方法的使用3===");
        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"));
        System.out.println(filename.startsWith("hello"));

        
        //字符串方法的使用4
        //10、replace(char old,char new);用新的字符或字符串替换旧的字符或字符串
        //11、split();对字符串进行拆分
        System.out.println("===字符串方法的使用4===");
        System.out.println(content.replace("java","php"));
        String say = "java is the best   programing language,java hao";
        String[] arr = say.split("[ ,]+");
        System.out.println(arr.length);
        for (String string: arr) {
            System.out.println(string);
        }
        

        //补充两个方法equals、 compare( ) ; 比较大小
        System.out.println("===字符串方法的使用5===");
        String s1 = "hello";
        String s2 = "HELLO";
        System.out.println(s1.equalsIgnoreCase(s2));

        String s3 = "abc";
        String s4 = "xyz";
        String s5 = "ABC";
        String s6 = "abcxyz";
        System.out.println(s3.compareTo(s4));
        System.out.println(s3.compareToIgnoreCase(s5));
        System.out.println(s5.compareTo(s6));
        
    }
}

String案例

/*己知String str = "this is a text";
1.将str中的单词单独获取出来
2.将Str中的text替接为practice
3.在text前面插入一个easy
4,将每个单词的首字母改为大写*/

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

        // 2.将Str中的text替接为practice
        System.out.println("===将Str中的text替接为practice===");
        String str2 = str.replace("text","practice");
        System.out.println(str2);

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


       // 4,将每个单词的首字母改为大写
        System.out.println("===将每个单词的首字母改为大写===");
        for (int i = 0; i < arr.length; i++) {
            char first = arr[i].charAt(0);
            //把第一个字符转成大写
            char upperfirst = Character.toUpperCase(first);
            String news = upperfirst + arr[i].substring(1);
            System.out.println(news);
        }

    }
}

可变字符串

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

/*
stringBuffer和stringBuilder的使用功能相同
和String区别：(1)效率比String高；(2)比String节省内存
*/

public class StringDemo04 {
    public static void main(String[] args) {
        StringBuffer stringBuffer = new StringBuffer();
        //1.append()，追加
        stringBuffer.append("hello");
        System.out.println(stringBuffer.toString());
        stringBuffer.append("java");
        System.out.println(stringBuffer.toString());
        //2.insert();添加
        stringBuffer.insert(0,"first");
        System.out.println(stringBuffer.toString());
        //3.replace();替换
        stringBuffer.replace(0,5,"next");
        System.out.println(stringBuffer.toString());
        //4.delete();删除
        stringBuffer.delete(0,4);
        System.out.println(stringBuffer.toString());
        //清空
        stringBuffer.delete(0,stringBuffer.length());
        System.out.println(stringBuffer.length());
    }
}

/*验证StringBuilder效率比String高*/
public class StringDemo05 {
    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);
        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < 9999; i++) {
            stringBuffer.append(i);
        }
        System.out.println(stringBuffer);
        long end = System.currentTimeMillis();
        System.out.println("用时：" + (end - start));
    }
}

BigDecimal类

• 位置:java.matk包中。
• 作用:精确计算浮点数。
• 创建方式:BigDecimal bd=new BigDecimal(“1.0”);
• 方法:

• BigDecimal add(BigDecimal bd) 加
• BigDecimal subtract(BigDecimal bd) 减
• BigDecimal multiply(BigDecimal bd) 乘
• BigDecimal divide(BigDecimal bd) 除

• 除法: divide(BigDecimal bd,int scal, RoundingMode mode)

• 参数scal :指定精确到小数点后几位。
• 参数mode :

• 指定小数部分的取舍模式,通常采用四舍五入的模式，
• 取值为BigDecimal.ROUND_HALF_UP。

import java.math.BigDecimal;

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

        //面试题
        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");
        //减法
        BigDecimal r1 = bd1.subtract(bd2);
        System.out.println(r1);
        //加法
        BigDecimal r2 = bd1.add(bd2);
        System.out.println(r2);
        //乘法
        BigDecimal r3 = bd1.multiply(bd2);
        System.out.println(r3);
        //除法
        BigDecimal r4 = new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"));
        System.out.println(r4);
        BigDecimal r5 = new BigDecimal("20").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_DOWN);
        System.out.println(r5);
    }
}

Date类

import java.util.Date;

public class Demo02 {
    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.toString());
        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);
        //比较comepareTo()
        int d = date1.compareTo(date2);
        System.out.println(d);
        //比较是否相等equals()
        boolean b3 = date1.equals(date2);
        System.out.println(b3);

    }
}

Calendar类

• Calendar提供了获取或设置各种日历字段的方法。
• 构造方法

• protected Calendar() :由于修饰符是protected，所以无法直接创建该对象。

• 其他方法

import java.util.Calendar;

public class Dmeo03 {
    public static void main(String[] args) {
        //创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());
        //2.获取时间信息
        //获取年
        int year = calendar.get(Calendar.YEAR);
        //月
        int month = calendar.get(Calendar.MONTH);
        //日
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        //时
        int hour = calendar.get(Calendar.HOUR);
        int hour2 = calendar.get(Calendar.HOUR_OF_DAY);
        //分
        int minute = calendar.get(Calendar.MINUTE);
        //秒
        int second = calendar.get(Calendar.SECOND);
        System.out.println(year + "年" + (month+1) + "月" + day + "日" + hour2 +":" + minute + ":" + second);
        //修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH,27);
        System.out.println(calendar2.getTime().toLocaleString());
        //4.add方法修改时间
        calendar2.add(Calendar.HOUR,-1);
        System.out.println(calendar2.getTime().toLocaleString());
        //5.补充方法
        calendar2.add(Calendar.MONTH,2);
        int maximum = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        int minimum = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(maximum);
        System.out.println(minimum);

    }
}

SimpleDateFormat类

• SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。
• 进行格式化（日期→>文本）、解析（文本 -〉日期）。
• 常用的时间模式字母

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

public class Demo04 {
    public static void main(String[] args) throws ParseException {
        //1.创建SimpleDateFormat对象
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");

        //2.创建Date
        Date date = new Date();
        //格式化date,把日期转成字符串
        String format = simpleDateFormat.format(date);
        System.out.println(format);
        //解析，把字符串转成日期
        Date date1 = simpleDateFormat.parse("2010/12/12 12:12:12");
        System.out.println(date1);

    }
}

System类

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

public class Demo05 {
    public static void main(String[] args) {
        //arraycopy:数组复制
        //src:原数组
        //srcPos:从那个位置开始复制
        //dest:目标数组
        //destPos:目标数组的位置
        //length：复制的长度
        int[] arr ={1,22,33,44,55,66,77,88};
        int[] dest = new int[8];
        System.arraycopy(arr,2,dest,1,3);

        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }

        System.out.println(System.currentTimeMillis());

        long start = System.currentTimeMillis();
        for (int i = 0; i < 99999999; i++) {
            for (int i1 = 0; i1 < 99999999; i1++) {
                int result = i + i1;
            }
        }
        //获取毫秒数
        long end = System.currentTimeMillis();
        System.out.println("用时："+(end - start));

        //System.gc():告诉垃圾回收器回收垃圾
        Student s1 = new Student("aa", 19);
        new Student("bb", 20);
        new Student("cc",21);
        System.gc();

        //4.退出jvm
        System.exit(0);
        System.out.println("程序结束了");
    }
}

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

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

    public Student() {
    }

    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
    protected void finalize() throws Throwable {
        System.out.println("回收垃圾"+name + " "+ age);
    }
}

总结

• 内部类:

• 在一个类的内部再定义一个完整的类。
• 成员内部类、静态内部类、局部内部类、匿名内部类

• Object类:

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

• 包装类:

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

• String类:

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

• BigDecimal:

• 可精确计算浮点数。

• Date

• 特定时间

• Calendar。

• 日历

• SimpleDateFormat

• 格式化时间

• System

• 系统类