第二章 Java基本语法（上）—— 变量与运算符

最新推荐文章于 2022-05-25 18:12:52 发布

四平二六

最新推荐文章于 2022-05-25 18:12:52 发布

阅读量265

点赞数

分类专栏： Java基础文章标签： java 编程语言

本文链接：https://blog.csdn.net/weixin_42248447/article/details/108907625

版权

Java基础专栏收录该内容

3 篇文章 0 订阅

订阅专栏

2.1、关键字与保留字

2.1.1、关键字（keyword）的定义和特点

定义：被Java语言赋予了特殊含义，用作专门用途的字符串（单词）
特点：关键字种所有字母都是小写
官方地址

2.1.2、保留字（reserved word）

Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字，如：goto、const……

2.2、标识符（Identifier）

标识符：
- Java对各种变量、方法和类等要素命名时使用的字符序列称为标识符
- 技巧：凡是自己可以其名字的地方都叫标识符
定义合法标识符规则（如不遵守，编译不过）：
- 由26个英文字母大小写，0-9，_或$组成
- 数字不可以开头
- 不可以使用关键字和保留字，但能包含关键字和保留字
- Java中严格区分大小写，长度无限制
- 标识符不能包含空格
Java中的命名规范（若不遵守，编译可过，但约定俗成，否则自己像个傻子）
- **包名：**多单词组成时所有字母都小写：xxxyyyzzz
- **类名、接口名：**多单词组成时，所有单词的首字母大写：XxxYyyZzz
- **变量名、方法名：**多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
- **常量名：**所有字母都大写，多单词时每个单词用下划线连接：XXX_YYY_ZZZ
注意1：在起名字时，为了提高阅读性，尽量有意义，“见名知意”。
注意2：Java采用Unicode字符集，因此标识符也可以使用汉字声明，但是强烈不建议使用。

/*
标识符（Identifier）
> java对各种变量、方法和类等要素命名时使用的字符序列成为标识符
> 技巧：凡是自己可以起名字的地方都叫标识符

定义合法标识符规则：——>若不遵守，编译不通过
> 由26个英文字母大小写，0-9，_或$组成
> 数字不可以开头
> 不可以使用关键字和保留字，但能包含关键字和保留字
> Java中严格区分大小写，长度无限制。
> 标识符不能包含空格。

Java中的名称命名规范：——>若不遵守，编译可以通过，强烈建议遵守。
 包名：多单词组成时所有字母都小写：xxxyyyzzz
 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
 常量名：所有字母都大写，多单词时每个单词用下划线连接：XXX_YYY_ZZZ
 
注意1：在起名字时，为提高阅读性，要尽量有意义，“见名知意”。
注意2：Java采用Unicode字符集，因此标识符也可以使用汉字声明，但是强烈不建议使用。

*/

public class IdentifierTest{
	public static void main(String[] args){
		System.out.println("IdentifierTest");
		
		int myNumber = 1000;
		System.out.println(myNumber);
		
		int mynumber = 1001;
		System.out.println(mynumber);
		
		int 学号 = 1002;//可以作为标识符，但强烈不建议这么用
		System.out.println(学号);
	}
}

class hello{
	
}

//class 1hello{//编译不通过
	
//}

class hello1{
	
}

class hello_${
	
}

//class public{//编译不通过
	
//}

class Public {//编译通过
	
}
 
class publicstatic{//编译通过
	
}

2.3、变量

变量的概念：
> 内存中的一个存储区域
> 该区域的数据可以在同一类型范围内不断变化
> 变量是程序中最基本的存储单元，包含变量类型、变量名和存储的值
变量的作用：
> 用于在内存中保存数据
使用变量注意：
> Java中每个变量必须先声明，后使用
> 使用变量名来访问这块区域的数据
> 变量的作用域：其定义所在的一对{ }内
> 变量只有在其作用域内才有效
> 同一个作用域内，不能定义重名的变量
声明变量：
> 语法：<数据类型> <变量名称>
> 例如：int var;
变量赋值：
> 语法：<变量名称> = <值>
> 例如： var = 10;
声明和赋值变量：
> 语法：<数据类型> <变量名> = <初始化值>
> 例如：int var = 10;

2.3.1、变量的分类

按数据类型

对于每一种数据都定义了明确的具体数据类型（强制型语言），在内存中分配了不同大小的内存空间。

按声明位置
在方法体外、类体内声明的变量称为成员变量。
在方法体内声明的变量称为局部变量。
注意：二者在初始化值方面的异同：
同：都有生命周期
异：局部变量除形参外，需显式初始化

2.3.2、整数类型：byte、short、int、long

Java中各整数类型有固定的表示范围和字段长度，不受具体OS（操作系统 Operating System）的影响，以保证Java程序的可移植性。
Java的整型常量默认为int型，声明long型常量后须加 ‘l’ 或 ‘L’
Java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long

2.3.3、浮点类型：float、double

与整数类型相似，Java浮点类型也有固定的表数范围和字段长度，不受具体OS影响。
浮点型常量由两种表示形式：
① 十进制数形式：5.12 512.0f .512(必须有小数点)
② 科学计数法形式：5.12e2 512E2 100E-2
float：单精度，尾数可以精确到7位有效数字，很多情况下，精度很难满足需求。
double：双精度，精度是float的两倍，通常采用此类型。
Java的浮点型常量默认位double型，声明float型常量，后须加 ‘f’ 或 ‘F’。

2.3.4、字符类型：char

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

2.3.5、布尔类型：boolean

boolean类型用来判断逻辑条件，一般用于程序流程控制：
① if条件控制语句
② while循环控制语句
③ do-while循环控制语句
④ for循环控制语句
boolean类型数据只允许取值true和false，无null。
- 不可以使用0或非0的整数替代false和true，这点和C语言不同。
- Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的boolean值，在编译之后都是用Java虚拟机中的int数据类型来代替，true用1表示，false用0表示。

/*
Java定义的数据类型
一、变量按照数据类型来分：
	基本数据类型：
		整型：byte、short、int、long
		浮点型：float、double
		字符型：char
		布尔型：boolean
		
	引用数据类型：
		类（class）<—— 字符串在这里
		接口（interface）
		数组（array）	

二、变量按照在类中声明的位置来分：
	成员变量  vs  局部变量
*/
class VariableTest1{
	public static void main(String[] args){
		//1、整型：byte(1字节=8bit)、short(2字节)、int(4字节)、long(8字节)
		//① byte范围：-128~127（2^8）
		byte b1 = -128;
		System.out.println(b1);
		
		//byte b2 = 128;//编译不通过，范围超了
		//System.out.println(b2);
		
		//② 声明long型变量，必须以“l”或“L”结尾
		//③ 通常，定义整型变量时，使用int型
		short s1 = 1242;
		int i1 = 152445;
		long l1 = 15824532L;
		System.out.println(l1);
		
		//2、浮点型：float(4字节)、double(8字节)
		//① 浮点型，表示带小数点的数值
		//② float表示数值的范围比long还大
		double d1 = 123.02;
		System.out.println(d1);
		//③ 定义float类型变量时，变量要以“f”或“F”结尾
		float f1 = 12.3F;
		System.out.println(f1);
		//④ 通常，定义浮点型变量时，使用double型。
		
		//3、字符型：char(1字符=2字节)
		//① 定义char型变量，通常使用一对单引号‘’
		char c1 = 'a';
		//编译不通过
		//c1 = 'AB';
		System.out.println(c1);
		
		//② 表示方式：1.声明一个字符 2.转义字符 3.直接使用Unicode值来表示字符型常量
		char c2 = '\n';//换行符
		System.out.print("hello" + c2);
		System.out.println("world");
		char c3 = '\t';//制表符
		System.out.print("hello" + c3);
		System.out.println("world");
		
		char c4 = '\u0043';
		System.out.println(c4);
		
		//4、布尔型：boolean
		//① 只能取两个值：true、false
		//② 常常在条件判断、循环结构中使用
		boolean bb1 = true;
		System.out.println(bb1);
	}
}

2.3.6、了解ASCII码

在计算机内部，所有数据都是用二进制表示。每一个二进制位（bit）有0和1两种状态，因此8个二进制位就可以组合出256种状态，这被称为一个字节（byte）。一个字节一共可以用来表示256种不同的状态，每一个状态对应一个符号，就是256个符号，从00000000到11111111.
ASCII码： 上个世纪了六十年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系做了统一规定，这被称为ASCII码。ASCII码一共规定了128个字符的编码，比如空格“SPACE”是32（二进制是00100000），大写的字母A是65（二进制是01000001）。这128个符号（包括32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前面的1位统一规定为0。
缺点：
① 不能表示所有字符。
② 相同的编码表示的字符不一样：比如130在法语编码中代表代表的字符和在希伯来语编码种代表的字符不同。

2.3.7、了解Unicode编码

乱码： 世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读，就会出现乱码。
Unicode编码： 将世界上所有的符号都纳入其中，每个符号都给予一个独一无二的编码，使用Unicode没有乱码的问题。
Unicode的缺点： Unicode只规定了富豪的二进制代码，却没有规定这个二进制代码应该如何存储：无法却别Unicode和ASCII。计算机无法区分三个字节表示一个符号还是分别表示三个符号。另外，我们知道，英文字母只用一个字节表示就够了，如果Unicode统一规定，每个符号用三个或四个字节表示，那么每个英文字母前都必然有二到三个字节是0，这对于存储空间来说是极大的浪费。

2.3.8、了解UTF-8

UTF-8是在互联网上使用最广的一种Unicode的实现方式。
UTF-8使用中变长的编码方式，它可以使用1-6个字节表示一个符号，根据不同的符号而变化字节长度。
UTF-8的编码规则：
① 对于单字节的UTF-8编码，该字节的最高位位0，其余7位用来对字符进行编码（等同于ASCII码）。
② 对于多字节的UTF-8编码，如果编码包含n个字节，那么第一个字节的前n位为1，第一个字节的第n+1位为0，该字节的剩余各位用来对字符进行编码。在第一个字节之后的所有字节，都是最高两位为“10”，其余6位用来对字符进行编码。

2.3.9、基本数据类型转换

自动类型提升： 容量小的类型自动转换为容量大的数据类型，特别说明这儿的容量指的是容纳数的范围，而不是内存容量。数据类型按容量大小排序：
有多种类型的数据混个运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
byte、short、char之间不会相互转换，他们三者在计算时首先转换为int类型。
boolean类型不能与其他数据类型运算。
当把任何基本数据类型和字符串（String）进行连接运算（+）时，基本数据类型的值将自动转化位字符串（String）类型。

/*
基本数据类型之间的运算规则：
前提：这里讨论只是7种基本数据类型变量间的运算，不包含boolean类型的。

1、自动类型提升：
	结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
	byte、char、short --> int --> long --> float --> double
	特别的：当byte、char、short三种类型做运算时，结果为int。

2、强制类型转换：
说明：此时的容量大小指的是，表示书的范围的大和小，而不是占用内存的大和小。比容float容量大于long的容量。
*/
class VariableTest2{
	public static void main(String[] args){
		
		byte b1 = 2;
		int i1 = 135;
		//编译不通过
		//byte b2 = b1 + i1;
		int i2 = b1 + i1;
		System.out.println(i2);
		
		float f1 = 12.02F;
		double d1 = f1;
		System.out.println(d1);
		
		System.out.println("****************");
		
		char c1 = 'a';//97
		int i3 = 10;
		int i4 = c1 + i3;
		System.out.println(i4);
		
		short s2 = 10;
		//char c2 = c1 + s2;//编译不通过
		
		byte b2 = 10;
		//char c3 = c1 + b2;//编译不通过
		
		//short s3 = b2 + s2;//编译不通过
		
		int i5 = b1 + b2;//byte + byte 结果也是int
	}
}

2.3.10、字符串类型：String

String不是基本数据类型，属于引用类型
使用方式与基本数据类型一致。例如：String str = “abcd”;
一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。例如：
str = str + “xyz”;
int n = 100;
str = str + n;

/*
String类型变量的使用：
1.String属于引用数据类型，翻译为：字符串
2.声明String类型变量时，使用一对双引号""
3.String可以和8种基本数据类型变量做运算，且运算只能是连接运算，运算符为+
4.运算的结果仍然是String类型
*/
class StringTest{
	public static void main(String[] args){
		String s1 = "Hello World";
		System.out.println(s1);
		
		String s2 = "a";
		String s3 = "";
		
		//char c = '';//编译不通过
		
		System.out.println("*****************");
		int number = 1000;
		String numberStr = "学号：";
		String info = numberStr + number;//+：连接运算
		System.out.println(info);
		boolean b1 = true;
		String info1 = info + b1;
		System.out.println(info1);
		
		System.out.println("*****************");
		//练习1
		char c = 'a';//97   A:65
		int num = 10;
		String str = "hello";
		System.out.println(c + num +str);//107hello
		System.out.println(c + str + num);//ahello10
		System.out.println(c + (num + str));//a10hello
		System.out.println((c + num) + str);//107hello
		System.out.println(str + num + c);//hello10a
		
		System.out.println("*****************");
		//练习2
		//*	*
		System.out.println("*	*");
		System.out.println('*' + '\t' + '*');//结果：93  因为char对应的是ASCII码，+运算后结果是int型
		System.out.println('*' + "\t" + '*');//结果：*	*  因为“\t”是字符串（仍然是制表符），+变成了连接符，进行连接运算，就不做加法了
		System.out.println('*' + '\t' + "*");//结果：51*   因为前边的‘*’取的是ASCII码，后边“*”是字符串
		System.out.println('*' + ('\t' + "*"));//结果：*	*   因为后边括号内先做运算，是一个字符串
		
		System.out.println("*****************");
		
		//练习3
		//String str1 = 4;//编译错误：int无法转换为String
		String str2 = 3.5f + "";
		System.out.println(str2);//输出：3.5
		System.out.println(3+4+"hello");//输出：7hello
		System.out.println("hello" + 3 + 4);//输出：hello34
		System.out.println('a' + 1 + "hello");//输出：98hello
		System.out.println("hello" + 'a' + 1);//输出：helloa1
	}
}

2.3.11、强制类型转换

自动类型提升的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符：()，但可能造成精度降低或溢出，要格外注意。
通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现吧字符串换成基本类型。
如：String a = “43”; int i = Integer.parseInt(a);
boolean类型不可以转换为其它的数据类型。

/*
强制类型转换：自动类型提升的逆运算。
1、需要使用强转符：()
2、注意点：强制类型转换，可能导致精度损失。
*/

class VariableTest3{
	public static void main(String[] args){
		double d1 = 12.3;
		
		int i1 = (int)d1;//截断操作，损失精度
		System.out.println(i1);
		
		long l1 = 123;
		short s1 = (short)l1;
		System.out.println(s1);
		
		int i2 = 128;
		byte b1 = (byte)i2;
		System.out.println(b1);
	}
}

class VariableTest4{
	public static void main(String[] args){
		//1.编码情况：
		long l = 123146;
		System.out.println(l);
		
		//编译失败：过大的整数
		//long l1 = 1564619974645463453;
		long l1 = 1564619974645463453L;//加上L编译通过
		System.out.println(l1);
		System.out.println("***************");
		
		//编译失败
		//float f1 = 125.3;
		
		//2.编码情况2：
		//整型常量，默认类型为int型
		//浮点型常量，默认类型为double型
		byte b = 12;
		//byte b1 = b + 1;//编译失败
		
		//float f1 = b + 12.3;//编译失败
	}
}

2.3.12、进制

世界上有10种人，喜欢和还没有发现自己喜欢戏曲的。

所有数字在计算机底层都以二进制形式存在
对于整数，有四种表示方式：
① 二进制（binary）：0，1，满2进1，以0b或0B开头。
② 十进制（decimal）：0-9，满10进1。
③ 八进制（octal）：0-7，满8进1，以数字0开头表示。
④ 十六进制（hex）：0-9及A-F，满16进1，以0x或0X开头表示。此处的A-F不区分大小写。如：0x21AF + 1 = 0X21B0
二进制
Java整数常量默认是int类型，当用二进制定义整数时，其第32位时符号位；当是long类型时，二进制默认占64位，第64位是符号位。
二进制的整数有如下三种形式：
① 原码：直接将一个数值换成二进制数，最高位是符号位
② 负数的反码：是对原码按位取反，只是最高位（符号位）确定为1
③ 负数的补码：其反码加1
计算机以二进制补码的形式保存所有的整数：
- 正数的原反补码相同
- 负数的补码是其反码+1
为什么要使用原码、反码、补码表示形式呢？
计算机辨别“符号位”显然会让计算机的基础电路设计变得十分复杂！于是人们想出了将符号位也参与运算的方法。我们知道，根据运算法则减去一个正数等于加上一个负数，即：1 - 1 = 1 + （-1）= 0，所以及其可以只有加法而没有减法，这样计算机运算你的设计就更简单了。

2.4、运算符

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

算数运算符
赋值运算符
比较运算符（关系运算符）
逻辑运算符
位运算符
三元运算符（三目运算符）

2.4.1、算术运算符

在这里插入图片描述
算术运算符的注意问题

如果对负数取模，可以把模数负号忽略不计，如：5%-2=1。但被模数是负数则不可忽略，如：-5%2=-1。此外，取模运算的结果不一定总是整数。
对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
“+”除字符串相加功能外，还能把非字符串转成字符串。
符号：=
① 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
② 支持连续赋值。
扩展赋值运算符
+=、-=、*=、/=、%=

/*
运算符之一：算数运算符
+、-、*、/、%、（前）++、（后）++、（前）--、（后）--、（连接符）+
*/
class AriTest{
	public static void main(String[] args){
		//除号：/
		int num1 = 12;
		int num2 = 5;
		int result1 = num1/num2;
		System.out.println(result1);//2
		
		int result2 = num1/num2*num2;
		System.out.println(result2);//10
		
		double result3 = num1/num2;
		System.out.println(result3);//2.0
		
		double result4 = num1/num2 + 0.0;//2.0
		double result5 = num1/(num2 + 0.0);//2.4
		double result6 = (double)num1/num2;//2.4
		double result7 = (double)(num1/num2);//2.0
		System.out.println(result5);
		System.out.println(result6);
		System.out.println(result7);
		
		//%：取余（取模）运算
		//结果的符号与被模数的符号相同
		//开发中，经常使用%来判断能否被除尽的情况
		int m1 = 12;
		int n1 = 5;
		System.out.println("m1 % n1 = " + m1 % n1);//2
		
		m1 = -12;
		n1 = 5;
		System.out.println("m1 % n1 = " + m1 % n1);//-2
		
		m1 = 12;
		n1 = -5;
		System.out.println("m1 % n1 = " + m1 % n1);//2
		
		m1 = -12;
		n1 = -5;
		System.out.println("m1 % n1 = " + m1 % n1);//-2
		
		//（前）++：先自增1，后运算
		//（后）++：先运算，后自增1
		int a1 = 10;
		int b1 = ++a1;
		System.out.println("a1 = " + a1 + "; " + " b1 = " + b1);//a1=11;b1=11;
		
		int a2 = 10;
		int b2 = a2++;
		System.out.println("a2 = " + a2 + "; " + " b2 = " + b2);//a2=11;b2=10;

		//注意点：
		short s1 = 10;
		//s1 = s1 + 1;//编译失败
		//s1 = (short)s1 + 1;//编译失败
		s1 = (short)(s1 + 1);//正确的
		s1++;//自增1不会改变本身变量的数据类型
		System.out.println(s1);//12
		
		//问题：
		byte by1 = 127;
		by1++;
		System.out.println("by1 = " + by1);//-128
		
		//（前）--：先自减1，后运算
		//（后）--：先运算，后自减1
		int a3 = 10;
		int b3 = --a3;
		System.out.println("a3 = " + a3 + "; " + " b3 = " + b3);//a3=9;b3=9;
		
		int a4 = 10;
		int b4 = a4--;
		System.out.println("a4 = " + a4 + "; " + " b4 = " + b4);//a4=9;b4=10;
	}
}

算术运算符练习

/*
随意给出一个整数，打印显示它的
个位数，十位数，百位数的值。
格式如下：
数字xxx的情况如下：
个位数：
十位数：
百位数：
例如：
数字153的情况如下：
个位数：3
十位数：5
百位数：1
*/
class AriExer{
	public static void main(String[] args){
		int num = 153;
		System.out.println("个位数：" + num%10);
		
		System.out.println("十位数：" + num%100/10);
		
		System.out.println("百位数：" + num/100);
	}
}

/*
运算符之二：赋值运算符
=、+=、-=、*=、/=、%=
*/
class SetValueTest{
	public static void main(String[] args){
		//赋值符号：=
		int i1 = 10;
		int j1 = 10;
		
		int i2,j2;
		//连续赋值
		i2 = j2 = 10;
		
		int i3 = 10,j3 = 20;
		
		System.out.println("****************");
		
		int num1 = 10;
		num1 += 2;//num1 = num1 + 2;
		System.out.println("num1 = " + num1);
		
		int num2 = 12;
		num2 %= 5;//num2 = num2 % 5;
		System.out.println("num2 = " + num2);
		
		short s1 = 10;
		//s1 = s1 + 2;//编译失败
		s1 += 2;//不会改变变量本身的数据类型
		System.out.println(s1);
		//开发中，如果希望变量实现+2的操作，有几种方法？前提：int num = 10;
		//方法一：num = num + 2;
		//方法二：num += 2;(推荐：① 代码量略少；② 不改变变量本身数据类型)
		
		//开发中，如果希望变量实现+1的操作，有几种方法？前提：int num = 10;
		//方法一：num = num + 1;
		//方法二：num += 1;(推荐：① 代码量略少；② 不改变变量本身数据类型)
		//方式三：num++;(推荐)
		
		//练习一
		int i = 1;
		i *= 0.1;
		System.out.println(i);//0
		i++;
		System.out.println(i);//1
		
		//练习二
		int m = 2;
		int n = 3;
		n *= m++; 
		System.out.println("m=" + m);//3
		System.out.println("n=" + n);//6
		
		//练习三
		int n1 = 10;
		n1 += (n1++) + (++n1);
		System.out.println(n1);//32
	}
}

2.4.2、比较运算符

在这里插入图片描述
① 比较运算符的结果都是boolean型，也就说要么true，要么false
② 比较运算符 “==” 不能误写成 “=”

/*
运算符之三：比较运算符
==、!=、>、<、>=、<=、instanceof

结论：
1.比较运算符的结果是boolean类型
2.区分 == 和 = 
*/
class CompareTest{
	public static void main(String[] args){
		int i = 10;
		int j = 20;
		System.out.println(i == j);//false
		System.out.println(i = j);//20
		
		boolean b1 = true;
		boolean b2 = false;
		System.out.println(b2 == b1);
		System.out.println(b2 = b1);
	}
}

2.4.3、逻辑运算符

&——逻辑与 |——逻辑或 !——逻辑非
&&——短路与 ||——短路或 ^——逻辑异或
在这里插入图片描述

逻辑运算符用于连接boolean型表达式，在Java中不可以写成3<x<6，应该写成 x>3 & x<6。
“&” 和 “&&”的区别：
① 单&时，左边无论真假，右边都进行运算
② 双&&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算
“|” 和 “||”的区别同理，|| 表示：当左边为真，右边不参与运算
异或（^）和或（|）的不同之处是：当左右都为true时，结果为false。理解：异或，追求的是“异”！

/*
运算符之四：逻辑运算符
&	&&	|	||	!	^

说明：
1.逻辑运算符操作的都是boolean类型的变量
*/
class LogicTest{
	public static void main(String[] args){
		//区分 & 与 &&
		//相同点：① & 与 && 的运算结果相同
		//		  ② 当符号左边是true时，二者都会执行符号右边的运算
		//不同点：当符号左边是false时，& 继续执行符号右边的运算，&& 不再执行符号右边的运算（短路）
		//开发中推荐使用&&
		boolean b1 = true;
		b1 = false;
		int num1 = 10;
		if(b1 & (num1++ > 0)){
			System.out.println("我现在在北京");
		} else {
			System.out.println("我现在在南京");
		}
		
		System.out.println("num1 = " + num1);
		
		boolean b2 = true;
		b2 = false;
		int num2 = 10;
		if(b2 && (num2++ > 0)){
			System.out.println("我现在在北京");
		} else {
			System.out.println("我现在在南京");
		}
		
		System.out.println("num2 = " + num2);
		
		//区分：| 与 ||
		//相同点：① | 与 || 的运算结果相同
		//		  ② 当符号左边是false时，二者都会执行符号右边的运算
		//不同点：当符号左边是true时，& 继续执行符号右边的运算，&& 不再执行符号右边的运算（短路）
		//开发中推荐使用||
		boolean b3 = false;
		b3 = true;
		int num3 = 10;
		if(b3 | (num3++ > 0)){
			System.out.println("北京");
		} else {
			System.out.println("南京");
		}
		System.out.println("num3 = " + num3);
		
		boolean b4 = false;
		b4 = true;
		int num4 = 10;
		if(b4 || (num4++ > 0)){
			System.out.println("北京");
		} else {
			System.out.println("南京");
		}
		System.out.println("num4 = " + num4);
	}
}

2.4.4、位运算符

在这里插入图片描述

位运算是直接对整数的二进制进行的运算

/*
运算符之五：位运算符（了解）
1.<<：在一定范围内，每向左移一位，相当于*2
2.>>：在一定范围内，每向右移一位，相当于/2

面试题：最高效方式的计算2*8？	2<<3 或 8<<1
*/
class BitTest{
	public static void main(String[] args){
		int i = 21;
		i = -21;
		System.out.println("i << 1 = " + (i << 1));
		System.out.println("i << 2 = " + (i << 2));
		System.out.println("i << 3 = " + (i << 3));
		
		System.out.println("i << 26 = " + (i << 26));
		System.out.println("i << 27 = " + (i << 27));
		
		int m = 12;
		int n = 5;
		System.out.println("m & n = " + (m & n));
		System.out.println("m | n = " + (m | n));
		System.out.println("m ^ n = " + (m ^ n));
		
		//练习：交换两个变量的值
		int num1 = 10;
		int num2 = 20;
		
		//方式一：定义临时变量的方式
		//推荐的方式
		int temp = num2;
		num2 = num1;
		num1 = temp;
		System.out.println("交换后num1 = " + num1);
		System.out.println("交换后num2 = " + num2);
		
		//方式二：好处：不用定义临时变量
		//弊端：① 相加操作可能超出存储范围
		//		② 有局限性：只适用于数值类型
		num1 = num1 + num2;
		num2 = num1 - num2;
		num1 = num1 - num2;
		System.out.println("交换后num1 = " + num1);
		System.out.println("交换后num2 = " + num2);
		
		//方式三：使用位运算符
		//局限性：仅适用于数值型
		num1 = num1 ^ num2;
		num2 = num1 ^ num2;
		num1 = num1 ^ num2;
		System.out.println("交换后num1 = " + num1);
		System.out.println("交换后num2 = " + num2);
	}
}

2.4.5、三元运算符

格式：
（条件表达式）？表达式1：表达式2
① 条件表达式为true，运算后的结果是表达式1
② 条件表达式为false，运算后的结果是表达式2
表达式1和表达式2为同种类型
三元运算符与 if-else 的练习与区别：
① 三元运算符可简化 if-else 语句
② 三元运算符要求必须返回一个结果
③ if 后的代码块可有多个语句

/*
运算符之六：三元运算符
1.结构：（条件表达式）？表达式1：表达式2
2.说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假，决定执行表达式1还是表达式2
  如果条件表达式为true，则执行表达式1.
  如果条件表达式为false，则执行表达式2.
③ 表达式1和表达式2要求时一致的。
④ 三元运算符可以嵌套使用

3.凡是可以使用三元运算符的地方都可以使用if-else代替
  反之，不成立。
4.如果程序既可以使用三元运算符，又可以使用if-else结构，则优先选择使用三元运算符
	原因：简洁、执行效率高
*/
class SanYuanTest{
	public static void main(String[] args){
		//获取两个整数的较大值
		int m = 12;
		int n = 5;
		
		int max = (m > n) ? m : n;
		System.out.println(max);
		
		double num = (m > n) ? 2 : 1.6;
		
		//(m > n) ? 2 : "n大";//编译错误
		
		//**************
		String maxStr = (m > n) ? "m大" : ((m == n) ? "m和n相等" : "n大");
		System.out.println(maxStr);
		
		//**************
		//获取三个数的最大值
		int n1 = 12;
		int n2 = 30;
		int n3 = -132;
		int max1 = (n1 > n2) ? n1 : n2;
		int max2 = (max1 > n3) ? max1 : n3;
		System.out.println("三个数种最大的数：" + max2);
		//不建议
		int max3 = (((n1 > n2) ? n1 : n2) > n3) ? (n1 > n2) ? n1 : n2 : n3;
		System.out.println("三个数种最大的数：" + max3);
		
		//改写成if-else代替
		if(m > n){
			System.out.println(m);
		} else {
			System.out.println(n);
		}
	}
}

2.4.6、运算符的优先级

运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。
只有单目运算符、三元运算符、赋值运算符是从右向左运算的。

四平二六

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第二章 Java基本语法（上）—— 变量与运算符

2.1、关键字与保留字2.1.1、关键字（keyword）的定义和特点定义：被Java语言赋予了特殊含义，用作专门用途的字符串（单词）特点：关键字种所有字母都是小写官方地址2.1.2、保留字（reserved word）Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字，如：goto、const……2.2、标识符（Identifier）标识符：- Java对各种变量、方法和类等要素命名时使用的字符序列称为标识符-
复制链接

扫一扫