API篇（Java - 数值类（Number&Integer&BigInteger...））（doing）

目录

一、数值类（Number）

二、包装类（Integer...）

1. 为什么提供包装类？

2. 包装类装箱和拆箱

3. 包装一个对象中的原始类型 int 的值

4. 包装类的缓存技术

5. 源码分析

6. valueOf

6.1. 原理

6.2. 包装类作为方法形参,采用按值传递还是按引用传递?

6.3. 如下代码 结果是什么? 如何解释?

7. 八种包装类

Byte

构造方法

常见方法

常量

Short

Integer

Long（父类Number）

Float

Double

Boolean

Character

简介

继承机制

构造方法

方法

静态方法

1. 如何将一个字符转换为大写字母或小写字母？

2. 何判断一个字符是否是数字？

3. 如何将一个字符转换为数字？

4. 如何将一个字符串转换为字符数组？

5. 如何判断一个字符是否是字母？

参考文献

8. 演示示例

8.1. 将基本数据类型包装成类

8.2. 包装类对象名存储的引用地址是可以更换的

8.3. 将字符串解析成基本数据类型的数据

8.4. 判断一个字符是不是数

8.5. 自动装箱

8.6. 自动拆箱

8.7. 验证包装类缓存技术

8.8. 封装方法

8.9. 明白包装类的概念并使用

三、大数值（Biglnteger & BigDecimal）

1. 简介

2. API

3. 示例演示

四、格式化数字（DecimalFormat）

1. 简介

2. 参考链接

---

一、数值类（Number）

Number类是java.lang包下的一个抽象类，提供了将包装类型拆箱成基本类型的方法，

所有基本类型（数据类型）的包装类型都继承了该抽象类，并且是final声明不可继承改变；

public abstract class Number implements java.io.Serializable {

    public Number() {super();}


    public abstract int intValue();


    public abstract long longValue();


    public abstract float floatValue();


    public abstract double doubleValue();


    public byte byteValue() {
        return (byte)intValue();
    }

    public short shortValue() {
        return (short)intValue();
    }

   
    @java.io.Serial
    private static final long serialVersionUID = -8742448824652078965L;
}

二、包装类（Integer...）

包装类其实就是8种基本数据类型对应的引用类型

基本数据类型	包装类型
byte	java.lang.Byte（父类Number）
short	java.lang.Short（父类Number）
int	java.lang.Integer（父类Number）
long	java.lang.Long（父类Number）
float	java.lang.Float（父类Number）
double	java.lang.Double（父类Number）
boolean	java.lang.Boolean（父类Object）
char	java.lang.Character（父类Object）

1. 为什么提供包装类？

目的就是Java为了实现一切皆对象, 为8种基本类型提供了对应的引用类型,

同时, 集合和泛型也只能支持包装类型, 不支持基本数据类型, 所以需要包装类进行替换基本数据类型

包装类变量的默认值可以是null, 容错率更高

2. 包装类装箱和拆箱

JDK5之后出现的自动装箱与拆箱

自动装箱：基本类型的数据和变量可以直接赋值给包装类型的变量

自动拆箱：包装类型的变量可以直接赋值给基本数据类型的变量

3. 包装一个对象中的原始类型 int 的值

public Integer(int value)	根据 int 值创建 Integer 对象(过时）
public Integer(String s)	根据 String 值创建 Integer 对象(过时)
public static Integer valueOf(int i)	返回表示指定的 int 值的 Integer 实例
public static Integer valueOf(String s)	返回一个保存指定值的 Integer 对象 String

4. 包装类的缓存技术

包装类在使用时,某些特殊的包装类会预先在内存上创建一些包装类对象作为缓存

当我们使用的包装类对象数字范围在指定的范围之内时,就会使用缓存中的对象

以Integer为例

low -128

high 127

Integer cache[]：Integer对象数组

Integer是一个final修饰的最终类

5. 源码分析

6. valueOf

6.1. 原理

6.2. 包装类作为方法形参,采用按值传递还是按引用传递?

当参数是基本数据类型时 按值传递 实参和形参在内存上是两个独立的变量 修改形参不会对实参产生影响

当参数是引用数据类型时 按引用传递 实参和形参执行堆内存上同一个地址 修改形参会对实参产生影响，但是包装

类不是！

6.3. 如下代码 结果是什么? 如何解释?

包装类作为方法参数仍然是按引用传递, 但是包装类的特点是内部存储的值是不可以修改的，

内部维护了一个  final修饰的 对应的基本数据类型的常量，

自动装箱技术在给包装类赋值时 调用valueOf方法 valueOf方法会给我们返回一个新对象，

在方法中修改包装类其实是让形参指向了内存上另一个包装类对象 并没有也不可能影响实参

Java为每个基本数据类型都提供了包装类以扩展我们基本数据类型，让我们完全面向对象类型！

大多数基本类型的包装类的名称与对应的基本数据类型名称一样，第一个字母要大写。

Integer和Character例外。数值包装类相互之间都非常相似。

每个都包含了doubleValue()、floatValue(),intValue()、longValue()、shortValue()和byteValue()方法。

这些方法将对象“转换”为基本类型值。

Integer类和Double类的主要特征如图：

既可以用基本数据类型值也可以用表示数值的字符串来构造包装类。

例如，newDouble(5.0)、newDouble("5.0")、newInteger（5)和newInteger("5")。

包装类没有无参构造方法。所有包装类的实例都是不可变的，这意味着一旦创建对象后，它们的内部值就不能再

改变。

每一个数值包装类都有常量MAX_VALUE和MIN_VALUE。MAX_VALUE表示对应的基本数据类型的最大值。

对于Byte、Short、Integer和Long而言，MIN_VALUE表示对应的基本类型byte、short、int和long的最小值。

对Float和Double类而言，MIN_VALUE表示float型和double型的最小正值。

根据上下文环境，基本数据类型值可以使用包装类自动转换成一个对象，反过来的自动转换也可以。

将基本类型值转换为包装类对象的过程称为装箱（boxing）,相反的转换过程称为开箱（unboxing）。

Java允许基本类型和包装类类型之间进行自动转换，这种自动转换的过程也就是装箱和拆箱的过程，JDK5开始提

供这一特性。

如果一个基本类型值出现在需要对象的环境中，编译器会将基本类型值进行自动装箱；

如果一个对象出现在需要基本类型值的环境中，编译器会将对象进行自动开箱。这称为自动装箱和自动开箱。

7. 八种包装类

基本数据类型	包装类型
byte	java.lang.Byte（父类Number）
short	java.lang.Short（父类Number）
int	java.lang.Integer（父类Number）
long	java.lang.Long（父类Number）
float	java.lang.Float（父类Number）
double	java.lang.Double（父类Number）
boolean	java.lang.Boolean（父类Object）
char	java.lang.Character（父类Object）

注意： 8种包装类属于 引用数据类型

Byte

构造方法

Byte(byte value)：该方法创建的Byte对象，可表示指定的byte的值。

byte mybyte =45；
Byte b=new Byte(mybyte)；

Byte(String str)：该方法创建的Byte对象，可表示String参数所指示的byte值。

Byte mybyte =new Byte("12");

常见方法

方法	返回值	功能描述
byteValue	byte	以一个byte值返回Byte对象
compareTo(Byte anotherByte)	int	在数字上比较两个Byte对象
doubleValue()	double	以一个double值返回此Byte的值
intValue()	int	以一个int值返回此Byte的值
parseByte(String s)	byte	将String类型参数解析成等价的字节（byte）形式
toString()	String	返回表示此Byte的值String对象
valueOf(String str)	byte	返回一个保存指定String所给出的值的Byte对象
equals(Object obj)	boolean	将此对象与指定对象比较，如果调用该方法的对象与obj相等，则返回true，否则返回false

常量

Byte类提供了4个常量：

MIN_VALUE:byte类型可取的最小值。

MAX_VALUE:byte类型可取的最大值。

SIZE：用于以二进制补码形式表示byte值的位数。

TYPE：表示基本类型byte的Class实例。

Short

Integer

Long（父类Number）

Float

Double

Boolean

Character

简介

Java.lang.Character类是一个将基础类型char值包装为一个对象,

每一个Character类都只包含一个char字段

Character类中的所有字段，方法，构造函数都由Unicode数据文件指定

继承机制

Java.lang Character类的声明方法

public final class Character
   extends Object
      implements Serializable, Comparable<Character>

构造方法

方法	描述
Character(char value)	构造一个Character表示指定char值的新分配对象。

方法

方法	描述
char charValue()	将此对象转化为char。
int hashCode()	返回此Character的哈希码。
boolean equals(Object obj)	将此对象与指定的对象进行比较。
int compareTo(Character anotherCharacter)	用Character数字比较两个对象。
String toString()	返回String表示此Character值的对象 。

静态方法

1. isLetter(char c)：检查字符是否是字母。
2. isDigit(char c)：检查字符是否是数字。
3. isWhitespace(char c)：检查字符是否为空格、制表符或换行符。
4. isUpperCase(char c)：检查字符是否为大写字母。
5. isLowerCase(char c)：检查字符是否为小写字母。
6. toUpperCase(char c)：将字符转换为大写字母。
7. toLowerCase(char c)：将字符转换为小写字母。

1. 如何将一个字符转换为大写字母或小写字母？

可以使用Character类的静态方法toUpperCase(char c)和toLowerCase(char c)

例如：

char ch = 'a';
char upperCh = Character.toUpperCase(ch); // 'A'
char lowerCh = Character.toLowerCase(ch); // 'a'

2. 何判断一个字符是否是数字？

可以使用Character类的静态方法isDigit(char c)来判断一个字符是否是数字，例如：

char ch = '5';
boolean isDigit = Character.isDigit(ch); // true

3. 如何将一个字符转换为数字？

可以使用Characchar ch = '5';

int num = Character.getNumericValue(ch); // 5ter类的静态方法getNumericValue(char c)将一个字符转换为

数字，例如：

char ch = '5';
int num = Character.getNumericValue(ch); // 5

4. 如何将一个字符串转换为字符数组？

可以使用String类的toCharArray()方法将一个字符串转换为字符数组，例如：

String str = "hello";
char[] chars = str.toCharArray(); // {'h', 'e', 'l', 'l', 'o'}

5. 如何判断一个字符是否是字母？

可以使用Character类的静态方法isLetter(char c)来判断一个字符是否是字母，例如：

char ch = 'a';
boolean isLetter = Character.isLetter(ch); // true

参考文献

Java Java.lang.Boolean.booleanValue()用法及代码示例 - 纯净天空

8. 演示示例

8.1. 将基本数据类型包装成类

package com.zheng.d15_integer.demo1;

public class Test1 {
    public static void main(String[] args) {
        // 基本数据类型 不是类 没有方法和属性可以让我们调用
        int a=10;
        // 将基本数据类型包装成类
        // Integer类 类中有一些现成的功能功我们使用
        Integer b =10;
        System.out.println(a);
        System.out.println(b);


        // 八种基本数据类型 对应着自己的包装类
        byte c=10;
        Byte c2 =10;


    }
}

8.2. 包装类对象名存储的引用地址是可以更换的

包装类内部存储的对应基本数据类型的值是不可以修改的，包装类对象名存储的引用地址是可以更换的

package com.zheng.d15_integer.demo1;

public class Test2 {
    public static void main(String[] args) {
        /*Integer a =new Integer(10);
        Character c=new Character('x');
        Double d =new Double(3.14);
        Boolean b=new Boolean(true);*/


        // 包装类内部存储的对应基本数据类型的值是不可以修改的
        // 包装类对象名存储的引用地址是可以更换的
        Integer a =new Integer(10);
        System.out.println(a);
        a=new Integer(20);
        System.out.println(a);
    }
}

8.3. 将字符串解析成基本数据类型的数据

package com.zheng.d15_integer.demo2;

public class Test1 {
    public static void main(String[] args) {
        String n="10";
        // 将字符串解析成基本数据类型的数据
        byte a =Byte.parseByte(n);
        System.out.println(a);
        short b =Short.parseShort(n);
        System.out.println(b);
        int c = Integer.parseInt(n);
        System.out.println(c);
        long l = Long.parseLong(n);
        System.out.println(l);
        String n2="3.14";
        float e = Float.parseFloat(n2);
        System.out.println(e);
        double f = Double.parseDouble(n2);
        System.out.println(f);
        boolean aTrue = Boolean.parseBoolean("true");
        System.out.println(aTrue);
    }
}

8.4. 判断一个字符是不是数

package com.zheng.d15_integer.demo2;

public class Test2 {
    public static void main(String[] args) {
        // 判断一个字符是不是数字
        System.out.println(Character.isDigit('a'));
        System.out.println(Character.isLetter('7'));
        System.out.println(Character.isLetterOrDigit('#'));
        System.out.println(Character.isLowerCase('A'));
        System.out.println(Character.isUpperCase('a'));
        //isSpace 转义字符也被判断是空格  isSpaceChar 转义字符不会被判断是空格
        System.out.println(Character.isSpaceChar(' '));
        System.out.println(Character.isSpaceChar('\t'));
        System.out.println(Character.isSpace('\r'));
        System.out.println(Character.isSpace('\n'));

    }
}

8.5. 自动装箱

使用基本数据类型的常量直接给包装类对象赋值，在早期的JDK版本中是不允许的，从JDK1.5开始可以使用的一种

写法，自动装箱技术帮助我们实现的，java自动将基本数据类型的常量值转换成一个包装对象，java自动的帮助我

们调用 valueOf方法完成。

package com.zheng.d15_integer.demo2;

public class Test3 {
    public static void main(String[] args) {
        /*
        * 使用基本数据类型的常量直接给包装类对象赋值
        * 在早期的JDK版本中是不允许的
        * 从JDK1.5开始可以使用的一种写法
        * 自动装箱技术帮助我们实现的
        * java自动将基本数据类型的常量值转换成一个包装对象
        * java自动的帮助我们调用 valueOf方法完成
        * */
        byte a1=10;
        Byte a2=a1;
        // ***.valueOf() 将基本数据类型的常量 转换成 包装类对象
        Byte a3=a1;//Byte.valueOf(a1);
        Integer b=10;//Integer.valueOf(10);

        Double aDouble = 3.14;//Double.valueOf(3.14);
        Float aFloat = 3.14f;//Float.valueOf(3.14f);

        Boolean aBoolean = true;//Boolean.valueOf(true);
        Character a = 'a';//Character.valueOf('a');
    }
}

8.6. 自动拆箱

包装类对象直接给一个基本数据类型的变量赋值，***value() 获取一个包装类对象所存储的对应的基本数据类型的

值。自动拆箱技术，从JDK1.5开始 可以不用调用***Value方法了 有java自动帮我们调用。

package com.zheng.d15_integer.demo2;

public class Test4 {
    public static void main(String[] args) {
        Integer i=new Integer(10);
        Byte j=new Byte("10");
        /*
        * 包装类对象直接给一个基本数据类型的变量赋值
        * ***value() 获取一个包装类对象所存储的对应的基本数据类型的值
        * 自动拆箱技术
        * 从JDK1.5开始 可以不用调用***Value方法了 有java自动帮我们调用
        * */
        int i2=i;//i.intValue();
        byte j2=j;//j.byteValue();
    }
}

8.7. 验证包装类缓存技术

package com.zheng.d15_integer.demo3;

public class Test1 {
    public static void main(String[] args) {
       /* Integer i=-5;
        Integer i2=-5;
        System.out.println(i==i2);*/

        Integer i = Integer.valueOf(456);
        Integer i2 = Integer.valueOf(456);
        System.out.println(i==i2);

    }
}

结果：

false

8.8. 封装方法

package com.zheng.d15_integer.demo3;

public class Test2 {
    public static void main(String[] args) {
        Integer i =10;
        change(i);
        System.out.println(i);
        Integer.valueOf(10);
        Double.valueOf(3.14);
        Character.valueOf('a');
        Boolean.valueOf(true);
    }
    public static void change(Integer i){
        i=100;
    }
}

8.9. 明白包装类的概念并使用

package com.zheng.d15_integer;

/**
    目标：明白包装类的概念并使用。
 */
public class Test {
    public static void main(String[] args) {
        int a = 10;
        Integer a1 = 11;
        Integer a2 = a; // 自动装箱
        System.out.println(a);
        System.out.println(a1);

        Integer it = 100;
        int it1 = it; // 自动拆箱
        System.out.println(it1);

        double db = 99.5;
        Double db2 = db; // 自动装箱了
        double db3 = db2; // 自动拆箱
        System.out.println(db3);

        // int age = null; // 报错了！
        Integer age1 = null;
        Integer age2 = 0;

        System.out.println("-----------------");
        // 1、包装类可以把基本类型的数据转换成字符串形式。（没啥用）
        Integer i3 = 23;
        String rs = i3.toString();
        System.out.println(rs + 1);

        String rs1 = Integer.toString(i3);
        System.out.println(rs1 + 1);

        // 可以直接+字符串得到字符串类型
        String rs2 = i3 + "";
        System.out.println(rs2 + 1);

        System.out.println("-----------------");

        String number = "23";
        //转换成整数
        // int age = Integer.parseInt(number);
        int age = Integer.valueOf(number);
        System.out.println(age + 1);

        String number1 = "99.9";
        //转换成小数
//        double score = Double.parseDouble(number1);
        double score = Double.valueOf(number1);
        System.out.println(score + 0.1);
    }
}

三、大数值（Biglnteger & BigDecimal）

1. 简介

如果基本的整数和浮点数精度不能够满足需求，我们就就可以借助java.math包中的两个有用的类：BigInteger

和 BigDecimal这两个类可以处理任意长度数字序列的数值。

BigInteger实现类任意精度的整数运算，BigDecimal实现类任意精度的浮点数运算。

2. API

3. 示例演示

package com.zheng.d10_bigdecimal;


import java.math.BigDecimal;
import java.math.RoundingMode;

/**
    目标：BigDecimal大数据类。

    引入：
        浮点型运算的时候直接+  * / 可能会出现数据失真（精度问题）。
        BigDecimal可以解决浮点型运算数据失真的问题。

    BigDicimal类：
        包：java.math.
        创建对象的方式（最好的方式：）
              public static BigDecimal valueOf(double val) :包装浮点数成为大数据对象。
        方法声明
              public BigDecimal add(BigDecimal value)       加法运算
              public BigDecimal subtract(BigDecimal value)  减法运算 
              public BigDecimal multiply(BigDecimal value)  乘法运算 
              public BigDecimal divide(BigDecimal value)    除法运算
              public double doubleValue(): 把BigDecimal转换成double类型。
 */
public class BigDecimalDemo {
    public static void main(String[] args) {
        // 浮点型运算的时候直接+  * / 可能会出现数据失真（精度问题）。
        System.out.println(0.09 + 0.01);
        System.out.println(1.0 - 0.32);
        System.out.println(1.015 * 100);
        System.out.println(1.301 / 100);

        System.out.println("-------------------------");
        double a = 0.1;
        double b = 0.2;
        double c = a + b;
        System.out.println(c);
        System.out.println("--------------------------");
        // 包装浮点型数据成为大数据对象 BigDeciaml
        BigDecimal a1 = BigDecimal.valueOf(a);
        BigDecimal b1 = BigDecimal.valueOf(b);
        BigDecimal c1 = a1.add(b1);
        // BigDecimal c1 = a1.subtract(b1);
        // BigDecimal c1 = a1.multiply(b1);
        // BigDecimal c1 = a1.divide(b1);
        System.out.println(c1);

        // 目的：double
        double rs = c1.doubleValue();
        System.out.println(rs);

        // 注意事项：BigDecimal是一定要精度运算的
        BigDecimal a11 = BigDecimal.valueOf(10.0);
        BigDecimal b11 = BigDecimal.valueOf(3.0);
        /**
           参数一：除数 参数二：保留小数位数  参数三：舍入模式
         */
        BigDecimal c11 = a11.divide(b11, 2, RoundingMode.HALF_UP); // 3.3333333333
        System.out.println(c11);


        System.out.println("-------------------");
    }
}

四、格式化数字（DecimalFormat）

1. 简介

NumberFormat.getInstance()方法返回NumberFormat的一个实例(实际上是NumberFormat具体的一个子类，

例如DecimalFormat),这适合根据本地设置格式化一个数字。你也可以使用非缺省的地区设置，例如德国。然后格

式化方法根据特定的地区规则格式化数字。这个程序也可以使用一个简单的形式：

NumberFormat.getInstance().format(1234.56)

但是保存一个格式然后重用更加有效。国际化是格式化数字时的一个大问题。

另一个是对格式的有效控制，例如指定小数部分的位数，下面是解决这个问题的一个简单例子：

import java.text.DecimalFormat;
import java.util.Locale;
public class DecimalFormat2 {
    public static void main(String args[]) {
        // 得到本地的缺省格式
        DecimalFormat df1 = new DecimalFormat("####.000");
        System.out.println(df1.format(1234.56));
        // 得到德国的格式
        Locale.setDefault(Locale.GERMAN);
        DecimalFormat df2 = new DecimalFormat("####.000");
        System.out.println(df2.format(1234.56));
    }
}

在这个例子中设置了数字的格式，使用像"####.000"的符号。这个模式意味着在小数点前有四个数字，

如果不够就空着，小数点后有三位数字，不足用0补齐。

程序的输出：

1234.560
1234,560

相似的，也可以控制指数形式的格式，例如：

import java.text.DecimalFormat;
public class DecimalFormat3 {
    public static void main(String args[]) {
        DecimalFormat df = new DecimalFormat("0.000E0000");
        System.out.println(df.format(1234.56));
    }
}

输出：

1.235E0003

对于百分数：

import java.text.NumberFormat;
public class DecimalFormat4 {
    public static void main(String args[]) {
        NumberFormat nf = NumberFormat.getPercentInstance();
        System.out.println(nf.format(0.47));
    }
}

输出：

47%

至此，你已经看到了格式化数字的几个不同的技术。另一方面，如何读取并解析包含格式化的数字的字符串？

解析支持包含在NumberFormat中。

例如：

import java.util.Locale;
import java.text.NumberFormat;
import java.text.ParseException;
public class DecimalFormat5 {
    public static void main(String args[]) {
        // 本地格式
        NumberFormat nf1 = NumberFormat.getInstance();
        Object obj1 = null;
        // 基于格式的解析
        try {
            obj1 = nf1.parse("1234,56");
        }
        catch (ParseException e1) {
            System.err.println(e1);
        }
        System.out.println(obj1);
        // 德国格式
        NumberFormat nf2 =NumberFormat.getInstance(Locale.GERMAN);
        Object obj2 = null;
        // 基于格式的解析
        try {
            obj2 = nf2.parse("1234,56");
        }
        catch (ParseException e2) {
            System.err.println(e2);
        }
        System.out.println(obj2);
    }
}

这个例子分两部分，都是解析一个字符串："1234,56"。

第一部分使用本地格式解析，第二部分使用德国格式解析。

当程序在美国运行，结果是：

123456
1234.56

换句话说，"1234,56"在美国被认为是一个巨大的整数"123456"而在德国被认为是一个小数"1234.56"。

DecimalFormat 和NumberFormat的联系

在上面的例子中， DecimalFormat 和 NumberFormat 都被使用了。

DecimalFormat 常用于获得很好的格式控制，而NumberFormat 常用于指定不同于本地的地区。如何结合两个

类呢？

答案围绕着这样的事实：DecimalFormat是NumberFormat的一个子类,其实例被指定为特定的地区。

因此，你可以使用NumberFormat.getInstance 指定一个地区，然后将结构强制转换为一个DecimalFormat对

象。

文档中提到这个技术可以在大多情况下适用，但是你需要用try/catch  块包围强制转换以防转换不能正常工作 (大

概在非常不明显得情况下使用一个奇异的地区)。

下面是一个这样的例子：

import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.Locale;
public class DecimalFormat6 {
    public static void main(String args[]) {
        DecimalFormat df = null;
        // 得到一个NumberFormat 对象并
        // 强制转换为一个 DecimalFormat 对象
        try {
            df = (DecimalFormat)NumberFormat.getInstance(Locale.GERMAN);
        }
        catch (ClassCastException e) {
            System.err.println(e);
        }
        // 设置格式模式
        df.applyPattern("####.00000");
        // format a number
        System.out.println(df.format(1234.56));
    }
}

getInstance() 方法获得格式，然后调用applyPattern()方法设置格式模式，输出：

1234,56000

如果你不关心国际化，可以直接使用DecimalFormat 。

其中 v 为未处理的double,scale为需求精度，返回需要小数位数的double

    public static double round(double v,int scale){
        if(scale<0){
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(Double.toString(v));
        BigDecimal one = new BigDecimal("1");
        return b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
    }

2. 参考链接

• DecimalFormat多种用法详解_java_脚本之家