第二章基本语法
关键字
Java中定义了关键字如if、class、int 、string、main、、、等等均为小写，自己不能将关键字作为命名。
标识符
标识符的使用
- 标识符：凡是自己可以起名字的地方都叫标识符，比如：类名、变量名、方法名、接口名、报名、、
- 标识符的命名规则：
- 由26个英文字母大小写，0-9，_或$组成
- 数字不可以开头
- 不可以使用关键字和保留字，但能包含关键字和保留字
- Java中严格区分大小写，长度无限制
- 标识符不能包含空格
Java中命名规范
- 包名 ： 多单词组成时所有字母都小写：xxxyyyzzz
- 类名 、接口名： 多单词组成时，所有的首字母大写： XxxYyyZzz
- **变量名 、方法名：**多单词组成时，第一个首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
- **常量名：**所有字母都大写，多单词时每个单词用下划线连接：XXX_YYY_ZZZ
变量
- 基本数据类型
整型：byte、short、int、long
浮点型：float、double
字符型：char
布尔型：bool
- 引用数据类型
类（class） 其中字符串属于类
接口（interface）
数组（array）
byte占1字节表示范围-128~127
int占4个字节，可表示232 个数，既要表示正数和负数，则正数和负数各占231 个，再加一个0，所以表示范围即为
-231 ~231 -1
- 声明long型必须以"l"或"L"结尾
//定义变量时候为规范要多敲一个空格，或者说任意一个词中间都要隔开
long l1 = 3414234324L;
最常使用int即可
Java浮点型默认为double，声明float型时须后面加"f"或"F"
float：单精度，尾数可以精确到7位有效数字，很多时候很难满足需求。
double：双精度，精度是float的两倍，通常采用此类型
float占4字节表数范围-3.403E38~3.403E38[其中E表示科学计数法E38即为1038 ]比整型的long还大
double占8字节表数范围-1.798E308~1.798E308
char占2个字节（1字符=2字节）：定义char型变量通常使用一对’'单引号，内部只能写一个字符，要写多个只能用字符串
定义变量时候为规范要多敲一个空格，或者说任意一个词中间都要隔开
//定义变量时候为规范要多敲一个空格，或者说任意一个词中间都要隔开
char c1 = 'a';
char c2 = '1';
char c3 = '好';
//转义字符
char c4 = '\n';//换行符
char c5 = '\t';//制表符Tab
字符集说明
中文字符集GBK
国际字符集UTF-8
英文字符集ASCII码
为保证不出现乱码，保存文件和读文件的时候编码格式必须统一，命令行cmd默认使用GBK
基本数据类型之间的运算规则
- 自动类型提升：
当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
byte、char、short–>short–>int–>long–>float–>double
特别的：当byte、char、short三种类型的变量做运算时，结果为int型
- 强制类型转换
即自动类型提升运算的逆运算，1.需要使用强转符（）；2.注意点：强制类型转换，可能导致精度损失。
class VariableTest3{
public static void main(String[] args){
double d1 = 12.9;
//精度损失举例1
int i1 = (int)d1;//截断操作
System.out.println(i1);//12
//没有精度损失
long l1 = 123L;
short s2 = (short)l1;
System.out.println(s2);//123
//精度损失举例2
int i2 = 128;
byte b = (byte)i2;
System.out.println(b);//-128
}
}
//编码情况
long l1 = 123456;//当没有加“l”或“L”时其实是当作int型进行了自动提升运算
long l2 = 123123123123123123132L;//当超出int范围时必须加
float f1 = 12.3f;//float必须加
整型常量默认类型为int型，浮点型常量默认为double
String类型变量的使用：
-
String属于引用数据类型，翻译为：字符串
-
声明String类型变量时使用一对“”双引号
-
String可以和8种基本数据类型做运算，且运算只能是连接运算：+
-
运算的结果仍然是String类型
int number = 1001;
String numberStr = "学号";
String info = numberStr + number;//+:连接符
System.out.println(ingo);//学号：1001
//String str1 = 123;//编译不通过
String str1 = 123 + "";
System.out.println(str1);//"123"
//int num1 = str1;
//int num1 = (int)str1;//错误写法，不能用这种方法强转
//以下才是将字符串转化成整数的方法
int num1 = Integer.parseInt(str1);
System.out.println(num1);//123;
进制
- 二进制：以0b或0B开头
- 十进制：直接写
- 八进制：以数字0开头
- 十六进制：以0x或0X开头
二进制的整数有如下三种形式
- 原码：直接将一个数值换成二进制数。最高位是符号位
- 负数的补码：是对原码按位取反，只是最高位（符号位）确定为1
- 负数的补码：其反码加1
特别强调：计算机内部均是以二进制补码的形式保存所有的整数。
正数的原码、反码、补码都相同，（即三码相同）
负数的补码是其反码+1
已知计算机内的一个二进制数，求表示的十进制
计算机内给的都是补码，要算对应的十进制数应该先求出对应的原码。
当为正数时三码相同，当为负数时，通过补码求出反码再求原码
这就解释了
int num1 = 128;
byte num2 = (byte)num1;
System.out.println(num2);//-128
十进制—>二进制方法：除2取余的逆（整数部分）
小数部分用乘2取整法
运算符
- 除号：/
/*
注意运算符之间也要用空格隔开，美观
*/
int num1 = 12;
int num2 = 5;
int result1 = num1 / num2;//2
int result2 = num1 / num2 * num2;//10
double result3 = num1 / num2；//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
- 取余运算：%
//结果的符号与被模数的符号相同
//开发中经常使用%来判断能否被除尽的问题
int m1 = 12;
int n1 = 5;
System.out.println(m1 % n1);//2
int m2 = -12;
int n2 = 5;
System.out.println(m2 % n2);//-2
int m3 = 12;
int n3 = -5;
System.out.println(m3 % n3);//2
int m4 = -12;
int n4 = -5;
System.out.println(m4 % n4);//-2
（前）++
（后）++
++a;//先自增1，后运算
a++;//先运算，后自增1
特别的，自增1不会改变本身变量的数据类型，在代码中效率高
- 赋值运算符=、+=、-=、*=、/=、%=
其中+=、-=、*=、/=、%=不会改变变量本身的数据类型
int num1 = 10;
num1 += 2;//num1 = num1 + 2;
System.out.println(num1);//12
int num2 = 12;
num2 %= 5;//num2 = num2 % 5;
System.out.println(num2);//2
short s1 = 10;
//s1 = s1 + 2;//编译失败
s1 += 2;//结论：不会改变变量本身的数据类型
System.out.println(s1);//12
//开发中，如果希望变量实现+2的操作，有几种方法？（前提：int num = 10；）
//方式一：num = num + 2;
//方式二：num += 2;(推荐)
//开发中，如果希望变量实现+1操作，有几种方法？（前提：int num = 10;）
//方式一：num = num + 1;
//方式二：num += 1;
//方式三：num++;(推荐，原因代码少且不改变数据类型效率高)
-
比较运算符结果为bool类型
-
逻辑运算符
区分&与&&
相同点1：&与&&的运算结果相同
相同点2：当符号左边是true时，二者都会执行符号右边的运算
不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算
开发中推荐使用&&，效率高
bool b1 = true;
int num1 = 10;
if(b1 & (num1++ > 0)){
System.out.println("正确");
}else{
System.out.println("错误");
}
System.out.println(num1);
//正确
//11
bool b2 = true;
int num2 = 10;
if(b2 && (num2++ > 0)){
System.out.println("正确");
}else{
System.out.println("错误");
}
System.out.println(num2);
//正确
//11
bool b1 = false;
int num1 = 10;
if(b1 & (num1++ > 0)){
System.out.println("正确");
}else{
System.out.println("错误");
}
System.out.println(num1);
//错误
//11
bool b2 = false;
int num2 = 10;
if(b2 && (num2++ > 0)){
System.out.println("正确");
}else{
System.out.println("错误");
}
System.out.println(num2);
//错误
//10
区分|与||
相同点1：|与||的运算结果相同
相同点2：当符号左边是false时，二者都会执行符号右边的运算
不同点：当符号左边是true时，|继续执行符号右边的运算。||不再执行符号右边的运算
开发中推荐使用||，效率高
- 位运算符
结论：
-
位运算符操作的都是整型的数据
-
<<在一定范围内（不能无限移动），每向左移1位，相当于 * 2；
">>"在一定范围内（不能无限移动），每向右移1位，相当于 / 2；
面试题：最高效方式计算2 * 8？方法 2 << 3 或者 8 << 1
- 三目运算符
- 结构：（条件表达式）? 表达式1 : 表达式2
- 说明①条件表达式的结果为bool类型；②根据条件表达式真或假决定执行表达式1还是表达式2，如果表达式为true则执行表达式1，如果表达式为false，则执行表达式2。③表达式1和表达式②要求是一致的，即可以统一为一种类型（不要求是同一种类型，但必须可以化为同一种类型）④三目运算符可以嵌套使用
- 凡是可以使用三目运算符的地方，都可以改写为if-else，反之不成立
- 如果程序既可以使用三目运算符，又可以使用if-else结构，那么优先选择三目运算符。原因：简介、执行效率高
程序流程控制if-else
分支结构中的if-else（条件判断结构）
//三种结构
/*
第一种：
if(条件表达式){
}
第二种：二选一
if(条件表达式){
执行表达式1
}else{
执行表达式2
}
执行顺序从上到下依次寻找符合条件的，if-else结构都是选择一个
第三种：n选一
if(条件表达式){
执行表达式1
}else if{
执行表达式2
}else if{
执行表达式3
}
....
else{
执行表达式n
}
*/
说明：
- if-else结构是可以相互嵌套的。（实际开发中不会嵌套超过三层，如嵌套过多还不能解决问题，这时候应该想其他方法简化）
- 如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略，但是不建议省略。
练习题
bool x = true;
bool y = false;
short z = 40;
//注意 == 是比较运算符， = 是赋值运算符
if((z++ == 40) && (y = true)){
z++;
}
if((x = false) || (++z == 43)){
z++;
}
System.out.println("z = " + z);//z=44
使用Scanner类从键盘获取多种数据类型
如何从键盘获取不同类型的变量：需要使用Scanner类
具体实现步骤:
- 导包：import java.util.Scanner;
- Scanner的实例化：Scanner scan = new Scanner(System.in);
- 调用Scanner类的相关方法（next（）/ nextXxx（）），来获取指定类型的变量(具体参看API文档)
- 注意：需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常：InputMisMatchException导致程序终止。
//导包
import java.unil.Scanner;
class ScannerTest{
public static void main(String[] args){
//Scanner实例化
Scanner scan = new Scanner(System.in);
//调用Scanner类的相关方法
//字符串类型
System.out.println("请输入你的姓名：");
String name = scan.next();
System.out.println(name);
//整数类型
System.out.println("请输入你的年龄");
int age = scan.nextInt();
System.out.println(age);
//Scanner没有单独的char方法，只能调用字符串方法
}
}
练习：如何获取一个随机数：10 - 99
//[0.0,1.0)-->[0.0,90.0)-->[10.0,100.0)-->[10,99]
int value = (int)(Math.random() * 90 + 10);
//公式：获取[a,b]: (int)(Math.random() * (b - a + 1) + a)
switch-case结构的使用
格式
switch（表达式）{
case 常量1:
执行语句1;
//break;
case 常量2
执行语句2;
//break;
…
default:
执行语句
//break;
}
class SwitchCaseTest{
public static void main(String[] args){
int number = 1;
switch(number){
case 0:
System.out.println("zero");
break;
case 1:
System.out.println("one");
break;
case 2:
System.out.println("two");
break;
case 3:
System.out.println("three");
break;
default:
System.out.println("other");
}
}
}
说明：
- 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句**（且此时不再需要判断，直接进入后续语句开始执行）**，直到遇到break关键字或此switch-case结构末尾结束为止。
- break关键字可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构。
- switch结构中的表达式，只能是如下的6种数据类型之一：byte、short、char、int、枚举类型（JDK5.0新增）、String类型（JDK7.0新增）
- case之后只能声明常量，不能声明范围
- break关键字是可选的
- default相当于if-else结构中的else，可省略。且位置不唯一但我们都放在最后面
例题：使用switch-case结构对学生成绩大于60分的，输出“合格”，低于60分的输出“不合格”
说明：如果switch-case结构中的多个case的执行语句相同，则可以考虑进行合并
int score = 78;
switch(score / 10){
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println("不及格")；
break;
case 6:
case 7:
case 8:
case 9:
case 10:
System.out.println("及格")；
break;
}
//优化
switch(score / 60){
case 0:
System.out.println("不及格")；
break;
case 1:
System.out.println("及格")；
break;
}
练习编写程序：从键盘上输入2019年的“month”和“day”，要求通过程序输出输入的日期为2019年的第几天。
分析：输入2 15：31 + 15
输入5 7：31 + 28 + 31 + 30 + 7
这个例子说明break在switch-case结构中是可选的（通常都会加）
Scanner scan = new Scanner(System.in);
System.out.println("请输入2019年的month：");
int month = scan.nextInt();
System.out.println("请输入2019年的day");
int day = scan.nextInt();
//定义一个变量来保存总天数
int sumDays = 0;
//方式一：有冗余
if(month == 1){
sumDays = day;
}else if(month == 2){
sumDays = 31 + day;
}else if(month == 3){
sumDays = 31 + 28 + day;
}
....
else{//month == 12
sumDays = ....... + day;
}
//方式二
switch(month){
case 1:
sumDays = day;
break;
case 2:
sumDays = 31 + day;
break;
case 3:
sumDays = 31 + 28 + day;
break;
....
}
//方式三（最佳）
switch(month){
case 12:
sumDays += 30;
case 11:
sumDays += 31;
case 10:
sumDays += 30;
case 9:
sumDays += 31;
case 8:
sumDays += 31;
case 7:
sumDays += 30;
case 6:
sumDays += 31;
case 5:
sumDays += 30;
case 4:
sumDays += 31;
case 3:
sumDays += 28;
case 2:
sumDays += 31;
case 1:
sumDays += day;
}
从键盘上分别输入年、月、日，判断这一天是当年的第几天
判断是否为闰年的标准：
- 可以被4整除，但不可被100整除或者2.可以被400整除
//只需将方式三做如下修改
case 3:
//判断year是否为闰年
if((year % 4 == 0 && year % 100 != 0 ) || year % 400 == 0){
sumDays += 29;
}else{
sumDays += 28;
}
说明：
- 凡是可以使用switch-case的结构，都可以转换为if-else，反之不成立。
- 在写分支结构时，当发现既可以使用switch-case，同时switch中表达式的取值情况不太多，又可以使用if-else时，优先选择使用switch-case。原因是switch-case执行效率稍高。【但开发中极大部分还是使用if-else，无妨】
循环结构for循环
for循环的使用
循环结构的4个要素
- 初始化条件
- 循环条件 ------> 是bool类型
- 循环体
- 迭代条件
for循环的结构
for(1;2;4){
3
}
执行过程1–>2–>3–>4–>2–>3–>4—>…–>2
通常情况下，循环结束都是因为2中循环条件返回false了（通过break也可以跳出循环）
//练习
for(System.out.println('a');num <= 3;System.out.println('c'),num++){
System.out.println('b');
}//输出结果：abcbcbc
//例题：遍历100以内的偶数，输出所有偶数的和，输出偶数的个数
int sum = 0;//记录所有偶数的和
int count = 0;//记录偶数的个数
for(int i = 1;i <= 100;i++){
if(i % 2 == 0){
System.out.println(i);//遍历
sum += i;//求和
count++;//记数
}
}
System.out.println("总和为：" + sum);
System.out.println("个数为：" + count);
for循环例题：输入两个正整数m和n，求其最大公约数和最小公倍数。比如12和20的最大公约数是4，最小公倍数是60
（用到了break）
import java.util.Scanner;
class ForTest{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个正整数：");
int m = scan.nextInt();
System.out.println("请输入第二个正整数：");
int n = scan.nextInt();
//获取最大公约数
//1.获取两个数中的较小值
int min = (m <= n) ? m : n;
//2.遍历
for(int i = min;i >= 1;i--){
if(m % i == 0 && n % i == 0){
System.out.println("最大公约数为：" + i);
break;//一旦在循环中执行到break，就跳出循环
}
}
//获取最小公倍数
//1.获取两个数中的较大值
int max = (m >= n) ? m : n;
//2.遍历
for(int i = max;i <= m * n;i++){
if(i % m == 0 && i % n == 0){
System.out.println("最小公倍数为：" + i);
break;
}
}
}
}
while循环
while循环结构的4个要素
- 初始化条件
- 循环条件 ------> 是bool类型
- 循环体
- 迭代条件
结构
/*
1;
while(2){
3;
4;
}
*/
执行过程：1–>2–>3–>4–>2–>3–>4–>2–>3–>4–>…–>2
说明：
- 写while循环千万小心不要丢了迭代条件。一旦丢了就可能导致死循环！
- 写程序时要避免出现死循环（算法的有限性）
- for循环和while循环是可以相互转换的！二者区别for循环和while循环的初始化条件部分的作用范围不同。
int i = 1;
while(i <= 100){
if(i % 2 == 0){
System.out.println(i);
}
i++;
}
System.out.println(i);//除了while循环仍然可以调用
do-while循环四个要素
- 初始化条件
- 循环条件 ------> 是bool类型
- 循环体
- 迭代条件
结构
1;
do{
3;
4;
}while(2);
执行过程：1–>3–>4–>2–>3–>4–>2–>3–>4–>2–>…–>2
说明：
- do-while循环至少会执行一次循环体！
- 开发中使用for和while更多一些，较少使用do-while
当do-while可以多次循环的时候，同for循环和while循环一样。只有for循环和while循环一次也不执行的时候do-while会执行一次。
//遍历100以内的偶数并计算所有偶数的和及偶数的个数
int num = 1;
int sum = 0;//记录总和
int count = 0;//记录个数
do{
if(num % 2 == 0){
System.out.println(num);
sum += num;
count++;
}
num++;
}while(num <= 100);
System.out.println(sum);
System.out.println(count);
//区别（只会执行一次时）,最终只会输出do-while
int number1 = 10;
while(number1 > 10){
System.out.println("while");
number1--;
}
int number2 = 10;
do{
System.out.println("do-while");
number2--;
}while(number2 > 10);
练习while（true）结构的使用
题目：从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。
说明：
- **不在循环条件部分限制次数的结构：**for( ; 😉 或 while(true)
- 结束循环有几种方式？
方式一：循环条件部分返回false
方式二：在循环体中，执行break
import java.util.Scanner;
class ForWhileTest{
public static void main(String[] args){
Scanner scan = new Scanner(Ststem.in);
int positiveNumber = 0;//记录正数的个数
int negativeNumber = 0;//记录负数的个数
//while(true)结构还可以使用如下
//只需将while(true)替换为for(;;)即可
//表示任何情况下都可以进入循环
while(true){
int number = scan.nextInt();
//判断number的正负情况
if(number > 0){
positiveNumber++;
}else if(number < 0){
negativeNumber++;
}else{
//一旦执行break，跳出循环
break;
}
}
System.out.println("正数的个数" + positiveNumber);
System.out.println("负数的个数" + negativeNumber);
}
}
while（true）的意思就是永远都是true可以一直执行，当要跳出循环的时候需要用到break。
嵌套循环
-
内层循环遍历一遍，只相当于外层循环循环体执行了一次
-
外层循环需要执行m次，内层循环需要执行n次，此时内层循环的循环体一共执行了m * n次。
for(int j = 1;j <= 4;j++){
for(int i = 1;i <= 6;i++){
System.out.print("*");
}
System.out.println();
}
/*
输出
******
******
******
******
*/
嵌套循环的应用：九九乘法表
for(int i = 1;i <= 9;i++){
for(int j = 1;j <= i;j++){
System.out.println(i + " * " + j + " = " + (i * j) + " ");
}
System.out.println();
}
100以内的所有的质数的输出
bool isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
for(int i = 2;i <= 100;i++){//遍历100以内的自然数
for(int j = 2;j < i;j++){
if(i % j == 0){//i被j除尽
isFlag = false;
break;//优化一：只对本身非质数的自然数是有效的
}
}
if(isFlag == true){
System.out.println(i);
}
//重置isFlag
isFlag = true;
}
优化二
bool isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
for(int i = 2;i <= 100;i++){//遍历100以内的自然数
//优化二：对本身是质数的自然数是有效的。
//Math.sqrt()表示开方，判断是否为质数只需除以从2到开方，看是否能被整除即可
for(int j = 2;j <= Math.sqrt(i);j++){
if(i % j == 0){//i被j除尽
isFlag = false;
break;//优化一：只对本身非质数的自然数是有效的
}
}
if(isFlag == true){
System.out.println(i);
}
//重置isFlag
isFlag = true;
}
两个都进行优化之后将提升非常非常大
break和continue关键字的使用
| 使用范围 | 循环中使用的作用（不同点） | 相同点 | |
|---|---|---|---|
| break | switch-case；循环结构中 | 结束当前循环 | 关键字后面不能声明执行语句 |
| continue | 循环结构中 | 结束当次循环 | 关键字后面不能声明执行语句 |
for(int i = 1;i <= 10;i++){
if(i % 4 == 0){
//break;//执行break输出结果123
//continue;//执行continue输出结果123567910
//System.out.println(" ");//这两个关键字后面的执行不到，如果写了编译会出错
}
System.out.println(i);
}
for(int i = 1;i <= 4;i++){
for(int j = 1;j <= 10;j++){
if(j % 4 == 0){
//break;//默认跳出包裹此关键字最近的一层循环
//continue;//默认跳出包裹此关键字最近的当次循环
}
System.out.print(j);
}
System.out.println();
}
label:for(int i = 1;i <= 4;i++){
for(int j = 1;j <= 10;j++){
if(j % 4 == 0){
continue label;//结束指定标识的一层循环结构的当次循环
}
System.out.print(j);
}
System.out.println();
}
求质数：在代码写法上进行优化
label:for(int i = 2;i <= 100;i++){//遍历100以内的自然数
for(int j = 2;j <= Math.sqrt(i);j++){
if(i % j == 0){//i被j除尽
continue label;//有一个不符合立即跳出带标签的当次循环开始执行下一次
}
}
System.out.println(i);
}
练习Project1家庭收支记账软件(项目需要多练习)
3332
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
