2.1 Java 基本语法
2.1.1 注释
Java 中的注释有三种类型，具体如下：
-
单行注释
int age = 18;//这是一个单行注释 -
多行注释
/* * 这是一个多行注释 */ int age = 18; -
文档注释
/** * 这是文档注释 * */生成文档注释命令
- javadoc -d 目录名 -author -version Java文件名.java -encoding UTF-8 -charset UTF-8
2.1.2 标识符
- 标识符
- Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
- 技巧：凡是自己可以起名字的地方都叫标识符
- 定义合法标识符规则
- 由 26 个英文字母大小写，0-9，_ 或 $ 组成
- 数字不可以开头
- 不可以使用关键字和保留字，但能包含
- Java 中严格区分大小写，长度无限制
- 标识符不能包含空格
- 命名规范
- 包名：多单词组成时所有的字母都小写 xxxyyyyzzz
- 类名、接口名：多单词组成时，所有单词的首字母大写 XxxYyyZzz
- 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词的首字母大写 xxxYyyZzz
- 常量名：所有字母都大写。多单词时每个单词都用下划线连接 XXX_YYY_ZZZ
- 命名的时候尽量见名知意
2.1.3 关键字
- 关键字的定义和特点：
- 定义：被 Java 语言赋予了特殊含义，用做专门用途的字符串
- 特点：关键字中所有的字母都为小写
| 用于定义关键数据类型的关键字 | |||
|---|---|---|---|
| class | interface | enum | byte |
| short | int | float | long |
| double | char | boolean | void |
| 用于定义流程控制的关键字 | |||
|---|---|---|---|
| if | else | switch | case |
| default | while | do | for |
| break | continue | return |
| 用于定义访问权限修饰符的关键字 | ||
|---|---|---|
| private | protected | public |
| 用于定义类，函数，变量修饰符的关键字 | |||
|---|---|---|---|
| abstract | final | static | synchronized |
| 用于定义类与类之间关系的关键字 | |
|---|---|
| extends | implements |
| 用于定义建立实例及引用实例，判断实例的关键字 | |||
|---|---|---|---|
| new | this | super | instanceof |
| 用于异常处理的关键字 | ||||
|---|---|---|---|---|
| try | catch | finally | throw | throws |
| 用于包的关键字 | |
|---|---|
| package | import |
| 其他修饰符关键字 | ||||
|---|---|---|---|---|
| native | strictfp | transient | volatile | assert |
| 用于定义数据类型值的字面值 | ||
|---|---|---|
| true | false | null |
- 保留字
- 定义：现有 Java 版本尚未使用
- goto、const
2.1.4 常量
- 常量就是在程序中固定不变的值，是不能改变的数据。
2.2 变量
2.2.1 变量的定义
- 变量的概念
- 内存中的一个存储区域
- 该区域的数据可以在同一类型范围内不断变化
- 变量是程序中最基本的储存单元。包含变量类型、变量名和存储的值
- 变量的作用
- 用于在内存中保存数据
- 使用变量注意
- Java 中每个变量必须先声明，后使用
- 使用变量名来访问这块区域的数据
- 变量的作用域：其定义所在的一对 {} 内
- 变量只有在其作用域内才有效
- 同一作用域内，不能定义重名的变量
- 在方法体外，类体内声明的变量称为成员变量
- 在方法体内部声明的变量称为局部变量
2.2.2 变量的数据类型
| 类型 | 占用存储空间 | 表数范围 |
|---|---|---|
| byte | 1 字节 = 8bit 位 | -128 ~ 127 |
| short | 2 字节 | -215 ~ 215 -1 |
| int | 4 字节 | -231 ~ 231 -1 (约21亿) |
| long | 8 字节 | -263 ~ 263 -1 |
| 单精度 float | 4 字节 | -3.403E38 ~ 3.403E38 |
| 双精度 double | 8 字节 | -1.798E308 ~ 1.798E308 |
-
Java 的整型常量默认为 int 型，声明 long 型常量须后加 l 或者 L
-
Java 程序中变量通常声明为 int 型，除非不足以表示较大的数才使用 long
-
Java 的浮点型常量默认为 double 型，声明 float 型常量，须后加 f 或者 F
-
转义字符
转义字符 说明 \b退格符 \n换行符 \r回车符 \t制表符 \"双引号 \'单引号 \\反斜线 -
boolean 类型数据只允许取值 true 和 false，无 null
2.2.3 变量的类型转换
在程序中，当把一种数据类型的值赋给另一种数据类型的变量时，需要进行数据类型转换。根据转换方式的不同，数据类型转换可分为两种：自动类型转换和强制类型转换。
-
自动类型转换
- 当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型
- byte \ short \ char --> int --> long --> float --> double
- 特别的：当 byte、char、short 三种类型的变量做运算时，结果为 int 型
-
强制类型转换
-
需要使用强转符：
() -
强制类型转换可能导致精度损失
-
例：
byte b1 = 10; int i1 = 126; byte b2 = (byte) (b1 + i1); char c1 = 'a'; short s2 = 10; short s3 = (short) (s2 + c1);
-
-
注意
- 整型常量，默认为 int 型
- 浮点型常量，默认为 double 型
2.2.4 变量的作用域
public static void main(String[] args) {
int x = 12; //变量 x
{
int y = 20;
}
y = x; //将 x 的值赋给 y，但 y 出了它的作用域
}
2.3 运算符
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等
分类：
- 算数运算符（Arithmetic operator）
- 赋值运算符（Assignment Operators）
- 比较运算符（Comparison operator）
- 逻辑运算符（Logical operator）
- 位运算符（Bitwise Operators）
- 三元运算符（Ternary operator）
2.3.1 算数运算符
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| + | 正号 | +3 | 3 |
| - | 负号 | b = 4; -b | -4 |
| + | 加 | 5+5 | 10 |
| - | 减 | 5 - 4 | 1 |
| * | 乘 | 5 * 2 | 10 |
| / | 除 | 5 / 2 | 2 |
| % | 取模（取余） | 5 / 2 | 1 |
| ++ | 自增（前）：先相加后赋值 自增（后）：先赋值后相加 |
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; |
| + | 字符串连接 | "Hell" + "o" | "Hello" |
public class ArithmeticTest {
public static void main(String[] args) {
int num1 = 14;
int num2 = 6;
int num3 = 5;
int num4 = -10;
int num5 = -7;
//除号：/
int result1 = num1 / num2;
System.out.println(result1); //2
double result2 = (double) num1 / num2;
System.out.println(result2); //2.3333333333333335
//去余：%
int result3 = num1 % num3;
System.out.println(result3); //4
double result4 = num4 % num3;
System.out.println(result4); //0.0
double result5 = num4 % num5;
System.out.println(result5); //-3.0
//后 ++：先赋值后相加
int a1 = 10;
int a2 = a1++;
System.out.println("a1 = " + a1 + "\t" + "a2 = " + a2);
//前 ++：先相加后赋值
int a3 = 10;
int a4 = ++a3;
System.out.println("a3 = " + a3 + "\t" + "a4 = " + a4);
}
}
/*
练习，随意一个整数，打印出它的个位数，十位数，百位数
*/
public class ArithmeticExercise {
public static void main(String[] args) {
int number = 157;
int singleDigit = number % 10;
System.out.println("个位数是：" + singleDigit);
int tenDigits = number / 10 % 10;
System.out.println("十位数是：" + tenDigits);
int hundreds = number / 100;
System.out.println("百位数是：" + hundreds);
}
}
2.3.2 赋值运算符
public class AssignmentTest {
public static void main(String[] args) {
int number1 = 10;
int number2;
int number3 = 4;
number2 = number1;
System.out.println(number2);
int result1 = number1-=number3;
System.out.println(result1); //6
number1 = 10;
number3 = 4;
number1 += number3;
System.out.println(number1); //14
}
}
2.3.3 比较运算符
比较运算符的结果是 boolean 类型
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| == | 相等于 | 4 == 3 | false |
| != | 不等于 | 4 != 3 | true |
| < | 小于 | 4 < 3 | false |
| > | 大于 | 4 > 3 | true |
| <= | 小于等于 | 4 <= 3 | false |
| >= | 大于等于 | 4 >= 3 | true |
| instanceof | 检查是否是类的对象 | "hello" instanceof String | true |
public class ComparisonTest {
public static void main(String[] args) {
int i = 10;
int j = 12;
System.out.println(i == j); //false
System.out.println(i <= j); //true
}
}
2.3.4 逻辑运算符
-
区分 & 与 &&
- 相同点：
- & 和 && 的运算结果相同
- 当符号左边是 true 时，二者都会执行符号右边的运算
- 不同点：
- 当符号左边是 false 时，& 会继续执行符号右边的运算，&& 则不再执行符号右边的运算
- 相同点：
-
区分 | 和 ||
- 相同点：
- | 和 || 的运算结果相同
- 当符号左边是 false 时，二者都会执行符号右边的运算
- 不同点：
- 当符号左边是 true 时，| 会继续执行符号右边的运算，|| 则不再执行符号右边的运算
- 相同点：
| 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 | ture | false | false | true | true | true | true |
| false | false | false | false | false | false | true | false |
public class LogicalTest {
public static void main(String[] args) {
//& 和 && 的区别
boolean b1 = true;
b1 = false;
int num1 = 10;
if (b1 & (num1++ > 0)) {
System.out.println("true");
} else {
System.out.println("false");
}
System.out.println("num1 = " + num1); //num1 = 11
boolean b2 = true;
b2 = false;
int num2 = 10;
if (b2 && (num2++ > 0)) {
System.out.println("true");
} else {
System.out.println("false");
}
System.out.println("num2 = " + num2); //num2 = 10
// | 和 || 的区别
boolean b3 = true;
int num3 = 10;
if (b3 | (num3++ > 0)) {
System.out.println("true");
} else {
System.out.println(false);
}
System.out.println("num3 = " + num3); //num3 = 11
boolean b4 = true;
int num4 = 10;
if (b4 || (num4++ > 0)) {
System.out.println("true");
} else {
System.out.println(false);
}
System.out.println("num4 = " + num4); //num4 = 10
}
}
2.3.5 位运算符
- 位运算是直接对整数的二进制进行的运算
| 运算符 | 运算 | 范例 | 细节 |
|---|---|---|---|
| << | 左移 | 3 << 2 = 12 --> 3 * 2 * 2 = 12 | 空位补0，被移除的高位丢弃，空缺位补0。 |
| >> | 右移 | 3 >> 1 = 1 --> 3/2=1 | 被移位的二进制最高位是0，右移后，空缺位补0； 最高位是1，空缺位补1。 |
>>> |
无符号右移 | 3 >>> 1 = 1 --> 3/2=1 | 被移位二进制最高位无论是0或者是1，空缺位都用0补。 |
| & | 与运算 | 6 & 3 = 2 | 二进制位进行&运算，只有1&1时结果是1，否则是0; |
| | | 或运算 | 6 | 3 = 7 | 二进制位进行 | 运算，只有0 | 0时结果时0，否则是1 |
| ^ | 异或运算 | 6 ^ 3 = 5 | 相同二进制位进行 ^ 运算，结果是0；1^1=0 , 0^0=0 不相同二进制位 ^ 运算结果是1。1^0=1 , 0^1=1 |
| ~ | 取反运算 | ~6 = -7 | 正数取反，各二进制码按补码各位取反 负数取反，各二进制码按补码各位取反 |
/*
1.位运算符操作的都是整形的数据
2. <<：在一定范围内，每向左移 1 位，相当于 * 2
>>：在一定范围内，每向右移 1 位，相当于 / 2
面试题：最高效方式计算 2 * 8 ？ 2 << 3 或 8 << 1
*/
public class BitwiseTest {
public static void main(String[] args) {
int i = 21;
System.out.println("i << 2 = " + (i << 2));
System.out.println("i << 3 = " + (i << 3));
System.out.println("i >> 1 = " + (i >> 1));
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 = num1;
num1 = num2;
num2 = temp;
System.out.println(num1 + "\t" + num2);
//方式二：好处：不用定义临时变量
//弊端：相加操作可能超出存储范围；有局限性：只能适用于基本数据类型
num1 += num2;
num2 = num1 - num2;
num1 = num1 - num2;
System.out.println(num1 + "\t" + num2);
//方式三：使用位运算符
//有局限性：只能适用于基本数据类型
num1 = num1 ^ num2;
num2 = num1 ^ num2;
num1 = num1 ^ num2;
System.out.println(num1 + "\t" + num2);
}
}
2.3.6 三元运算符
/*
三元运算符
1.结构：(条件表达式)? 表达式1 : 表达式2
2.说明
①条件表达式的结果为 boolean 类型
②根据条件表达式真或假，决定执行表达式1或2
*/
public class TernaryTest {
public static void main(String[] args) {
//获取两个整数的较大值
int m = 0;
int n = 1;
int x = 2;
int max = Math.max(m, n);
int max2 = m > n ? m: n;
System.out.println(max2);
String maxStr = m > n ? "m大" : n == m ? "m和n相等": "n大";
System.out.println(maxStr);
String str = m == 0 ? "老板":m == 1 ? "经理":"员工";
System.out.println(str);
//获取三个数中的最大值
int n1 = 12;
int n2 = 11;
int n3 = 13;
int maxN = ((n1 > n2 ? n1 : n2) > n3 ? n2 : (n3 > n1 ? n3 : n1));
System.out.println(maxN);
int maxN2 = n1 > n2 ? n1 : n2;
int maxN3 = maxN2 > n3 ? maxN2 : n3;
System.out.println(maxN3);
}
}
2.4 选择结构语句
2.4.1 if 条件语句
if 条件语句指的是如果满足某种条件，就执行改分支下的语句
public class IfTest {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.print("请输入年龄：");
String myAge = in.next();
int age = Integer.parseInt(myAge);
if (age <= 18) {
System.out.println("禁止进入");
}
if (age >= 18) {
System.out.println("你已成年");
} else {
System.out.println("未成年");
}
if (age < 0) {
System.out.println("非法");
} else if (age < 18) {
System.out.println("青少年");
} else if (age < 35) {
System.out.println("青壮年");
} else if (age < 60) {
System.out.println("中年");
} else {
System.out.println("老年");
}
in.close();
}
}
2.4.2 switch 条件语句
- 根据 switch 表达式中的值，依次匹配各个 case 中的常量。一旦匹配成功，则进入相应 case 结构中，调用其执行语句。当调用完执行语句以后，则仍然继续向下执行其他 case 结构中的执行语句，直道遇到 break 关键字或此 switch-case 结构末尾为止
- break，可以使用在 switch-case 中，表示一旦执行到此关键字，就跳出
- switch 结构中的表达式，只能是如下的 6种 数据类型之一：byte、short、char、int、枚举类型（JDK5.0）、String 类型（JDK7.0）
- case 之后只能声明常量。不能声明范围。
- break 关键字是可选的
- default：当其他 case 都不满足时则会执行
public class SwitchCaseTest {
public static void main(String[] args) {
int number = 2;
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");
}
}
}
public class SwitchCaseTest2 {
public static void main(String[] args) {
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("不及格");
case 1:
System.out.println("及格");
}
}
}
2.5 循环结构语句
2.5.1 while 循环语句
-
while 循环结构的四个要素
- 初始化条件
- 循环条件
- 循环体
- 迭代条件
-
while 循环的结构
初始化条件 while(循环条件){ 循环体 迭代条件 } //先判断，后执行 -
注意：写 while 循环千万不要丢失了迭代条件，一旦丢失，将会导致死循环
public class WhileTest {
public static void main(String[] args) {
//遍历 100 以内的所有偶数
int i = 1;
while (i < 101) {
if (i % 2 == 0) {
System.out.println(i);
}
i++;
}
}
}
2.5.2 do...while 循环语句
-
do-while 循环的四个要素
- 初始化条件
- 循环条件 --> 是boolean类型
- 循环体
- 迭代条件
-
do-while 的结构
初始化条件 do { 循环体 迭代条件 } while(循环条件); //先执行，后判断条件 -
do-while 循环至少会执行一次循环体
public class DoWhileTest {
public static void main(String[] args) {
//打印 100 以内的偶数和
int i = 1;
int sum = 0;
int count = 0;
do {
if (i % 2 == 0) {
sum += i;
count++;
}
i++;
} while (i<101);
System.out.println("总和为：" + sum);
System.out.println("个数为：" + count);
}
}
2.5.3 for 循环语句
-
语法格式
for(初始化条件;循环条件;迭代条件){ 循环体 } -
使用 for 循环遍历 100 以内的偶数
public class ForTest { public static void main(String[] args) { for (int i = 0; i < 5; i++) { System.out.println("Hello World!"); } //例题：遍历 100 以内的偶数，输出所有偶数的和 int sum = 0; int count = 0; for (int i = 1; i <= 100; i++) { if (i % 2 == 0) { sum += i; count ++; System.out.println(i); } } System.out.println("总和为：" + sum); System.out.println("偶数的个数为：" + count); } } -
使用 for 循环请求最大公约数和最小公倍数
public class ForTest3 { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.print("请输入数值1："); int m = scanner.nextInt(); System.out.print("请输入数值2："); int n = scanner.nextInt(); //获取两个数中的较小值 int minNum = m >= n ? n: m; for (int i = minNum; i > 0; i--) { if (m % i == 0 && n % i == 0) { System.out.println(String.format("%d 和 %d 的最大公约数是：%d", m,n,i)); break; } } int maxNum = m >= n ? m: n; for (int i = maxNum; i <= m * n; i++) { if (i % m == 0 && i % n == 0) { System.out.println(String.format("%d 和 %d 的最小公倍数是：%d", m,n,i)); break; } } } }
2.5.4 循环嵌套
-
使用 for 循环打印九九乘法表
public class NineNineTable { public static void main(String[] args) { for (int i = 1; i <= 9; i++) { for (int j = 1; j <= i; j++) { System.out.print(j + "*" + i + "=" + i * j + "\t"); } System.out.println(); } } } -
使用 for 循环打印质数
public class PrimeNumberTest { public static void main(String[] args) { int count = 0; //记录素数的个数 boolean isPrime = true; for (int i = 2; i < 10001; i++) { //优化二：对本身质数的自然数是有效的 for (int j = 2; j < Math.sqrt(i); j++) { if (i % j == 0) { isPrime = false; break; //优化一：只对本身非质数的自然数是有效的 } } if (isPrime) { count++; // System.out.println(i); } isPrime = true; } System.out.println("个数：" + count); } }public static void main(String[] args) { int count = 0; //记录素数的个数 label:for (int i = 2; i < 10001; i++) { for (int j = 2; j < Math.sqrt(i); j++) { if (i % j == 0) { continue label; } } //能执行到此步骤的，都是质数 count++; } System.out.println("个数：" + count); }
2.5.6 跳转关键字（break、continue）
- break：结束当前循环
- continue：结束本次循环
- break 只能用于 switch 语句和循环语句中
- continue 只能用于循环语句中
- break、continue 之后不能有其他的语句，因为程序永远不会执行其后的语句
public class BreakContinueTest {
public static void main(String[] args) {
// for (int i = 1; i < 11; i++) {
//
// if (i % 4 == 0) {
//// break; //123
// continue; //123567910
// }
// System.out.println(i);
// }
lable:for (int i = 1; i <= 4; i++) {
for (int j = 1; j <= 10; j++) {
if (j % 4 == 0) {
// break; //默认跳出包裹此关键字最近的一层循环
// continue;
break lable; //结束指定标识层级的循环结构
}
System.out.println(i + "\t" + j);
}
}
}
}
衡量一个功能代码的优劣：
1.正确性（正确的实现功能）
2.可读性（让人看得懂）
3.健壮性（经得住考验）
4.高效率与低存储：时间复杂度与空间复杂度（衡量算法的好坏）