【JAVA BASICS】Day02 变量、八种基本数据类型、类型间的转换

张禹垚

已于 2024-08-19 09:06:42 修改

阅读量705

点赞数 24

分类专栏： Java Basics 文章标签： java intellij-idea

于 2024-08-03 11:33:44 首次发布

本文链接：https://blog.csdn.net/HLJ_Student/article/details/140887804

版权

Java Basics 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

Day02目标：

理解变量的作用
掌握变量的基本操作
了解Java的8种基本数据类型都有哪些
重点掌握int、long、double、boolean、char类型
掌握类型间转换的两种方式与两种规则
预计代码量：课上130行、作业260行

变量

什么是变量：

存储数据的“盒子”；
变量具有复用性：一次定义，多次使用；
变量具有可变性：随时随地，依需可变

问题引入：

如果一直正方形边长为2，我们想求面积及其周长该如何写这个需求的代码？

public static void main(String[] args){
  System.out.println("正方形的边长为：");
  System.out.println(2);
  System.out.println("正方形的面积为：");
  System.out.println(2 * 2);
  System.out.println("正方形的周长为：");
  System.out.println(2 * 4);
}

这段代码存在一些缺点，比如：如果要修改需要整体修改代码，且代码复杂，例如修改边长，代码量较大，于是引入变量进行改进：

public static void main(String[] args){
  int x = 2;
  System.out.println("正方形的边长为：");
  System.out.println(x);
  System.out.println("正方形的面积为：");
  System.out.println(x * x);
  System.out.println("正方形的周长为：");
  System.out.println(x * 4);
  
  int x = 3;
  System.out.println("正方形的边长为：");
  System.out.println(x);
  System.out.println("正方形的面积为：");
  System.out.println(x * x);
  System.out.println("正方形的周长为：");
  System.out.println(x * 4);
}

这样只需要改x的值，即可做到修改边长的值。

变量的声明

变量的声明，需要包括两部分：数据类型和变量名；
声明变量的格式：数据类型 (+) 变量名; //声明了一个整型的变量，名为a

int b; //声明了一个整型的变量，名为b
int c; //声明了一个整型的变量，名为c
int d; //声明了一个整型的变量，名为d

变量的初始化

=：赋值符号，作用是存数据，第一次赋值的过程叫做初始化，就像给账户存钱的过程。

int a = 5; // 声明同时初始化

int b; //先声明
b = 5; //后赋值

小结演示代码：

public static void main(String[] args) {
    // 1）变量的声明：———— 相当于在银行创建了一个账户
        int a; // 声明一个整型变量，名为a
        int b, c, d; // 声明三个整型变量，分别名为a、b、c

        // int a; // 编译错误，变量不能重名（就相当于不可能两个人开通一个账户）

    // 2）变量的初始化：———— 相当于给账户存钱
        int e = 250; // 声明整型变量e 并且赋值为250 ———— 相当于开户的同时存钱

        int f; // 声明整型变量f ———— 先开户
        f = 250; // 给变量f赋值为250 ———— 后存钱
        f = 360; // 修改变量f的值，改为360

        int g = 5, h = 8, i = 10; // 同时声明三个整型变量g、h、i，并分别赋值为5、8、10
    }

变量的访问：

对变量的访问就是对其所存数据的访问 ——— 访问的是账户里面的钱

int a = 5;
int b = a + 10; // 去除a的值5，加10后，在赋值给整型变量b

System.out.println(b); // 输出b的值
System.out.println("b"); //原样输出“b”

int a = 5;
a = a + 10; // 取出a的值5，加10后，在赋值给整型变量a
            // 注意是在a本身基础之上增加10 ———— 应用率较高

在访问变量之前，必须声明并初始化

System.out.println(i); // 编译错误，变量i未声明

int i;
System.out.println(i); // 编译错误，变量i未初始化

小结示例代码：

int j = 5; // 声明变量j，并给j赋值为5
int k = j + 10; // 去除j的值5，加10后，再赋值给变量k
System.out.println(k); //输出k的值，应为15
System.out.println("k"); // 原样输出字符“k”

j = j + 10; // 在j本身基础上增加10
System.out.println(j); // 15

 // 案例：声明变量(banlance)作为银行账户余额，进行取款1000元操作
int banlance = 5000; // 账户余额
banlance = banlance - 1000; // 取款1000元
System.out.println(banlance); // 输出结果应为5000-1000=4000

// 注意
// System.out.println(m); // 编译错误，由于m变量未声明
int m;
// System.out.println(m); // 编译错误，由于m变量未经初始化

变量的命名

变量的命名必须符合Java标识符的规则（标识符：自己起的名字，用于与其他名字做区分）—— 相当于给银行卡号命名的过程
规定：
- 只能包含字母、数字、 _ 和 $ 符，并且不能以数字开头
- 严格区分大小写
- 不能使用Java关键字（Java关键字：Java语言规定的，有特殊含义的符号）
建议：
- 允许中文命名，但是不建议，建议**“英文的见名知意”**、小驼峰命名法

int a1, a_5$, _3c, $5b;
// int a*b; // 编译错误，由于不能包含*等特殊符号
// int 1a; // 编译错误，由于不能使用关键字

int aa = 5;
// System.out.println(aA); // 编译错误，由于严格区分大小写所以无法找到变量aA
// int class; // 编译错误，由于不能使用Java关键字作为变量名

int 年龄; // 正确，但不建议
int nianLing; // 必须杜绝实用拼音
int age; // 建议“英文的见名知意”
int score, myScore, myJavaScore; // 建议“小驼峰命名法” ———— 变量名，其次建议类名采用“大驼峰命名法/Pascal命名法” ———— 例如：VarDemo

八种基本数据类型

Java的基本数据类型

整数类型

    byte

    short

    **int**

    **long**

浮点类型

    float

    **double**

    **boolean**

    **char**

int类型

整型，占4个字节，范围**-2^31到231-1** → 正负21个多亿（变量（数据）存储在内存中，内存是有大小的；变量到底占用多大的内存，是由它的数据类型控制的）

int a = 5; // 在内存中占用4个字节
int b = 500000000; // 在内存中同样占用4个字节

int类型的特点：

整数直接量默认为int类型，但不能超过范围，若超过范围则发生编译错误

int a = 25; // 25为整数直接量
int b = 10000000000; // 编译错误，由于100亿默认为int型，但是超出了范围
int c = 3.14; // 编译错误，整型变量只能容纳整数

两个整数相除，结果还是整数，小数位无条件舍弃（舍弃：不会四舍五入）

System.out.println(5/2); // 2
System.out.println(2/5); // 0
System.out.println(5.0/2); // 2.5 如果有小数参与就能保留小数位

运算时若超出范围，则会发生溢出（溢出不是错误，但是要避免）

int d = 2147483647; // int的最大值
d = d + 1;
System.out.println(d); // -2147483648（int的最小值），发生了溢出现象

long类型

长整型，占8个字节，范围**-2^63到263-1** → 正负900万万亿多
- 能用int就不用long，由于内存占用量越大，速度越慢

long类型特点

表示长整型直接量，需在数字后加L或l（建议写L）

long a = 25L; // 25L为长整型直接量
long b = 10000000000; // 编译错误，100亿默认int类型，但是超过了范围
long c = 10000000000L; // c值被赋100亿
long d = 3.14; // 编译失败，长整型内只能存整数

运算时若有可能溢出，建议在地1个数字后加L**（往前放）**

long e = 1000000000 * 2 * 10L; // 200亿
long f = 1000000000 * 3 * 10L; // 前两项计算产生溢出，所以无法和后面进行转换long类型了
long g = 1000000000L * 3 * 10; // 300亿，所以要提前加L

double类型

小数直接量默认为double型

double a = 3.14; // 3.14为小数直接量，默认为double型
float b = 3.14F; // 3.14F为float类型

不能表示精确数据，运算时可能发生舍入误差，无法避免！精确场合不能使用double或float！

double c = 3.0, d = 2.9;
System.out.println(c - d); // 0.100000000009...往上飘

double e = 6.0， f = 4.9;
System.out.println(e - f); // 1.099999999999999996...往下飘

double g = 6.0, h = 1.9;
System.out.println(g - h); // 4.1 不飘

银行、财务、保险系统中使用的几乎都是BigDecimal（后续再说！）

boolean类型

布尔型，占用一个字节
只能存储true或false → 后续常用

boolean a = true; // true为布尔型直接量
boolean b = false; // false为布尔型直接量
boolean c = 250; // 编译错误，只有true和false

char类型

字符型，占用两个字节
字符型直接量需放在单引号中，只能有一个

char c1 = '女'; // 字符“女”
char c2 = 'f'; // 字符“f”
char c3 = '6'; // 字符“6”
char c4 = ' '; // 空格符
char c5 = 女; // 编译错误，字符型直接量必须放在单引号中
char c6 = "; // 编译错误，必须有字符
char c7 = '10'; // 编译错误，只能存储1个字符，单引号里面有两个了

采用Unicode编码格式（万国码、统一码、通用码，为世界级通用的字符集，Java中的char采用的是其中最常用的子集）
- Unicode的特点：一个字符对应一个码
- （背下来）ASCII码：‘a’的码是97，‘A’的码是65，‘0’的码是48

char c8 = 65; // 0到65535之间，这种赋值方法不常见，但是可以这样用
System.out.println(c8); // println()会依据变量的类型做输出展示
                        // c8为char类型，所以会以字符形式输出

特殊符号需要通过**\来转义**

char c9 = '''; // 编译错误，无法解析
char c9 = '\''; // 特殊符号需要用反斜杠进行转义

char c9 = '\'; // 编译错误，无法解析
char c9 = '\\'; // 特殊符号需要用反斜杠进行转义

基本类型间转换

业务中需要一个int型数据，但程序中只有一个double型数据
将double型数据转换为int类型
反之亦然

两种转换方式

自动类型转换/隐式类型转换：从小类型到大类型
强制类型转换：从大类型到小类型
基本数据类型由小到大依次为：byte → short & char → int → long → float →double

int a = 5;
long b = a; // 自动类型转换
int c = b; // 编译错误，由大到小必须通过强制类型转换

强制类型转换语法格式：(要转换成为的数据类型)变量名

int c = (int)b; // 强制类型转换

自动类型转换的特殊形式：

long d = 5; // 自动类型转换：long类型 -> int类型
double e = 5; // 自动类型转换： double类型 -> int类型
System.out.println(e); // 将输出：5.0，默认保留一位小数

强制类型转换的特殊形式：

long f = 10000000000L;
int g = (int)f;
System.out.println(g); // 出现溢出现象，强制转换有可能发生溢出

double h = 25.897;
int i = (int)h;
System.out.println(h); // 25，强转有可能丢失精度

两点规则：

整数直接量可以直接赋值给byte、short、char

byte b1 = 5; // 5为整数直接量
byte b2 = 6; // 6为整数直接量
byte b3 = 800; // 编译错误，由于800超出了byte类型的最大值，byte的最大值为127

byte、short、char型数据参与运算时，先一律自动转换为int再进行运算

byte b1 = 5;
byte b2 = 6;
byte b3 = b1 + b2; // 编译错误，由于现在是int类型转换至byte类型，属于大转小，需要进行强制转换
byte b3 = (byte)b1 + b2; // 编译错误，强转计算优先级高于后面的运算
byte b3 = (byte)(b1 + b2); // 编译成功，结果为11