韩顺平Java 第3章变量

最新推荐文章于 2024-06-12 23:40:32 发布

想坠入漫天星河随黑夜隐退

最新推荐文章于 2024-06-12 23:40:32 发布

阅读量844

点赞数 18

文章标签： java

本文链接：https://blog.csdn.net/m0_55274145/article/details/135424481

版权

韩顺平_零基础学Java(自用) 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

3.1 为什么需要变量

3.1.1 一个程序就是一个世界

在这里插入图片描述

3.1.2 变量是程序的基本组成单位

不论是使用哪种高级程序语言编写程序,变量都是其程序的基本组成单位，比如:

//变量有三个基本要素(类型+名称+值)
class Testf {  
    public static void main(String[] args) {  
        int a = 1; // 定义了一个变量，类型int整型, 名称a, 值1  
        int b = 3; // 定义了一个变量, 类型int整型, 名称b, 值3  
        b = 89; // 把89值赋给 b变量  
        System.out.println(a); // 输出a变量的值  
        System.out.println(b); // 输出b变量的值  
    }  
}

在这里插入图片描述

3.1.3 简单的原理示意图

在这里插入图片描述

3.2 变(变化)量(值)的介绍

3.2.1概念

变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，而通过变量名可以访问到变量(值)。

3.2.2变量使用的基本步骤

声明变量
int a;
赋值
a = 60; 应该这么说：把 60 赋给 a
使用System.out.println(a);
也可一步到位int a = 60;通常我们是一步完成

3.3 变量快速入门

变量使用入门案例——“人的信息的代码”
Var02.java

public class Var02 {  
    public static void main(String[] args) {  
        // 记录人的信息  
        int age = 30;  
        double score = 88.9;  
        char gender = '男';  
        String name = "king";  
          
        // 输出信息, 快捷键  
        System.out.println("人的信息如下:");  
        System.out.println("姓名: " + name);  
        System.out.println("年龄: " + age);  
        System.out.println("分数: " + score);  
        System.out.println("性别: " + gender);  
    }  
}

3.4 变量使用注意事项

变量表示内存中的一个存储区域【不同的变量，类型不同，占用的空间大小不同，比如:int 4 个字节，double 8 个字节】
该区域有自己的名称[变量名]和类型[数据类型]
变量必须先声明，后使用，即有顺序
该区域的数据/值可以在同一类型范围内不断变化
变量在同一个作用域内不能重名
变量三要素：变量=变量名+值+数据类型

VarDetail.java

public class VarDetail {  
    public static void main(String[] args) {  
        // 3.变量必须先声明，后使用，即有顺序  
        int a = 50; // int  
        System.out.println(a); // 50  
        // 4.该区域的数据/值可以在同一类型范围内不断变化  
        // a = "jack"; //×  
        a = 88; // 对  
        System.out.println(a); // 88  
        // 5.变量在同一个作用域内不能重名  
        // int a = 77; // 错误  
    }  
}  
  
class Dog {  
    public static void main(String[] args) {  
        int a = 666; // 对  
        System.out.println(a); // 666  
    }  
}

3.5 程序中 +号的使用

当左右两边都是数值型时，则做加法运算
当左右两边有一方为字符串，则做拼接运算
运算顺序：从左到右

课堂测试题：下面代码输出什么?

System.out.println(100 + 98); 198
解释：这里有两个整数相加，所以它们会进行数学加法运算。
System.out.println("100" + 98); 10098
解释：这里有一个字符串和一个整数。当使用加号 (+) 运算符将一个字符串和一个整数或其他数据类型组合时，Java 会进行字符串连接，而不是数学加法。因此，整数 98 被转换成了字符串 “98”，然后与 “100” 连接，得到 “10098”。
System.out.println(100 + 3 + "hello"); 103hello
解释：这里首先有两个整数相加，得到 103。然后，这个结果与字符串 “hello” 进行连接，得到 “103hello”。
System.out.println("hello" + 100 + 3); hello1003
解释：这里首先有一个字符串 “hello” 和一个整数 100。如前所述，当字符串和整数组合时，Java 会进行字符串连接。因此，100 被转换成了 “100”，然后与 “hello” 连接，得到 “hello100”。接着，这个结果与整数 3 进行连接，但此时 3 也被转换成了字符串 “3”。所以，最终得到 “hello1003”。

3.6 数据类型

每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间(字节)。
在这里插入图片描述

3.7 整数类型

3.7.1 基本介绍

Java的整数类型就是用于存放整数值的，比如12，30，3456等等

3.7.2 案例演示：

byte n1 = 10;
short n2 = 10;
int n3 = 10;//4 个字节
long n4 = 10; //8 个字节

3.7.3 整型的类型

在这里插入图片描述

3.7.4 整型的使用细节

Java各整数类型有固定的范围和字段长度，不受具体OS[操作系统]的影响，以保证java程序的可移植性。
Java的整型常量(具体值)默认为int型，声明long型常量须后加l或L
java程序中变量常声明为int型，除非不足以表示大数，才使用long
bit：计算机中的最小存储单位。
byte：计算机中基本存储单元

1 byte = 8 bit

IntDetail.java

public class IntDetail {  
    // 编写一个 main 方法  
    public static void main(String[] args) {  
        // Java 的整型常量（具体值）默认为 int 型，声明 long 型常量须后加‘l’或‘L’  
        int n1 = 1; // 4 个字节  
        // int n2 = 1L; // 错  
        long n3 = 1L; // 对  
    }  
}

3.8

浮点类型

3.8.1 基本介绍

Java的浮点类型可以表示一个小数，比如123.4，7.8，0.12等等

3.8.2 案例演示

3.8.3 浮点型的分类

类型	占用储存空间	范围
单精度 float	4字节	-3.403E38 ~ 3.403E38
双精度 double	8字节	-1.798E308 ~ 1.798E308

3.8.4 说明一下

关于浮点数在机器中存放形式的简单说明，浮点数=符号位+指数位+尾数位
尾数部分可能丢失，造成精度损失(小数都是近似值)。

3.8.5浮点型使用细节

以下是对文中提到的Java浮点数的整理：

Java浮点数类型

与整数类型类似，Java浮点类型也有固定的范围和字段长度，不受具体OS的影响。
Java的浮点型常量(具体值)默认为double型，要声明float型常量，须后加“f”或“F”。
浮点型常量有两种表示形式：
- 十进制数形式：如5.12、512.0f、.512(必须有小数点)。
- 科学计数法形式：如5.12e2[5.12*10的2次方]、5.12E-2 [5.12/10的2次方]。
通常情况下，应该使用double型，因为它比float型更精确。
- 举例说明:
```
double num9 = 2.1234567851;
float num10 = 21234567851F;
```
浮点数使用陷阱：浮点数比较2.7和8.1/3
由于浮点数的精度问题，直接比较可能会得出不相等的结论。
解决方式：可以通过设置一个很小的阈值（如0.00001），如果两个浮点数的差的绝对值小于这个阈值，则认为它们是相等的。

double num7 = 2.7;  
double num8 = 8.1 / 3;  
if(Math.abs(num7 - num8) < 0.00001)  
    System.out.println("相等~~");

FloatDetail.java

public class FloatDetail {  
	// 编写一个main方法
    public static void main(String[] args) {  
        
        // Java 的浮点型常量默认为 double，若要声明 float，需要后加 'f' 或 'F'  
        // float num1 = 1.1; // 错
        float num2 = 1.1F; // 正确声明 float 常量  
        double num3 = 1.1; // 正确声明 double 常量  
        double num4 = 1.1f; // 正确声明 double 常量  
  
        // 十进制数形式：如5.12、512.0f、 .512(必须有小数点)
        double num5 = .123; // 等价于 0.123  
        System.out.println(num5);  
  
        // 科学计数法形式：如5.12e2[5.12*10的2次方]、5.12E-2[5.12/10的2次方]
        System.out.println(5.12e2); // 输出512.0  
        System.out.println(5.12E-2); // 输出0.0512  
  
        // 一般使用 double，因为它比 float 更精确  
        double num9 = 2.1234567851;  
        float num10 = 2.1234567851F;  
        System.out.println(num9);  // 2.1234567851
        System.out.println(num10); // 2.1234567
  
        // 浮点数陷阱：2.7 和 8.1 / 3 的比较  
        double num11 = 2.7;  
        double num12 = 8.1 / 3; // 结果应为 2.7，但由于浮点数精度问题，可能不会精确为 2.7  
        System.out.println(num11); // 输出 2.7  
        System.out.println(num12); // 可能输出一个接近但不完全等于 2.7 的值  
        // 当我们对运算结果是小数的进行相等判断时， 要小心
        // 当比较浮点数时，由于精度问题，不能直接使用 ==，而应使用差值的绝对值进行比较  
        if (Math.abs(num11 - num12) < 0.000001) {  
            System.out.println("num11 和 num12 的差值非常小，可以认为它们相等");  
        } else {  
            System.out.println("num11 和 num12 不相等");  
        }  
        System.out.println(Math.abs(num11 - num12));
        // 细节:如果是直接查询得到的小数或者直接赋值， 是可以判断相等
    }  
}

3.9 Java API 文档

在这里插入图片描述

3.10 字符类型(char)

3.10.1 基本介绍

字符类型可以表示单个字符，字符类型是char，char是两个字节(可以存放汉字)，多个字符我们用字符串String

3.10.2 案例演示

char c1 = 'a';
char c2 = '\t';
char c3 = '韩';
char c4 = 97;

3.10.3 字符类型使用细节

字符常量是用单引号(' ')括起来的单个字符。
```
char c1 = 'a';
char c2 = '中';
char c3 = '9';
```
Java中可以使用转义字符\'将后面的字符转变为特殊字符型常量。
```
char c3 ='\n'; // '\n'表示换行符
```
在Java中，char的本质是一个整数，代表Unicode码。

http://tool.chinaz.com/Tools/Unicode.aspx
可以直接给char赋一个整数，然后输出时，会按照对应的Unicode字符输出。

97 → a
char类型可以进行运算，相当于一个整数，因为它都对应有Unicode码。

CharDetail.java

public class CharDetail {  
    public static void main(String[] args) {  
        // 在 Java 中， char 的本质是一个整数， 在默认输出时， 是 unicode 码对应的字符  
        // 要输出对应的数字， 可以(int)字符  
        char c1 = 97;  
        System.out.println(c1); // a  
          
        char c2 = 'a'; // 输出 'a' 对应的数字  
        System.out.println((int) c2);  
          
        char c3 = '韩';  
        System.out.println((int) c3); // 38889  
          
        char c4 = 38889;  
        System.out.println(c4); // 韩  
          
        // char 类型是可以进行运算的， 相当于一个整数， 因为它都对应有 Unicode 码.  
        
        System.out.println('a' + 10); // 107  
          
        // 课堂小测试  
        char c5 = 'b' + 1; // 98 + 1 → 99  
        System.out.println((int) c5); // 99  
        System.out.println(c5); // 99 → 对应的字符 → 编码表 ASCII (规定好的) → c  
    }  
}

字符型存储到计算机中，需要将字符对应的码值(整数)找出来
比如：'a'存储：'a' → 码值97 → 二进制(110 0001) → 存储读取：二进制(110 0001) → 97 → 'a' → 显示
字符和码值的对应关系是通过字符编码表决定的(是规定好)

介绍一下字符编码表 [sublime测试]
- ASCII(ASCII编码表一个字节表示，一个128个字符.实际上一个字节可以表示256个字符，只用128个)
- Unicode (Unicode编码表固定大小的编码使用两个字节来表示字符，字母和汉字统一都是占用两个字节，这样浪费空间 )
- utf-8(编码表，大小可变的编码字母使用1个字节，汉字使用3个字节)
- gbk(可以表示汉字，而且范围广，字母使用1个字节，汉字2个字节)
- gb2312 (可以表示汉字，gb2312 < gbk)
- big5 码(繁体中文,台湾，香港)

3.11 ASCII 码介绍(了解)

在这里插入图片描述

3.12 Unicode 编码介绍(了解)

在这里插入图片描述

3.13 UTF-8 编码介绍(了解)

在这里插入图片描述

3.14 布尔类型： boolean

基本介绍

布尔类型也叫boolean类型，booolean类型数据只允许取值true和false，无null
boolean类型占1个字节
boolean 类型适于逻辑运算，一般用于程序流程控制：
- if条件控制语句
- while循环控制语句
- do-while循环控制语句
- for循环控制语句

Boolean01.java

public class Boolean01 {  
      
    public static void main(String[] args) {  
          
        // 定义一个布尔变量来表示考试是否通过  
        boolean isPass = true;  
          
        // 使用if-else语句进行条件判断  
        if (isPass) {  
            System.out.println("考试通过，恭喜！");  
        } else {  
            System.out.println("考试没有通过，下次再努力！");  
        }  
    }  
}

3.15 基本数据类型转换

3.15.1 自动类型转换

介绍：当 java 程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数据类型这个就是自动类型转换。
数据类型按精度(容量)大小排序为：
在这里插入图片描述

int a = 'c'; //对
double d = 80; //对

3.15.2 自动类型转换注意和细节

数据类型转换：当多种类型的数据混合运算时，系统会首先将所有数据转换成容量最大的那种数据类型，然后再进行计算。
如果一个操作数是一个byte或short类型，而另一个操作数是int或float类型，那么byte和short类型的数据会被自动转换为int类型或float类型。
自动类型提升：当进行算术运算时，如果操作数的类型比结果的类型精度(容量）小，那么Java会自动将操作数提升(转换)为结果的类型。
如果你有一个float和一个int，并且你执行加法运算，那么int值会被自动转换为float。
(byte, short) 和 char 之间不会相互自动转换：byte, short, 和 char 之间的转换需要显式地进行。
要将一个byte值转换为char，你需要将其值加上一个偏移量（对于ASCII码中的字符通常是其对应的整数值）
boolean 不参与转换
自动提升原则：表达式结果的类型自动提升为操作数中最大的类型：
如果你有两个操作数，一个是int，另一个是float，那么结果将是float类型，因为它的精度更高。

public class AutoConvertDetail {  
    // 编写一个 main 方法  
    public static void main(String[] args) {  
    
        // 细节 1： 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型， 然后再进行计算
        int n1 = 10; // ok  
        // float d1 = n1 + 1.1; // 错误 n1 + 1.1 => 结果类型是 double  
        // double d1 = n1 + 1.1; // 对 n1 + 1.1 => 结果类型是 double  
        float d1 = n1 + 1.1F; // 对 n1 + 1.1 => 结果类型是 float  
        
        // 细节 2: 当我们把精度(容量)大的数据类型赋值给精度(容量)小的数据类型时，就会报错， 反之就会进行自动类型转换。
        // int n2 = 1.1; // 错误 double -> int 
         
        // 细节 3: (byte, short) 和 char 之间不会相互自动转换当把具体数赋给 byte 时， (1)先判断该数是否在 byte 范围内， 如果是就可以  
        byte b1 = 10; // 对 , -128-127  
        // int n2 = 1; // n2 是 int  
        // byte b2 = n2; // 错误， 原因： 如果是变量赋值， 判断类型  
        // char c1 = b1; // 错误， 原因 byte 不能自动转成 char  
       
        // 细节 4: byte， short， char 他们三者可以计算， 在计算时首先转换为 int 类型  
        byte b2 = 1;  
        byte b3 = 2;  
        short s1 = 1;  
        // short s2 = b2 + s1; // 错, b2 + s1 => int  
        int s2 = b2 + s1; // 对, b2 + s1 => int  
        // byte b4 = b2 + b3; // 错误: b2 + b3 => int  
        // boolean 不参与转换  
        boolean pass = true;  
        // int num100 = pass; // boolean 不参与类型的自动转换  
        
        // 自动提升原则： 表达式结果的类型自动提升为 操作数中最大的类型  


        // 看一道题  
        byte b4 = 1;  
        short s3 = 100;  
        int num200 = 1;  
        float num300 = 1.1F;  
        double num500 = b4 + s3 + num200 + num300; // float -> double  
    }  
}

3.15.3 强制类型转换

介绍：自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符(，但可能造成精度降低或溢出，格外要注意。
案例演示 ForceConvert.java

int i = (int)1.9; // 1.9会被转换为1
System.out.println(i); // 1

int j = 100;
byte b1 = (byte)j; // 100会被转换为44（100%256的结果）
System.out.println(b1); // 44

3.15.4 强制类型转换细节说明

当进行数据的大小从大到小转换时，需要使用强制类型转换。
强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级。

        int x = (int)10*3.5+6*1.5;  
        int y = (int)(10*3.5+6*1.5);  
        System.out.println(y);   // 44

char类型可以保存int的常量值，但不能保存int的变量值,需要强制类型转换。

        char c1 = 100; //ok  
        int m = 100; //ok  
        char c2 = m; //错误  
        char c3 = (char)m; //ok  
        System.out.println(c3); //输出100对应的字符d

当byte、short和char类型进行运算时，它们会被当做int类型处理。

ForceConvertDetail.java

public class ForceConvertDetail {  
    public static void main(String[] args) {  
    
        // 演示强制类型转换  
        // 强转符号只针对于最近的操作数有效， 往往会使用小括号提升优先级  
        // int x = (int)10*3.5+6*1.5; // 编译错误： double -> int  
        int x = (int)(10 * 3.5 + 6 * 1.5); // (int)44.0 -> 44  
        System.out.println(x); // 44  
        char c1 = 100; // ok  
        int m = 100; // ok  
        // char c2 = m; // 错误  
        char c3 = (char) m; // ok  
        System.out.println(c3); // 100 对应的字符, d 字符  
    }  
}

3.16 基本数据类型转换-练习题

在这里插入图片描述

3.17 基本数据类型和 String 类型的转换

3.17.1 介绍和使用

在这里插入图片描述
StringToBasic.java

public class StringToBasic {  
    public static void main(String[] args) {  
        
        // 基本数据类型 -> String  
        int n1 = 100;  
        float f1 = 1.1F;  
        double d1 = 4.5;  
        boolean b1 = true;  
        String s1 = n1 + "";  
        String s2 = f1 + "";  
        String s3 = d1 + "";  
        String s4 = b1 + "";  
        System.out.println(s1 + " " + s2 + " " + s3 + " " + s4);  
        // 输出: 100 1.1 4.5 true  
  
        // String -> 对应的基本数据类型  
        String s5 = "123";  
        
        // 使用基本数据类型对应的包装类，的相应方法，得到基本数据类型  
        int num1 = Integer.parseInt(s5);  
        double num2 = Double.parseDouble(s5);  
        float num3 = Float.parseFloat(s5);  
        long num4 = Long.parseLong(s5);  
        byte num5 = Byte.parseByte(s5);  
        boolean b = Boolean.parseBoolean("true");  
        short num6 = Short.parseShort(s5);  
        System.out.println("===================");  
        System.out.println(num1); // 123  
        System.out.println(num2); // 123.0  
        System.out.println(num3); // 123.0  
        System.out.println(num4); // 123  
        System.out.println(num5); // 123  
        System.out.println(num6); // 123  
        System.out.println(b); // true  
  
        // 把字符串转成字符 (char -> ) 含义是指 把字符串的第一个字符得到  
        // 解读 s5.charAt(0) 得到 s5 字符串的第一个字符 '1'  
        System.out.println(s5.charAt(0)); // 输出: 1  
    }  
}

3.17.2 注意事项

案例演示: StringToBasicDetail.java

在将 String 类型转成基本数据类型时，要确保String类型能够转成有效的数据，比如，我们可以把 “123”,转成一个整数，但是不能把 “hello” 转成一个整数。
如果格式不正确，就会抛出异常，程序就会终止，这个问题在异常处理章节中，会处理

// 演示字符串转基本数据类型的细节
public class StringToBasicDetail {  
    public static void main(String[] args) {  
        String str = "hello";  
        // 转成 int  
        int n1 = Integer.parseInt(str);  
        System.out.println(n1);  
    }  
}