首页 > 编程语言 >JavaNote-变量与运算符

JavaNote-变量与运算符

时间：2023-08-29 21:22:05浏览次数：32  
标签：变量 int true System 运算符 println JavaNote out

1. 关键字（keyword）

类型 关键字
用于定义数据类型的关键字 class、interface、enum、byte、short、int、long、float、double、char、boolean、void
用于定义流程控制的关键字 if、else、switch、case、default、while、do、for、break、continue、return
用于定义访问权限修饰符的关键字 private、protected、public
用于定义类，函数，变量修饰符的关键字 abstrace、final、static、synchronized
用于定义类与类之间关系的关键字 extends、implements
用于定义建立实例及引用实例，判断实例的关键字 new、this、super、instanceof
用于定义字面量的关键字 true、false、null
用于异常处理的关键字 try、catch、finally、throw、throws
用于包的关键字 package、import
其他修饰符关键字 native、strictfp、transient、volatile、assert、const、goto

说明：

  1. 关键字一共50个，其中const和goto是保留字（暂时还没有进行启用的关键字）。
  2. true，false，null不在其中，它们看起来像关键字，其实是字面量，表示特殊的布尔值和空值。

2. 标识符( identifier)

Java中变量、方法、类等要素命名时使用的字符序列，称为标识符。凡是自己可以起名字的地方都叫标识符。

2.1 标识符的命名规则

  • 由26个英文字母大小写，0-9 ，_ 或 $ 组成。
  • 数字不可以开头。
  • 不可以使用关键字和保留字，但能包含关键字和保留字。
  • Java中严格区分大小写，长度无限制。
  • 标识符不能包含空格。

2.2 标识符的命名规范

  • 包名：多单词组成时所有字母都小写：xxxyyyzzz。例如：java.lang、com.atguigu.bean
  • 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz。例如：HelloWorld，String，System等
  • 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz。例如：age,name,bookName,main,binarySearch,getName
  • 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ。例如：MAX_VALUE,PI,DEFAULT_CAPACITY

注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

3. 变量

3.1 变量概述

变量是程序中不可或缺的组成单位，最基本的存储单元。

  • 变量的概念：

    • 内存中的一个存储区域，该区域的数据可以在同一类型范围内不断变化

    • 变量的构成包含三个要素：数据类型、变量名、存储的值

    • Java中变量声明的格式：数据类型 变量名 = 变量值

  • 变量的作用：用于在内存中保存数据。

  • 使用变量注意：

    • Java中每个变量必须先声明，后使用。
    • 使用变量名来访问这块区域的数据。
    • 变量的作用域：其定义所在的一对{ }内。
    • 变量只有在其作用域内才有效。出了作用域，变量不可以再被调用。
    • 同一个作用域内，不能定义重名的变量。

3.2 Java中变量的数据类型

Java中变量的数据类型分为两大类：

  • 基本数据类型：包括 整数类型、浮点数类型、字符类型、布尔类型。

  • 引用数据类型：包括数组、 类、接口、枚举、注解、记录。

image

3.3 变量的使用

步骤1：变量的声明

// 格式：数据类型  变量名;

// 举例：
//存储一个整数类型的年龄
int age; 

//存储一个小数类型的体重
double weight;

//存储一个单字符类型的性别 
char gender;

//存储一个布尔类型的婚姻状态
boolean marry;

//存储一个字符串类型的姓名
String name;

//声明多个同类型的变量
int a,b,c; //表示a,b,c三个变量都是int类型。

注意：变量的数据类型可以是基本数据类型，也可以是引用数据类型。

步骤2：变量的赋值

给变量赋值，就是把“值”存到该变量代表的内存空间中。同时，给变量赋的值类型必须与变量声明的类型一致或兼容。

变量赋值的语法格式：

变量名 = 值;
  • 举例1：可以使用合适类型的常量值给已经声明的变量赋值
age = 18;
weight = 109;
gender = '女';
  • 举例2：可以使用其他变量或者表达式给变量赋值
int m = 1;
int n = m;
        
int x = 1;
int y = 2;
int z = 2 * x + y;
  • 举例3：变量可以反复赋值
//先声明，后初始化
char gender;
gender = '女';

//给变量重新赋值，修改gender变量的值
gender = '男';
System.out.println("gender = " + gender);//gender = 男
  • 举例4：也可以将变量的声明和赋值一并执行
boolean isBeauty = true;
String name = "迪丽热巴";

4. 基本数据类型介绍

4.1 整数类型

整数类型根据接收数据的大小分为4种类型：byte、short、int、long。

类型 占用存储空间 范围
byte 1字节 = 8bit位 -128 ~ 127
short 2字节 -2的15次方 ~ 2的15次方 -1
int 4字节 -2的31次方 ~ 2的31次方 -1
long 8字节 -2的63次方 ~ 2的63次方 -1

  • Java各整数类型有固定的表数范围和字段长度，不受具体操作系统的影响，以保证Java程序的可移植性。

  • 定义long类型的变量，赋值时需要以"l"或"L"作为后缀。

  • Java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long。

  • Java的整型常量默认为 int 型。

补充：计算机存储单位

  • 字节（Byte）：是计算机用于计量存储容量的基本单位，一个字节等于8 bit。

  • 位（bit）：是数据存储的最小单位。二进制数系统中，每个0或1就是一个位，叫做bit（比特），其中8 bit 就称为一个字节(Byte)。

  • 转换关系：

    • 8 bit = 1 Byte
    • 1024 Byte = 1 KB
    • 1024 KB = 1 MB
    • 1024 MB = 1 GB
    • 1024 GB = 1 TB

4.2 浮点类型：

浮点数类型根据接收数据的大小分为：float、double。

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

  • 与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。

  • 浮点型常量有两种表示形式：

    • 十进制数形式。如：5.12 512.0f .512 (必须有小数点）
    • 科学计数法形式。如：5.12e2 512E2 100E-2

  • float：单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。

  • double：双精度，精度是float的两倍。通常采用此类型。

  • 定义float类型的变量，赋值时需要以"f"或"F"作为后缀。

  • Java 的浮点型常量默认为double型。

关于浮点型精度的说明

  • 并不是所有的小数都能可以精确的用二进制浮点数表示。二进制浮点数不能精确的表示0.1、0.01、0.001这样10的负次幂。

    System.out.println(0.1 + 0.2);  // 0.30000000000000004

/*
问：0.1 + 0.2为什么得到的不是0.3？
答：对于小数，并不能做到“每个小数都有对应的二进制数字”。举例来说，二进制小数0.0001表示十进制数0.0625 ；二进制小数0.0010表示十进制数0.125；二进制小数0.0011表示十进制数0.1875。看，对于四位的二进制小数，二进制小数虽然是连贯的，但是十进制小数却不是连贯的。比如，你无法用四位二进制小数的形式表示0.125 ~ 0.1875之间的十进制小数。所以在编程中，遇见小数判断相等情况，比如开发银行、交易等系统，可以采用`四舍五入`或者“`同乘同除`”等方式进行验证，避免上述问题。
*/

float ff1 = 123123123f;      // 实际是123123123
float ff2 = ff1 + 1;         // 实际是123123124
System.out.println(ff1);
System.out.println(ff2);     // 科学计数法表示都是 1.2312312E8
System.out.println(ff1 == ff2);   // 判断结果也是true

  • 浮点类型float、double的数据不适合在不容许舍入误差的金融计算领域。如果需要精确数字计算或保留指定位数的精度，需要使用 BigDecimal类 。

案例：定义圆周率并赋值为3.14，现有3个圆的半径分别为1.2、2.5、6，求它们的面积。

public class Exercise1 {
    public static void main(String[] args) {
        double PI = 3.14; //圆周率

        double radius1 = 1.2;
        double radius2 = 2.5;
        int radius3 = 6;

        System.out.println("第1个圆的面积：" + PI * radius1 * radius1);
        System.out.println("第2个圆的面积：" + PI * radius2 * radius2);
        System.out.println("第3个圆的面积：" + PI * radius3 * radius3);
    }
}
/*
结果：
第1个圆的面积：4.521599999999999
第2个圆的面积：19.625
第3个圆的面积：113.03999999999999
*/

4.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码，可以看做是一个数值。

    System.out.println('a' + 3);       // 100 = 97+3
System.out.println('b' + 3);       // 101 = 98+3
System.out.println('a' + 'b');     // 195 = 97+98

4.4 布尔类型：boolean

  • boolean 类型用来判断逻辑条件，一般用于流程控制语句中：

    • if条件控制语句；
    • while循环控制语句；
    • for循环控制语句；
    • do-while循环控制语句；

  • boolean类型数据只有两个值：true、false。

    • 不可以使用0或非 0 的整数替代false和true，这点和其他一些语言不同。
    • 但是Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false用0表示。

  • 举例：

boolean isFlag = true;

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

经验之谈：

建议不要这样写：if ( isFlag == true )，也很容易写错成if(isFlag = true)，这样就变成赋值isFlag为true而不是判断！推荐写法是if (isFlag)或者if ( !isFlag)。

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

在Java程序中，不同的基本数据类型（只有7种，不包含boolean类型）变量的值经常需要进行相互转换。

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

5.1 自动类型提升

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

基本数据类型的转换规则如图所示：

image

（1）当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时

int i = 'A';                   //char自动升级为int，其实就是把字符的编码值赋值给i变量了
double d = 10;                 //int自动升级为double
long num = 1234567;            //右边的整数常量值如果在int范围呢，编译和运行都可以通过，这里涉及到数据类型转换
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自动升级为int

char c1 = '0';
char c2 = 'A';
int i = c1 + c2;//至少需要使用int类型来接收
System.out.println(c1 + c2);//113

5.2 强制类型转换

将3.14 赋值到int 类型变量会发生什么？产生编译失败，肯定无法赋值。

int i = 3.14; // 编译报错

想要赋值成功，只有通过强制类型转换，将double 类型强制转换成int 类型才能赋值。

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

自动类型提升是Java自动执行的，而强制类型转换是自动类型提升的逆运算，需要我们自己手动执行。

转换格式：

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

（1）当把存储范围大的值（常量值、变量的值、表达式计算的结果值）强制转换为存储范围小的变量时，可能会损失精度或溢出。

int i = (int)3.14;    // 3 损失精度

double d = 1.2;
int num = (int)d;     // 1 损失精度

int i = 200;
byte b = (byte)i;     //溢出报错

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

int i = 1;
int j = 2;
double bigger = (double)(i/j);

（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）short  s = 5;
   s = s-2;                     //判断：no
2） byte b = 3;
    b = b + 4;                  //判断：no
    b = (byte)(b+4);            //判断：yes
3）char c = ‘a’;
   int  i = 5;
   float d = .314F;
   double result = c+i+d;       //判断：yes
4） byte b = 5;
    short s = 3;
    short t = s + b;            //判断：no

问答：为什么标识符的声明规则里要求不能数字开头？

//如果允许数字开头，则如下的声明编译就可以通过：
int 123L = 12;
//进而，如下的声明中l的值到底是123？还是变量123L对应的取值12呢？ 出现歧义了。
long l = 123L;

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

5.3.1 字符串类型：String

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

5.3.2 运算规则

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

System.out.println("" + 1 + 2);//12

int 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);//正确的，借助包装类的方法才能转换

6. 运算符（Operator）

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

运算符的分类：

  • 按照功能分为：算术运算符、赋值运算符、比较(或关系)运算符、逻辑运算符、位运算符、条件运算符、Lambda运算符
分类 运算符
算术运算符（7个） +、-、*、/、%、++、--
赋值运算符（12个） =、+=、-=、*=、/=、%=、>>=、<<=、>>>=、&=、|=、^=等
比较(或关系)运算符（6个） >、>=、<、<=、==、!=
逻辑运算符（6个） &、|、^、!、&&、||
位运算符（7个） &、|、^、~、<<、>>、>>>
条件运算符（1个） (条件表达式)?结果1:结果2
Lambda运算符（1个） ->
  • 按照操作数个数分为：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符 （三目运算符）
分类 运算符
一元运算符（单目运算符） 正号（+）、负号（-）、++、--、!、~
二元运算符（双目运算符） 除了一元和三元运算符剩下的都是二元运算符
三元运算符 （三目运算符） (条件表达式)?结果1:结果2

7.1 算术运算符

运算符 运算方式 范例 结果
+ 正号 +3 3
- 负号 -4 -4
+ 加 5+5 10
- 减 6-4 2
* 乘 3*4 12
/ 除 10/5 2
% 取模（取余） 12%10 2
++ 自增（前）:先运算后取值
自增（后）:先取值后运算		 a=2;b=++a
a=2;b=a++		 a=3;b=3
a=3;b=2
-- 自减（前）:先运算后取值
自减（后）:先取值后运算		 a=2;b=--a
a=2;b=a--		 a=1;b=1
a=1;b=2
+ 字符串连接 "ab"+"cd" "abcd"

举例1：加减乘除模

public class ArithmeticTest1 {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;
		
		System.out.println(a + b);// 7
		System.out.println(a - b);// -1
		System.out.println(a * b);// 12
		System.out.println(a / b);// 计算机结果是0，为什么不是0.75呢？
		System.out.println(a % b);// 3
        
        //结果与被模数符号相同
        System.out.println(5%2);//1
		System.out.println(5%-2);//1
		System.out.println(-5%2);//-1
		System.out.println(-5%-2);//-1		
		//商*除数 + 余数 = 被除数
		//5%-2  ==>商是-2，余数时1    (-2)*(-2)+1 = 5
		//-5%2  ==>商是-2，余数是-1   (-2)*2+(-1) = -4-1=-5
	}
}

举例2：“+”号的两种用法

  • 第一种：对于+两边都是数值的话，+就是加法的意思
  • 第二种：对于+两边至少有一边是字符串的话，+就是拼接的意思
public class ArithmeticTest2 {
	public static void main(String[] args) {
		// 字符串类型的变量基本使用
		// 数据类型 变量名称 = 数据值;
		String str1 = "Hello";
		System.out.println(str1); // Hello
		
		System.out.println("Hello" + "World"); // HelloWorld
		
		String str2 = "Java";
		// String + int --> String
		System.out.println(str2 + 520); // Java520
		// String + int + int
		// String		+ int
		// String
		System.out.println(str2 + 5 + 20); // Java520
	}
}

举例3：自加自减运算

理解：++ 运算，表示自增1。同理，-- 运算，表示自减1，用法与++ 一致。

1、单独使用

  • 变量在单独运算的时候，变量前++和变量后++，是没有区别的。
  • 变量前++ ：例如 ++a 。
  • 变量后++ ：例如 a++ 。
public class ArithmeticTest3 {
	public static void main(String[] args) {
		// 定义一个int类型的变量a
		int a = 3;
		//++a;
		a++;
        // 无论是变量前++还是变量后++，结果都是4
		System.out.println(a);
	}
}

2、复合使用

  • 和其他变量放在一起使用或者和输出语句放在一起使用，前++和后++就产生了不同。
  • 变量前++ ：变量先自增1，然后再运算。
  • 变量后++ ：变量先运算，然后再自增1。
public class ArithmeticTest4 {
	public static void main(String[] args) {
		// 其他变量放在一起使用
		int x = 3;
		//int y = ++x; // y的值是4，x的值是4，
		int y = x++; // y的值是3，x的值是4
		
		System.out.println(x);
		System.out.println(y);
		System.out.println("==========");
        
		// 和输出语句一起
		int z = 5;
		//System.out.println(++z);// 输出结果是6，z的值也是6
		System.out.println(z++);// 输出结果是5，z的值是6
		System.out.println(z);
        
	} 
}

7.2 赋值运算符

  • 符号：=

    • 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
    • 支持连续赋值。

  • 扩展赋值运算符： +=、 -=、*=、 /=、%=

    赋值运算符 符号解释
    += 将符号左边的值和右边的值进行相加操作，最后将结果赋值给左边的变量
    -= 将符号左边的值和右边的值进行相减操作，最后将结果赋值给左边的变量
    *= 将符号左边的值和右边的值进行相乘操作，最后将结果赋值给左边的变量
    /= 将符号左边的值和右边的值进行相除操作，最后将结果赋值给左边的变量
    %= 将符号左边的值和右边的值进行取余操作，最后将结果赋值给左边的变量 
public class SetValueTest1 {
	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
		
		//练习1：开发中，如何实现一个变量+2的操作呢？
		// += 的操作不会改变变量本身的数据类型。其他拓展的运算符也如此。
		//写法1：推荐
		short s1 = 10;
		s1 += 2; //编译通过，因为在得到int类型的结果后，JVM自动完成一步强制类型转换，将int类型强转成short
		System.out.println(s1);//12
		//写法2：
		short s2 = 10;
		//s2 = s2 + 2;//编译报错，因为将int类型的结果赋值给short类型的变量s时，可能损失精度
		s2 = (short)(s2 + 2);
		System.out.println(s2);


		//练习2：开发中，如何实现一个变量+1的操作呢？
		//写法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);

	}
}

7.3 比较(关系)运算符

运算符 运算方式 范例 结果
== 等于 4 == 3 false
!= 不等于 4 != 3 true
< 小于 4 < 3 false
> 大于 4 > 3 true
<= 小于等于 4 <= 3 false
>= 大于等于 4 >=3 true
instanceof 检查是否是类的对象 “Hello” instanceof String true

  • 比较运算符的结果都是boolean型，也就是要么是true，要么是false。

  • > < >= <= ：只适用于基本数据类型（除boolean类型之外）

    == != ：适用于基本数据类型和引用数据类型

  • 比较运算符“==”不能误写成“=”

举例：

class CompareTest {
	public static void main(String[] args) {
		int i1 = 10;
		int i2 = 20;
		
		System.out.println(i1 == i2);//false
		System.out.println(i1 != i2);//true
		System.out.println(i1 >= i2);//false


		int m = 10;
		int n = 20;
		System.out.println(m == n);//false
		System.out.println(m = n);//20

		boolean b1 = false;
		boolean b2 = true;
		System.out.println(b1 == b2);//false
		System.out.println(b1 = b2);//true
	}
}

思考：

boolean b1 = false;
//区分好==和=的区别。
if(b1 == true)  //if(b1 = true)
	System.out.println("结果为真");
else
	System.out.println("结果为假");

7.4 逻辑运算符

a b a&b a&&b a|b a||b !a a^b
true true true true true true false false
true false false false true true false true
false true false false true true true true
false false false false false false true false

  • 逻辑运算符，操作的都是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则false
		System.out.println((a > b) & (a > c)); 
		System.out.println((a > b) & (a < c)); 
		System.out.println((a < b) & (a > c)); 
		System.out.println((a < b) & (a < c)); 
		System.out.println("===============");
		// | 或；有true则true
		System.out.println((a > b) | (a > c)); 
		System.out.println((a > b) | (a < c)); 
		System.out.println((a < b) | (a > c));
		System.out.println((a < b) | (a < c));
		System.out.println("===============");
		// ^ 异或；相同为false，不同为true
		System.out.println((a > b) ^ (a > c));
		System.out.println((a > b) ^ (a < c)); 
		System.out.println((a < b) ^ (a > c)); 
		System.out.println((a < b) ^ (a < c)); 
		System.out.println("===============");
		// ! 非；非false则true，非true则false
		System.out.println(!false);
		System.out.println(!true);
        
        //&和&&的区别
        System.out.println((a > b) & (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a > b) && (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a == b) && (a++ > c)); 
        System.out.println("a = " + a);
        
        //|和||的区别
        System.out.println((a > b) | (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a > b) || (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a == b) || (a++ > c)); 
        System.out.println("a = " + a);
	}
}

7.5 位运算符

7.5.1 基本语法

运算符 运算方式 范例
<< 左移 3 << 2=12 等同于 3*2*2=12
>> 右移 3 >>1 =1 等同于 3/2=1
>>> 无符号右移 3 >>>1=1等同于 3/2=1
& 与运算 6 & 3 = 2
| 或运算 6 | 3 = 7
^ 异或运算 6 ^ 3 = 5
~ 取反运算 ~ 6 = -7

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

（1）左移：<<

运算规则：在一定范围内，数据每向左移动一位，相当于原数据*2。（正数、负数都适用）

【注意】

当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位；

空位补0，被移除的高位丢弃，空缺位补0。

3<<4  类似于  3*2的4次幂 => 3*16 => 48

image

-3<<4  类似于  -3*2的4次幂 => -3*16 => -48

image

（2）右移：>>

运算规则：在一定范围内，数据每向右移动一位，相当于原数据/2。（正数、负数都适用）

【注意】

如果不能整除，向下取整。

被移位的二进制最高位是0，右移后，空缺位补0;最高位是1，空缺位补1。

69>>4  类似于  69/2的4次 = 69/16 =4

image

-69>>4  类似于  -69/2的4次 = -69/16 = -5

image

（3）无符号右移：>>>

运算规则：往右移动后，左边空出来的位直接补0。（正数、负数都适用）

69>>>4  类似于  69/2的4次 = 69/16 =4

image

-69>>>4   结果：268435451

image

（4）按位与：&

运算规则：对应位都是1才为1，否则为0。

  • 1 & 1 结果为1

  • 1 & 0 结果为0

  • 0 & 1 结果为0

  • 0 & 0 结果为0

9 & 7 = 1

image

-9 & 7 = 7

image

（5）按位或：|

运算规则：对应位只要有1即为1，否则为0。

  • 1 | 1 结果为1

  • 1 | 0 结果为1

  • 0 | 1 结果为1

  • 0 | 0 结果为0

9 | 7  //结果： 15

image

-9 | 7 //结果： -9

image

（6）按位异或：^

运算规则：对应位相同为0为1，否则为1。

  • 1 ^ 1 结果为0

  • 1 ^ 0 结果为1

  • 0 ^ 1 结果为1

  • 0 ^ 0 结果为0

9 ^ 7  //结果为14

image

-9 ^ 7 //结果为-16

image

（7）按位取反：~

运算规则：对应位为1，则结果为0；对应位为0，则结果为1。

  • ~0就是1

  • ~1就是0

~9  //结果：-10

image

~-9  //结果：8

image

7.5.2 案例

案例1：高效的方式计算2 * 8的值（经典面试题）

答案：2 << 3 、  8  << 1

案例2：如何交换两个int型变量的值？String呢？

m = 15
n = 10

//（推荐）实现方式1：优点：容易理解，适用于不同数据类型    缺点：需要额外定义变量
int temp = m;
m = n;
n = temp;

//实现方式2：优点：没有额外定义变量    缺点：可能超出int的范围；只能适用于数值类型
m = m + n; 
n = m - n;
m = m - n;
	
//实现方式3：优点：没有额外定义变量    缺点：不易理解；只能适用于数值类型
m = m ^ n; 
n = m ^ n; 
m = m ^ n;

7.6 条件运算符

7.6.1 基本语法

  • 条件运算符格式：
(条件表达式)? 表达式1:表达式2
  • 说明：条件表达式是boolean类型的结果，根据boolean的值选择表达式1或表达式2

image

  • 如果运算后的结果赋给新的变量，要求表达式1和表达式2为同种或兼容的类型
public static void main(String[] args) {
    int i = (1==2 ? 100 : 200);
    System.out.println(i);//200
    
    boolean marry = false;
	System.out.println(marry ? "已婚" : "未婚"  );
    
    double d1 = (m1 > m2)? 1 : 2.0;
	System.out.println(d1);
    
    int num = 12;
    System.out.println(num > 0? true : "num非正数");
}

7.6.2 与if-else的转换关系

  • 凡是可以使用条件运算符的地方，都可以改写为if-else结构。反之，不成立。

  • 开发中，如果既可以使用条件运算符，又可以使用if-else，推荐使用条件运算符。因为执行效率稍高。

//if-else实现获取两个数的较大值

int i1 = 10;
int i2 = 20;

int max;//声明变量max，用于记录i1和i2的较大值

if(i1 > i2){
    max = i1;
}else{
    max = i2;
}

System.out.println(max);

7.7 运算符优先级

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

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

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

建议：

  1. 不要过多的依赖运算的优先级来控制表达式的执行顺序，这样可读性太差，尽量使用()来控制表达式的执行顺序。
  2. 不要把一个表达式写得过于复杂，如果一个表达式过于复杂，则把它分成几步来完成。例如：
    ​ (num1 + num2) * 2 > num3 && num2 > num3 ? num3 : num1 + num2;

标签：变量,int,true,System,运算符,println,JavaNote,out
From： https://www.cnblogs.com/lkztrovo-lsh/p/17596864.html

相关文章

  • pytest + yaml 框架 -54. variables 可以引用同一层级变量
    前言v1.4.5新增功能。同一层级variables变量中，可以引用前面的变量了config中variables可以引用同一层级变量用例中variables可以引用同一层级变量引用同一层级变量最近有部分学员遇到的问题，在同一个层级设置变量，后面的变量引用前面的变量（v1.4.4之前的版本不支持）con......
  • C++运算符重载
    C语言是没运算符重载的，C++进行了扩充。C++比C语言多了面向对象（类），多了函数重写，运算符重载，实现了（函数重载跟运算符重载都属于编译器静态绑定了地址，所以是静态多态，而虚函数需要在运行期确定，是动态多态）。 如何实现C++跟C语言混合编程？extern"C",其修饰的代码段需要以C语言的方式进......
  • 软件测试|Python中的变量与关键字详解
    简介在Python编程中，变量和关键字是非常重要的概念。它们是构建和控制程序的基本要素。本文将深入介绍Python中的变量和关键字，包括它们的定义、使用方法以及一些常见注意事项。变量变量的定义变量是用于存储数据值的名称。在Python中，变量无需声明，可以直接赋值使用。变量可以存储不同......
  • JavaScript 中的变量声明与赋值
    在计算机编程中，使用名称（或标识符）来表示值是最基本的技术之一。将名称与值绑定为我们提供了一种在程序中引用值并利用它们的方式。当涉及到绑定名称与值时，我们通常称之为将值赋给变量。术语“变量”暗示了新的值可以被赋给它，这意味着与变量关联的值在程序执行过程中可能会改变。如......
  • 在ardiuno中把String变量#true#2a#3#转化为按照#分隔的数组, 然后再把数组第一个元素
    在Arduino中，你可以使用strtok()函数将一个String变量按照指定的分隔符切割为多个子字符串，并将它们存储到一个数组中。然后，你可以使用strcmp()函数将数组的第一个元素与字符串"true"进行比较。以下是一个示例，演示如何在Arduino中将String变量str按照#分隔符切割......
  • JS变量的类型和计算
    变量类型和计算-知识点变量类型值类型和引用类型//值类型leta=100letb=aa=200console.log(b)//100//引用类型leta={age:20}letb=ab.age=21console.log(a.age)//21（画图解释其中的玄机——用一个excel表格即可表示）常见值类型const......
  • java基础-运算符--day03
    目录1.算数运算符2.+号3.++4.=赋值操作5.关系运算6.逻辑运算7.三元运算8位运算1.算数运算符/处以%取余publicclassTestOper01{ publicstaticvoidmain(String[]args){ System.out.println(13/5);//结果为2 System.out.println(13%5);//结果为3 ......
  • 【转载】如何解决 nginx proxy_pass 使用变量 $arg 404 ?
    为什么location/auth0/{proxy_passhttps://cdn.eu.auth0.com/;}这样就可以但是location/auth0/{proxy_passhttps://$arg_host/;}就404$arg_host===cdn.eu.auth0.com  proxy_pass是用了变量的话,nginx就不会自动添加path到host后面例如......
  • UE4.27, Debug issues, "变量已被优化掉，因而不可用"
    调试时添加监控后，变量未被成功监控，显示"变量已被优化掉，因而不可用" 所使用的解决办法从解决方案配置的下拉菜单中选择DebugGameEditor  感谢阅读，敬请斧正......
  • python逻辑运算符与流程控制
    Python的基础逻辑运算内容概要算数运算符比较运算符赋值运算符逻辑运算符成员运算符身份运算符流程控制ifelse算术运算符代码演示a=21b=10c=0c=a+bprint("1-c的值为：",c)c=a-bprint("2-c的值为：",c)c=a*bprint("3-c的值......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99