Java 变量和运算符

news/2024/12/26 0:16:06/文章来源:https://www.cnblogs.com/miaotechisland/p/18628903

Java 变量和运算符
- 1. 变量（Variable）
  - 1.1 何为变量
  - 1.2 数据类型（Data Types）
    - 1.2.1 整型：byte、short、int、long
    - 1.2.2 浮点类型：float、double
    - 1.2.3 字符类型：char
    - 1.2.4 布尔类型：boolean
  - 1.3 变量的使用
    - 1.3.1 步骤1：变量的声明
    - 1.3.2 步骤2：变量的赋值
  - 1.4. 基本数据类型变量间运算规则
    - 1.4.1 自动类型提升
    - 1.4.2 强制类型转换
  - 1.5 基本数据类型与String的运算
- 2. 运算符（Operator）
  - 2.1 算数运算符
  - 2.2 赋值运算符
  - 2.4 逻辑运算符
    - 2.4.1 基本语法
  - 2.5 位运算符
  - 2.6 条件运算符
    - 2.6.1 基本语法
  - 2.7 运算符优先级

Java 变量和运算符

万物皆数 ——— 毕达哥拉斯

1. 变量（Variable）

1.1 何为变量

方程 $y = x^2 + 1 $ 中的 $y,x$ 就是变量，计算机中的变量不是简单出现在纸面上，需要存储在内存中。计算机的内存就像一栋酒店，酒店有许多房间，每个房间都可以用于存储数居，这些数据就叫做变量，并且是可以人为修改的（所以叫变量）。变量有不同类型，比如整数、小数、字符等，所以根据不同类型就需要划分变量类型，以适配不同大小的存储空间。另外，为了使用变量，就要给变量赋予变量名（类似房间的门牌号）。

变量构成三要素：变量类型、变量名、变量值
变量声明的格式：数据类型变量名 = 变量值
变量的作用：用于在内存中保存数据

使用变量注意：

每个变量必须先声明，后使用

使用变量名来访问某区域的数据

变量的作用域：其定义所在的一对{ }内

变量只有在其作用域内才有效。出了作用域，变量不可以再被调用

同一个作用域内，不能定义重名的变量

1.2 数据类型（Data Types）

每个变量一定有数据类型。Java中数据类型分为两大类：

基本数据类型： 整型、浮点数类型、字符类型、布尔类型
引用数据类型：数组、 类、接口、枚举、注解、记录

1.2.1 整型：byte、short、int、long

定义long类型的变量，赋值时需要以"l"或"L"作为后缀。
Java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long。
Java的整型常量默认为 int 型。
Java各整数类型有固定的表示范围和字段长度，不受具体操作系统的影响，以保证Java程序的可移植性。

C语言中没有byte类型

C语言中的数居类型可能会随着计算机字长不同而改变，例如指针和long型在32位系统中占4个字节，在64位系统中占8个字节

1.2.2 浮点类型：float、double

Java 浮点类型有固定的表数范围和字段长度，不受具体操作系统的影响。
浮点型常量有两种表示形式：
- 十进制数形式。如：5.12 、 512.0f 、 .512 （必须有小数点）
- 科学计数法形式。如：5.12e2 、 512E2 、 100E-2
float：单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
double：双精度，精度是float的两倍。通常采用此类型。
定义float类型的变量，赋值时需要以"f"或"F"作为后缀。
Java 的浮点型常量默认为double型。

关于浮点型精度的说明

因为在计算机中，浮点数采用的是IEEE 754 标准表述。然而，并不是所有的小数都能可以精确的用二进制浮点数表示。如果一个分数使用基数（2）的质因数（即2）来表示，那么它可以被精确地表示。例如，1/2、1/4 和 1/8 可以被精确地表示。而 1/5 (0.2) 或 1/10 (0.1) 是二进制中无限循环的小数，因为分母使用了 5 或 10 的质因数。既然是无限循环小数，在计算机中就存在截断，使用有限位数的小数来近似表示。

    //测试1：System.out.println(0.1 + 0.2);// 0.30000000000000004System.out.println(0.1f + 0.2f);// 0.3System.out.println(6 * 0.1);// 0.6000000000000001System.out.println(0.11 + 0.12);// 0.22999999999999998 System.out.println(0.1 + 0.7);// 0.7999999999999999System.out.println(0.3 + 0.6);// 0.8999999999999999

    //测试2：float ff1 = 123123123f;float ff2 = ff1 + 1;System.out.println(ff1);// 1.2312312E8System.out.println(ff2);// 1.2312312E8System.out.println(ff1 == ff2);// true

1.2.3 字符类型：char

char 型数据用来表示通常意义上“字符”（占2字节）
Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。
字符型变量的三种表现形式：
- 形式1： 使用单引号(' ')括起来的单个字符。
  
  例如：char c1 = 'a'； char c2 = '中'； char c3 = '9';
- 形式2： 直接使用 Unicode值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。
  
  例如：\u0023 表示 '#'。
- 形式3： Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。
  
  例如：char c3 = '\n'; // '\n'表示换行符

转义字符	说明	Unicode表示方式
`\n`	换行符	\u000a
`\t`	制表符	\u0009
`\"`	双引号	\u0022
`\'`	单引号	\u0027
`\\`	反斜线	\u005c
`\b`	退格符	\u0008
`\r`	回车符	\u000d

char类型是可以进行运算的。因为它都对应有Unicode码，可以看做是一个数值。

1.2.4 布尔类型：boolean

boolean 类型用来判断逻辑条件，一般用于流程控制语句中
boolean类型数据只有两个值：true、false
- 不可以使用0或非 0 的整数替代false和true，这点和C语言不同。
- 拓展：Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false用0表示。——《java虚拟机规范 8版》
举例：

    boolean isFlag = true;if(isFlag){//true分支}else{  //false分支}

1.3 变量的使用

1.3.1 步骤1：变量的声明

    //整数类型：月份int month; //浮点类型：价格double price;//单字符类型：性别char gender;//布尔类型：婚姻状态boolean isMarried;//字符串类型：姓名String name;//声明多个同类型的变量int a,b,c; //表示a,b,c三个变量都是int类型。

1.3.2 步骤2：变量的赋值

方式1：声明的同时赋值

    int age = 18;float salary = 100.45f;

方式2：将合适类型的常量值给已经声明的变量赋值

    int month;month = 10;double price;price = 199.75;char gender;gender = '女';

方式3：用其他变量或者表达式给变量赋值

    int m = 1;int n = m;int x = 1;int y = 2;int z = x + y;

方式4：变量可以反复赋值

    //先声明，后初始化char gender;gender = '女';//给变量重新赋值，修改gender变量的值gender = '男';System.out.println("gender = " + gender);//gender = 男

1.4. 基本数据类型变量间运算规则

在Java程序中，不同的基本数据类型（char、byte、short、int、long、float、double）变量经常需要进行相互转换。这就涉及到了“向上转换”和“向下转换”两种转换方式。本质上是对数值精度的取舍。

转换的方式有两种：自动类型提升和强制类型转换。

1.4.1 自动类型提升

规则：将取值范围小（或容量小）的类型自动提升为取值范围大（或容量大）的类型。

（1）当把存储范围小的值赋值给存储范围大的变量时，自动完成提升

  int i = 'A';// char自动升级为int，其实就是把字符A的编码值（65）赋值给变量idouble d = 10;// int自动升级为doublelong num = 1234567; // 右边的整数常量值在int范围，编译和运行都可以通过，这里涉及到数据类型转换int升级为long//byte bigB = 130;// 错误，右边的整数常量值超过byte范围（最大127）long bigNum = 12345678912L;// 右边的整数常量值如果超过int范围，必须加L，显式表示long类型。否则编译不通过

（2）当存储范围小的数据类型与存储范围大的数据类型变量一起混合运算时，会按照其中最大的类型运算。

  int i = 1;byte b = 1;double d = 1.0;double sum = i + b + d;// 混合运算，升级为double

（3）当byte,short,char数据类型的变量进行算术运算时，按照int类型处理。

  byte b1 = 1;byte b2 = 2;byte b3 = b1 + b2;// 编译报错，b1 + b2自动升级为intchar c1 = '0';char c2 = 'A';int i = c1 + c2;// 至少需要使用int类型来接收System.out.println(c1 + c2);// 48 + 65 = 113

1.4.2 强制类型转换

将3.14 赋值到int 类型变量会发生什么？肯定无法赋值。

  int i = 3.14; // 编译报错

想要赋值成功，只有通过强制类型转换，将double 类型强制转换成int 类型才能赋值，这将必然带来精度的损失或者溢出。

规则：将取值范围大（或容量大）的类型强制转换成取值范围小（或容量小）的类型需要手动完成。

转换格式：

  数据类型1 变量名 = (数据类型1)被强转数据值;  //()中的数据类型必须<=变量值的数据类型

（1）当把存储范围大的值强制转换为存储范围小的变量时，可能会损失精度或溢出。

  int i = (int)3.14;//损失精度 i = 3double d = 1.2;int num = (int)d;//损失精度int i = 200;byte b = (byte)i;//溢出

（2）当某个值想要提升数据类型时，也可以使用强制类型转换。这种情况的强制类型转换是没有风险的，通常省略。

  int i = 1;int j = 2;double num1 = (double)(i/j);// num1 = 0.0 这是由于i/j=0，再强制转换成double后num1就变为0.0int num2 = i/j;// num2 = 0double k = 2;// 或者 k = 2.0double num3 = i/k;// num3 = 0.5System.out.println(1./2);// 0.5System.out.println(1/2.);// 0.5

（3）声明long类型变量时，可以出现省略后缀的情况。float则不同。

  long l1 = 123L;long l2 = 123;//此时可以看做是int类型的123自动类型提升为long类型//long l3 = 123123123123; //报错，因为123123123123超出了int的范围。long l4 = 123123123123L;//float f1 = 12.3; //报错，因为12.3看做是double，不能自动转换为float类型float f2 = 12.3F;float f3 = (float)12.3;

1.5 基本数据类型与String的运算

String不是基本数据类型，属于引用数据类型。
使用一对""来表示一个字符串，内部可以包含0个、1个或多个字符。
声明方式与基本数据类型类似。例如：String str = “Java教程”;

运算规则

（1）任意八种基本数据类型的数据与String类型只能进行连接“+”运算，且结果一定也是String类型

  System.out.println("" + 1 + 2);//字符类型12int num = 10;boolean b1 = true;String s1 = "abc";String s2 = s1 + num + b1;System.out.println(s2);//abc10true//String s3 = num + b1 + s1;//编译不通过，因为int类型不能与boolean运算String s4 = num + (b1 + s1);//编译通过

（2）String类型不能通过强制类型()转换，转为其他的类型

  String str = "123";int num = (int)str;//错误的int num = Integer.parseInt(str);//正确，包装类

2. 运算符（Operator）

有了变量就可以进行运算了。运算符就是变量之间运算、比较、赋值等操作的符号。
运算符可以按照不同种类进行分类：

按照功能分为：算术运算符、赋值运算符、比较(或关系)运算符、逻辑运算符、位运算符、条件运算符、Lambda运算符

分类	运算符
算术运算符（7个）	+、-、*、/、%、++、--
赋值运算符（12个）	=、+=、-=、*=、/=、%=、>>=、<<=、>>>=、&=、\|=、^=等
比较(或关系)运算符（6个）	>、>=、<、<=、==、!=
逻辑运算符（6个）	&、\|、^、!、&&、\|\|
位运算符（7个）	&、\|、^、~、<<、>>、>>>
条件运算符（1个）	(条件表达式)?结果1:结果2
Lambda运算符（1个）	->

按照操作数个数分为：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符（三目运算符）

分类	运算符
一元运算符（单目运算符）	正号（+）、负号（-）、++、--、!、~
二元运算符（双目运算符）	除了一元和三元运算符剩下的都是二元运算符
三元运算符（三目运算符）	(条件表达式)?结果1:结果2

2.1 算数运算符

+、-、*、/、%（取模）没什么好说的。主要理解++（自加）、--（自减）运算符

++与--是连体操作符，中间不能有空格
++ 运算，表示自增1
-- 运算，表示自减1

（1）单独使用

变量在单独运算的时候，变量i++和变量++i没有区别

public class AddTest1{public static void main(String[] args) {int i = 3;//++i;i++;// 无论是变量前++还是变量后++，结果都是4System.out.println(i);}
}

（2）复合使用

和其他变量放在一起使用或者和输出语句放在一起使用，++和--的位置不同所代表的含义也不同

j = i++ 等价于 j = i, i = i + 1，即先将i的值赋给j，然后i再自增
j = ++i 等价于 i = i + 1, j = i，即先将i自增，再将自增结果赋给j

public class AddTest2{public static void main(String[] args) {int x = 3;//int y = ++x; // y的值是4，x的值是4，int y = x++; // y的值是3，x的值是4System.out.println(x);System.out.println(y);System.out.println("==========");// 和输出语句一起int z = 5;//System.out.println(++z);// 输出结果是6，z的值也是6System.out.println(z++);// 输出结果是5，z的值是6System.out.println(z); } 
}

一个小坑：i = i++

public class AddTest3{public static void main(String[] args) {int i = 10;i = i++;System.out.println(i);// i = 10}
}

我们可以通过Java的字节码文件查看更加仔细的操作

0 bipush 10       // 生成整数 102 istore_1        // 将整数10赋值给1号存储单元，即 i = 103 iload_1         // 将1号存储单元的值加载到数据栈，即i = 10，栈顶值为104 iinc 1 by 1     // 1号存储单元的值+1，此时i = 117 istore_1        // 将数据栈的值（10）取出来赋给1号存储单元，即i = 108 getstatic #7 <java/lang/System.out : Ljava/io/PrintStream;>
11 iload_1
12 invokevirtual #13 <java/io/PrintStream.println : (I)V>
15 return

Java中i++和++i都只能是右值，不能是左值。这和C语言不同，C语言中i++只能是右值，++i可以是左值，也可以是右值。当两者操作无异时，一般建议使用++i。

2.2 赋值运算符

符号：=
- 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
- 支持连续赋值。
扩展赋值运算符： +=、 -=、*=、 /=、%=
原理：$ A x= B $ 相当于 $ A = AxB $ 即将符号`左边的值`和`右边的值`进行$x$操作，最后将结果赋值给左边的变量

public class SetValueTest{public static void main(String[] args) {int i1 = 10;long l1 = i1; //自动类型转换byte bb1 = (byte)i1; //强制类型转换int i2 = i1;//连续赋值的测试//以前的写法int a1 = 10;int b1 = 10;//连续赋值的写法int a2,b2;a2 = b2 = 10;int a3 = 10,b3 = 20;//举例说明+=  -=  *=  /=   %=  int m1 = 10;m1 += 5; //类似于 m1 = m1 + 5的操作，但不等同于。System.out.println(m1);//15// 加2操作//写法1：推荐short s1 = 10;s1 += 2; //编译通过，因为在得到int类型的结果后，JVM自动完成一步强制类型转换，将int类型强转成shortSystem.out.println(s1);//12//写法2：short s2 = 10;//s2 = s2 + 2;//编译报错，因为将int类型的结果赋值给short类型的变量s时，可能损失精度s2 = (short)(s2 + 2);System.out.println(s2);// 加一操作//写法1：推荐int num1 = 10;num1++;System.out.println(num1);//写法2：int num2 = 10;num2 += 1;System.out.println(num2);//写法3：int num3 = 10;num3 = num3 + 1;System.out.println(num3);}
}

2.4 逻辑运算符

2.4.1 基本语法

逻辑运算符，操作的都是boolean类型的变量或常量，而且运算得结果也是boolean类型的值。
运算符说明：
- & 和 &&：表示"且"关系，当符号左右两边布尔值都是true时，结果才能为true。否则，为false。
- | 和 || ：表示"或"关系，当符号两边布尔值有一边为true时，结果为true。当两边都为false时，结果为false
- ! ：表示"非"关系，当变量布尔值为true时，结果为false。当变量布尔值为false时，结果为true。
- ^ ：当符号左右两边布尔值不同时，结果为true。当两边布尔值相同时，结果为false。
  - 理解：异或，追求的是“异”！
逻辑运算符用于连接布尔型表达式，在Java中不可以写成 3 < x < 6，应该写成x > 3 & x < 6 。
区分“&”和“&&”：
- 相同点：如果符号左边是true，则二者都执行符号右边的操作
- 不同点：& ：如果符号左边是false,则继续执行符号右边的操作
&& ：如果符号左边是false,则不再继续执行符号右边的操作
- 建议：开发中，推荐使用 &&
区分“|”和“||”：
- 相同点：如果符号左边是false，则二者都执行符号右边的操作
- 不同点：| ：如果符号左边是true，则继续执行符号右边的操作
  
  || ：如果符号左边是true，则不再继续执行符号右边的操作
- 建议：开发中，推荐使用 ||

代码举例：

public class LoginTest {public static void main(String[] args) {int a = 3;int b = 4;int c = 5;// & 与，且；有false则falseSystem.out.println((a > b) & (a > c)); //falseSystem.out.println((a > b) & (a < c)); //falseSystem.out.println((a < b) & (a > c)); //falseSystem.out.println((a < b) & (a < c)); //trueSystem.out.println("===============");// | 或；有true则trueSystem.out.println((a > b) | (a > c)); //falseSystem.out.println((a > b) | (a < c)); //trueSystem.out.println((a < b) | (a > c)); //trueSystem.out.println((a < b) | (a < c)); //trueSystem.out.println("===============");// ^ 异或；相同为false，不同为trueSystem.out.println((a > b) ^ (a > c)); //falseSystem.out.println((a > b) ^ (a < c)); //trueSystem.out.println((a < b) ^ (a > c)); //trueSystem.out.println((a < b) ^ (a < c)); //falseSystem.out.println("===============");// ! 非；非false则true，非true则falseSystem.out.println(!false); //trueSystem.out.println(!true); //false//&和&&的区别System.out.println((a > b) & (a++ > c)); //falseSystem.out.println("a = " + a); // a = 4System.out.println((a > b) && (a++ > c)); //falseSystem.out.println("a = " + a); // a = 4System.out.println((a == b) && (a++ > c)); //falseSystem.out.println("a = " + a); // a = 5//|和||的区别System.out.println((a > b) | (a++ > c)); //trueSystem.out.println("a = " + a); // a = 6System.out.println((a > b) || (a++ > c)); //trueSystem.out.println("a = " + a); // a = 6System.out.println((a == b) || (a++ > c)); //trueSystem.out.println("a = " + a); // a = 7}
}

2.5 位运算符

位运算符的运算过程都是基于二进制的补码运算

2.6 条件运算符

2.6.1 基本语法

条件运算符格式：

(条件表达式)? 表达式1:表达式2

说明：条件表达式是boolean类型的结果，根据boolean的值选择表达式1或表达式2

如果运算后的结果赋给新的变量，要求表达式1和表达式2为同种或兼容的类型

    int i = (1==2 ? 100 : 200);System.out.println(i);//200boolean marry = false;System.out.println(marry ? "已婚" : "未婚"  );//未婚int num = 12;System.out.println(num > 0? true : "num非正数");//true

案例1： 获取两个数中的较大值

public class ConditionExer1 {public static void main(String[] args) {//获取两个数的较大值int m1 = 10;int m2 = 20;int max1 = (m1 > m2)? m1 : m2;System.out.println("m1和m2中的较大值为" + max1);}
}

案例2： 获取三个数中的最大值


public class ConditionExer2 {public static void main(String[] args) {int n1 = 23;int n2 = 13;int n3 = 33;//写法1：int tempMax = (n1 > n2)? n1:n2;int finalMax = (tempMax > n3)? tempMax : n3;System.out.println("三个数中最大值为：" + finalMax);//写法2：不推荐，可读性差int finalMax1 = (((n1 > n2)? n1:n2) > n3)? ((n1 > n2)? n1:n2) : n3;System.out.println("三个数中最大值为：" + finalMax1);}
}

2.7 运算符优先级

运算符有不同的优先级，所谓优先级就是在表达式运算中的运算符顺序。

上一行中的运算符总是优先于下一行的。

优先级	运算符说明	Java运算符
1	括号	`()`、`[]`、`{}`
2	正负号	`+`、`-`
3	单元运算符	`++`、`--`、`~`、`！`
4	乘法、除法、求余	`*`、`/`、`%`
5	加法、减法	`+`、`-`
6	移位运算符	`<<`、`>>`、`>>>`
7	关系运算符	`<`、`<=`、`>=`、`>`、`instanceof`
8	等价运算符	`==`、`!=`
9	按位与	`&`
10	按位异或	`^`
11	按位或	`\|`
12	条件与	`&&`
13	条件或	`\|\|`
14	三元运算符	`? :`
15	赋值运算符	`=`、`+=`、`-=`、`*=`、`/=`、`%=`
16	位赋值运算符	`&=`、`\|=`、`<<=`、`>>=`、`>>>=`

开发建议：

不要过多的依赖运算的优先级来控制表达式的执行顺序，这样可读性太差，尽量使用()来控制表达式的执行顺序。

不要把一个表达式写得过于复杂，如果一个表达式过于复杂，则把它分成几步来完成。例如：
(num1 + num2) * 2 > num3 && num2 > num3 ? num3 : num1 + num2;

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/858413.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！