Java| 02 基本教程 运算符、判断、循环等

😀 Java不仅仅是早晨提神的咖啡，它还是一种能让你的创意无限放大的编程语言！在这篇基本教程中，我们不会让你单调地敲代码，而是要一起探索Java的奥秘，从运算符到循环，每一步都充满了发现的喜悦。无论你是初次涉足编程的新手，还是想要回顾基础的资深开发者，这里都有你期待的惊喜。让我们一起把这些看似普通的代码行，变成能够解决实际问题、创造有趣项目的强大工具吧！

运算符和表达式

运算符是对字面量或者变量进行操作的符号。

表达式是用运算符把字面量或变量连接起来, 符合java语法的式子. 不同运算符链接的表达式体现的是不同类型的表达式.

例如在以下代码中, +是运算符, 并且是算数运算符; a+b是表达式, 并且+是算术表达式; 所以这表表达式叫算术表达式.

1
2
3
4
5
6
7
public class test {
    public static void main(String[] args) {
        int a = 10;
        int b = 30;
        int c = a + b;
    }
}

在IDEA中, 输入psvm可以自动填充public static void main(String[] args) {}.

输入sout可以自动填充System.*out*.println()**;.**

算数运算符

符号 作用
+ 加
- 减
* 乘
/ 除
% 取模, 取余

注意: 如果有小数参与计算, 结果有可能不精确.

小练习: 数据拆分

题目: 键盘录入三个数, 将其拆分为个位, 十位, 百位并输出

公式:

需求 方法
输出个位 数值 % 10
输出十位 数值 / 10 %10
输出百位 数值 / 100 %10

完整代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 导包

import java.util.Scanner;

public class test {
    // 主函数
    public static void main(String[] args) {
        // 输入提示
        System.out.println("请输入3个整数:");
        // 创建对象
        Scanner input_int = new Scanner(System.in);
        // 获取数据
        int a = input_int.nextInt();
        // 取个位并输出
        int ones_digit = a % 10;
        System.out.println("个位\t" + ones_digit);
        // 取十位并输出
        int tenth_place = a / 10 % 10;
        System.out.println("十位\t" + tenth_place);
        // 取百位并输出
        int hundred_place = a / 100 % 10;
        System.out.println("百位\t" + hundred_place);
    }
}

输出结果:

https://picningguoxu.080912.xyz/file/ac24deac2f91581be3991.png

隐式转换与强制转换

数字相加

数字进行运算时, 数据类型不一样不能运算, 需要转成一样的, 才能运算.

隐式转换

**隐式转换(自动类型提升)**是把取值范围小的数字转成取值范围大的数字.

范例:

1
2
int a = 10;
double b = a;

取值范围从小到大: byte < short < int < long < float < double

提升规则：

取值范围小的和取值范围大的进行运算时, 小的会先提升成大的, 再进行运算.

byte, short, char在运算的时候会提升为int再进行运算.

强制转换

强制转换是把取值范围大的数字转成取值范围小的数字.

格式: 目标数据类型 变量名 = (目标数据类型) 被强转的数据

范例:

1
2
3
double a = 1.2;
// 将double类型的变量a强制类型转换为int类型，并赋值给变量b
int b = (int) a; // 强制类型转换为int类型

字符串相加

当”+”操作出现字符串时, 这个”+”是字符串连接符, 不是算数运算符. 会将前后的数据进行拼接, 并产生一个新的字符串.

1
2
3
4
5
6
7
public class Main {
    public static void main(String[] args) {
        String a = "123";
        int b = 123;
        System.out.println(a + b);    // 输出结果为123123
    }
}

连续进行”+”操作时, 按从左到右依次执行. 

1
2
3
4
5
6
7
8
public class Main {
    public static void main(String[] args) {
        int a = 123;
        int b = 456;
        String c = "测试";
        System.out.println(a + b + c);    // 输出结果为579测试
    }
}

字符相加

当字符+字符或字符+数字是, 会把字符通过ASCII码表查询的数字进行计算.

https://picningguoxu.080912.xyz/file/c163a6786c08efdd5a5b6.png

https://picningguoxu.080912.xyz/file/adef52f00b494622a89ec.png

自增自减运算符

符号 作用 说明
$++$ 加 变量的值+1
$–$ 减 变量的值-1

$++$和$–$均可放到变量的前边, 也可放到变量的后边.

赋值运算符

符号 作用 说明
= 赋值 int a = 10, 将10赋值给变量a
+= 加后赋值 a += b, 将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的值是否相等, 成立为true, 不成立为false
$!=$ 判断a和b是否不相等, 成立为true, 不成立为false
$>$ 判断a是否大于b, 成立为true, 不成立为false
$>=$ 判断a是否大于等于b, 成立为true, 不成立为false
$<$ 判断a是否小于b, 成立为true, 不成立为false
$<=$ 判断a是否小于等于b, 成立为true, 不成立为false

完整代码:

1
2
3
4
5
6
7
8
9
10
11
package learnjava;

public class test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 20;
        System.out.println(a == b);
        System.out.println(b == c);
    }
}

输出结果:

https://picningguoxu.080912.xyz/file/d22fd8999a8510143b780.png

逻辑运算符

符号 作用 说明
& 逻辑与(且) 并且, 两边都为真, 结果才为真
| 逻辑或 或者, 两边都为假, 结果才为假
^ 逻辑异或 相同为false, 不同为true
! 逻辑非 取反

短路逻辑运算符

符号 作用 说明
&& 短路与 结果和&一样, 但是又短路效果
|| 短路或 结果和

完整代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.learnjava.test;

public class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        // 当左边表达式能确定最终结果时, 那么右边就不会参与运算了.
        boolean result = a++ <5 && b++ <5;
        System.out.println(result);
        System.out.println(b);
        System.out.println(a);
    }
}

输出结果:

https://picningguoxu.080912.xyz/file/eb71b788ebf85df37a79c.png

就常用的逻辑运算符: &&, ||, !

三元运算符

格式: 关系表达式? 表达式1 : 表达式2;

范例: 求两个数的较大值

1
2
3
4
5
6
7
8
9
10
package com.learnjava.test;

public class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 30;
        int max = a>b ? a : b;
        System.out.println(max);
    }
}

计算规则:

  • 首先计算表达式的值
  • 如值为true, 则表达式1的值就是结果
  • 如值为false, 则表达式2的值就是结果

运算符优先级: 小括号优先所有

分支结构——if语句

格式1

1
2
3
if(关系表达式){
	语句体;
}

范例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.learnjava.test;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        System.out.println("请输入数据:");
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        // 输入数据判断数据是否大于2
        if (a > 2) {
            System.out.println(a + ">2");
        } else {
            System.out.println(a + "<=2");
        }
    }
}

格式2

1
2
3
4
5
if (关系表达式) {
    语句体1;
} else {
    语句体2;
}

范例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        System.out.println("请输入数据: ");
        Scanner sc = new Scanner(System.in);
        int var = sc.nextInt();
        // 使用if判断
        if (var <= 100) {
            System.out.println("这个数字小于等于100");
        } else {
            System.out.println("这个数字大于100");
        }
    }
}

格式3

1
2
3
4
5
6
7
if (关系表达式) {
    语句体1;
} else if (关系表达式) {
    语句体2;
} else {
    语句体n+1;
}

范例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        System.out.println("请输入数据: ");
        Scanner sc = new Scanner(System.in);
        int var = sc.nextInt();
        if (var < 100) {
            System.out.println("这个数字小于100");
        } else if (var == 100) {
            System.out.println("这个数字就是100");
        } else {
            System.out.println("这个数字大于100");
        }
    }
}

分支语句——switch语句

1
2
3
4
5
6
7
8
9
10
11
12
switch (表达式){
	case 值1:
			语句体1;
	    break;
	case 值2:
			语句体2;
	    break;
	    
	default:
			语句体n+1;
	    break;
}

范例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        System.out.println("请输入你想吃的东西的编号：");
        Scanner sc = new Scanner(System.in);
        int wantEat = sc.nextInt();
        switch (wantEat) {
            case 1:
                System.out.println("I want to eat pizza.");
                break;
            case 2:
                System.out.println("I want to eat apple.");
                break;
            case 3:
                System.out.println("I want to eat burger.");
                break;
            default:
                System.out.println("I don't want to eat.");
        }
    }
}

default的位置和省略

  1. default不一定要写在最后, 只是习惯上这么写.
  2. default可以省略, 语法不会报错, 但是不建议

case穿透

  1. 语句体没写break导致的
  2. 当一个case分支在执行完毕后没有遇到break语句而直接继续执行下一个case分支的代码的现象。这意味着，即使下一个case的条件并未满足，其代码也会被执行.
  3. 使用场景: 如果多个case语句体重复了, 可以尝试使用case穿透来简化代码.

Switch新特性

该特性只在JDK12后的版本可用

1
2
3
4
5
6
7
switch (表达式) {
case 10 -> {
    语句体1;
}
default -> {
		语句体2;
}

注: 如果大括号里只有一行代码, 那么可以将其省略.

if和switch的使用场景

  • if的第三种格式: 一般用于对范围的判断
  • switch: 把有限个数据一一列举出来, 让我们任选其一.

循环结构——for

1
2
3
for (初始化语句; 条件判断语句; 条件控制语句) {
     循环体语句;
}

范例: 打印10次HelloWorld

1
2
3
for (int a = 0; a < 10; a++){
    System.out.println(a + "Hello World");
}

运行结果:

https://picningguoxu.080912.xyz/file/4dad630cf1041426ffbe2.png

虽然图里显示打印到了9, 但是别忘了开头是0.

  1. 初始化语句只会执行一次
  2. 判断语句为true, 循环继续
  3. 判断语句为false, 循环结束

小项目: 计算1-5的总和

完整代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
// 主类
class Main {
    // 主方法
    public static void main(String[] args) {
        int sum = 0;
        // for循环，计算1到5的累加和
        for (int a = 1; a <= 5; a++) {
            sum = sum + a;
            // 输出当前累加和
            System.out.println(sum);
        }
    }
}

运行结果:

https://picningguoxu.080912.xyz/file/533bde4e208791ad729cb.png

循环结构——While

1
2
3
4
5
初始化语句;
while(条件判断语句){
    循环体语句;
    条件控制语句;
}

示例: 打印1-100

1
2
3
4
5
6
7
8
9
class Main{
    public static void main(String[] args) {
        int num = 0;
        while(num <100){
            num = num+1;
            System.out.println(num);
        }
    }
}
  • 什么时候用for? 什么时候用while?
    • for循环中, 控制循环的变量, 因为归属在for循环中, 所以循环结束后就不能再被访问了.并且知道循环次数或者循环范围.
    • while循环中, 控制循环的变量不在while语句体内, 所以结束后还可以被访问.并且不知道循环次数或者循环范围, 只知道结束条件

循环结构————do while

1
2
3
4
5
初始化语句;
do {
	循环体语句;
	条件控制语句;
} while(条件判断语句);

练习: ✨输出折纸次数————斯坦福大学Java练习题

题目: 世界最高山峰珠穆朗玛峰(8844.43m≈8844430mm), 现在有一张足够大的纸, 它的厚度是0.1mm, 请问需要折多少次, 才能达到珠穆朗玛峰的高度?

  • 分析及回答:

    • 每一次纸张折叠的厚度是原来的二倍.
    • 由于不知道循环次数或循环范围, 所以用for循环不合适; 有知道结束条件, 所以只利用while循环比较合适.

    综上, 完整代码应该是这样的:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    public class Main {
        public static void main(String[] args) {
            // 定义变量
            double height = 8844430;
            double paper =0.1;
            // 定义初始次数变量
            int count = 0;
            // 循环
            while (height > paper) {
                paper = paper * 2;
                // 自增运算
                count++;
            }
            // 输出结果
            System.out.println("当折叠"+count+"次时, 珠穆朗玛峰的高度小于纸的高度");
        }
    }

    输出结果:

    https://picningguoxu.080912.xyz/file/c585b871751ec3a30cd0a.jpg

练习: ✨回文数————力扣算法真题

题目: 给你一个整数X, 判断它是不是回文数, 若是输出true, 若不是输出false.(回文数是指正序和倒序读都是一样的数)例如:121是回文, 123则不是.

  • 分析及回答

    核心思路: 将数字倒过来和原来的数字进行比对, 如果一样输出True. 不一样就输出False.

    完整代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    import java.util.Scanner;

    public class Main {
        public static void main(String[] args) {
            // 键盘接收
            System.out.println("请输入整数来判断是否是回文数: ");
            Scanner scanner = new Scanner(System.in);
            int x = scanner.nextInt();
            // 定义变量
            int temp = x;
            int num = 0;
            while (x != 0) {
                // 从右向左获取每一位数字
                int ge = x % 10;
                // 修改x记录的值
                x = x / 10;
                // 拼接数字
                num = num * 10 + ge;
            }
            // 判断并输出结果
            if (num == temp) {
                System.out.println(temp + "是回文数");
            } else {
                System.out.println(num + "和" + temp + "不是回文数");
            }
        }
    }

    运行结果:

    https://picningguoxu.080912.xyz/file/fe4786808bc4d1de7982c.png

🤗 总结归纳

Java基本教程涵盖了运算符、判断、循环等基础知识。文章详细解释了算术运算符、隐式转换与强制转换、字符串相加、字符相加、自增自减运算符、赋值运算符、关系运算符、逻辑运算符、短路逻辑运算符、三元运算符、if和switch语句、for、while和do while循环结构。同时，文章还提供了一些实际的编程练习，包括计算1-5的总和、输出折纸次数和判断回文数等。