java 基本类型,数组,方法实例详解_Java

java 基本类型共 8 种，分为整数（4 种）、浮点（2 种）、字符（char）、布尔（boolean）四大类；

一、整数类型（用于存储整数，共 4 种）

byte（字节型）

占用内存：1 个字节（8 位）
取值范围：-128 到 127
默认值（仅成员变量有，局部变量无默认值）：0
对应的包装类：byte
使用要点：占用内存最小，适合存储小范围整数（如文件读取的字节数据）

short（短整型）

占用内存：2 个字节（16 位）
取值范围：-32768 到 32767
默认值：0
对应的包装类：short
使用要点：日常开发中较少使用，主要用于特定硬件接口的数据交互场景

int（整型）

占用内存：4 个字节（32 位）
取值范围：-2³¹ 到 2³¹-1（约 ±21 亿）
默认值：0
对应的包装类：integer
使用要点：java 中最常用的整数类型，声明普通整数时默认就是 int 类型（如100、25都是 int）

long（长整型）

占用内存：8 个字节（64 位）
取值范围：-2⁶³ 到 2⁶³-1（远超 int 的范围）
默认值：0l（注意后缀 l）
对应的包装类：long
使用要点：存储超大整数时使用，声明时必须加后缀l（大写 l 推荐，避免和数字 1 混淆），比如1234567890123l

二、浮点类型（用于存储小数，共 2 种）

float（单精度浮点型）

占用内存：4 个字节（32 位）
精度：约 6-7 位有效数字
默认值：0.0f（注意后缀 f）
对应的包装类：float
使用要点：声明时必须加后缀f，精度较低，日常开发中较少使用，多用于内存受限的嵌入式场景

double（双精度浮点型）

占用内存：8 个字节（64 位）
精度：约 15-16 位有效数字
默认值：0.0d（后缀 d 可省略）
对应的包装类：double
使用要点：java 中最常用的浮点类型，声明小数时默认就是 double 类型（如3.14、0.5都是 double）

三、字符类型（char）

占用内存：2 个字节（16 位）

//中文在utf-8中占3字节，gbk中占2字节。

四、布尔类型（boolean）

取值范围：只有两个值 ——true（真）或 false（假）
默认值：false
对应的包装类：boolean
使用要点：用于表示逻辑判断结果，无法参与数值运算

五.代码运行

下面的代码可以直接运行，直观展示基本类型的默认值、声明方式和取值特点：

public class basictypeproperties {
    // 成员变量：有默认值（无需初始化）
    byte bytevar;
    short shortvar;
    int intvar;
    long longvar;
    float floatvar;
    double doublevar;
    char charvar;
    boolean booleanvar;
    public static void main(string[] args) {
        // 1. 打印成员变量的默认值
        basictypeproperties obj = new basictypeproperties();
        system.out.println("=== 成员变量默认值 ===");
        system.out.println("byte: " + obj.bytevar);          // 输出 0
        system.out.println("short: " + obj.shortvar);        // 输出 0
        system.out.println("int: " + obj.intvar);            // 输出 0
        system.out.println("long: " + obj.longvar);          // 输出 0
        system.out.println("float: " + obj.floatvar);        // 输出 0.0
        system.out.println("double: " + obj.doublevar);      // 输出 0.0
        system.out.println("char(ascii码): " + (int)obj.charvar); // 输出 0
        system.out.println("boolean: " + obj.booleanvar);    // 输出 false
        // 2. 局部变量：必须手动初始化才能使用
        system.out.println("\n=== 局部变量声明示例 ===");
        int age = 25;                  // int（最常用）
        long bignum = 1234567890123l;  // long需加l
        float pifloat = 3.14f;         // float需加f
        double pidouble = 3.1415926535; // double无需加d
        char ch = '中';                // char存储中文
        boolean isadult = true;        // boolean只有true/false
        system.out.println("int(年龄): " + age);
        system.out.println("long(大数): " + bignum);
        system.out.println("float(π): " + pifloat);
        system.out.println("double(π): " + pidouble);
        system.out.println("char(字符): " + ch);
        system.out.println("boolean(是否成年): " + isadult);
    }
}

六.类型转换

隐式转换

自动进行的小范围到大范围的转换（如int转double）。

显式转换

需手动指定的强制转换（可能丢失精度）。

七.数组

1.定义数组

public class arrayproperties {
    public static void main(string[] args) {
        // 1. 数组声明与初始化（两种方式）
        // 方式1：静态初始化（指定元素，长度由元素个数决定）
        int[] intarr1 = {10, 20, 30}; 
        // 方式2：动态初始化（指定长度，元素为默认值）
        int[] intarr2 = new int[4]; // 长度4，元素默认值都是0
        boolean[] boolarr = new boolean[2]; // 长度2，元素默认值false
        // 2. 核心属性：length（获取长度）
        system.out.println("intarr1长度：" + intarr1.length); // 输出 3
        system.out.println("intarr2长度：" + intarr2.length); // 输出 4
        // 3. 访问数组元素（通过索引）
        system.out.println("intarr1[0]：" + intarr1[0]); // 输出 10
        system.out.println("intarr2[1]：" + intarr2[1]); // 输出 0（默认值）
        system.out.println("boolarr[0]：" + boolarr[0]); // 输出 false（默认值）
        // 4. 修改数组元素（索引赋值）
        intarr2[2] = 99;
        system.out.println("修改后intarr2[2]：" + intarr2[2]); // 输出 99
        // 5. 遍历数组（利用length属性）
        system.out.println("\n遍历intarr1：");
        for (int i = 0; i < intarr1.length; i++) {
            system.out.print(intarr1[i] + " "); // 输出 10 20 30
        }
        // 注意：索引越界会报错（注释掉，运行可验证）
        // system.out.println(intarr1[3]); // 抛出arrayindexoutofboundsexception
    }
}

八.方法

方法组成：public static（修饰符）、int/double/void（返回类型）、add/sayhello（方法名）、(int a, int b)（参数列表）、{}内是方法体；
重载：两个add方法名相同，参数类型（int/double）不同，符合重载规则；
参数传递：基本类型传值（修改不影响原变量），引用类型传地址（修改影响原对象）；
返回值：void无返回值，有返回值需用return返回对应类型数据

public class methoddemo {
    // 1. 无返回值、无参数方法
    public static void sayhello() {
        system.out.println("hello!");
    }
    // 2. 有返回值、有参数方法（计算两数之和）
    public static int add(int a, int b) {
        return a + b; // 返回int类型结果
    }
    // 3. 方法重载（同名、不同参数类型）
    public static double add(double a, double b) {
        return a + b;
    }
    // 4. 参数传递演示（基本类型传值、引用类型传地址）
    public static void changevalue(int num, int[] arr) {
        num = 100; // 基本类型：修改的是副本，原变量不变
        arr[0] = 200; // 引用类型：修改的是数组本身，原数组会变
    }
    public static void main(string[] args) {
        // 调用无返回值方法
        sayhello();
        // 调用有返回值方法（不同重载版本）
        int sum1 = add(10, 20);
        double sum2 = add(1.5, 2.5);
        system.out.println("int求和：" + sum1); // 输出30
        system.out.println("double求和：" + sum2); // 输出4.0
//接收返回值的核心语法：返回值类型 变量名 = 方法名(参数);
//变量类型必须和方法返回值类型匹配；
//接收的本质是 “用变量存方法的结果”，不接收则结果直接丢失，无法复用；
        // 验证参数传递
        int num = 10;
        int[] arr = {10};
        changevalue(num, arr);
        system.out.println("基本类型原值：" + num); // 仍为10
        system.out.println("引用类型修改后：" + arr[0]); // 变为200
    }
}

到此这篇关于java 基本类型,数组,方法实例详解的文章就介绍到这了,更多相关java基本类型数组方法内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！