java学习day1--运算符、判断、循环（习题讲解，附带全套源代码及其问题分析）

●VON

已于 2024-07-07 16:20:31 修改

阅读量839

点赞数 18

分类专栏： java从入门到起飞文章标签：学习 java chatgpt

于 2024-07-06 18:14:24 首次发布

本文链接：https://blog.csdn.net/2302_80329073/article/details/140232352

版权

java从入门到起飞专栏收录该内容

25 篇文章 0 订阅

订阅专栏

一、前言

本系列是java篇，因为有python和C语言的基础，所以准备一周将java拿下。我个人认为这些编程语言都是想通的，特别是前几张基础概念，这些基础概念如果在之前学习的过程中掌握的很好，那就没必要在这上面浪费时间了。要去寻找这些编程语言的不同之处。

特别提醒：如果自学能力足够强可以跟着小编一同学习欧❥(^_-)

二、概念

在Java中，运算符、选择结构（条件语句）、循环结构是编程中的基础知识点。这些基础知识点在各各编程语言中都十分相似，不能说不一样，只能说不完全一样。在这里不做过多赘述了

2.1运算符

在Java中，运算符用于执行各种操作，包括算术运算、逻辑运算、位运算等。常见的运算符包括：

算术运算符：用于基本数学运算，如 +、-、*、/、%。

int a = 10 + 5; // 加法
int b = 10 - 5; // 减法
int c = 10 * 5; // 乘法
int d = 10 / 5; // 除法
int e = 10 % 3; // 求余

关系运算符：用于比较两个值的关系，如 >、<、>=、<=、==、!=。

boolean isEqual = (a == b); // 等于
boolean isGreater = (a > b); // 大于

逻辑运算符：用于布尔逻辑运算，如 &&（与）、||（或）、!（非）。

boolean result = (a > 0 && b < 0); // 与
boolean result2 = (a > 0 || b < 0); // 或
boolean result3 = !(a > 0); // 非

位运算符：对数据的二进制位进行操作，如 &（按位与）、|（按位或）、^（按位异或）、<<（左移）、>>（右移）等。

int result = 5 & 3; // 按位与
int result2 = 5 | 3; // 按位或

赋值运算符：用于给变量赋值，如 =、+=、-=、*=、/= 等。

int x = 10;
x += 5; // 等价于 x = x + 5;

2.2选择结构

选择结构用于根据条件选择性地执行不同的代码块。Java中的选择结构包括 if、else if、else 和 switch 语句。

if 语句：用于根据条件执行单个代码块。

if (condition) {
    // 如果条件为真，则执行这里的代码
}

else if 语句：在 if 条件为假时，检查另一个条件。

if (condition1) {
    // 如果条件1为真，则执行这里的代码
} else if (condition2) {
    // 如果条件1为假且条件2为真，则执行这里的代码
}

else 语句：在前面的所有条件均不满足时执行。

if (condition) {
    // 如果条件为真，则执行这里的代码
} else {
    // 如果条件为假，则执行这里的代码
}

switch 语句：用于根据表达式的值执行不同的代码块。

switch (expression) {
    case value1:
        // 如果 expression 等于 value1，则执行这里的代码
        break;
    case value2:
        // 如果 expression 等于 value2，则执行这里的代码
        break;
    default:
        // 如果 expression 与任何 case 都不匹配，则执行这里的代码
}

2.3循环结构

循环结构用于重复执行一段代码，直到某个条件不再满足为止。Java中的循环结构包括 for、while、do-while 循环。

for 循环：在已知循环次数时使用。

for (initialization; condition; update) {
    // 循环体，当条件为真时执行
}

while 循环：在未知循环次数，但循环前需先检查条件时使用。

while (condition) {
    // 循环体，当条件为真时执行
}

do-while 循环：在未知循环次数，但循环体至少执行一次时使用。

do {
    // 循环体，至少执行一次
} while (condition);

三、习题

3.1输出三位数的每一位

package day1;

import java.util.Scanner;

public class text1 {
    public static void main(String[] args) {
        //1.键盘输入一个三位数
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个三位数");
        int num = sc.nextInt();
        //2.获取每一位
        int ge = num % 10;
        int shi = num / 10 % 10;
        int bai = num / 100 % 10;
        System.out.println("百位：" + bai + "十位:" + shi + "个位:" + ge);
    }
}

Scanner sc = new Scanner(System.in); 创建了一个 Scanner 对象 sc，用于从控制台获取用户输入。
int num = sc.nextInt(); 通过 nextInt() 方法获取用户输入的整数，并赋值给变量 num。
int ge = num % 10; 计算个位数。
int shi = num / 10 % 10; 计算十位数。
int bai = num / 100 % 10; 计算百位数。
System.out.println("百位：" + bai + " 十位:" + shi + " 个位:" + ge); 将结果输出到控制台。

3.2看代码说结果

package day1;

public class text2 {
    public static void main(String[] args) {
        //算术运算符
        //看代码说结果
        System.out.println(3.7+"abc");
        System.out.println("abc"+false);
        System.out.println(7+"天"+"拿下"+"java");
        int age = 18;
        System.out.println("我今年"+age+"岁");
        System.out.println("我今年"+"age"+"岁");
        System.out.println(1+2+"abc"+3+4);
    }
}

逐语句分析

1.System.out.println(3.7+"abc");

在Java中，如果一个操作数是字符串类型（如 "abc"），则其他操作数会被转换为字符串类型并进行拼接。

因此，3.7 会被转换为字符串 "3.7"，然后与 "abc" 进行拼接，输出结果为 3.7abc。

2.System.out.println("abc"+false);

同理，false 会被转换为字符串 "false"，然后与 "abc" 进行拼接。

输出结果为 abcfalse。

3.System.out.println(7+"天"+"拿下"+"java");

在这里，所有操作数都是字符串。

首先，7 被转换为字符串 "7"，然后依次与后面的字符串进行拼接。

输出结果为 7天拿下java。

4.int age = 18; System.out.println("我今年"+age+"岁");

age 是一个整数变量，但在拼接过程中，它会自动转换为字符串类型。

输出结果为 我今年18岁。

5.System.out.println("我今年"+"age"+"岁");

这里 "age" 是一个普通的字符串，不是变量。因此，会按照字符串拼接的规则直接输出。

输出结果为 我今年age岁，没有变量替换。

6.System.out.println(1+2+"abc"+3+4);

首先，先进行数字的加法运算，1 + 2 得到 3。

然后，3 会被转换为字符串 "3"，与后面的字符串 "abc" 进行拼接。

最终结果为 "3abc"。

然后，继续将字符串 "3abc" 与数字 3 和 4 进行拼接。

输出结果为 3abc34。

3.3字符串拼接

package day1;

public class text3 {
    public static void main(String[] args) {
        //当字符+字符或字符+数字的时候，会吧字符通过ascii码表查询到对应的数字在进行计算
        System.out.println(1+'a');
        //只要有字符串就是拼接操作
        System.out.println('a'+"abc");
    }
}

System.out.println(1+'a');
- 在Java中，当一个整数与一个字符相加时，会将字符转换为其对应的ASCII码值，然后进行相加。
- ASCII 码中，小写字母 'a' 对应的值为 97。
- 所以，表达式 1 + 'a' 等价于 1 + 97。
- 结果为整数相加，所以输出 98。
System.out.println('a'+"abc");
- 这里涉及字符串拼接操作。
- 字符 'a' 会被自动转换为字符串 "a"，然后与后面的字符串 "abc" 进行拼接。
- 输出结果为 "aabc"。

3.4比较年龄

package day1;

import java.util.Scanner;

public class text4 {
    //比较小明和小李的年龄
    public static void main(String[] args) {
        //赋值运算符和关系运算符
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入小明年龄：");
        int xm = sc.nextInt();
        System.out.println("请输入小李的年龄：");
        int xl = sc.nextInt();
        boolean result = xm > xl;
        System.out.println(result);
    }
}

逐语句分析

1.Scanner sc = new Scanner(System.in);

创建了一个 Scanner 对象 sc，用于从标准输入（通常是键盘输入）读取数据。

2.System.out.println("请输入小明年龄：");

在控制台输出提示信息，提示用户输入小明的年龄。

3.int xm = sc.nextInt();

使用 Scanner 对象 sc 的 nextInt() 方法，从用户输入中读取一个整数值，并将其赋给变量 xm。

4.System.out.println("请输入小李的年龄：");

输出另一条提示信息，提示用户输入小李的年龄。

5.int xl = sc.nextInt();

同样使用 nextInt() 方法，从用户输入中读取小李的年龄，并将其赋给变量 xl。

6.boolean result = xm > xl;

使用关系运算符 > 比较 xm 和 xl 的大小。如果 xm 大于 xl，则 result 变量被赋值为 true；否则赋值为 false。

7.System.out.println(result);

最后，输出变量 result 的值，即输出比较的结果，可能是 true（如果 xm 大于 xl）或 false（如果 xm 不大于 xl）。

3.5逻辑运算符

package day1;

public class text5 {
    public static void main(String[] args) {
        //逻辑运算符
        //&逻辑与，两边都为真结果为真
        //|逻辑或，两边都为假结果才是假
        //！逻辑非，取反
        //^异或，想同为false，不同为true
        System.out.println(true&true);
        System.out.println(true&false);
        System.out.println(false&true);
        System.out.println(false&false);

        System.out.println(true|true);
        System.out.println(true|false);
        System.out.println(false|true);
        System.out.println(false|false);

        System.out.println(true^true);
        System.out.println(true^false);
        System.out.println(false^true);
        System.out.println(false^false);

        System.out.println(!false);
        System.out.println(!true);
    }
}

逐语句分析

1.System.out.println(true&true);

& 是逻辑与运算符，用于判断两个条件是否同时为真。

true & true 的结果为 true，因为两边的条件都为真。

2.System.out.println(true&false);

true & false 的结果为 false，因为有一个条件不满足（即右边为假）。

3.System.out.println(false&true);

false & true 的结果为 false，因为有一个条件不满足（即左边为假）。

4.System.out.println(false&false);

false & false 的结果为 false，因为两个条件都不满足。

5.System.out.println(true|true);

| 是逻辑或运算符，用于判断两个条件是否至少有一个为真。

true | true 的结果为 true，因为至少有一个条件为真。

6.System.out.println(true|false);

true | false 的结果为 true，因为至少有一个条件为真。

7.System.out.println(false|true);

false | true 的结果为 true，因为至少有一个条件为真。

8.System.out.println(false|false);

false | false 的结果为 false，因为两个条件都不满足。

9.System.out.println(true^true);

^ 是逻辑异或运算符，用于判断两个条件是否相同。

true ^ true 的结果为 false，因为两个条件相同（都为真）。

10.System.out.println(true^false);

true ^ false 的结果为 true，因为两个条件不相同（一个为真，一个为假）。

11.System.out.println(false^true);

false ^ true 的结果为 true，因为两个条件不相同（一个为假，一个为真）。

12.System.out.println(false^false);

false ^ false 的结果为 false，因为两个条件相同（都为假）。

13.System.out.println(!false);

! 是逻辑非运算符，用于取反。

!false 的结果为 true，因为 false 取反后为 true。

14.System.out.println(!true);

!true 的结果为 false，因为 true 取反后为 false。

3.6回文数

package day1;

import java.util.Scanner;

public class text6 {
    public static void main(String[] args) {
        //回文数
        //需求：输入一个正整数，如果是回文数返回true，否则返回false
        //解释：回文数是指正序和倒序读的一样的整数
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个正整数：");
        int n = sc.nextInt();
        int temp = n;
        int num = 0;
        while (n != 0) {
            int a = n % 10;
            n /= 10;
            num = num * 10 + a;
        }
        System.out.println(num==temp);
    }
}

逐语句分析

1.Scanner sc = new Scanner(System.in);

创建了一个 Scanner 对象 sc，用于从控制台获取用户输入。

2.System.out.println("请输入一个正整数：");

打印输出提示信息，要求用户输入一个正整数。

3.int n = sc.nextInt();

使用 Scanner 对象 sc 的 nextInt() 方法获取用户输入的整数，并将其赋值给变量 n。

4.int temp = n;

创建变量 temp，用于保存输入的整数 n 的原始值，以便后续比较。

5.int num = 0;

创建变量 num，初始化为 0，用于存储 n 的反转后的数字。

6.while (n != 0) {

进入 while 循环，条件是 n 不等于 0，即当输入的整数还有未处理的数字时执行循环体。

7.int a = n % 10;

计算 n 的个位数字，将结果赋值给变量 a。

8.n /= 10;

将 n 除以 10，更新 n 为去掉个位数字后的剩余数字。

9.num = num * 10 + a;

将变量 a 加入到 num 中，实现 n 的反转过程。

}

结束 while 循环。

10.System.out.println(num == temp);

比较反转后的 num 是否等于最初输入的 temp。如果相等，输出 true，表示输入的整数是回文数；否则输出 false，表示输入的整数不是回文数。

3.7求商和余数

package day1;

import java.util.Scanner;

public class text7 {
    public static void main(String[] args) {
        //需求：求商和余数。
        //要求不使用乘法、除法、和%运算符
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入被除数：");
        int number = sc.nextInt();
        System.out.println("请输入除数：");
        int number1 = sc.nextInt();
        int count = 0;
        while(number>=number1)
        {
            number -= number1;
            count+=1;
        }
        System.out.println("商为："+count);
        System.out.println("余数："+number);
    }
}

逐语句分析

1.Scanner sc = new Scanner(System.in);

创建了一个 Scanner 对象 sc，用于从控制台获取用户输入。

2.System.out.println("请输入被除数：");

打印输出提示信息，要求用户输入被除数。

3.int number = sc.nextInt();

使用 Scanner 对象 sc 的 nextInt() 方法获取用户输入的被除数，并将其赋值给变量 number。

4.System.out.println("请输入除数：");

打印输出提示信息，要求用户输入除数。

5.int number1 = sc.nextInt();

使用 Scanner 对象 sc 的 nextInt() 方法获取用户输入的除数，并将其赋值给变量 number1。

6.int count = 0;

创建变量 count，用于存储商的值，初始化为 0。

7.while(number >= number1)

进入 while 循环，条件是被除数 number 大于等于除数 number1。

8.number -= number1;

在循环中，使用减法操作更新被除数 number，相当于模拟除法操作。

9.count += 1;

每次循环，商 count 增加 1。

}

结束 while 循环。

10.System.out.println("商为：" + count);

打印输出商的值。

11.System.out.println("余数：" + number);

打印输出余数的值，即最后剩余的 number。

3.8逢七过

package day1;

public class text8 {
    public static void main(String[] args) {
        //逢七过
        //规则：从任意一个数字开始报数，当你报的数字是包含7或者是7的倍数时都要说过
        //需求：打印出1-100之内满足逢七过规则的数据
        for (int i = 1; i < 100; i++) {
            if(i % 7 == 0 || i % 10 == 7 || i / 10 % 10 == 7) {
                System.out.println("过");
                continue;
            }
            System.out.println(i);
        }
    }
}

1.for (int i = 1; i < 100; i++) {

这是一个 for 循环，初始化变量 i 为1，每次循环递增 i，直到 i 小于100为止。

2.if (i % 7 == 0 || i % 10 == 7 || i / 10 % 10 == 7) {

在循环体内，使用 if 条件语句判断是否满足以下任一条件：

i % 7 == 0：i 是7的倍数。

i % 10 == 7：i 的个位数字是7。

i / 10 % 10 == 7：i 的十位数字是7。

如果满足任一条件，执行以下代码块。

3.System.out.println("过");

如果满足条件，输出字符串 "过"，表示按照规则需要说 "过"。

4.continue;

continue 语句使得程序跳过当前循环的剩余代码（即 System.out.println(i);），直接进行下一次循环。

5.System.out.println(i);

如果未满足上述条件，输出变量 i 的值。

3.9求平方根

package day1;

import java.util.Scanner;

public class text9 {
    public static void main(String[] args) {
        //求平方根
        //需求：键盘录入一个大于等于2的整数，计算并返回整数的平方根
        //结果：如果有平方根输出平方根，如果没有输出没有平方根
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int flag = 0;
        for (int i = 1; i < n/2; i++) {
            if(i*i == n) {
                System.out.println(n + "的平方根为" + i);
                flag = 1;
                break;
            }
        }
        if (flag == 0) {
            System.out.println(n + "没有平方根");
        }
    }
}

逐语句分析

1.Scanner sc = new Scanner(System.in);

创建了一个 Scanner 对象 sc，用于从控制台获取用户输入。

2.int n = sc.nextInt();

使用 Scanner 对象 sc 的 nextInt() 方法获取用户输入的整数，并将其赋值给变量 n。

3.int flag = 0;

创建一个 flag 变量，初始化为 0，用于标记是否找到了整数 n 的平方根。

4.for (int i = 1; i < n/2; i++) {

这是一个 for 循环，从 i = 1 开始，循环条件是 i < n/2，每次递增 i。

5.if(i*i == n) {

在循环体内，判断是否满足 i 的平方等于 n。

6.System.out.println(n + "的平方根为" + i);

如果满足条件，输出整数 n 的平方根为 i。

7.flag = 1;

将 flag 设置为 1，表示已经找到了整数 n 的平方根。

8.break;

跳出 for 循环，因为已经找到了平方根，不需要继续循环。

}

结束 if 语句。

9.if (flag == 0) {

判断 flag 是否为 0，即是否找到了整数 n 的平方根。

10.System.out.println(n + "没有平方根");

如果 flag 为 0，表示没有找到整数 n 的平方根，输出相应信息。

3.10求质数

package day1;

import java.util.Scanner;

public class text10 {
    public static void main(String[] args) {
        //求质数
        //需求：键盘输入一个大于2的正整数，判断整数是否为质数
        //结果：如果是质数，输出true，否则输出false
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数");
        int n = sc.nextInt();
        int flag = 0;
        for (int i = 2; i < n; i++) {
            if(n % i == 0){
                System.out.println(n + "不是质数");
                flag = 1;
                break;
            }
        }
        if(flag == 0){
            System.out.println(n + "是质数");
        }
    }
}

逐语句分析

1.Scanner sc = new Scanner(System.in);

创建了一个 Scanner 对象 sc，用于从控制台获取用户输入。

2.System.out.println("请输入一个整数");

在控制台输出提示信息，要求用户输入一个整数。

3.int n = sc.nextInt();

使用 Scanner 对象 sc 的 nextInt() 方法获取用户输入的整数，并将其赋值给变量 n。

4.int flag = 0;

创建一个 flag 变量，初始化为 0，用于标记是否找到 n 的因子。

5.for (int i = 2; i < n; i++) {

这是一个 for 循环，从 i = 2 开始，逐个检查 i 是否为 n 的因子，循环条件是 i < n。

6.if(n % i == 0){

在循环体内，判断是否存在 i 是 n 的因子（即 n 能被 i 整除）。

7.System.out.println(n + "不是质数");

如果找到 n 的因子，则输出 n 不是质数。

8.flag = 1;

将 flag 设置为 1，表示已经找到 n 的因子，因此 n 不是质数。

9.break;

跳出 for 循环，因为已经确定 n 不是质数。

}

结束 if 语句。

10.if(flag == 0){

判断 flag 是否为 0，即循环结束时未找到 n 的因子。

11.System.out.println(n + "是质数");

如果 flag 为 0，表示 n 没有除了1和自身以外的其他因子，因此输出 n 是质数。

3.11猜数字小游戏

package day1;

import java.util.Random;
import java.util.Scanner;

public class text11 {
    public static void main(String[] args) {
        //猜数字小游戏
        //需求：程序自动生成1-100的随机数字，使用程序实现猜出这个数字是多少
        //结果：返回该数字，及其猜测的次数
        Random r = new Random();
        int guess = r.nextInt(101);
        int count = 0;
        while(true){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你要猜的数字");
        int n = sc.nextInt();

            if(n > guess) {
                System.out.println("大了");
                count+=1;
            }
            else if(n < guess) {
                System.out.println("小了");
                count+=1;
            }
            else{
                break;
            }
        }
        System.out.println("恭喜您猜中了");
        System.out.println("一共猜了"+(count+1)+"次"+","+"所猜测数字为"+guess);
    }
}

逐语句分析

1.导入必要的类库

import java.util.Random;

import java.util.Scanner;

Random 类用于生成随机数。
Scanner 类用于从标准输入（键盘）读取用户输入的数据。

主程序类定义及主方法

public class text11 { public static void main(String[] args) {

2.生成随机数和初始化计数器

Random r = new Random();

int guess = r.nextInt(101); // 生成0到100之间的随机整数

int count = 0; // 初始化猜测次数计数器

Random r = new Random(); 创建一个 Random 对象 r，用于生成随机数。
int guess = r.nextInt(101); 生成一个范围在0到100之间的随机整数，作为待猜测的数字。
int count = 0; 初始化一个计数器 count，用来记录猜测的次数。

3.猜数字的逻辑循环

while(true){
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入你要猜的数字");
    int n = sc.nextInt();
    
    if(n > guess) {
        System.out.println("大了");
        count+=1;
    }
    else if(n < guess) {
        System.out.println("小了");
        count+=1;
    }
    else{
        break;
    }
}

while(true) { ... }：这是一个无限循环，直到用户猜中正确的数字才会跳出循环。
Scanner sc = new Scanner(System.in); 创建一个 Scanner 对象 sc，用于从标准输入读取用户输入的整数。
System.out.println("请输入你要猜的数字"); 提示用户输入猜测的数字。
int n = sc.nextInt(); 从标准输入读取用户输入的整数，并赋值给变量 n。
判断用户猜测的数字与随机生成的数字 guess 的关系：
- 如果 n > guess，提示用户数字太大，并增加猜测次数 count。
- 如果 n < guess，提示用户数字太小，并增加猜测次数 count。
- 如果 n == guess，表示用户猜中了，跳出循环。

4.猜中后的输出结果

System.out.println("恭喜您猜中了");
System.out.println("一共猜了" + (count + 1) + "次" + "," + "所猜测数字为" + guess);

输出恭喜信息表示用户猜中了。
输出总共猜测的次数 count + 1（因为初始化时 count 是0，但最后一次猜测也要算进去）和猜中的数字 guess。

四、总结

如果您能看到这，希望能够多多支持小编，本文对每一个小练习都做了逐语句分析，希望读者能够一句一句的去读程序，又不懂的地方可以去看看解析，对每一个语句都进行了讲解。这才是第一天，希望读者们也能在这个暑假中收获颇丰。❥(^_-)

●VON

关注

18
点赞
踩
17

收藏

觉得还不错? 一键收藏
1
评论
java学习day1--运算符、判断、循环（习题讲解，附带全套源代码及其问题分析）

本系列是java篇，因为有python和C语言的基础，所以准备一周将java拿下。我个人认为这些编程语言都是想通的，特别是前几张基础概念，这些基础概念如果在之前学习的过程中掌握的很好，那就没必要在这上面浪费时间了。要去寻找这些编程语言的不同之处。
复制链接

扫一扫

专栏目录