1 类型转换
1.1 自动类型转换（隐式类型转换）
-
从小的数据类型到大的数据类型的转换（如 int 到 long）。
-
从低精度的数据类型到高精度的数据类型的转换（如 float 到 double）。
1.2 强制类型转换（显式类型转换）
-
从大的数据类型到小的数据类型的转换（如 long 到 int）。
-
从高精度的数据类型到低精度的数据类型的转换（如 double 到 float）。
1.3 案例
案例1
public class ImplicitTypeConversion {
public static void main(String[] args) {
int intValue = 10;
long longValue = intValue; // 自动类型转换：int 到 long
float floatValue = 10.5f;
double doubleValue = floatValue; // 自动类型转换：float 到 double
System.out.println("intValue: " + intValue);
System.out.println("longValue: " + longValue);
System.out.println("floatValue: " + floatValue);
System.out.println("doubleValue: " + doubleValue);
}
}
输出结果
案例2
public class ExplicitTypeConversion {
public static void main(String[] args) {
long longValue = 10000000000L;
int intValue = (int) longValue; // 强制类型转换：long 到 int
double doubleValue = 10.5;
float floatValue = (float) doubleValue; // 强制类型转换：double 到 float
System.out.println("longValue: " + longValue);
System.out.println("intValue: " + intValue);
System.out.println("doubleValue: " + doubleValue);
System.out.println("floatValue: " + floatValue);
}
}
输出结果
2 运算符
2.1 算术运算符
2.1.1 算数运算符格式
| 操作符 | 描述 | 例子 |
|---|---|---|
| + | 加法 - 相加运算符两侧的值 | A + B 等于 30 |
| - | 减法 - 左操作数减去右操作数 | A – B 等于 -10 |
| * | 乘法 - 相乘操作符两侧的值 | A * B等于200 |
| / | 除法 - 左操作数除以右操作数 | B / A等于2 |
| ％ | 取余 - 左操作数除以右操作数的余数 | B%A等于0 |
| ++ | 自增: 操作数的值增加1 | B++ 或 ++B 等于 21（区别详见下文） |
| -- | 自减: 操作数的值减少1 | B-- 或 --B 等于 19（区别详见下文） |
2.1.2 案例
public class ArithmeticOperators {
public static void main(String[] args) {
int a = 10;
int b = 5;
int sum = a + b; // 加法运算符
int difference = a - b; // 减法运算符
int product = a * b; // 乘法运算符
int quotient = a / b; // 除法运算符
int remainder = a % b; // 取模运算符
System.out.println("a + b = " + sum);
System.out.println("a - b = " + difference);
System.out.println("a * b = " + product);
System.out.println("a / b = " + quotient);
System.out.println("a % b = " + remainder);
}
}
输出结果
2.2 关系运算符
2.2.1 关系运算符格式
| 运算符 | 描述 | 例子 |
|---|---|---|
| == | 检查如果两个操作数的值是否相等，如果相等则条件为真。 | （A == B）为假。 |
| != | 检查如果两个操作数的值是否相等，如果值不相等则条件为真。 | (A != B) 为真。 |
| > | 检查左操作数的值是否大于右操作数的值，如果是那么条件为真。 | （A> B）为假。 |
| < | 检查左操作数的值是否小于右操作数的值，如果是那么条件为真。 | （A <B）为真。 |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。 | （A> = B）为假。 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。 | （A <= B）为真。 |
2.2.2 案例
public class RelationalOperators {
public static void main(String[] args) {
int a = 10;
int b = 5;
boolean equal = a == b; // 等于运算符
boolean notEqual = a != b; // 不等于运算符
boolean greater = a > b; // 大于运算符
boolean less = a < b; // 小于运算符
boolean greaterOrEqual = a >= b; // 大于等于运算符
boolean lessOrEqual = a <= b; // 小于等于运算符
System.out.println("a == b: " + equal);
System.out.println("a != b: " + notEqual);
System.out.println("a > b: " + greater);
System.out.println("a < b: " + less);
System.out.println("a >= b: " + greaterOrEqual);
System.out.println("a <= b: " + lessOrEqual);
}
}
输出结果
2.3 自增自减运算符
2.3.1 自增自减运算符格式
| 符号 | 作用 |
|---|---|
| ++ | 用作变量前后，对自身值加一 |
| -- | 用作变量前后，对自身值减一 |
2.3.2 案例
public class selfAddMinus{
public static void main(String[] args){
int a = 3;//定义一个变量；
int b = ++a;//自增运算
int c = 3;
int d = --c;//自减运算
System.out.println("进行自增运算后的值等于"+b);
System.out.println("进行自减运算后的值等于"+d);
}
}
输出结果
2.4 逻辑运算符
2.4.1 逻辑运算符格式
| 操作符 | 描述 | 例子 |
|---|---|---|
| && | 称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。 | （A && B）为假。 |
| | | | 称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。 | （A | | B）为真。 |
| ！ | 称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。 | ！（A && B）为真 |
2.4.2案例
public class LogicalOperators {
public static void main(String[] args) {
boolean a = true;
boolean b = false;
boolean and = a && b; // 与运算符
boolean or = a || b; // 或运算符
boolean not = !a; // 非运算符
System.out.println("a && b: " + and);
System.out.println("a || b: " + or);
System.out.println("!a: " + not);
}
}
输出结果
2.5 位运算符
2.5.1 位运算符格式
| 操作符 | 描述 | 例子 |
|---|---|---|
| ＆ | 如果相对应位都是1，则结果为1，否则为0 | （A＆B），得到12，即0000 1100 |
| | | 如果相对应位都是 0，则结果为 0，否则为 1 | （A | B）得到61，即 0011 1101 |
| ^ | 如果相对应位值相同，则结果为0，否则为1 | （A ^ B）得到49，即 0011 0001 |
| 〜 | 按位取反运算符翻转操作数的每一位，即0变成1，1变成0。 | （〜A）得到-61，即1100 0011 |
| << | 按位左移运算符。左操作数按位左移右操作数指定的位数。 | A << 2得到240，即 1111 0000 |
| >> | 按位右移运算符。左操作数按位右移右操作数指定的位数。 | A >> 2得到15即 1111 |
| >>> | 按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 | A>>>2得到15即0000 1111 |
2.5.2 案例
public class BitwiseOperators {
public static void main(String[] args) {
int a = 5; // 二进制表示：101
int b = 3; // 二进制表示：011
int bitwiseAnd = a & b; // 按位与运算符
int bitwiseOr = a | b; // 按位或运算符
int bitwiseXor = a ^ b; // 按位异或运算符
int bitwiseNot = ~a; // 按位取反运算符
System.out.println("a & b: " + bitwiseAnd);
System.out.println("a | b: " + bitwiseOr);
System.out.println("a ^ b: " + bitwiseXor);
System.out.println("~a: " + bitwiseNot);
}
}
输出结果
2.6 赋值运算符
2.6.1 赋值运算符格式
| 操作符 | 描述 | 例子 |
|---|---|---|
| = | 简单的赋值运算符，将右操作数的值赋给左侧操作数 | C = A + B将把A + B得到的值赋给C |
| + = | 加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数 | C + = A等价于C = C + A |
| - = | 减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数 | C - = A等价于C = C - A |
| * = | 乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数 | C * = A等价于C = C * A |
| / = | 除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数 | C / = A，C 与 A 同类型时等价于 C = C / A |
| （％）= | 取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数 | C％= A等价于C = C％A |
| << = | 左移位赋值运算符 | C << = 2等价于C = C << 2 |
| >> = | 右移位赋值运算符 | C >> = 2等价于C = C >> 2 |
| ＆= | 按位与赋值运算符 | C＆= 2等价于C = C＆2 |
| ^ = | 按位异或赋值操作符 | C ^ = 2等价于C = C ^ 2 |
| | = | 按位或赋值操作符 | C | = 2等价于C = C | 2 |
2.6.2 案例
public class AssignmentOperators {
public static void main(String[] args) {
int a = 10;
int b = 5;
a += b; // 等价于 a = a + b
a -= b; // 等价于 a = a - b
a *= b; // 等价于 a = a * b
a /= b; // 等价于 a = a / b
a %= b; // 等价于 a = a % b
System.out.println("a += b: " + a);
System.out.println("a -= b: " + a);
System.out.println("a *= b: " + a);
System.out.println("a /= b: " + a);
System.out.println("a %= b: " + a);
}
}
输出结果
2.7 三元运算符
2.7.1 三元运算符格式
variable x = (expression) ? value if true : value if false
2.7.2 案例代码
public class TernaryOperator {
public static void main(String[] args) {
int a = 10;
int b = 5;
int max = (a > b) ? a : b; // 如果 a > b，则 max = a，否则 max = b
System.out.println("Max value: " + max);
}
}
输出结果
3 流程控制
3.1 分支结构
-
if-else：根据条件表达式的值选择执行不同的代码块。
-
switch-case：根据变量的值选择执行不同的代码块。
3.2 循环结构
-
for循环：通过初始化、条件判断和更新循环变量来控制循环次数。
-
while循环：当条件满足时循环执行某段代码。
-
do-while循环：先执行代码块，再判断条件是否满足，若满足则继续循环。
3.3 挑战关键字
-
break：用于跳出循环或switch语句。
-
continue：用于跳过当前循环的剩余部分，进入下一次循环。
3.4 多重循环
多重循环指的是在一个循环体内部再嵌套另一个或多个循环。常见的有多重for循环、while循环嵌套等。
3.5 案例
例1 使用if-else进行数字比较
public class IfElseExample {
public static void main(String[] args) {
int a = 5;
int b = 10;
if (a > b) {
System.out.println("a 大于 b");
} else if (a < b) {
System.out.println("a 小于 b");
} else {
System.out.println("a 等于 b");
}
}
}
输出结果
例2 使用switch进行字符串匹配
public class SwitchStringExample {
public static void main(String[] args) {
String day = "MONDAY";
switch (day) {
case "MONDAY":
System.out.println("Today is Monday");
break;
case "TUESDAY":
System.out.println("Today is Tuesday");
break;
// 其他情况...
default:
System.out.println("Invalid day");
}
}
}
输出结果
例3 使用for循环和break打印1到10之间的奇数
public class ForBreakExample {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i % 2 == 0) {
continue; // 跳过偶数
}
System.out.println(i);
if (i == 5) {
break; // 当i等于5时跳出循环
}
}
}
}
输出结果
例4 使用嵌套for循环打印九九乘法表
public class NestedForExample {
public static void main(String[] args) {
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + "x" + i + "=" + (i * j) + "\t");
}
System.out.println(); // 换行
}
}
}
输出结果
例5 使用while循环和continue打印1到10之间非3的倍数
public class WhileContinueExample {
public static void main(String[] args) {
int i = 1;
while (i <= 10) {
if (i % 3 == 0) {
i++; // 跳过3的倍数
continue;
}
System.out.println(i);
i++;
}
}
}
输出结果
例6 使用do-while循环打印1到10
public class DoWhileExample {
public static void main(String[] args) {
int i = 1;
do {
System.out.println(i);
i++;
} while (i <= 10);
}
}
输出结果
4 数组
4.1 一维数组的使用
4.1.1一维数组的基本概念
一维数组是最简单的数组，用于存储相同类型的数据，且这些数据在内存中连续存放。
4.1.2 一维数组的声明和初始化
1.声明：
int[] array; // 声明一个整型数组
2.初始化：
-
静态初始化：在声明数组的同时指定数组的元素。
int[] array = {1, 2, 3, 4, 5};
-
动态初始化：只指定数组的长度，由系统自动为数组元素分配默认值（对于数值类型，默认值为0；对于引用类型，默认值为null）。
int[] array = new int[5]; // 数组元素默认为0
4.1.3 访问数组元素
通过索引（下标）来访问数组元素，索引从0开始。
int value = array[2]; // 访问数组中索引为2的元素，即第3个元素
4.1.4 数组的长度
通过length属性来获取数组的长度。
int length = array.length; // 获取数组的长度
4.1.5 案例
public class OneDArrayExample {
public static void main(String[] args) {
// 静态初始化数组
int[] numbers = {10, 20, 30, 40, 50};
// 访问和修改数组元素
System.out.println("第一个元素：" + numbers[0]);
numbers[1] = 25;
System.out.println("修改后的第二个元素：" + numbers[1]);
// 遍历数组
for (int i = 0; i < numbers.length; i++) {
System.out.println("数组元素：" + numbers[i]);
}
}
}
输出结果
4.2 多维数组的使用
4.2.1 多维数组的基本概念
多维数组是数组的数组，最常见的多维数组是二维数组。二维数组常用于表示表格或矩阵。
4.2.2 二维数组的声明和初始化
1.声明：
int[][] matrix; // 声明一个整型二维数组
2.初始化：
-
静态初始化：
int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
-
动态初始化：
int[][] matrix = new int[3][]; // 第一维长度为3，第二维长度动态指定 matrix[0] = new int[3]; matrix[1] = new int[2]; matrix[2] = new int[4];
4.2.3 访问二维数组元素
通过两个索引（下标）来访问二维数组元素。
int value = matrix[1][2]; // 访问第二行第三列的元素
4.2.4 案例代码
public class TwoDArrayExample {
public static void main(String[] args) {
// 静态初始化二维数组
int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
// 访问二维数组元素
System.out.println("第二行第三列的元素：" + matrix[1][2]);
// 遍历二维数组
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[i].length; j++) {
System.out.print(matrix[i][j] + " ");
}
System.out.println(); // 换行
}
}
}
输出结果
5 方法
5.1 方法的定义
在Java中，方法（也称为函数）是用来执行特定任务的代码块。方法的定义包括方法名、返回类型（如果方法返回值）、参数列表以及方法体。
示例：
public class Example {
// 一个无参数、无返回值的方法（void表示不返回任何值）
public void sayHello() {
System.out.println("Hello, World!");
}
// 一个带参数、有返回值的方法
public int addNumbers(int a, int b) {
return a + b;
}
}
5.2 方法的使用
使用（或调用）方法时，你需要指定方法名，并传递任何必要的参数（如果方法有参数的话）。调用方法的结果（如果有的话）可以被赋值给一个变量，或者直接使用（如果返回类型是void）。
示例：
public class ExampleDemo {
public static void main(String[] args) {
Example example = new Example();
// 调用无参数的方法
example.sayHello();
// 调用带参数的方法，并将结果赋值给变量
int sum = example.addNumbers(5, 3);
System.out.println("The sum is: " + sum);
}
}
5.3 方法的返回值
方法的返回类型决定了方法执行完毕后返回给调用者的值的类型。如果方法没有返回值，其返回类型应该是void。
示例（见上面addNumbers方法）。
5.4 方法的调用
方法的调用是通过方法名进行的，并可能包含传递给方法的参数列表（用括号包围）。调用方法后，控制权会传递给该方法，执行其中的代码块，然后返回（如果有返回值的话）。
示例（见上面main方法中的方法调用）。
5.5 递归
递归是一种编程技术，其中方法会直接或间接地调用自己。递归通常用于解决可以分解为更小、类似子问题的问题，如阶乘、斐波那契数列等。
示例：计算阶乘的递归方法：
public class Factorial {
public static int factorial(int n) {
if (n == 0 || n == 1) {
return 1;
} else {
return n * factorial(n - 1);
}
}
public static void main(String[] args) {
System.out.println("Factorial of 5 is: " + factorial(5));
}
}
6 局部变量和成员变量
6.1 局部变量
-
定义位置：在方法、构造器或者初始化块中定义。
-
作用范围：定义它的块内，包括该块中的嵌套块。
-
生命周期：当进入定义它的块时，被创建；当退出该块时，被销毁。
-
初始化：局部变量在使用前必须显式初始化，否则编译会报错。
6.2 成员变量
-
定义位置：在类中，但在任何方法、构造器或初始化块之外。
-
作用范围：整个类体。
-
生命周期：与对象的存在时间一致，当对象被创建时，成员变量被分配内存空间并初始化；当对象被销毁时，成员变量所占用的内存空间被释放。
-
初始化：如果没有显式初始化，则会有默认值（如数值类型默认为0，引用类型默认为null）。
6.3 案例
public class VariableExample {
// 成员变量（静态成员变量）
static int staticVar = 10;
// 成员变量（实例成员变量）
int instanceVar = 20;
public static void main(String[] args) {
// 静态方法中的局部变量
int localVarInStaticMethod = 30;
System.out.println("Local variable in static method: " + localVarInStaticMethod);
// 创建对象
VariableExample example = new VariableExample();
// 访问静态成员变量
System.out.println("Static member variable: " + staticVar);
// 访问实例成员变量（通过对象）
System.out.println("Instance member variable: " + example.instanceVar);
// 对象方法中的局部变量
example.printLocalVariable();
}
// 实例方法
public void printLocalVariable() {
// 局部变量
int localVarInInstanceMethod = 40;
System.out.println("Local variable in instance method: " + localVarInInstanceMethod);
// 访问实例成员变量（直接访问，因为当前对象上下文中）
System.out.println("Instance member variable (inside instance method): " + this.instanceVar);
// 访问静态成员变量（也可以，但通常不推荐在实例方法中直接访问静态成员）
System.out.println("Static member variable (inside instance method): " + staticVar);
}
}
输出：
Local variable in static method: 30 Static member variable: 10 Instance member variable: 20 Local variable in instance method: 40 Instance member variable (inside instance method): 20 Static member variable (inside instance method): 10
