Java变量及基本数据类型基础

1. 变量

变量：变量是用于存储数据的可变存储空间（相当于存储数据的可变盒子） 变量的声明：数据类型 变量名                      变量的声明相当于在银行开户，一个变量只能声明一次，不能重复声明 变量的初始化：声明变量后为变量第一次赋值的过程                          变量在访问之前必须声明并初始化 特性     复用性：一次定义，多次使用     可变性：根据需求随时更改

第一个java代码⮷

// 声明包bases
package bases;

// 声明类HelloWorld
public class Demo01_HelloWorld {
    /**
     * 1. java严格区分大小写
     * 2. 符号使用英文状态下的
     * 3. 每个语句以 ; 分号结尾
     * @param args 字符数组形式
     */
    // 主方法（程序入口)
    public static void main(String[] args) {
        // 程序主体
        System.out.println("Hello World！");
    }
}

变量的声明，初始化，赋值⮷

package bases;

public class Demo02_Var {
    public static void main(String[] args) {
        /**
         * 变量的声明：声明相当于在银行开户
         */
        int a;            // 变量声明
        a = 5;            // 变量的初始化
        int b, c, d;      // 同时声明多个变量
        int e = 10;       // 声明变量的同时赋值
        int f, i = 50, h; // 声明多个变量，对其中的某个变量赋值

        // 变量的修改
        int m = 15;
        m = 20;

        // 变量的使用
        int n = 100;
        n = n + 80;
        System.out.println(n);
    }
}

变量的命名规则：小驼峰命名法                    ① 只能包含字母，数字，_和$，且不能以数字开头                    ② 严格区分大小写                    ③不能使用java关键字

2. java基本数据类型

java的8中基本数据类型：整型（byte，short，int，long），浮点型（float，double），布尔型boolean，字符型char

flowchart TD
    B["fab:fa-twitter 基本数据类型"]
    B-->C[fa:fa-ban 整数类型]
    B-->D(fa:fa-spinner 浮点类型)
    B-->E(fa:fa-camera-retro boolean)
    B-->F(fa:fa-camera-retro char)
    C-->H(fa:fa-camera-retro byte)
    C-->I(fa:fa-camera-retro short)
    C-->J(fa:fa-camera-retro int)
    C-->K(fa:fa-camera-retro long)
    D-->L(fa:fa-camera-retro float)
     D-->M(fa:fa-camera-retro double)
     A(4类8种)
     style A fill:cyan,fill-opacity:0.1,stroke:cyan,stroke-width:2px
     style B fill:green,fill-opacity:0.1,stroke:orange,stroke-width:2px
     style C fill:#C1FFC1,fill-opacity:1,stroke:#CDC673,stroke-width:2px
     style E fill:#C1FFC1,fill-opacity:1,stroke:#CDC673,stroke-width:2px
     style F fill:#C1FFC1,fill-opacity:1,stroke:#CDC673,stroke-width:2px
     style D fill:#C1FFC1,fill-opacity:1,stroke:#CDC673,stroke-width:2px

2.1 整数类型

byte、short、int、long 数据类型都表示整数（取值范围不同）

数据类型	名称	占用字节	包装类	范围
byte	字节型	1	Byte	-2^7^ 到 2^7^-1
short	短整型	2	Short	-2^15^ 到 2^15^-1
int	整型	4	Integer	-2^31^ 到 2^31^-1
long	长整型	8	Long	-2^63^ 到 2^63^-1

演示代码⮷ 整型数据类型，==int的最小值-2147483648==，计算时超出范围会发生溢出

package bases;

public class Demo02_DataType {
    /**
     * 数据类型:整型，浮点型，布尔型，字符型
     */
    public static void main(String[] args) {
        /*
        整型int：4个字节（-2^31~2^31-1）
         */
        // 整数直接量超出范围 -- 报错
        // int a = 2178945612;     // 超出最大范围
        // 整数计算超出范围 -- 溢出
        int b = 2147483647;
        System.out.println("发生溢出：" + (b + 1));
        // 整数相除只能得到整数
        System.out.println("整数相除得到整数：" + (5/2));
        // 有浮点数参与的计算得到浮点数
        System.out.println("有浮点数参与的计算：" + (5/2.0));
    }
}

演示代码⮷ 长整型数据类型

package bases;

public class Demo02_DataType {
    /**
     * 数据类型:整型，浮点型，布尔型，字符型
     */
    public static void main(String[] args) {        
        /*
        长整型long：8个字节（-2^63~2^63-1）
         */
        // 长整型直接量
        long w = 60L;
        // 计算量（L建议放在第一个数的后面）
        long x = 1000000000*2*10L;  // 结果200亿
        long y = 1000000000*3*10L;  // 结果不是300亿（溢出）
        long z = 1000000000L*3*10;  // 结果300亿
        System.out.println("w=" + x + "\ny=" + y + "\nz=" + z);
        String str = String.format("x的值为:%d",x);
        System.out.println(str);
        System.out.printf("x=%d,y=%d", x, y);
    }
}

2.2 浮点数类型

浮点数类型有float，double               1.小数直接量默认为double型，若想表示float需在数字后加F或f               2.不能表示精确数据，运算时可能发生舍入误差

演示代码⮷ 浮点型

数据类型	名称	指数位	尾数位	占用字节	包装类	范围	精度范围
float	单精度浮点型	8 bit	23 bit	4	Float	-2^128^ 到 2^127^-1	7位
double	双精度浮点型	11 bit	52 bit	8	Double	-2^1024^ 到 2^1023^-1	16位

package bases;

public class Demo02_DataType {
    /**
     * 数据类型:整型，浮点型，布尔型，字符型
     */
    public static void main(String[] args) {
        /*
        浮点型数据类型：精确度不高
         */
        // 默认double类型，直接量
        double m = 3.141592;
        // float类型
        float n = 3.1654F;
        // 计算量（精度：舍入误差）
        double p = 3.0, q = 2.9;
        System.out.println("存在误差：" + (p - q));
    }
}

2.3 布尔型和字符型

布尔型：布尔型占用1个字节，值为仅true或false 字符型：字符型占2用个字节               1.字符型直接量需要放在单引号中，只能放一个字符               2.采用Unicode（国际标准）编码格式               3.特殊符号需要通过 \ 来转义

数据类型	名称	占用字节	包装类
boolean	布尔型	1byte	Boolean
char	字符型	2byte	Character

演示代码⮷ 布尔型和字符型

package bases;

public class Demo02_DataType {
    /**
     * 数据类型:整型，浮点型，布尔型，字符型
     */
    public static void main(String[] args) {
        /*
        布尔型boolean：值为true或false,占1个字节
         */
        boolean u = false;
        boolean v = true;


        /*
        字符型char：占两个字节
         */
        // 字符
        char cha = '人';
        char cha1 = ' ';
        // 0 到 65535之间
        char cha2 = 65;
        // 特殊字符转义
        char cha3 = '\\';
        System.out.printf("字符：%c，空格%c,65的ASCII字符:%c,转义斜杠%c", cha, cha1, cha2, cha3);
    }
}

3. java基本数据类型转换

两种转换方式               自动类型转换（隐式类型转换）：小类型到大类型               强制类型转换：大类型到小类型               强转语法：（要转换成为的数据类型）变量 注意：强转有可能溢出或丢失精度

• 数据类型转换

flowchart LR
byte-->short-->int-->long-->float-->double
char-->int

演示代码⮷ 类型转换的两种方式

package bases;

public class Demo02_DataTypeConvert {
    public static void main(String[] args) {
        // 自动转换
        int a = 100;
        long b = a;
        // 强制转换
        int c = (int)b;

        // 强转溢出
        long l = 10000000000L;
        int i = (int)l;
        System.out.println("发生溢出：" + i);

        // 强转导致精度丢失
        double d = 12.265;
        int e = (int)d;
        System.out.println("丢失精度：" + e);
    }
}

两点规则               整数直接量可以直接赋值给byte、short、char，但不能超出范围               byte、short、char参与计算时，一律先转换成int，再参与计算

演示代码⮷ 两种规则

package bases;

public class Demo02_DataTypeConvert {
    public static void main(String[] args) {
        /*
        两点规则
         */
        // 直接赋值，直接量（不能超过范围)
        byte bs = 127;
        // 先转换在计算
        byte bt = (byte) (5 + 10);
        System.out.println(bt);

        // 查看对应字符的码
        int m = '我';
        System.out.println("“我”的ASCII码值：" + m);
        // 查看码的对应字符
        char cha = 100;
        System.out.println("100对应的字符：" + cha);

        System.out.println("参与计算时，先转换为int，再参与计算：" + (2 + '2'));
    }
}