Java教程
第二章、Java基本语法(上)：变量与运算符
本文主要是介绍第二章、Java基本语法(上)：变量与运算符，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
Java基本语法(上)
1.1 关键字
1.1.1、关键字的定义与特点
定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
特点：关键字中所有字母都为小写
1.1.2、所有的关键字
1.2 保留字
1.2.1 保留字的定义
-
Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字
-
现有两个保留字：goto 、const
1.3 标识符
1.3.1 标识符的定义
标识符：Java 对各种变量、方法和类等要素命名时使用的字符序列
1.3.2 标识符命名的规则
- 由26个英文字母大小写，0-9 ，_或 $ 组成
- 数字不可以开头。
- 不可以使用关键字和保留字，但能包含关键字和保留字。
- Java中严格区分大小写，长度无限制。
- 标识符不能包含空格。
注意：如果不遵守如下的规则，编译不通过！需要大家严格遵守
1.3.3 Java中的名称命名规范
- 包名：多单词组成时所有字母都小写：xxxyyyzzz
- 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
- 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
- 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
注意：如果不遵守如下的规范，编译可以通过！建议大家遵守
1.3.4 标识符命名代码演示
package com.atguigu.java1;
/*
1. 标识符的命名规则:--->如果不遵守如下的规范，编译不用过通过！ 一定要遵守
> 由26个英文字母大小写，0-9 ，_或 $ 组成
> 数字不可以开头。
> 不可以使用关键字和保留字，但能包含关键字和保留字。
> Java中严格区分大小写，长度无限制。
> 标识符不能包含空格。
Java中的名称命名规范： --->如果不遵守如下的规范，编译可以通过！建议大家遵守
包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
*/
public class IdentifierTest {
public static void main(String[] args) {
}
}
class Aa1_${
}
//class 1A{ 数字不能打头
//
//}
//class static{ // 不能使用关键字
//
//}
//class const{ // 不能使用保留字
//
//}
class publicstatic{ // 可以包含关键字保留字
}
class A{ // 严格区分大小写
}
class a{ // 严格区分大小写
}
1.4 变量
1.4.1 变量的定义
- 定义：
- 内存中的一个存储区域。
- 该区域的数据可以在同一类型范围内不断变化（其数据值可以改变的量）。
- 变量是程序中最基本的存储单元。
1.4.2 变量的三要素
-
数据类型
-
变量名
-
值
1.4.3 变量的作用
作用：用于在内存中保存数据
1.4.4 变量的使用
1.4.4.1 变量的定义格式
1.变量的声明：
数据类型 变量名;
2.变量的赋值：
变量名 = 数据值;
3.变量声明的同时初始化值：
数据类型 变量名 = 数据值;
1.4.4.2 变量的使用的注意点（变量的代码演示）
package com.atguigu.java1;
/*
变量的使用
说明：
① 变量必须先声明，后使用
② 变量都定义在其作用域内。在作用域内，它是有效的。换句话说，出了作用域，就失效了
③ 同一个作用域内，不可以声明两个同名的变量
④使用变量名来访问这块区域的数据
注意：此时研究的是局部变量。
局部变量应声明且初始化后才能使用。
*/
public class VariableTest1 {
public static void main(String[] args) {
// 变量的定义
int age = 12;
// 变量的使用
System.out.println(age); // 通过变量名来访问这块区域
//变量必须先声明后使用
// System.out.println(name); // name cannot be resolved to a variable(未声明name)
// 变量的声明
String name;
// System.out.println(name); // The local variable name may not have been initialized （局部变量name要初始化了才能使用）
name = "卢本伟";
System.out.println(name);
// 变量的作用域
// System.out.println(myClassNumber); // myClassNumber cannot be resolved to a variable 在main方法这块区域没声明过myClassNumber
// 同一个作用域内，不可以声明两个同名的变量
// String name = "周淑怡"; // Duplicate local variable name (重复定义name)
}
public void method(){
int myClassNumber = 1;
}
}
1.4.5 变量的分类
1.4.5.1按数据类型来分
1.4.5.1按声明的位置的不同来分
1.5 常量（constant）
1.5.1 常量的定义
常量：在程序执行的过程中，其值不可以发生改变的量
1.5.2 常量的分类
-
常量的分类：
-
自定义常量：通过final关键字定义（后面在面向对象部分讲解）
-
字面值常量：
字面值常量 举例 字符串常量 ”HelloWorld“ 整数常量 12，-23 浮点常量 12.34 字符常量 ‘a’，‘0’，‘我’ 布尔常量 true，false 空常量 null
-
1.5.3 常量的代码演示
package com.atguigu.java1;
/*
* 常量：
* 自定义常量：通过final关键字定义（后面在面向对象部分讲解）
*
* 字面值常量：字符串常量、基本类型那几种常量（整型常量、浮点型常量。。。）、空常量（null）
*/
public class ConstantTest {
public static void main(String[] args) {
// 字符串常量
System.out.println("卢本伟");
// 整型常量
System.out.println(26);
System.out.println(-26);
// 浮点型常量
System.out.println(-23.3);
System.out.println(23.3);
// char型常量
//字符常量，单引号里面有且仅有一个字符
System.out.println('1');
System.out.println('a');
System.out.println('中');
// 布尔型常量
System.out.println(true);
System.out.println(false);
//空常量，不可以在输出语句中直接打印
// System.out.println(null);
}
}
注意事项：!!!
字符常量，单引号里面有且仅有一个字符
空常量，不可以在输出语句中直接打印
1.6 数据类型
1.6.1 数据类型的分类
1.6.2 基本数据类型
- bit: 计算机中的最小存储单位。
- byte:计算机中基本存储单元。
1.6.2.1 整型：byte、short、int、long
- Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。
- java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’
- java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long
1.6.2.2 浮点型：float、double
- 与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。
- float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
- double:双精度，精度是float的14~15。通常采用此类型。
- Java 的浮点型常量默认为double型。
- 声明float型常量，须后加‘f’或‘F’。
1.6.2.3 字符型：char
- char 型数据用来表示通常意义上“字符”(2字节)
- Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字 母，一个汉字，或其他书面语的一个字符。
- 字符型变量的四种表现形式：详细看代码
- char类型是可以进行运算的。因为它都对应有Unicode码。
1.6.2.4 布尔型：boolean
- 只能取2个值：true、false
- 常常在条件判断、循环结构中使用
1.6.3 数据类型代码演示
package com.atguigu.java1;
/*
* 八种基本数据类型
* 整型：byte、short、int、long
* 浮点型：float、double
* 字符型：char
* 布尔型：boolean
*
*/
public class VariableTest2 {
public static void main(String[] args) {
// 整型：表示整数
// 整型： byte(1个字节 = 8个bit)、short(2个字节)、int(4个字节)、long(8个字节)
// byte的范围：-128 ~ 127
byte b1 = 12;
byte b2 = 127;
// byte b3 = 128; // 报错，超过byte的取值范围
short s1 = 123;
// 通常，定义整型变量时，使用int型。
// 整型的默认类型为：int
int i1 = 12345;
System.out.println(i1);
// 声明long型变量，必须以"l"或"L"结尾
long l1 = 123456789L;
long l2 = 123;// 为什么long型没加L结尾也没有报错，因为整型的默认类型为int，自动类型转换为long
//long l3 = 11561651561615656; // 超过了int的取值范围就不能自动类型转换了，须手动添加L
long l3 = 11561651561615656L;
System.out.println(l1);
System.out.println(l2);
//****************************************************************************
// 浮点型：表示小数
// 浮点型：float(4个字节)、double(8个字节)
//float的取值范围比long的取值范围要大
// 为什么float和long同样是4个字节，但是float的取值范围比long要大？ 二者底层存储方式不一样
// 定义float类型变量时，变量要以"f"或"F"结尾
float f1 = 12.3F;
System.out.println(f1);
// 通常，定义浮点型变量时，使用double型。
// 浮点型的默认数据类型为：boolean
double d1 = 12.3;
System.out.println(d1);
//****************************************************************************
// 字符型：char(2个字节)
// 定义char型变量，通常使用一对'',内部有且仅有有一个字符
// char c1 = 'ab'; 报错
// 字符型四种定义方式：
// ①一个字符
char c2 = 'a';
char c3 = '中';
System.out.println(c2);
System.out.println(c3);
// ②转义字符
char c4 = '\n';
char c5 = '\r';
// ③\ u字符的Unicode编码值的十六进制型
char c6 = '\u5c1a';
System.out.println(c6);
// ④直接给char类型变量赋值十进制的0~65535之间的Unicode编码值
char c7 = 97;// a
System.out.println(c7);
//****************************************************************************
// 布尔型：boolean
// 只能取2个值：true、false
// 常常在条件判断、循环结构中使用
boolean isMarried = true;
if(isMarried){
System.out.println("你已经结婚了，不能参加单身派对了");
}else{
System.out.println("你可以多谈谈恋爱");
}
}
}
1.7 基本数据类型——自动类型转换
1.7.1 自动类型转换的定义
- 自动类型转换：容量小的类型自动转换为容量大的数据类型
- 说明：此时的容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量
1.7.2 自动类型转换适用前提
适用前提：这里讨论只是7种基本数据类型变量间的运算。不包含boolean类型的。
1.7.3 自动类型转换规则
- 结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
- byte 、char 、short --> int --> long --> float --> double
- 特别的：当byte、char、short三种类型的变量做运算时，结果为int型
- 自动类型转换的三种转换形式
- 当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时
- 当存储范围小的数据类型与存储范围大的数据类型一起混合运算时，会按照其中最大的类型运算
- 当byte,short,char数据类型进行算术运算时，按照int类型处理
1.7.4 自动类型转换代码演示
package com.atguigu.java1;
/*
基本数据类型之间的运算规则：
前提：这里讨论只是7种基本数据类型变量间的运算。不包含boolean类型的。
1. 自动类型提升：
结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
byte 、char 、short --> int --> long --> float --> double
特别的：当byte、char、short三种类型的变量做运算时，结果为int型
2. 强制类型转换：见VariableTest3.java
说明：此时的容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量
*/
public class VariableTest3 {
public static void main(String[] args) {
// 当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时
byte b1 = 12;
int i1 = 123;
//b1 = b1 + 1;// 1是int型，右边整体是int型，编译报错
// byte b2 = i1 + b1;// 超出byte的范围，报错
int i2 = i1 + b1;
long l1 = i1 + b1;
System.out.println(i2);
System.out.println(l1);
// 当存储范围小的数据类型与存储范围大的数据类型一起混合运算时，会按照其中最大的类型运算
byte b2 = 6;
int i3 = 125;
double d1 = 12.3;
double sum = b2 + i3 + d1; // 结果转为double
System.out.println(sum);
// 当byte,short,char数据类型进行算术运算时，按照int类型处理
byte b3 = 12;
char c1 = 32;
short s1 = 25;
// short s2 = b3 + s1; // 报错
// char c2 = s1 + c1;// 报错
int i4 = b3 + c1 + s1;
System.out.println(i4);
}
}
1.8 基本数据类型——强制类型转换
1.8.1 强制类型转换的定义
强制类型转换：将容量大的数据类型转换为容量小的数据类型。
1.8.2 强制类型转换使用规则
- 强制转换符：()
- **可能**造成精度降低或溢出
1.8.3 强制类型转换代码演示
package com.atguigu.java1;
/*
强制类型转换：自动类型提升运算的逆运算。
1.需要使用强转符：()
2.注意点：强制类型转换，可能导致精度损失。
*/
public class VariableTest4 {
public static void main(String[] args) {
// 损失精度示例1
double d1 = 12.34;//截断操作
int i1 = (int)d1;
System.out.println(i1);// 12
// 损失精度示例2
int i2 = 128;
byte b1 = (byte)i2;
System.out.println(b1); // -128
// 没有损失精度
long l1 = 123L;
short s1 = (short)l1;
System.out.println(s1); // 123
}
}
1.9 String简述
1.9.1 String的使用规则
- String属于引用数据类型,翻译为：字符串
- 声明String类型变量时，使用一对""
- String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+ ，运算的结果仍然是String类型
1.9.2 String代码演示
package com.atguigu.java1;
/*
String类型变量的使用
1. String属于引用数据类型,翻译为：字符串
2. 声明String类型变量时，使用一对""
3. String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+ ，运算的结果仍然是String类型
*/
public class StringTest {
public static void main(String[] args) {
// String的定义：
String s1 = "Hello,world!";
String s2 = "a";
String s3 = "";// 空串
// String的运算
int number = 1001;
String numberStr = "学号：";
String str1 = numberStr + number; // 只要与字符串运算，结果必然是字符串
System.out.println(str1);
// ***********************
// 考察：char与基本数据类型运算时，化为其ASCII码值
// 练习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
// 练习2
// * *
System.out.println("* *");
System.out.println('*' + '\t' + '*');
System.out.println('*' + "\t" + '*');
System.out.println('*' + '\t' + "*");
System.out.println('*' + ('\t' + "*"));
}
}
1.9 进制
1.9.1 进制在Java中的表示
- 对于整数，有四种表示方式：
- 二进制(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不区分大小写。
1.9.2 进制代码演示
package com.atguigu.java1;
/*
对于整数，有四种表示方式：
二进制(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
*/
public class BinaryTest {
public static void main(String[] args) {
int i1 = 0b10; //二进制
int i2 = 010; //八进制
int i3 = 10; //十进制
int i4 = 0x10; //十六进制
// 输出时，都以十进制位数输出
System.out.println(i1);
System.out.println(i2);
System.out.println(i3);
System.out.println(i4);
}
}
1.10 运算符
- 表达式：用运算符连接起来的式子
1.10.1 算数运算符
+（正号） -（减号） +（加号） -（减号） *（乘） /（除） %（取模） （前）++ （后）++ （前）-- （后）-- +：字符串连接 具体内容看代码
1.10.1.1 算数运算符代码演示：
package com.atguigu.java2;
/*
* 算数运算符
*
* + - + - * / % (前)++ (后)++ (前)-- (后)-- +
*/
public class AriTest {
public static void main(String[] args) {
// +（正号）
int i1 = +12;
// -（减号）
int i2 = -12;
System.out.println(i1);
System.out.println(i2);
//***********************************************************
// +（加号）
int i3 = 13;
int i4 = 15;
System.out.println(i3 + i4);
// -（减号）
System.out.println(i3 - i4);
// *（乘）
System.out.println(i3 * i4);
//***********************************************************
// / （除）
// 整数之间做除法时，只保留整数部分而舍弃小数部分。
int i5 = 12;
int i6 = 5;
System.out.println(i5 / i6); // 2 (舍去小数部分)
System.out.println(i5 / i6 * i6); // 10
// 整数之间做除法时，只保留整数部分而舍弃小数部分。 即使我使用double接收也没有用
double d1 = i5 / i6;
System.out.println(d1);
// 那怎么才能使得数变成2.4，那么我就要从等号右边做文章
// 把其中一个数变成浮点型就好了
double d2 = (double) i5 / i6;
double d3 = i5 / (double) i6;
System.out.println(d2);
System.out.println(d3);
//***********************************************************
// %（取模）
// 结果的符号与被模数的符号相同
// 开发中，经常使用%来判断能否被除尽的情况。
int m1 = 12;
int n1 = 5;
System.out.println("m1 % n1 = " + m1 % n1);
int m2 = -12;
int n2 = 5;
System.out.println("m2 % n2 = " + m2 % n2); // -2
int m3 = 12;
int n3 = -5;
System.out.println("m3 % n3 = " + m3 % n3);
int m4 = -12;
int n4 = -5;
System.out.println("m4 % n4 = " + m4 % n4); // -2
//***********************************************************
// （前）++：先自增一，后运算
// （后）++：先运算，后自增一
int a1 = 10;
int a2 = ++a1;
System.out.println("a1 = " + a1 + " a2 = " + a2);
int a3 = 10;
int a4 = a3++;
System.out.println("a3 = " + a3 + " a4 = " + a4);
int a5 = 10;
a5++;// ++a5 (这种情况这样写，无论如何都会自增一)
System.out.println(a5);
// 区分一下例子
short s1 = 10;
// s1 = s1 + 1; // 报错
s1++; // 不会改变自身的数据类型
System.out.println(s1);
//***********************************************************
// （前）--
// （后）--
// 与 ++同理
//***********************************************************
// +：字符串连接
String myNumber = "学号：";
int number = 1001;
System.out.println(myNumber + number);
}
}
1.10.2 赋值运算符
注意：所有的赋值运算符的=左边一定是一个变量
| 赋值运算符 | 符号解释 |
|---|---|
= | 将符号右边的值，赋值给左边的变量 |
+= | 将符号**左边的值和右边的值进行相加操作，最后将结果赋值给左边的变量** |
-= | 将符号**左边的值和右边的值进行相减操作，最后将结果赋值给左边的变量** |
*= | 将符号**左边的值和右边的值进行相乘操作，最后将结果赋值给左边的变量** |
/= | 将符号**左边的值和右边的值进行相除操作，最后将结果赋值给左边的变量** |
%= | 将符号**左边的值和右边的值进行取余操作，最后将结果赋值给左边的变量** |
- += -= *= /= %= （扩展赋值运算符）
- 扩展赋值运算符在将最后的结果赋值给左边的变量前，都做了一步强制类型转换。
1.10.2.1 赋值运算符代码演示
package com.atguigu.java2;
/*
运算符之二：赋值运算符
=
+= -= *= /= %= （扩展赋值运算符）
*/
public class SetValueTest {
public static void main(String[] args) {
// =
int i1 = 10;
// 连续赋值
int i2, i3;
i2 = i3 = 10;
int i4 = 10, i5 = 10;
// ***********************************************************
// 扩展赋值运算符在将最后的结果赋值给左边的变量前，都做了一步强制类型转换。
// +=
int j1 = 10;
j1 += 5;// 相当于 j1 = j1 + 5
System.out.println(j1);
short s1 = 10;
// s1 = s1 + 1; // 报错
s1 += 1; // 编译通过，且没有改变s1的数据类型
// 因为在得到int类型的结果后，JVM自动完成一步强制类型转换，将int类型强转成short
// ***********************************************************
// -=
int j2 = 10;
j2 -= 2;
System.out.println(j2);
// ***********************************************************
// /=
int j3 = 10;
j3 /= 2;
System.out.println(j3);
// ***********************************************************
// %=
int j4 = 10;
j4 %= 3;
System.out.println(j4);
// ***********************************************************
// 开发中，如果希望变量实现+2的操作，有几种方法？(前提：int num = 10;)
// 方式一：num = num + 2;
// 方式二：num += 2; (推荐)
// 开发中，如果希望变量实现+1的操作，有几种方法？(前提：int num = 10;)
// 方式一：num = num + 1;
// 方式二：num += 1;
// 方式三：num++; (推荐)
}
}
1.10.3 比较运算符
| 关系运算符 | 符号解释 |
|---|---|
< | 比较符号左边的数据是否小于右边的数据，如果小于结果是true。 |
> | 比较符号左边的数据是否大于右边的数据，如果大于结果是true。 |
<= | 比较符号左边的数据是否小于或者等于右边的数据，如果大于结果是false。 |
>= | 比较符号左边的数据是否大于或者等于右边的数据，如果小于结果是false。 |
== | 比较符号两边数据是否相等，相等结果是true。 |
！= | 不等于符号 ，如果符号两边的数据不相等，结果是true。 |
| instanceof | 检查左边数据是否是类的对象，如果是结果为true |
-
比较运算符，是两个数据之间进行比较的运算，运算结果一定是boolean值
true或者false。 -
其中>,<,>=,<=不支持boolean，String类型，==和!=支持boolean和String。
-
上面的一个说明换句话说
- > ,<,>=,<= 只能使用在数值类型的数据之间
- == 和 != 不仅可以使用在数值类型数据之间，还可以使用在其他引用类型变量之间。
-
区分 == 和 =
1.10.3.1 比较运算符代码演示
package com.atguigu.java2;
/*
运算符之三：比较运算符
== != > < >= <= instanceof
结论：
1.比较运算符的结果是boolean类型
2.区分 == 和 =
3.> < >= <= :只能使用在数值类型的数据之间。
4. == 和 !=: 不仅可以使用在数值类型数据之间，还可以使用在其他引用类型变量之间。
*/
public class CompareTest {
public static void main(String[] args) {
// 区分 == 和 =
int i1 = 10;
int i2 = 20;
System.out.println(i1 == i2);
System.out.println(i1 = i2); // 20
int i3 = 10;
int i4 = 20;
System.out.println(i3 == i4);
System.out.println(i3 != i4);
System.out.println(i3 > i4);
System.out.println(i3 < i4);
System.out.println(i3 >= i4);
System.out.println(i3 <= i4);
}
}
1.10.4 逻辑运算符
- 逻辑运算符操作的都是boolean类型的变量，其结果也是boolean类型
- && 与 &的区别
- 相同点1：& 与 && 的运算结果相同
- 相同点2：当符号左边是true时，二者都会执行符号右边的运算
- 不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
- 开发中，推荐使用&&
- || 与 |的区别
- 相同点1：| 与 || 的运算结果相同
- 相同点2：当符号左边是false时，二者都会执行符号右边的运算
- 不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
- 开发中，推荐使用||
1.10.4.1 逻辑运算符代码演示
package com.atguigu.java2;
/*
运算符之四：逻辑运算符
& && | || ! ^
说明：
1.逻辑运算符操作的都是boolean类型的变量
2.其运算结果也是boolean类型
*/
public class LogicTest {
public static void main(String[] args) {
boolean bool1 = false;
boolean bool2 = true;
// !
System.out.println(!bool2);
// ^
System.out.println(bool1 ^ bool2);
// *****************************************
// 区分& 与 &&
// 相同点1：& 与 && 的运算结果相同
// 相同点2：当符号左边是true时，二者都会执行符号右边的运算
// 不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
// 开发中，推荐使用&&
// &
boolean b1 = true;
b1 = false;
int i1 = 10;
if (b1 & (i1++ > 0)) {
System.out.println("我在北京");
} else {
System.out.println("我在广州");
}
System.out.println("i1 = " + i1);
// &&
boolean b2 = true;
b2 = false;
int i2 = 10;
if (b2 && (i2++ > 0)) {
System.out.println("我在北京");
} else {
System.out.println("我在广州");
}
System.out.println("i2 = " + i2);
// *****************************************
// 区分：| 与 ||
// 相同点1：| 与 || 的运算结果相同
// 相同点2：当符号左边是false时，二者都会执行符号右边的运算
// 不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
// 开发中，推荐使用||
boolean b3 = false;
b3 = true;
int i3 = 20;
if(b3 | (i3++ > 0)){
System.out.println("我在深圳");
}else{
System.out.println("我在上海");
}
System.out.println("i3 = " + i3);
boolean b4 = false;
b4 = true;
int i4 = 20;
if(b4 || (i4++ > 0)){
System.out.println("我在深圳");
}else{
System.out.println("我在上海");
}
System.out.println("i4 = " + i4);
}
}
1.10.5 位运算符
| 位运算符 | 符号解释 |
|---|---|
& | 按位与，当两位相同时为1时才返回1 |
| | 按位或，只要有一位为1即可返回1 |
~ | 按位非，将操作数的每个位（包括符号位）全部取反 |
^ | 按位异或。当两位相同时返回0，不同时返回1 |
<< | 左移运算符 |
>> | 右移运算符 |
>>> | 无符号右移运算符 |
1.10.5.1 位运算符细节
1.10.5.2 位运算符代码演示
package com.atguigu.java2;
/*
运算符之五：位运算符 （了解）
& | ^ ~
<< >> >>>
结论：
1. 位运算符操作的都是整型的数据
2. << ：在一定范围内，每向左移1位，相当于 * 2
>> :在一定范围内，每向右移1位，相当于 / 2
面试题：最高效方式的计算2 * 8 ？ 2 << 3 或 8 << 1
*/
public class BitTest {
public static void main(String[] args) {
// & | ^ ~
int i1 = 12;
int i2 = 5;
// 把数据化成二进制，按位操作
System.out.println(i1 & i2);
System.out.println(i1 | i2);
System.out.println(i1 ^ i2);
System.out.println(~i2);
//******************************************
// <<：在一定范围内，每向左移1位，相当于 * 2(在二进制的层面，左移)
int i3 = 12;
System.out.println(i3 << 2);
// 超出范围会变成一个极大或极小的数
System.out.println(i3 << 28); // -1073741824
//******************************************
// >>:>> :在一定范围内，每向右移1位，相当于 / 2
// 被移位的二进制最高位是0，右移后，空缺位补0； 最高位是1，空缺位补1。
int i4 = 12;
int i5 = -12;
System.out.println(i4 >> 2);
System.out.println(i5 >> 2);
// >>>:被移位二进制最高位无论是0或者是1，空缺位都用0补。
int i6 = 5;
int i7 = -5;
System.out.println(i6 >>> 2);
System.out.println(i7 >>> 2); // 1073741822
}
}
1.10.5.3 交换两个数的三种方式
package com.atguigu.java2;
/*
* 交换两个数
*
*
*/
public class Swap {
public static void main(String[] args) {
// 方式一：使用临时变量
int i = 10;
int j = 20;
System.out.println("i = " + i + " j = " + j);
int temp = i;
i = j;
j = temp;
System.out.println("i = " + i + " j = " + j);
// ***********************************************
// 方式二：好处：不用定义临时变量
// 弊端：① 相加操作可能超出存储范围 ② 有局限性：只能适用于数值类型
int i1 = 10;
int j1 = 20;
System.out.println("i1 = " + i1 + " j1 = " + j1);
i1 = i1 + j1;
j1 = i1 - j1;
i1 = i1 - j1;
System.out.println("i1 = " + i1 + " j1 = " + j1);
// ***********************************************
// 方式三：使用位运算符
// 有局限性：只能适用于数值类型
int i2 = 10;
int j2 = 20;
System.out.println("i2 = " + i2 + " j2 = " + j2);
i2 = i2 ^ j2;
j2 = i2 ^ j2;
i2 = i2 ^ j2;
System.out.println("i2 = " + i2 + " j2 = " + j2);
}
}
1.10.6 三元运算符
- 三元运算符格式：
(条件表达式)？表达式1：表达式2
- 条件表达式的结果为boolean类型
- 三元运算符计算方式：
- 条件判断的结果是true，条件运算符整体结果为表达式1，赋值给变量。
- 判断条件的结果是false，条件运算符整体结果为表达式2，赋值给变量。
- 表达式1和表达式2要求是一致的(兼容，类型能满足自动类型转换)。
- 三元运算符可以嵌套使用
- 三元运算符和if-else结构的联系
- 凡是可以使用三元运算符的地方，都可以改写为if-else。反之，不成立。
- 如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁、执行效率高。
1.10.6.1 三元运算符代码演示
package com.atguigu.java2;
/*
运算符之六：三元运算符
1.结构：(条件表达式)? 表达式1 : 表达式2
2. 说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假，决定执行表达式1，还是表达式2.
如果表达式为true，则执行表达式1。
如果表达式为false，则执行表达式2。
③ 表达式1 和表达式2要求是一致的(兼容，类型能满足自动类型转换)。
④ 三元运算符可以嵌套使用
3.
凡是可以使用三元运算符的地方，都可以改写为if-else
反之，不成立。
4. 如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁、执行效率高。
*/
public class SanYuanTest {
public static void main(String[] args) {
//获取两个整数的较大值
int i1 = 10;
int i2 = 20;
int max = (i1 > i2)? i1 : i2;
System.out.println(max);
// 嵌套使用三元运算符
int i3 = 30;
int i4 = 30;
String max1 = (i3 > i4)? "i3大" :((i3 == i4)? "i3 == i4" : "i4大");
System.out.println(max1);
//*******************************************************
//获取三个数的最大值
int i = 10;
int j = 20;
int k = 30;
int max2 = (i > j)? i : j;
int max3 = (max2 > k)? max2 : k;
System.out.println(max3);
}
}
1.10.7 运算符的优先级
提示说明：
（1）表达式不要太复杂
（2）先算的使用()
大体的排序：算术->位–>比较–>逻辑–>三元–>赋值
写为if-else。反之，不成立。
- 如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁、执行效率高。
1.10.6.1 三元运算符代码演示
package com.atguigu.java2;
/*
运算符之六：三元运算符
1.结构：(条件表达式)? 表达式1 : 表达式2
2. 说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假，决定执行表达式1，还是表达式2.
如果表达式为true，则执行表达式1。
如果表达式为false，则执行表达式2。
③ 表达式1 和表达式2要求是一致的(兼容，类型能满足自动类型转换)。
④ 三元运算符可以嵌套使用
3.
凡是可以使用三元运算符的地方，都可以改写为if-else
反之，不成立。
4. 如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁、执行效率高。
*/
public class SanYuanTest {
public static void main(String[] args) {
//获取两个整数的较大值
int i1 = 10;
int i2 = 20;
int max = (i1 > i2)? i1 : i2;
System.out.println(max);
// 嵌套使用三元运算符
int i3 = 30;
int i4 = 30;
String max1 = (i3 > i4)? "i3大" :((i3 == i4)? "i3 == i4" : "i4大");
System.out.println(max1);
//*******************************************************
//获取三个数的最大值
int i = 10;
int j = 20;
int k = 30;
int max2 = (i > j)? i : j;
int max3 = (max2 > k)? max2 : k;
System.out.println(max3);
}
}
1.10.7 运算符的优先级
提示说明：
（1）表达式不要太复杂
（2）先算的使用()
大体的排序：算术->位–>比较–>逻辑–>三元–>赋值
这篇关于第二章、Java基本语法(上)：变量与运算符的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
Java中定时任务实现方式及源码剖析11-24
-
Java中定时任务实现方式及源码剖析11-24
-
鸿蒙原生开发手记：03-元服务开发全流程（开发元服务，只需要看这一篇文章）11-24
-
细说敏捷：敏捷四会之每日站会11-24
-
Springboot应用的多环境打包入门11-23
-
Springboot应用的生产发布入门教程11-23
-
Python编程入门指南11-23
-
Java创业入门：从零开始的编程之旅11-23
-
Java创业入门：新手必读的Java编程与创业指南11-23
-
Java对接阿里云智能语音服务入门详解11-23
-
Java对接阿里云智能语音服务入门教程11-23
-
JAVA对接阿里云智能语音服务入门教程11-23
-
Java副业入门：初学者的简单教程11-23
-
JAVA副业入门：初学者的实战指南11-23
-
JAVA项目部署入门：新手必读指南11-23
栏目导航
