S01-03 基础-基础语言结构
[TOC]
注释
注释：源文件中用于解释、说明程序的文字就是注释。
注释是一个程序员必须要具有的良好编程习惯。实际开发中，程序员可以先将自己的思想通过注释整理出来，再用代码去体现。
程序员最讨厌两件事：
一件是自己写代码被要求加注释
另一件是接手别人代码，发现没有注释
Java 中的注释类型：
单行注释：
// 注释文字多行注释：
/* 注释文字1 注释文字2 注释文字3 */文档注释 (Java 特有)：
/** @author 指定java程序的作者 @version 指定源文件的版本 */
注释的作用：
- 它提升了程序的可阅读性。
- 调试程序的重要方法。
注释的特性：
不会被解释执行：
被注释的文字不会出现在字节码文件中，进而不会被 JVM（java 虚拟机）解释执行。
多行注释里面不允许嵌套多行注释：
文档注释可以通过
javadoc生成 HTML 文档：文档注释内容可以被 JDK 提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。
shjavadoc -d mydoc -author -version HelloWorld.java
示例：
//单行注释
/*
多行注释
*/
/**
文档注释演示。这是我的第一个Java程序！^_^
@author songhk
@version 1.0
*/
public class HelloWorld{
/**
Java程序的入口
@param args main方法的命令参数
*/
public static void main(String[] args){
System.out.println("hello");
}
}关键字 keyword@
关键字（keyword）：是被 Java 语言赋予特定含义的保留字，用于定义程序结构、数据类型、流程控制等核心逻辑。这些关键字不能作为变量名、方法名、类名或标识符，且大小写敏感（所有关键字均为小写）。
- HelloWorld 案例中，出现的关键字有
public、class、static、void等，这些单词已经被 Java 定义好了。
关键字使用规则：
- 大小写敏感：所有关键字均为小写（如
class正确，Class错误，Class是类名）。 - 不能作为标识符：关键字不能用作变量名、方法名、类名、包名等（如
int int = 10;错误）。 - 部分关键字有多重含义：
default：既可以是switch的默认分支，也可以是接口的默认方法修饰符。final：可修饰类、方法、变量，含义不同但核心是 “不可变”。
- 保留字不可用：
const和goto虽未被 Java 使用，但属于保留字，不能作为标识符。
关键字比较多，不需要死记硬背，学到哪里记到哪里即可。
官方地址： https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html
说明：
- 关键字一共50 个，其中
const和goto是保留字(reserved word)。true，false，null不在其中，它们看起来像关键字，其实是字面量，表示特殊的布尔值和空值。
标识符 identifier
标识符（identifier）：是用来给 Java 程序中的变量、方法、类、接口、包等元素命名的符号。简单来说，标识符就是你在写代码时为各种 “东西” 起的名字。
示例：
public class HelloWorld { // HelloWorld 是类名标识符
public static void main(String[] args) { // main 是方法名标识符，args 是变量名标识符
String message = "Hello"; // message 是变量名标识符
}
}标识符的命名规则（必须遵守的硬性规定，否则编译不通过）：
由合法字符组成：
标识符可以由 字母（a-z, A-Z）、数字（0-9）、下划线（_） 和 美元符号（$） 组成。
注意：不能以数字开头。
注意：不能包含空格。
大小写敏感 (Case-Sensitive)：
Java 是大小写敏感的语言。这意味着
age、Age和AGE是三个完全不同的标识符。不能使用关键字和保留字：
标识符不能是 Java 中预定义的关键字（如
class,public,int,if）或保留字（如goto,const）。这些词已经被 Java 语言本身占用了。长度没有限制：
从语法上讲，Java 标识符的长度没有上限。
最佳实践：但为了代码的可读性和可维护性，标识符应该简洁明了，通常建议在 1-20 个字符之间。
练习：miles、Test、a++、 --a、4#R、$4、 #44、apps、class、public、int、x、y、radius
标识符的命名规范（建议遵守的软性要求，否则工作时容易被鄙视）:
包名：
全小写字母，使用点（
.）分隔，通常采用反向域名的形式，以保证唯一性。：xxxyyyzzz。例如：java.lang、com.atguigu.bean
类名、接口名：
采用PascalCase（帕斯卡命名法，大驼峰），多单词组成时，所有单词的首字母大写：XxxYyyZzz
例如：HelloWorld，String，System 等
变量名、方法名：
采用camelCase（驼峰命名法，小驼峰），多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
例如：age,name,bookName,main,binarySearch,getName
常量名：
所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
例如：MAX_VALUE, PI, DEFAULT_CAPACITY
注意 1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
注意 2：java 采用 unicode 字符集，因此标识符也可以使用汉字声明，但是不建议使用汉字。
更多细节详见《代码整洁之道.pdf》《阿里巴巴 Java 开发手册-1.7.1-黄山版》
变量
一花一世界，如果把一个程序看做一个世界或一个社会的话，那么变量就是程序世界的花花草草、万事万物。即，变量是程序中不可或缺的组成单位，最基本的存储单元。
初识变量
变量：是 Java 程序中存储数据的基本单元，你可以把它想象成一个有名字的容器，这个容器里可以存放不同类型的数据，并且数据的值可以在程序运行过程中被修改。也可以在同一类型范围内不断变化。
变量的定义与构成：
一个完整的变量定义包含三个核心要素：数据类型、变量名和值。
// 数据类型 变量名 = 值;
int age = 25;
String name = "张三";数据类型 (Data Type)：
- 决定了变量可以存储什么样的数据（例如整数、小数、文本等）。
- 决定了变量在内存中占用的空间大小。
- Java 是一种强类型语言，变量在声明时必须明确指定其数据类型，并且赋值时的数据类型必须与声明的类型匹配（或可以自动转换）。
变量名 (Variable Name)：
- 是变量的唯一标识，用于在程序中引用这个变量。
- 命名必须遵循 Java 的标识符命名规则：
- 可以由字母、数字、下划线
_和美元符号$组成。 - 不能以数字开头。
- 不能是 Java 关键字（如
int,class,public等）。 - 大小写敏感（
age和Age是两个不同的变量）。
- 可以由字母、数字、下划线
- 命名规范（建议）：
- 采用 驼峰命名法 (camelCase)：第一个单词首字母小写，后续单词首字母大写，如
userName,totalPrice。 - 见名知意：变量名应能清晰地表达其用途，避免使用
a,b,c等无意义的名称。
- 采用 驼峰命名法 (camelCase)：第一个单词首字母小写，后续单词首字母大写，如
值 (Value)：
是变量存储的具体数据。
在声明变量时可以立即赋值（初始化），也可以先声明后赋值。
java// 方式1：声明时初始化 int score = 95; // 方式1：先声明，后赋值 String address; address = "北京市"; // 赋值语句
变量的作用域：仅限于定义它的方法或代码块{}内部。出了这个范围，变量就会被销毁，无法访问。同一个作用域内，不能定义重名的变量。
变量的数据类型
Java 中变量的数据类型分为两大类：
基本数据类型（8 个）：包括整数类型、浮点数类型、字符类型、布尔类型。引用数据类型（6 个）：包括数组、类、接口、枚举、注解、记录。
变量的使用
步骤 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 = "迪丽热巴";内存结构如图：
基本数据类型@
变量的数据类型决定了在内存中开辟多大空间。
变量的数据类型也决定了该变量可以存什么值。
整数类型：byte、short、int、long
- Java 各整数类型有固定的表数范围和字段长度，不受具体 OS 的影响，以保证 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
浮点类型：float、double
- 与整数类型类似，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 的负次幂。
不要使用浮点数进行
比较！很多新人甚至很多理论不扎实的有工作经验的程序员也会犯这个错误！需要比较请使用BigDecimal类（后续内容讲）。浮点类型 float、double 的数据不适合在
不容许舍入误差的金融计算领域。如果需要精确数字计算或保留指定位数的精度，需要使用BigDecimal类。测试用例：
//测试1：（解释见章末企业真题：为什么0.1 + 0.2不等于0.3）
System.out.println(0.1 + 0.2);//0.30000000000000004
//测试2：
float ff = 0.1f;
double dd = 1.0/10;
System.out.println(ff == dd);//
//测试3：
float ff1 = 123123123f;
float ff2 = ff1 + 1;
System.out.println(ff1);
System.out.println(ff2);
System.out.println(ff1 == ff2);应用举例
案例 1：定义圆周率并赋值为 3.14，现有 3 个圆的半径分别为 1.2、2.5、6，求它们的面积。
/**
* @author 尚硅谷-宋红康
* @create 12:36
*/
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);
}
}案例 2：小明要到美国旅游，可是那里的温度是以华氏度为单位记录的。 它需要一个程序将华氏温度（80 度）转换为摄氏度，并以华氏度和摄氏度为单位分别显示该温度。
℃ = (℉ - 32) / 1.8/**
* @author 尚硅谷-宋红康
* @create 12:51
*/
public class Exercise2 {
public static void main(String[] args) {
double hua = 80;
double she = (hua-32)/1.8;
System.out.println("华氏度" + hua+"℉转为摄氏度是" +she+"℃");
}
}字符类型：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 - 形式 1：使用单引号（
char 类型是可以进行运算的。因为它都对应有 Unicode 码。
布尔类型：boolean
boolean 类型用来判断逻辑条件，一般用于程序流程控制语句中：
- if 条件控制语句；
- while 循环控制语句；
- for 循环控制语句；
- do-while 循环控制语句；
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分支
}经验之谈：
Less is More！建议不要这样写：if ( isFlag = = true )，只有新手才如此。关键也很容易写错成 if(isFlag = true)，这样就变成赋值 isFlag 为 true 而不是判断！
老鸟的写法是 if (isFlag)或者 if ( !isFlag)。
类型转换
在 Java 程序中，不同的基本数据类型的值经常需要进行相互转换。Java 语言所提供的七种基本数据类型（不包括 boolean 类型） 之间可以相互转换，基本数据类型转换有两种转换方式：自动类型提升和强制类型转换。
自动类型提升
规则：将取值范围小（或容量小）的类型自动提升为取值范围大（或容量大）的类型 。
基本数据类型的转换规则如图所示：
（1）当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时
int i = 'A';//char自动升级为int，其实就是把字符的编码值赋值给i变量了
double d = 10;//int自动升级为double
long num = 1234567; //右边的整数常量值如果在int范围呢，编译和运行都可以通过，这里涉及到数据类型转换
//byte bigB = 130;//错误，右边的整数常量值超过byte范围
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声明 long 类型省略L后缀原理：
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;练习：
设 x 为float型变量，y为double型变量，a为int型变量，b为long型变量，c为char型变量，则表达式
x + y * a / x + b / y + c的值类型为：
A. int B. long C. double D. char强制类型转换
将3.14 赋值到int 类型变量会发生什么？产生编译失败，肯定无法赋值。
int i = 3.14; // 编译报错想要赋值成功，只有通过强制类型转换，将double 类型强制转换成int 类型才能赋值。
强制类型转换（Explicit Type Conversion）：是 Java 中一种显式的类型转换方式，用于将一个数据类型的值转换为另一个不兼容或范围更小的数据类型。
这种转换可能导致精度丢失或数据溢出，Java 编译器不会自动执行，必须由程序员手动指定。
语法格式：
通过括号 () 包裹目标类型，将一个表达式的值从一种类型强制转换为另一种类型。
目标数据类型 变量名 = (目标数据类型) 源数据或变量;基本数据类型的强制转换：
转换规则：将范围大、精度高的类型向范围小、精度低的类型转换。
// 1. double -> int (丢失小数部分)
double pi = 3.14159;
int intPi = (int) pi; // 结果为 3 (小数部分被舍弃)
// 2. float -> long (丢失小数部分)
float f = 123.45f;
long longF = (long) f; // 结果为 123
// 3. long -> int (可能溢出)
long bigLong = 1234567890123L;
int intFromLong = (int) bigLong; // 结果取决于 bigLong 的值是否在 int 范围内
// 4. int -> byte (可能溢出)
int largeInt = 200;
byte byteFromInt = (byte) largeInt; // 结果为 -56 (因为 200 超出了 byte 的范围 -128~127)注意事项：
数据精度丢失与溢出：
精度丢失：当浮点类型转换为整数类型时，小数部分会被直接舍弃，而不是四舍五入。
javadouble d1 = 12.7; int i1 = (int) d1; // 结果为 12 (小数部分被直接舍弃，而不是四舍五入)数据溢出：当一个大数值转换为小范围类型时，超出小范围类型表示范围的值会按照模运算进行处理，导致结果不正确。
javaint largeInt = 128; byte byteFromInt = (byte) largeInt; // 结果为 -128 (因为 128 超出了 byte 的范围 -128~127)模运算：int 转 byte 后会截除高位的 3 个字节，只剩 1 个字节。此时最高位为
1，就变成了负数。
boolean类型不能转换：boolean类型不能与任何其他基本数据类型进行强制转换。转换必须在兼容类型之间进行：
例如，不能将一个
String类型强制转换为int类型（需要使用Integer.parseInt()方法）。可以通过强制类型转换提升数据类型：
当某个值想要提升数据类型时，也可以使用强制类型转换。这种情况的强制类型转换是没有风险的，通常省略。
java// int -> double（提升数据类型） int i = 1; int j = 2; double bigger = (double)(i/j);
练习：判断是否能通过编译
1）short s = 5;
s = s-2; //判断：n
2） byte b = 3;
b = b + 4; //判断：n
b = (byte)(b+4); //判断：y
3）char c = ‘a’;
int i = 5;
float d = .314F;
double result = c+i+d; //判断：y
4） byte b = 5;
short s = 3;
short t = s + b; //判断：n问答：为什么标识符的声明规则里要求不能数字开头？
如果允许数字开头，则如下的声明编译就可以通过：
int 123L = 12;
进而，如下的声明中l的值到底是123？还是12呢？ 出现歧义了。
long l = 123L;与 String 的运算
字符串类型：String：
- String 不是基本数据类型，属于引用数据类型
- 使用一对
""来表示一个字符串，内部可以包含0 个、1 个或多个字符。 - 声明方式与基本数据类型类似。例如：
String str = "尚硅谷";
运算规则：
任意八种基本数据类型的数据与 String 类型只能进行连接“+”运算，且结果一定也是 String 类型
javaSystem.out.println("" + 1 + 2);// 12 int num = 10; boolean b1 = true; String s1 = "abc"; System.out.println(s1 + num + b1);// abc10true System.out.println(num + b1 + s1);// 编译不通过：num+b1是加法运算，不是连接运算，布尔类型不能参与加法运算 System.out.println(num + (b1 + s1));// 编译通过：10trueabcString 类型不能通过()强制类型转换为其他的类型，只能通过
Integer.parseInt()转换。javaString str = "123"; int num = (int)str;//错误的 int num = Integer.parseInt(str);//正确的，后面才能讲到，借助包装类的方法才能转
案例：公安局身份登记
要求填写自己的姓名、年龄、性别、体重、婚姻状况（已婚用 true 表示，单身用 false 表示）、联系方式等等。
/**
* @author 尚硅谷-宋红康
* @create 12:34
*/
public class Info {
public static void main(String[] args) {
String name = "康师傅";
int age = 37;
char gender = '男';
double weight = 145.6;
boolean isMarried = true;
String phoneNumber = "13112341234";
System.out.println("姓名：" + name);
System.out.println("年龄：" + age);
System.out.println("性别：" + gender);
System.out.println("体重：" + weight);
System.out.println("婚否：" + isMarried);
System.out.println("电话：" + phoneNumber);
System.out.println("name = " + name + ",age = " + age + "，gender = " +
gender + ",weight = " + weight + ",isMarried = " + isMarried +
",phoneNumber = " + phoneNumber);
}
}练习：
练习 1：
String str1 = 4; //判断对错：N
String str2 = 3.5f + “”; //判断str2对错：Y
System.out.println(str2); //输出：3.5
System.out .println(3+4+“Hello!”); //输出：7Hello!
System.out.println(“Hello!”+3+4); //输出：Hello!34
System.out.println(‘a’+1+“Hello!”); //输出：98Hello!
System.out.println(“Hello”+‘a’+1); //输出：Helloa1练习 2：
System.out.println("* *"); //输出：* *
System.out.println("*\t*"); //输出：* *
System.out.println("*" + "\t" + "*"); //输出：
System.out.println('*' + "\t" + "*"); //输出：
System.out.println('*' + '\t' + "*"); //输出：
System.out.println('*' + "\t" + '*'); //输出：
System.out.println("*" + '\t' + '*'); //输出：
System.out.println('*' + '\t' + '*'); //输出：运算符
什么是运算符
运算符：是一种特殊的符号，用以表示数据的运算、赋值和比较等。
运算符的分类：
按照功能分为：
算术运算符、赋值运算符、比较(或关系)运算符、逻辑运算符、位运算符、条件运算符、Lambda 运算符
分类 运算符 算术运算符（7 个） +、-、*、/、%、++、-- 赋值运算符（12 个） =、+=、-=、*=、/=、%=、>>=、<<=、>>>=、&=、|=、^=等 比较(或关系)运算符（6 个） >、>=、<、<=、==、!= 逻辑运算符（6 个） &、|、^、!、&&、|| 位运算符（7 个） &、|、^、~、<<、>>、>>> 条件运算符（1 个） (条件表达式)?结果 1:结果 2 Lambda 运算符（1 个） ->（后面学） 按照操作数个数分为：
一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符 （三目运算符）
分类 运算符 一元运算符（单目运算符） 正号（+）、负号（-）、++、--、!、~ 二元运算符（双目运算符） 除了一元和三元运算符剩下的都是二元运算符 三元运算符 （三目运算符） (条件表达式)?结果 1:结果 2
算术运算符
基本语法
举例 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);
}
}案例与练习
案例 1：
随意给出一个整数，打印显示它的个位数，十位数，百位数的值。
格式如下：
数字xxx的情况如下：
个位数：
十位数：
百位数：
例如：
数字153的情况如下：
个位数：3
十位数：5
百位数：1/**
* @author 尚硅谷-宋红康
* @create 12:20
*/
class ArithmeticExer1 {
public static void main(String[] args) {
int num = 187;
int bai = num / 100;
int shi = num % 100 / 10;//int shi = num / 10 % 10;
int ge = num % 10;
System.out.println("百位为：" + bai);
System.out.println("十位为：" + shi);
System.out.println("个位为：" + ge);
}
}拓展：获取一个四位数的个位，十位，百位，千位
/**
* @author 尚硅谷-宋红康
* @create 12:39
*/
public class ArithmeticExer01 {
public static void main (String [] args) {
//1.定义一个变量，赋值为一个四位数整数，例如1234
int num = 1234;
//2.通过运算操作求出个位，十位，百位，千位
int ge = num % 10;
int shi = num /10 % 10;
int bai = num /100 % 10;
int qian = num / 1000 % 10;
System.out.println("个位上的数字是：" + ge);
System.out.println("十位上的数字是：" + shi);
System.out.println("百位上的数字是：" + bai);
System.out.println("千位上的数字是：" + qian);
}
}案例 2：为抵抗洪水，战士连续作战 89 小时，编程计算共多少天零多少小时？
/**
* @author 尚硅谷-宋红康
* @create 17:47
*/
public class ArithmeticExer2 {
public static void main(String[] args){
int hours = 89;
int day = hours / 24;
int hour = hours % 24;
System.out.println("为抵抗洪水，战士连续作战89小时：");
System.out.println(hours + "是" + day + "天" + hour +"小时");
}
}练习 1：算术运算符：自加、自减
public class ArithmeticExer3{
public static void main(String[] args){
int i1 = 10;
int i2 = 20;
int i = i1++;
System.out.print("i="+i); //10
System.out.println("i1="+i1);//11
i = ++i1;
System.out.print("i="+i);//12
System.out.println("i1="+i1);//12
i = i2--;
System.out.print("i="+i);//20
System.out.println("i2="+i2);//19
i = --i2;
System.out.print("i="+i);//18
System.out.println("i2="+i2);//18
}
}练习 2：
System.out.println("5+5=" + 5 + 5); //打印结果是？ 5+5=55 ?练习 3：
byte bb1 = 127;
bb1++;
System.out.println("bb1 = " + bb1);//-128练习 4：
int i = 1;
int j = i++ + ++i * i++;
System.out.println("j = " + j);练习 5：（企业真题）写出下列程序的输出结果
int m = 2;
m = m++; //(1)先取b的值“2”放操作数栈 (2)m再自增,m=3 (3)再把操作数栈中的"2"赋值给m,m=2
System.out.println(m);
int n = m++;
System.out.println(n);赋值运算符
基本语法
符号：=
类型转换：当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
javaint i1 = 10; long l1 = i1; // 自动类型转换 byte bb1 = (byte)i1; // 强制类型转换支持连续赋值。
java// 连续赋值的测试 // 写法一：正常写法 int a1 = 10; int b1 = 10; // 写法二：连续赋值写法 int a2, b2; a2 = b2 = 10; // 写法三：多重变量声明 int a3 = 10, b3 = 20;
扩展赋值运算符： +=、 -=、*=、 /=、%=
| 赋值运算符 | 符号解释 |
|---|---|
+= | 将符号左边的值和右边的值进行相加操作，最后将结果赋值给左边的变量 |
-= | 将符号左边的值和右边的值进行相减操作，最后将结果赋值给左边的变量 |
*= | 将符号左边的值和右边的值进行相乘操作，最后将结果赋值给左边的变量 |
/= | 将符号左边的值和右边的值进行相除操作，最后将结果赋值给左边的变量 |
%= | 将符号左边的值和右边的值进行取余操作，最后将结果赋值给左边的变量 |
示例：
+=示例：类似于m1 = m1 + 5，但不等同。m1 += 5：该写法不会改变 m1 的 short 类型。m1 = m1 + 5：该写法由于和 int 类型的 5 运算，会改变 m1 的类型为 int，再将 init 类型的值赋值给 short 类型，编译不会通过。
java// 举例说明：+= -= *= /= %= short m1 = 10; m1 += 5; // 类似于 m1 = m1 + 5 的操作，但不等同 System.out.println(m1);// 15
练习：
开发中，如何实现一个变量+2 的操作呢？
java//写法1：s1 += 2(推荐) short s1 = 10; s1 += 2; //编译通过，因为在得到int类型的结果后，JVM自动完成一步强制类型转换，将int类型强转成short System.out.println(s1);//12 //写法2：s2 = s2 + 2 short s2 = 10; //s2 = s2 + 2;// 编译报错，因为将int类型的结果赋值给short类型的变量s时，可能损失精度 s2 = (short)(s2 + 2); // 正确写法 System.out.println(s2);开发中，如何实现一个变量+1 的操作呢？
java//写法1：num1++（推荐） int num1 = 10; num1++; System.out.println(num1); //写法2：num2 += 1 int num2 = 10; num2 += 1; System.out.println(num2); //写法3：num3 = num3 + 1 int num3 = 10; num3 = num3 + 1; System.out.println(num3);
练习
练习 1：
short s = 3;
s = s+2; //① 编译报错
s += 2; //② 正常执行
//①和②有什么区别？练习 2：
int i = 1;
i *= 0.1;
System.out.println(i);//0
i++;
System.out.println(i);//1练习 3：
int m = 2;
int n = 3;
n *= m++; //n = n * (m++)
System.out.println("m=" + m);
System.out.println("n=" + n);练习 4：
int n = 10;
n += (n++) + (++n); //n = n + (n++) + (++n)
System.out.println(n);练习 5：
int j = 1;
j += ++j * j++;//相当于 j = j + (++j * j++);
System.out.println(j);//5练习 6：你有几种办法实现变量值 - 1？变量值-2 呢？
/**
* @author 尚硅谷-宋红康
* @create 16:55
*/
public class MinusTest {
public static void main(String[] args) {
//练习①：变量-1
short s = 10;
//方式1：
//s = (short)(s - 1);
//方式2：推荐
s--; // --s
//方式3：
s -= 1;
//练习②：变量-2
short s1 = 10;
//方式1：
//s1 = (short)(s1 - 2);
//方式2：推荐
s1 -= 2;
}
}关系(比较)运算符
运算结果：比较运算符的结果都是boolean类型，也就是要么是 true，要么是 false。
适用数据类型：
== != > < >= <=：只适用于基本数据类型（除 boolean 类型之外，== !=适用于布尔类型）== !=：适用于基本数据类型和引用数据类型
比较运算符“==”不能误写成“=”
示例：
关系运算符的基本使用
java// 关系运算符的基本使用 int i1 = 10; int i2 = 20; System.out.println(i1 == i2);//false System.out.println(i1 != i2);//true System.out.println(i1 >= i2);//false== 和 = 的区别
java// == 和 = 的区别 int m = 10; int n = 20; System.out.println(m == n);//false System.out.println(m = n);//20boolean 类型不能参与比较运算
java// boolean 类型不能参与比较运算 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)
System.out.println("结果为真");
else
System.out.println("结果为假");逻辑运算符
基本语法
逻辑运算符：操作的都是 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);
}
}案例与练习
案例：
1. 定义类 CompareLogicExer
2. 定义 main方法
3. 定义一个int类型变量a,变量b,都赋值为20
4. 定义boolean类型变量bo1 , 判断++a 是否被3整除,并且a++ 是否被7整除,将结果赋值给bo1
5. 输出a的值,bo1的值
6. 定义boolean类型变量bo2 , 判断b++ 是否被3整除,并且++b 是否被7整除,将结果赋值给bo2
7. 输出b的值,bo2的值/**
* @author 尚硅谷-宋红康
* @create 12:42
*/
public class CompareLogicExer {
public static void main(String[] args){
int a = 20;
int b = 20;
boolean bo1 = ((++a % 3) == 0) && ((a++ % 7) == 0);
System.out.println("bo1的值：" + bo1);
System.out.println("a的值：" + a);
System.out.println("----------------------------");
boolean bo2 = ((b++ % 3) == 0) && ((++b % 7) == 0);
System.out.println("bo2的值：" + bo2);
System.out.println("b的值：" + b);
}
}练习：
**练习 1：**区分 & 和 &&
int x = 1;
int y = 1;
if(x++ == 2 & ++y == 2){
x = 7;
}
System.out.println("x=" + x + ",y=" + y);int x = 1,y = 1;
if(x++ == 2 && ++y == 2){
x =7;
}
System.out.println("x="+x+",y="+y);**练习 2：**区分 | 和 ||
int x = 1,y = 1;
if(x++==1 | ++y==1){
x =7;
}
System.out.println("x="+x+",y="+y);int x = 1,y = 1;
if(x++==1 || ++y==1){
x =7;
}
System.out.println("x="+x+",y="+y);**练习 3：**程序输出
class Test {
public static void main (String [] args) {
boolean x = true;
boolean y = false;
short z = 42;
//if(y == true)
if ((z++ == 42) && (y = true)) z++;
if ((x = false) || (++z == 45)) z++;
System.out.println("z=" + z);
}
}//结果为：
//z= 46位运算符（难点、非重点）@
基本语法
- 位运算符的运算过程都是基于二进制的补码运算
（1）左移：<<
运算规则：在一定范围内，数据每向左移动一位，相当于原数据*2。（正数、负数都适用）
【注意】当左移的位数 n 超过该数据类型的总位数时，相当于左移（n-总位数）位
byte,short,char 在计算时按照 int 类型处理
3<<4 类似于 3*2的4次幂 => 3*16 => 48
-3<<4 类似于 -3*2的4次幂 => -3*16 => -48
（2）右移：>>
运算规则：在一定范围内，数据每向右移动一位，相当于原数据/2。（正数、负数都适用）
【注意】如果不能整除，向下取整。
69>>4 类似于 69/2的4次 = 69/16 =4
-69>>4 类似于 -69/2的4次 = -69/16 = -5
（3）无符号右移：>>>
运算规则：往右移动后，左边空出来的位直接补 0。（正数、负数都适用）
69>>>4 类似于 69/2的4次 = 69/16 =4
-69>>>4 结果：268435451
（4）按位与：&
运算规则：对应位都是 1 才为 1，否则为 0。
1 & 1 结果为 1
1 & 0 结果为 0
0 & 1 结果为 0
0 & 0 结果为 0
9 & 7 = 1
-9 & 7 = 7
（5）按位或：|
运算规则：对应位只要有 1 即为 1，否则为 0。
1 | 1 结果为 1
1 | 0 结果为 1
0 | 1 结果为 1
0 & 0 结果为 0
9 | 7 //结果： 15
-9 | 7 //结果： -9
（6）按位异或：^
运算规则：对应位一个为 1 一个为 0，才为 1，否则为 0。
1 ^ 1 结果为 0
1 ^ 0 结果为 1
0 ^ 1 结果为 1
0 ^ 0 结果为 0
9 ^ 7 //结果为14
-9 ^ 7 //结果为-16
（7）按位取反：~
运算规则：对应位为 1，则结果为 0；对应位为 0，则结果为 1。
~0 就是 1
~1 就是 0
~9 //结果：-10
~-9 //结果：8
举例
举例 1：
举例 2：体会 m = k ^ n = (m ^ n) ^ n
案例
**案例 1：**高效的方式计算 2 * 8 的值
答案：2 << 3 、 8 << 1**案例 2：**变量换值：交换两个 int 型变量的值。 String 呢？
/**
* @author 尚硅谷-宋红康
* @create 16:58
*/
public class BitExer {
public static void main(String[] args) {
int m = 10;
int n = 5;
System.out.println("m = " + m + ", n = " + n);
//（推荐）实现方式1：优点：容易理解，适用于不同数据类型 缺点：需要额外定义变量
//int temp = m;
//m = n;
//n = temp;
//实现方式2：优点：没有额外定义变量 缺点：可能超出int的范围；只能适用于数值类型
//m = m + n; //15 = 10 + 5
//n = m - n;//10 = 15 - 5
//m = m - n;//5 = 15 - 10
//实现方式3：优点：没有额外定义变量 缺点：不易理解；只能适用于数值类型
m = m ^ n;
n = m ^ n; //(m ^ n) ^ n
m = m ^ n;
System.out.println("m = " + m + ", n = " + n);
}
}条件运算符
基本语法
- 条件运算符格式：
(条件表达式) ? 表达式1 : 表达式2说明：条件表达式是 boolean 类型的结果，根据 boolean 的值选择表达式 1 或表达式 2
表达式 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非正数");
}案例
**案例 1：**获取两个数中的较大值。
/**
* @author 尚硅谷-宋红康
* @create 12:40
*/
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：**获取三个数中的最大值。
/**
* @author 尚硅谷-宋红康
* @create 12:43
*/
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);
}
}**案例 3：**今天是周 2，10 天以后是周几？
要求：控制台输出"今天是周 2，10 天以后是周 x"。
/**
* @author 尚硅谷-宋红康
* @create 12:46
*/
public class ConditionExer3 {
public static void main(String[] args) {
int week = 2;
week += 10;
week %= 7;
System.out.println("今天是周2,10天以后是周" + (week == 0 ? "日" : week));
}
}案例 4：
给定一个年份，判断是否是闰年。输出"xxx年(是/不是)闰年"。
闰年的判断标准是：
1）可以被4整除，但不可被100整除
2）可以被400整除/**
* @author 尚硅谷-宋红康
* @create 12:49
*/
public class ConditionExer4 {
public static void main(String[] args) {
int year = 2018;
boolean isLeapYear = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
System.out.println(year + (isLeapYear ? "是闰年" : "不是闰年"));
}
}与 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);运算符优先级
运算符有不同的优先级，所谓优先级就是在表达式运算中的运算符顺序。
上一行中的运算符总是优先于下一行的。
| 优先级 | 运算符说明 | 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;- 逻辑与、逻辑或、逻辑非的优先级一定要熟悉！（
逻辑非 > 逻辑与 > 逻辑或）。如： a || b && c 的运算结果是：a || ( b && c )，而不是( a|| b ) && c