小白学习日志-Nebula

2026.4.7

变量：

相当于一个储存临时数据的容器
但是这个容器只能存一个值

public class VariableDemo{
public static void main(String[] args){
    //定义一个整数类型的变量
    //数据类型 变量名 = 数据值;
    int a = 16;
    System.out.println(a);//16
    //定义一个小数类型的变量
    double b = 10.1;
    System.out.println(b);//10.1
  }
}

变量的注意事项：

变量名不能重复
一条语句可以定义多个变量，但是我不习惯用
变量在使用之前必须要赋值

基本数据类型：

整数类型：byte, short, int, long
浮点数类型：float, double
字符串类型：char
布尔类型：boolean

编程的本质

编就是编写
程，程序，是由数据和函数组成的
数据的本质就是处于计算硬盘上的数字0和1
而程序的主要任务就是编写函数来处理计算机上的数据
这么说只要掌握了数据和函数，其他的就是这些理论的实践了
对于现实世界来说，整个宇宙就是一个巨大的程序
小到细胞，原子
大到生物，星球
无一不是遵循着酷似函数处理的机制一样运行着
他们会迭代进化
无机到有机，水生到陆生
都是从原本简单的程序迭代到复杂的程序
作为人
奋斗者每日吾日三省，专注于改善和提高自己的程序，其处理效率日益增长
躺平者每日欢呼享乐，专注于如何让自己安乐于躺平，其程序酷似古董一般
编程
不断编写，不断完善，提高level

感想：虽然学的不多，但是相对于AI给我的安排来说，这个学起来更加的轻松和细致

2026.4.8

键盘录入（Scanner）:

创建对象
接收数据
导报的话我的IDEA会自动导报上去

//导包，其实就是先找到Scanner这个类在哪
import java.util.Scanner;
public class ScannerDemo1{
  public static void main(String[] args){
    //2.创建对象，其实就是申明一下，我准备开始用Scanner这个类了。
    Scanner sc = new Scanner(System.in);
    //3.接收数据
    //当程序运行之后，我们在键盘输入的数据就会被变量i给接收了
    System.out.println("请输入一个数字");
    int i = sc.nextInt();
    System.out.println(i);
  }
}

算数运算符：

基本介绍：

分类：+ - * / %

运算特点：

整数相除必须为整数
小数直接参与计算的时候可能不准确，这是计算机二进制转换的问题，相当于十进制的三分之一

public class OperatorDemo1 {
    public static void main(String[] args) {
        /*
            算数运算符：+ - * / %

            整数计算、小数计算

        */
        // 1. 整数计算
        // 细节：整数相除结果还是整数，就是商
        //       其他运算跟数学中是一模一样的
        int a = 10;
        int b = 3;

        System.out.println(a + b);// 13
        System.out.println(a - b);// 7
        System.out.println(a * b);// 30
        System.out.println(a / b);// 3
        System.out.println(a % b);// 1

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

        // 2.小数计算
        // 细节：
        //     小数直接参与计算，结果有可能不精确的
        double c = 1.1;
        double d = 1.01;

        System.out.println(c + d);// 13.0
        System.out.println(c - d);// 7.0
        System.out.println(c * d);// 30.0
        System.out.println(c / d);// 3.3333333333333335
        System.out.println(c % d);// 1.0



    }
}

关于对技能大赛的了解和启发

技能大赛，之前叫全国职业技能大赛，现在更名为世界职业技能大赛
正如上述操作无非就是改了名字
但是其对参赛者有着比较高的素养的要求，因此不管是名誉上的亮眼还是对自己技能的一个证明
迫使着有抱负，有追求的高职学生往着技能大赛的方向努力着
但是要想有世界职业技能大赛的参赛资格则必须要拿到重庆市一个等奖
而市级技能大赛是高职院校主办的，但是呢根据政策的规定，他们出的样题80%都是按照国赛的标准来办理的，20%是自由发挥的
说是自由发挥，无疑就是给自己学校的团队走后门罢了
但是这并不意味着我们就不需要对这个赛事上心而敷衍了事
反而是我们必须更加的努力提高自身的素养，并且和团队的队员们提高配合的默契度，是我们能够产出更加牛逼的东西出来，让所有的评委都认可，这是我们需要努力的
关于赛事要求：
比如说实训操作、与团队的配合、细致程度这些都要必须重视和反复的去打磨
不应该在一些小事情上失误

2026.4.9

数值拆分（算法题）：

package com.itheima.operator;

import java.util.Scanner;

public class OperatorDemo2 {
    static void main() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个三位数：");

        int num = sc.nextInt();

        int ge = num % 10;
        int shi = num / 10 % 10;
        int bai = num / 100;
        System.out.println("个位；" + ge);
        System.out.println("十位：" + shi);
        System.out.println("百位；" + bai);



    }
}

时间转换：

package com.itheima.operator;

import java.util.Scanner;

public class OperatorDemo3 {
    static void main() {

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入秒数：");

        int num = sc.nextInt();
        // 3611 / 3600 = 1....11
        int hour = num / 3600;
        // 3611 % 3600 / 60 = 0....11
        int min = num % 3600 / 60;
        // 3611 % 3600 % 60 = 0;
        int sec = num % 3600 % 60;

        System.out.println(hour + ":" + min + ":" + sec);
    }
}

隐式转换：

就是小的给大的，可以直接给

如果是byte类型和short类型就先提升为int类型
把取值范围小的提升为大的再进行计算（否则会损失精度）

比如说：

package com.itheima.operator;

public class OperatorDemo4 {
    static void main() {
        short s1 = 100;
        short s2 = 200;

//        byte result = s1 + s2; // 错误，运算结果超出了byte的范围,s1 + s2 的时候已经隐式转化成了int类型了
//        方法一：强制转化，有时候或损失精度，就比如下面这个，打印出的是44，而不是300
        byte s3 = (byte)(s1 + s2);
        System.out.println(s3);// 44

//        方法二；根据隐式转化来
        int s4 = s1 + s2;
        System.out.println(s4); // 300
    }
}

强制转换：

背景：

如果要把取值范围大的数据或者变量复制给取值范围小的变量是不允许直接操作的，但是硬要这样的话那就需要强制转换了

书写格式：

double a = 12.3;

int b = (int) a;

关于服务器本地部署：

关于云服务器的部署我不是很了解，但是看到刘杰一下午的操作，对其有祛魅，并没有想象中的那么复杂，只是我了解的东西不多

如果我了解的足够，知道他们的作用和关联，我想我大概是可以做出来的，而且是游刃有余，行云流水的操作

我有这个信心，因为我相信我的能力，目前只能写这么点，但是以后我会完善非常多

感想：

由下个星期二即将要交的政治作业而启动的一个非常有意义的项目

因为我们想做一个扬名立万的事情，不单单只是做一个简单的只局限于政治作业的项目

而是一个可以让我们燃起斗志，觉得每天都很美好，每天过得都很有意义很充实

这种感觉不是有一个人都有的

2026.4.10

随着项目的推进我们遇到的瓶颈：

一是这个论坛的一个flurm的一个底层的代码有很多BUG，毕竟是轻量化的，而且是开源免费的项目

另一个是短视频的脚本，这个脚本的框架我们讨论了很久，最终是以较为真实的角度来拍摄

但是脚本的开头，以及发展，我们陷入了困难，就是不知道怎么去呈现，拍摄的手法又不太行...

今天晚上我们把这个脚本的大致内容给搞出来了，我想只需要在我们拍摄的过程中进行修改就可以了

如果实在不行的话那就拍纪录片吧...

以此来纪念我们为了这个扬名立万的努力，就这一个记录就够我们回忆一壶了

万一成了呢..

2026.4.11

字符串的 + 操作

String name = "黑默丁格";
System.out.println("我的名字是" + name);

输出：我的名字是黑默丁格

自增自减运算符

分类：

注意：

不管是先++，还是后++，单独写在第一行的时候，运算结果是一模一样的

int a = 10;
a++;//就是让变量a里面的值 + 1
System.out.println(a);//11
++a;//就是让变量a里面的值 + 1
System.out.println(a);//12

赋值运算：

public class OperatorDemo6 {
    public static void main(String[] args) {
        
        int a = 10;//就是把10赋值给变量a
        System.out.println(a);

        //2.如果等号右边需要进行计算。
        int b = 20;
        int c = a + b;//先计算等号右边的，把计算的结果赋值给左边的变量
        System.out.println(c);

        //3.特殊的用法
        a = a + 10;// a += 10;
        System.out.println(a);//20
    }
}

扩展数值运算符：

注意：

扩展的赋值运算符中隐层还包含了一个强制转换：a += b,实际上相当于a = (byte)(a + b);

public class OperatorDemo8 {
    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        //a += b;
        a = (byte)(a + b);
        System.out.println(a);//30
    }
}

关系运算符：

==
！=
>=
<=
>
<

注意：

最终结果为布尔值

import java.util.Scanner;

public class OperatorDemo9 {
    static void main() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入我的身高：");
        double h1 = sc.nextDouble();

        System.out.println("请输入我好基友的身高：");
        double h2 = sc.nextDouble();

        if (h1 == h2) {
            System.out.println("他和我身高一样，什么身份啊这是和我同款升高");
        } else if (h1 < h2) {
            System.out.println("666 我居然比他矮");
        } else {
            System.out.println("我肯定是比他高的啊");
        }
    }
}

逻辑运算符

& 和 | 的使用：

&：

两边都为真，结果才为真，只要一个结果为假，结果就是假

|：

两边都为假，结果才为假，只要有一个为真，结果就为真

三元运算符：

格式：

关系表达式？表达式1：表达式2；

计算规则：

计算关表达式的值

如果为真就执行表达1

为假就执行表达2

注意：

三元表达式的最终结果一定要被使用，要么赋值给一个变量，要么直接打印出来

public class OpertaorDemo14 {
    static void main() {
        int a = 9;
        int b = 10;

        int max = a > b ? a : b;
        System.out.println("max:" + max);
    }
}

运算符的优先级：

先记一点：

小括号优先于所有

2026.4.13

流程控制语句：

判断语句 if:

if语句格式：

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

示例：

public class IfDemo {
  public static void main(String[] args) {
    System.out.println("开始");
    //定义两个变量
    int a = 10;
    int b = 20;
    //需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
    if(a == b) {
      System.out.println("a等于b");
    }    //需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于c
    int c = 10;
    if(a == c) {
      System.out.println("a等于c");
    }    System.out.println("结束");
  }
}

关于格式细节：

我比较喜欢K&R风格，就是平常我们写的格式
其他的了解了解就行了也不重要

比较有意思的题目（阶梯式计算）：

import java.util.Scanner;  
  
public class ifDemo9 {  
    static void main() {  
        Scanner sc = new Scanner(System.in);  
        System.out.println("请输入实际用电量：");  
        double usage = sc.nextDouble();  
        double cost = 0;  
  
        if (usage <= 100) {  
            cost = usage * 0.5;  
        } else if (usage <= 200) {  
            cost = 100 * 0.5 + (usage - 100) * 0.8;  
        } else if (usage > 200){  
            cost = 100 * 0.5 + 100 * 0.8 + (usage - 200) * 1.2;  
        } else {  
            System.out.println("输入有误");  
        }  
        System.out.println("总电费：" + cost);  
    }  
}

2026.4.14

选择语句（switch）

格式：

switch (表达式) {
	case 1:
		语句体1;
		break;
	case 2:
		语句体2;
		break;
	case 3:
		语句体3;
		break;
	default:
		语句体4;
		break;
}

switch的扩展知识：

default的位置可以省略
default可以放在任意位置

case穿透：

不写break会引发case穿透现象
但有些case现象可以提高代码可读性

int number = 10;
switch (number) {
	case 1 -> System.out.println("一");
	case 2 -> System.out.println("二);
	case 3 -> System.out.println("三");
	default -> System.out.println("其他");
}

yield关键字：

int number = 10;
String name = switch (number) {
	case 1, 2, 3, 4 -> "==";
	case 5, 6, 7 -> "二";
	case 8, 9, 10 -> "三";
	default -> "没有这个星期"
};

System.out.println(name);
// 优点就是可以操作结果

2026.4.15

循环结构

格式：

  
for (初始化语句;条件判断语句;条件控制语句) {

循环体语句;

}

题目：

import java.util.Scanner;  
  
public class ForDemo5 {  
    static void main() {  
        // 键盘录入两个数字，表示一个范围。统计这个范围中，既能被3整除又能被5整除数字有多少个？  
       /* Scanner sc = new Scanner(System.in);  
        System.out.println("请输入第一个数字：");  
        int a = sc.nextInt();        System.out.println("请输入第二个数字：");  
        int b = sc.nextInt();        int sum = 0;  
        for (int i = a; i <= b; i++) {            if (i % 3 == 0 && i % 5 == 0) {                sum += 1;            }        }  
        System.out.println(sum);*/  
        Scanner sc = new Scanner(System.in);  
        System.out.println("请输入第一个数字：");  
        int a = sc.nextInt();  
        System.out.println("请输入第二个数字：");  
        int b = sc.nextInt();  
        int sum = 0;  
  
        int min = a < b ? a : b;  
        int max = a < b ? b : a;  
  
        for (int i = min; i <= max; i++) {  
            if (i % 3 == 0 && i % 5 == 0) {  
                sum += 1;  
            }  
        }  
  
        System.out.println(sum);  
  
    }  
}

public class ForDemo6 {  
    static void main() {  
        // 有一组特殊的数字，从第三项开始，每一项都是前两项的数字和，请问第10项的数字是多少？  
        //0，1，1，2，3，5，8，13，21，34，55，89…  
       int a = 0;  
       int b = 1;  
       int c = 1;  
  
       for (int i = 3; i <= 10; i++) {  
          c = a + b;  
          a = b;  
          b = c;  
       }  
        System.out.println(c);  
  
    }  
}

import java.util.Scanner;  
  
public class ForDemo7 {  
    static void main() {  
        // 牛牛开始学习数列啦。现在他想计算以下数列前 n 项的和：  
        //S(n) = 1 − 2 + 3 − 4 + ⋯  
        int sum = 0;  
        Scanner sc = new Scanner(System.in);  
        System.out.println("请输入项数：");  
        int n = sc.nextInt();  
  
        for (int i = 1; i <= n; i += 2) {  
            sum += i - (i + 1);  
        }  
        System.out.println(sum);  
  
    }  
}

2026.4.16

while循环

格式：

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

复利：

public class WhileDemo2 {
    static void main() {
        // 假设你在银行投资了100000元，银行给出的复利是1.7%，问多少年后能实现本金翻倍？
        //请问：用什么循环呢？代码如何实现？
       /* double money = 100000;
        double exceptmoney = 0;

        int count = 0;
        while (exceptmoney < money) {
            exceptmoney += money * 0.017;
            count++;
        }  这个代码是单利
        System.out.println(count);*/

        /*double money = 200000;
        double exceptmoney = 100000;

        int count = 0;
        while (exceptmoney < 200000) {
            exceptmoney += exceptmoney * 0.017;
            count++;
        }  这个是利滚利
        System.out.println(count);*/
    }
}

珠穆朗玛峰

public class WhileDemo3 {
    static void main() {
        // 世界最高山峰珠穆朗玛峰高度是：8848.86米=8848860毫米，
        //假如我有一张足够大的纸，它的厚度是0.1毫米。
        //请问：该纸张折叠多少次，可以折成珠穆朗玛峰的高度？

        double m = 0.1;
        double height = 8848860;

        int count = 0;
        while (m < height) {
            m *= 2;
            count++;
        }

        System.out.println(count);

    }
}

数位之和

public class WhileDemo4 {
    static void main() {
        // 给定一个整数 n，请计算其所有数位之和。若 n 为负数，请先取其绝对值。
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int n = sc.nextInt();

        if (n < 0) {
            n = -n;
        }

       /* 467 % 10 = 7 // 提取出个位
        467 / 10 % 10 = 6 // 提取46的个位
        46 / 10 // 提取百位
        然后求和*/
        int sum = 0;
        while (n != 0) {
            sum += n % 10;
            n = n / 10;
        }
        System.out.println(sum);
    }
}

do...while循环


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

无限循环

for格式：

for(;;){
    System.out.println("循环执行一直在打印内容");
}

while格式：

while(true){
    System.out.println("循环执行一直在打印内容");
}

do...while格式：

do{
    System.out.println("循环执行一直在打印内容");
}while(true);

条件控制语句

break
continue

break：
不能单独存在的。可以用在switch和循环中，表示结束，跳出的

游戏人物：

public class BreakDemo2 {
    static void main() {

        /*初始最大生命200，受到X点伤害，技能恢复Y点血，X和Y由键盘录入而来。
        假设，游戏人物不会死亡，最少1点血
        问：最终游戏人物血量是多少？
        要考虑的情况：键盘录入必须大于0，否则需要重新输入*/

        Scanner sc = new Scanner(System.in);
        int maxHp = 200;
        int X = 0;
        int Y = 0;

        while (true) { // 循环 + break 只要录入数据是错误的，就一直录入
            System.out.println("请输入受到的伤害：");
            X = sc.nextInt();

            if (X > 0) {
                break;
            }else {
                System.out.println("输入的数据不合法");
            }

        }


        int hp = maxHp - X;

        if (hp < 1) {
            hp = 1;
        } else if (hp > 200) {
            hp = 200;
        }
        System.out.println("当前游戏人物的血量为：" + hp);

        while (true) {
            System.out.println("请输入技能恢复的血量：");
            Y = sc.nextInt();
            if (Y > 0) {
                break;
            } else {
                System.out.println("输入的数据不合法");
            }
        }

        hp = hp + Y;
        if (hp > 200) {
            hp = 200;
        }
        System.out.println("当前游戏人物的血量为：" + hp);


    }
}

找质数：

public class BreakDemo3 {
    static void main() {

        /*键盘录入一个大于等于2的整数，判断是否为质数*/

       Scanner sc = new Scanner(System.in);

       int num = 0;
       while (true) {

           System.out.println("请输入大于等于2的整数：");
           num = sc.nextInt();
           if (num >= 2) {
               break;
           } else {
               System.out.println("输入的数字不合法");
           }
       }
/*
       还有一个解法就是平方根
       1 100
       2 50
       4 25
       5 20
       10 10
       ---------------10---------------------    只需要判断一边就可以了，左边是小于10的，右边是大于10的
                                                 如果左边没有可以整除的数字的话，那么其他相乘要么大于100，要么小于100
       */
       // 质数是指只能被1和自身整除的数字
        int count = 0;
        for (int i = 2; i < num; i++) {

            if (num % i == 0) {
                count++;
                break;
            }
        }

        if (count == 0) {
            System.out.println("是质数");
        }else {
            System.out.println("不是质数");
        }

    }
}

continue语句

不能单独存在的。只能存在于循环当中。表示：跳过本次循环，继续执行下次循环

逢七过：

public class ContinueDemo2 {
    // 循环打印1~100之间的数字，如果数字包含7或者是7的倍数，输出”过”
    static void main() {

        for (int i = 1; i <= 100; i++) {
            if (i / 10 % 10 == 7 || i % 10 == 7 || i % 7 == 0) {
                System.out.println("过");
                continue;
            }
            System.out.println(i);
        }

    }
}

Random:

和Scanner一样

猜数字：

public class Test {
    static void main() {
        /*

        需求：程序自动生成一个1-100之间的随机数，在代码中使用键盘录入去猜出这个数字是多少？
        要求：使用循环猜，一直猜中为止。

        抽卡的时候有保底机制
        小保底，只要三次没有猜中，提示提示用户的猜测范围 ±5
        大保底，只要十次没猜中，就猜中了
        */
        Random r = new Random();
        Scanner sc = new Scanner(System.in);
        int num = r.nextInt(1, 101);
        System.out.println(num);

        // 加入计数器
        int countA = 0;
        int countB = 0;


        while (true) {
            System.out.println("请输入你猜的数字：");
            int n = sc.nextInt();

            countA++;
            countB++;

            if (countB > 10) {
                System.out.println("猜对了");
                break;
            }

            if (n < num) {
                System.out.println("猜小了");

            } else if (n > num) {
                System.out.println("猜大了");

            } else {
                System.out.println("猜对了");
                break;
            }

            if (countA % 3 == 0) {
                System.out.println("在" + (num - 5) + "到" + (num + 5) + "之间");
            }

            if (countB > 10) {
                System.out.println("猜对了");
                num = n;
                System.out.println(n);
                break;
            }
        }

    }
}

#学习日志

#学习

小白学习日志-Nebula

https://wlw301.top//archives/1ixZsJqY

作者

五月天

发布于

2026年04月08日

更新于

2026年04月17日

许可协议

小白学习日志-yupi 上一篇

饥荒联机版：威尔逊/威尔逊技能树下一篇

小白学习日志-Nebula

2026.4.7

变量：

变量的注意事项：

基本数据类型：

编程的本质

2026.4.8

键盘录入（Scanner）:

算数运算符：

基本介绍：

运算特点：

关于对技能大赛的了解和启发

2026.4.9

数值拆分（算法题）：

隐式转换：

比如说：

强制转换：

背景：

书写格式：

关于服务器本地部署：

感想：

2026.4.10

2026.4.11

字符串的 + 操作

自增自减运算符

赋值运算：

扩展数值运算符：

关系运算符：

注意：

逻辑运算符

三元运算符：

运算符的优先级：

2026.4.13

流程控制语句：

分类：

判断语句 if:

比较有意思的题目（阶梯式计算）：

2026.4.14

选择语句（switch）

switch的扩展知识：

2026.4.15

循环结构

2026.4.16

while循环

复利：

珠穆朗玛峰

数位之和

do...while循环

无限循环

for格式：

while格式：

do...while格式：

条件控制语句

break：不能单独存在的。可以用在switch和循环中，表示结束，跳出的

游戏人物：

找质数：

continue语句

逢七过：

Random:

猜数字：

break：
不能单独存在的。可以用在switch和循环中，表示结束，跳出的