Java 基础

一、Hello World 程序（入门第一个程序）

1. Hello_World.java

public class Hello_World {
    public static void main(String[] args)
    {
        System.out.println("Hello World");
    }
}

代码解释：

public class Hello_World：定义一个公开的类，类名必须和文件名（Hello_World.java）完全一致（包括大小写）
public static void main(String[] args)：程序的入口方法，所有 Java 程序都从这个方法开始执行
- public：公开的，允许外部访问
- static：静态的，不需要创建对象就能执行
- void：无返回值
- main：方法名，固定为main
- String[] args：方法参数，接收命令行输入的参数
System.out.println(“Hello World”)：打印语句，在控制台输出Hello World，println会自动换行

2. HelloWorld.java

package chuangjian.demo01;

public class HelloWorld {
    public static void main(String[] args){
        System.out.println("HelloWorld");
    }
}

代码解释：

/* … */：多行注释，注释内容不会被执行，用于说明代码
功能和上面的Hello_World.java一致，只是类名和输出内容少了空格，核心结构完全相同

二、数据类型与变量

1. 数据类型.java

public class 数据类型 {
    byte a = 1;
    short b = 1;
    int c = 1;
    long d = 1;
    float e =1.0f;
    double f =1.0d;
    boolean g =true;
    char h = 'A';
}

代码解释：
Java 中的基本数据类型分为四大类 8 种：

整数类型：byte（1 字节）、short（2 字节）、int（4 字节，默认）、long（8 字节）
浮点类型：float（4 字节）、double（8 字节，默认）
布尔类型：boolean（1 字节，值为true或false）
字符类型：char（2 字节，存储单个字符，用单引号’包裹）
注意：float类型赋值时需加后缀f（如1.0f），double可加d（也可省略）

2. 字面量.java

package chuangjian.demo01;

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

        //整数
        int a=10;
        System.out.println(a);

        byte b=10;
        System.out.println(b);

        short c=30;
        System.out.println(c);

        //如果要定义 long 类型的变量
        //在数据值的后面需要加一个 L 作为后缀
        long d = 9999999999L;
        System.out.println(d);

        //小数
        // float 类型数据值后面需加 F 作为后缀
        float e = 3.14F;
        System.out.println(e);
        // double 类型是小数的默认类型，可不加后缀
        double f = 2.718;
        System.out.println(f);

        //字符串
        String g = "Hello, World!";
        System.out.println(g);

        //字符
        char h = 'A';
        System.out.println(h);

        //布尔
        boolean i = true;
        System.out.println(i);
        boolean j = false;
        System.out.println(j);

        //空类型
        // null 不能直接打印，这里将其赋值给一个引用类型变量
        String k = null;
        System.out.println(k);
    }
}

代码解释：

字面量：直接写出来的数据值（如10、3.14、“Hello”）
整数字面量：默认是int类型，定义long时需加L（如9999999999L，避免超出int范围）
小数字面量：默认是double类型，定义float时需加F（如3.14F）
字符串字面量：用双引号"包裹（如"Hello, World!"），类型是String（引用类型）
字符字面量：用单引号’包裹单个字符（如’A’）
布尔字面量：只有true（真）和false（假）
null：表示引用类型变量没有指向任何对象（不能用于基本数据类型）

3. 定义变量.java

package chuangjian.demo01;

public class 定义变量 {
    public static void main(String[] args) {
        //定义变量记录姓名
        String name = "黑马";
        int age = 18;
        char gender = '男';
        double height = 180.2;
        boolean flag = true;

        //输出
        System.out.println(name);
        System.out.println(age);
        System.out.println(gender);
        System.out.println(height);
        System.out.println(flag);
    }
}

代码解释：

变量定义格式：数据类型变量名 = 初始值;（如int age = 18;）
作用：变量用于存储数据，方便后续使用和修改
示例中定义了不同类型的变量：
- String name：字符串类型，存储姓名
- int age：整数类型，存储年龄
- char gender：字符类型，存储性别
- double height：浮点类型，存储身高
- boolean flag：布尔类型，存储真假值
System.out.println(变量名)：打印变量存储的值

三、键盘输入

1. 键盘输入.java

package chuangjian.demo01;
import java.util.Scanner;

public class 键盘输入 {
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);

        System.out.println("请输入整数");
        int i=sc.nextInt();
        System.out.println(i);
    }
}

代码解释：

import java.util.Scanner;：导入Scanner类（用于获取键盘输入），必须放在类定义之前
Scanner sc = new Scanner(System.in);：创建Scanner对象，关联到键盘输入
System.out.println(“请输入整数”);：提示用户输入
int i = sc.nextInt();：获取用户输入的整数并赋值给变量i
注意：使用完Scanner后最好用sc.close();关闭（避免资源浪费）

2. 键盘输入并求和.java

package chuangjian.demo01;

import java.util.Scanner;

public class 键盘输入并求和 {
    public static void main(String[] args)
    {
        // 创建一个Scanner对象，用于从标准输入（键盘）读取数据
        Scanner sc=new Scanner(System.in);

        // 提示用户输入第一个数字
        System.out.println("请输入第一个数字：");
        // 从键盘读取第一个整数
        int number1=sc.nextInt();

        // 提示用户输入第二个数字
        System.out.println("请输入第二个数字：");
        // 从键盘读取第二个整数
        int number2=sc.nextInt();

        // 输出两个数字的和
        System.out.println(number1+number2);
    }
}

代码解释：

流程：创建Scanner → 提示输入 → 读取两个整数 → 计算并输出和
number1 + number2：整数相加，+在这里是算术运算符
扩展：如果要读取其他类型（如小数、字符串），可使用sc.nextDouble()、sc.next()等方法

四、控制流语句（循环与分支）

1. for循环.java

public class for循环 {
    public static void main(String[] args)
    {
        for (int i=0;i<5;i++)
        {
            System.out.println(i);
        }

        //for 增强循环
        int [] numbers = {1,2,3,4,5};
        for (int i:numbers)
        {
            System.out.println(i);
        }
    }
}

代码解释：

普通for循环：
- 格式：for (初始化; 循环条件; 迭代)
- 示例中for (int i=0; i<5; i++)：
  - 初始化：int i=0（定义循环变量并赋值）
  - 循环条件：i<5（条件为true时执行循环体）
  - 迭代：i++（每次循环后变量自增 1）
  - 循环体：System.out.println(i)（打印i的值，会输出0,1,2,3,4）
增强for循环（foreach 循环）：
- 格式：for (元素类型变量名 : 数组/集合)
- 作用：简化数组或集合的遍历，无需关注索引
- 示例中for (int i : numbers)：依次取出数组numbers中的元素赋值给i，并打印（输出1,2,3,4,5）

2. 小老虎吃包子.java

package chuangjian.demo01;

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

        for (int i = 1; i <=5; i++) {
            if (i==3) {
                continue;
            }
            System.out.println("小老虎在吃第"+i+"个包子");
        }

        for (int i = 1; i <=5; i++) {
            if (i==3) {
                break;
            }
            System.out.println("小老虎在吃第"+i+"个包子");
        }
    }
}

代码解释：

if (i==3)：条件判断，当i等于 3 时执行大括号内的代码
continue：跳过本次循环剩余部分，直接进入下一次循环
第一个循环中，当i=3时跳过，会输出：第 1、2、4、5 个包子
break：直接跳出整个循环
第二个循环中，当i=3时跳出，会输出：第 1、2 个包子

3. switch_case.java

public class switch_case {
    public static void main(String[] args)
    {
        char grade = 'A';
        switch (grade)
        {
            case 'A':
                System.out.println("A");
                break;
            case 'B':
                System.out.println("B");
                break;
            case 'C':
                System.out.println("C");
                break;
            case 'D':
                System.out.println("D");
                break;
            default:
                System.out.println("Unknown");
        }
        System.out.println("your grade is " + grade);
    }
}

代码解释：

switch语句：多条件分支判断，根据变量的值匹配对应的case
格式：

switch (变量) {
    case 值1: 代码1; break;
    case 值2: 代码2; break;
    ...
    default: 默认代码;
}

执行流程：
- 变量grade的值为’A’，匹配case ‘A’，执行System.out.println(“A”)
- break：跳出switch语句（如果没有break，会继续执行下一个case的代码）
- default：当所有case都不匹配时执行（可选）
- 最终输出：A 和 your grade is A

4. 逢七过.java

package chuangjian.demo01;

public class 逢七过 {
    public static void main(String[] args) {
        for (int i = 1; i <= 100; i++) {
            if (i % 7 == 0||i % 10 == 7||i / 10 == 7) {
                System.out.println("过");
            }
            else {
                System.out.println(i);
            }
        }
    }
}

代码解释：

功能：1-100 中，遇到 7 的倍数、个位是 7、十位是 7 的数，输出 “过”，否则输出数字
i % 7 == 0：判断是否是 7 的倍数（%是取余运算符）
i % 10 == 7：判断个位是否是 7（除以 10 的余数是 7）
i / 10 == 7：判断十位是否是 7（除以 10 的商是 7，如 70-79）
||：逻辑或运算符，只要其中一个条件为true，整体为true

五、方法（函数）

1. 方法定义和调用.java

package chuangjian.demo01;

public class 方法定义和调用 {

    public static void playGame(){
        System.out.println("开始游戏");
        System.out.println("游戏结束");
    }

    public static void method(int a,int b){
        int result=a+b;
        System.out.println(result);
    }

    public static int getSum(int a,int b,int c){
        int result=a+b+c;
        return result;
    }

    public static void main(String[] args){
        playGame();
        method(10,20);
        int sum=getSum(10,20,30);
        System.out.println(sum);
    }
}

代码解释：

方法：一段可重复使用的代码块，用于完成特定功能
方法定义格式：

修饰符 返回值类型 方法名(参数列表) {
    方法体;
    [return 返回值;]
}

示例方法解析：
- playGame()：
  - 修饰符：public static
  - 返回值类型：void（无返回值）
  - 方法名：playGame
  - 参数列表：无参数
  - 功能：打印 “开始游戏” 和 “游戏结束”
- method(int a, int b)：
  - 参数列表：int a, int b（两个 int 类型参数）
  - 功能：计算a+b并打印结果
- getSum(int a, int b, int c)：
  - 返回值类型：int（返回整数）
  - 功能：计算a+b+c，并通过return返回结果
方法调用：直接写方法名 + 参数（如playGame();、method(10,20);）
有返回值的方法可以赋值给变量（如int sum = getSum(10,20,30);）

2. 方法.java

import java.util.Scanner;

public class 方法 {
    public static int max (int num1,int num2)
    {
        int result;
        if(num1>num2)
        {
            result = num1;
        }
        else
        {
            result = num2;
        }
        return result;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入两个数：");
        int num1 = sc.nextInt();
        int num2 = sc.nextInt();
        int largest = max(num1,num2);
        System.out.println(largest);
        sc.close();
    }
}

代码解释：

max(int num1, int num2)：求两个数中的最大值
逻辑：如果num1 > num2，返回num1，否则返回num2
调用流程：
- 从键盘输入两个数num1和num2
- 调用max(num1, num2)得到最大值，赋值给largest
- 打印最大值
sc.close();：关闭Scanner对象，释放资源

六、数组

1. 数组.java

public class 数组 {
    public static void main(String[] args)
    {
        double [] mylist =new double[10];
        double [] mylist2 = {1,2,3,4,5,6,7,8,9,10};
        mylist[0]=1.1;
        mylist[1]=1.2;
        mylist[2]=1.3;
        mylist[3]=1.4;
        mylist[4]=1.5;
        mylist[5]=1.6;
        mylist[6]=1.7;
        mylist[7]=1.8;
        mylist[8]=1.9;
        mylist[9]=2.0;

        double sum=0;
        for (int i=0;i<mylist.length;i++)
        {
            sum+=mylist[i];
        }
        double sum2=0;
        for (double element:mylist2)
        {
            sum2+=element;
        }
        System.out.println(sum+" "+sum2);
    }
}

代码解释：

数组：存储多个相同类型数据的容器（长度固定）
数组定义方式：
- double[] mylist = new double[10];：声明并创建长度为 10 的 double 数组（初始值为 0.0）
- double[] mylist2 = {1,2,3,4,5,6,7,8,9,10};：声明并初始化数组（直接赋值元素）
数组元素访问：通过索引（从 0 开始），如mylist[0] = 1.1;（给第 1 个元素赋值）
mylist.length：获取数组长度（元素个数）
数组遍历求和：
- 普通 for 循环：for (int i=0; i<mylist.length; i++) { sum += mylist[i]; }
- 增强 for 循环：for (double element : mylist2) { sum2 += element; }（更简洁）

2. 打乱数组.java

package chuangjian.demo01;

import java.util.Random;

public class 打乱数组 {
    public static void main(String[] args) {

        int [] arr={1,2,3,4,5};
        Random r = new Random();
        for (int i=0;i<arr.length;i++){

            int randomIndex=r.nextInt(arr.length);
            int temp=arr[i];
            arr[i]=arr[randomIndex];
            arr[randomIndex]=temp;

        }
        for (int i=0;i<arr.length;i++){
            System.out.println(arr[i]+" ");
        }
    }
}

代码解释：

功能：将数组元素随机打乱（洗牌算法）
Random r = new Random();：创建随机数生成器对象
r.nextInt(arr.length)：生成 0 到arr.length-1之间的随机整数（作为随机索引）
打乱逻辑：循环遍历数组，每次将当前元素arr[i]与随机索引randomIndex的元素交换
- int temp = arr[i];：临时存储当前元素
- arr[i] = arr[randomIndex];：将随机元素赋值给当前位置
- arr[randomIndex] = temp;：将临时存储的当前元素赋值给随机位置
最后遍历打印打乱后的数组

七、类与对象（面向对象基础）

1. 类的定义与对象创建（以手机为例）

Phone.java（类的定义）

package chuangjian.demo01;

public class Phone{
    //属性（成员变量）
    String brand;
    double price;

    //方法（成员方法）
    public void call(){
        System.out.println("打电话");
    }
    public void playGame(){
        System.out.println("玩游戏");
    }
}

代码解释：

类：是对象的模板，定义了对象的属性和方法
Phone类包含：
- 属性（成员变量）：brand（品牌）、price（价格）
- 方法（成员方法）：call()（打电话）、playGame()（玩游戏）

PhoneTest.java（对象的使用）

package chuangjian.demo01;

public class PhoneTest {
    public static void main(String[] args) {
        Phone p = new Phone(); // 创建Phone对象

        p.brand = "小米"; // 给对象的属性赋值
        p.price = 1999.99;

        System.out.println("手机品牌：" + p.brand); // 访问属性

        p.call(); // 调用对象的方法
        p.playGame();

        // 创建第二个对象
        Phone p2 = new Phone();
        p2.brand = "华为";
        p2.price = 2999.99;
        System.out.println("手机品牌：" + p2.brand);
        p2.call();
        p2.playGame();
    }
}

代码解释：

对象创建：Phone p = new Phone();（new Phone()创建对象，p是对象的引用）
属性访问与赋值：对象名.属性名（如p.brand = “小米”;）
方法调用：对象名.方法名()（如p.call();）
每个对象都是独立的，属性值互不影响（p和p2是两个不同的手机对象）

2. 封装（private 与 get/set 方法）

GirlFriend.java（未封装的类）

package chuangjian.demo01;

public class GirlFriend {
    //属性
    String name;
    int age;

    //方法
    public void sleep(){
        System.out.println("女朋友在睡觉");
    }
    public void eat(){
        System.out.println("女朋友在吃饭");
    }
}

GirlFriendPlus.java（封装的类）

package chuangjian.demo01;

public class GirlFriendPlus {
    private int age; // 私有属性，只能在本类中访问
    private String name;

    //set方法：给私有属性赋值（可添加逻辑验证）
    public void setAge(int a){
        if (a>=18&&a<=50){ // 年龄必须在18-50之间
            age=a;
        }
        else{
            System.out.println("你给的年龄不符合要求");
        }
    }

    //get方法：获取私有属性的值
    public int getAge(){
        return age;
    }

    public void setName(String n){
        name=n;
    }

    public String getName(){
        return name;
    }

    public void sleep(){
        System.out.println("女朋友在睡觉");
    }
    public void eat(){
        System.out.println("女朋友在吃饭");
    }
}

代码解释：

封装：将属性私有化（private），通过公共方法（get/set）访问和修改，保护数据安全
private int age;：private修饰的属性只能在本类中直接访问，外部无法直接修改
setAge(int a)：设置年龄的方法，添加了验证逻辑（年龄必须 18-50），不符合则提示错误
getAge()：获取年龄的方法，返回age的值
好处：控制属性的赋值逻辑，避免不合理的数据（如年龄为负数）

GirlFriendTest.java（使用封装类）

package chuangjian.demo01;

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

        GirlFriendPlus gf1=new GirlFriendPlus();
        // gf1.age=18; // 错误！private属性不能直接访问
        gf1.setName("靓靓"); // 通过set方法赋值
        gf1.setAge(18);

        // System.out.println(gf1.age); // 错误！需通过get方法获取
        System.out.println(gf1.getName());
        System.out.println(gf1.getAge());

        gf1.eat();
        gf1.sleep();

        System.out.println("============");

        GirlFriendPlus gf2=new GirlFriendPlus();
        gf2.setName("悦悦");
        gf2.setAge(19);
        System.out.println(gf2.getName());
        System.out.println(gf2.getAge());
        gf2.eat();
        gf2.sleep();
    }
}

代码解释：

外部类不能直接访问private属性（如gf1.age会报错）
必须通过setXxx()方法赋值，通过getXxx()方法获取值
保证了数据的合法性（如设置年龄为 10，setAge会提示不符合要求）

3. 构造方法（对象初始化）

Student.java

package chuangjian.demo01;

public class Student {
    private String name;
    private int age;

    //空参构造方法（无参数）
    public Student() {
        System.out.println("空参构造器");
    }

    //有参构造方法（有参数）
    public Student(String name, int age) {
        this.name = name; // this表示当前对象，区分成员变量和参数
        this.age = age;
    }

    //get/set方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

代码解释：

构造方法：用于对象初始化，方法名与类名相同，无返回值（连void都没有）
分类：
- 空参构造：public Student() { … }，无参数，创建对象时调用
- 有参构造：public Student(String name, int age) { … }，有参数，创建对象时直接赋值
this.name = name;：this关键字表示当前对象，用于区分成员变量（this.name）和方法参数（name）
注意：如果定义了有参构造，系统不会再提供默认的空参构造，需手动定义

StudentTest.java

package chuangjian.demo01;

public class StudentTest {
    public static void main(String[] args) {
        //创建学生对象（调用空参构造）
        Student s1 = new Student();
        s1.setName("张三");
        s1.setAge(20);

        //创建学生对象（调用有参构造）
        Student s2 = new Student("李四", 21);
        System.out.println(s2.getName() + " " + s2.getAge());
    }
}

代码解释：

调用空参构造：Student s1 = new Student();，创建对象后通过set方法赋值
调用有参构造：Student s2 = new Student(“李四”, 21);，创建对象时直接给name和age赋值
有参构造简化了对象初始化的步骤

4. this关键字

this_girlfriend.java

package chuangjian.demo01;

public class this_girlfriend {
    private int age; // 成员变量

    public void method(){
        int age=10; // 局部变量
        System.out.println(age); // 就近原则，打印局部变量age（10）
        System.out.println(this.age); // this.age表示成员变量age（默认0）
    }
}

this_关键字.java

package chuangjian.demo01;

public class this_guanjianzi {
    public static void main(String[] args) {
        this_girlfriend gf1 = new this_girlfriend();
        gf1.method(); // 调用方法，输出10和0
    }
}

代码解释：

this关键字：代表当前对象的引用
作用：当成员变量和局部变量重名时，用this.成员变量区分成员变量
示例中：
- method()方法内有局部变量age=10，成员变量private int age;（默认值 0）
- System.out.println(age);：按就近原则，打印局部变量10
- System.out.println(this.age);：打印成员变量0

5. 标准 JavaBean（实体类规范）

标准Javabean文件.java

package chuangjian.demo01;

public class 标准Javabean文件 {
    //属性（私有）
    private String username;
    private String password;
    private String email;
    private String gender;
    private String age;

    //空参构造
    public 标准Javabean文件() {
    }

    //有参构造（全参）
    public 标准Javabean文件(String username, String password, String email, String gender, String age) {
        this.username = username;
        this.password = password;
        this.email = email;
        this.gender = gender;
        this.age = age;
    }

    //getter方法（获取属性）
    public String getUsername() {
        return username;
    }

    //setter方法（设置属性）
    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    //toString方法（打印对象信息）
    public String toString() {
        return "标准Javabean文件{username = " + username + ", password = " + password + ", email = " + email + ", gender = " + gender + ", age = " + age + "}";
    }
}

代码解释：

标准 JavaBean（实体类）规范：
- 类是公共的（public）
- 属性私有（private）
- 提供空参构造方法
- 提供有参构造方法（可选，通常提供全参构造）
- 为每个属性提供getter（获取）和setter（设置）方法
- 重写toString()方法（方便打印对象信息）
toString()：返回对象的字符串表示，当打印对象时会自动调用（如System.out.println(对象);）

八、其他常用功能

1. 随机数生成（随机数字.java）

package chuangjian.demo01;

import java.util.Random;

public class 随机数字 {
    public static void main(String[] args) {
        Random r=new Random();
        int number=r.nextInt(100); // 生成0-99之间的随机整数（包头不包尾）
        System.out.println(number);
    }
}

代码解释：

Random类：用于生成随机数，需导入java.util.Random;
r.nextInt(100)：生成[0, 100)之间的整数（即 0-99）
扩展：生成[a, b)之间的随机数：r.nextInt(b - a) + a（如生成 1-10：r.nextInt(10) + 1）

2. 字符串操作（StringTest.java）

package chuangjian.demo01;

public class StringTest {
    public static void main(String[] args){
    String s = "berbjsvsjrvbafvfbeabf";

    int len = s.length(); // 获取字符串长度
    System.out.println("字符串长度为：" + len);

    String ss=s.toUpperCase(); // 转换为大写
    System.out.println("转换为大写后的字符串为：" + ss);
    }
}

代码解释：

String：字符串类型（引用类型），值不可变
s.length()：返回字符串的长度（字符个数）
s.toUpperCase()：将字符串中的小写字母转换为大写，返回新字符串（原字符串不变）

3. 日期时间（日期时间.java）

import java.time.LocalDate;
import java.time.ZonedDateTime;
import java.util.Date;

public class 日期时间 {
    public static void main(String[] args)
    {
        LocalDate today = LocalDate.now(); // 获取当前日期（年-月-日）
        System.out.println(today);

        ZonedDateTime zonedDateTime = ZonedDateTime.now(); // 获取当前日期时间（带时区）
        System.out.println(zonedDateTime);

        Date date = new Date(); // 旧版日期类，获取当前时间
        System.out.println(date);
    }
}

代码解释：

Java 中常用的日期时间类：
- LocalDate：表示日期（年 - 月 - 日），now()获取当前日期
- ZonedDateTime：表示带时区的日期时间
- Date：旧版日期类（建议使用LocalDate等新版类）
输出示例：
- LocalDate：2024-05-20
- ZonedDateTime：2024-05-20T15:30:45+08:00[Asia/Shanghai]

4. 算法示例

回文数.java（反转数字）

package chuangjian.demo01;

public class 回文数 {
    public static void main(String[] args) {
        int x = 12345;
        int result = 0;
        while (x != 0)
        {
            int shu = x % 10; // 获取x的最后一位
            x = x / 10; // 去掉x的最后一位
            result = result * 10 + shu; // 拼接最后一位到result
        }
        System.out.println(result); // 输出54321
    }
}

代码解释：

功能：将数字12345反转为54321
逻辑：通过循环取出原数字的最后一位，拼接到结果中
x % 10：取最后一位（如12345 % 10 = 5）
x = x / 10：去掉最后一位（如12345 / 10 = 1234）
result = result * 10 + shu：将取出的数字拼接到结果（如010+5=5 → 510+4=54 → …）

求素数.java

package chuangjian.demo01;

import java.util.Scanner;

public class 求素数 {
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入整数");
        int number=sc.nextInt();
        boolean flag=true; // 标记是否为素数（默认是）
        int k=number/2;
        for (int i=2;i<=k;i++) {
            if (number % i == 0) { // 能被i整除，不是素数
                flag = false;
                System.out.println(number + "不是素数");
                break; // 跳出循环
            }
        }
        if (flag==true){
            System.out.println("flag语句判断"+number+"是素数");
        } else {
            System.out.println("flag语句判断"+number+"不是素数");
        }
    }
}

代码解释：

素数：大于 1 的自然数，除了 1 和自身外不能被其他数整除
逻辑：
- 输入一个整数number
- 假设是素数（flag = true）
- 循环判断2到number/2之间的数是否能整除number，如果能则不是素数（flag = false）
- 最后根据flag的值输出结果

平方根.java

package chuangjian.demo01;

import java.util.Scanner;

public class 平方根 {
    public static void main(String[]args){
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入整数");
        int number=sc.nextInt();

        for (int i = 1; i <=number; i++) {
            if(i*i==number){ // 找到精确平方根
                System.out.println(i+"是"+number+"的平方根");
                break;
            } else if (i*i>number) { // 超过则前一个数是整数部分
                System.out.println((i-1)+"是"+number+"的平方根的整数部分");
                break;
            }
        }
    }
}

代码解释：

功能：求一个整数的平方根（或整数部分）
逻辑：循环从 1 开始计算平方，直到找到平方等于该数（精确平方根）或平方大于该数（取前一个数为整数部分）
示例：输入16 → 输出4是16的平方根；输入10 → 输出3是10的平方根的整数部分（因为3²=9 < 10，4²=16 > 10）