Java基础笔记01

懒人8

571人浏览 · 2026-04-04 02:32:07

懒人8 · 2026-04-04 02:32:07 发布

Java基础笔记：变量、类型转换、运算符与流程控制

必知

计算机存储单位：1字节(byte) = 8比特(bit)，后续按1024倍换算
Java主要用途：开发跨平台应用程序、企业级系统
常用DOS命令：
- cd 目录名 - 进入目录
- cd.. - 返回上级
- dir - 查看当前目录内容
- 盘符: - 切换盘符
Java环境：
- JVM：运行Java程序的虚拟机，实现跨平台
- JRE：Java运行环境，包含JVM和核心类库
- JDK：Java开发工具包，包含JRE
环境变量：JAVA_HOME配置

入门程序：

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

编译：javac 文件名.java → 生成.class文件

运行：java 类名（不加.class后缀）

注释：

单行：//

多行：/* */

文档：/** */

关键字：Java预定义的有特殊含义的小写单词

print vs println：println自带换行，print不换行

第一章常量
1.1 概述
常量是在程序运行过程中值不会发生改变的数据，也叫字面值。

1.2 常量分类
类型示例说明
整数常量 100, -50 所有整数
小数常量 3.14, 0.5 带小数点的数
字符常量 ‘A’, ‘9’ 单引号内必须有且仅有一个字符
字符串常量 “Hello”, “Java” 双引号内任意内容
布尔常量 true, false 逻辑值
空常量 null 表示数据不存在，用于引用类型
java
public class ConstantDemo {
public static void main(String[] args) {
System.out.println(100); // 整数
System.out.println(3.14); // 小数
System.out.println(‘A’); // 字符
System.out.println(true); // 布尔
System.out.println(“Hello Java”); // 字符串
}
}
java
public class ConstantArithmetic {
public static void main(String[] args) {
System.out.println(20 + 5); // 25
System.out.println(20 - 5); // 15
System.out.println(20 * 5); // 100
System.out.println(20 / 5); // 4
// 除法注意：整数相除只取整数部分
System.out.println(20 / 6); // 3
System.out.println(20.0 / 6); // 3.333…
}
}
第二章变量
2.1 数据类型
数据类型关键字内存占用取值范围
字节型 byte 1字节 -128 ~ 127
短整型 short 2字节 -32768 ~ 32767
整型 int（默认） 4字节 -21亿 ~ 21亿
长整型 long 8字节 -2^63 ~ 2^63-1
单精度浮点 float 4字节约 ±3.4E38
双精度浮点 double（默认） 8字节约 ±1.8E308
字符型 char 2字节 0 ~ 65535
布尔型 boolean 1字节 true / false
2.2 变量定义与使用
变量：程序运行过程中值可以改变的数据。

定义格式：

java
数据类型变量名 = 初始值;
java
public class VariableDemo {
public static void main(String[] args) {
byte b = 100;
short s = 20000;
int i = 50000;
long l = 100000L; // 建议加L
float f = 3.14F; // 建议加F
double d = 3.14159;
char c = ‘张’;
boolean flag = true;

    // 字符串（引用类型）
    String name = "张三";
    
    System.out.println(b);
    System.out.println(s);
    System.out.println(i);
    System.out.println(l);
    System.out.println(f);
    System.out.println(d);
    System.out.println(c);
    System.out.println(flag);
    System.out.println(name);
}

}
2.3 变量运算示例
java
public class VariableOperation {
public static void main(String[] args) {
int a = 25;
int b = 7;
System.out.println(a + b); // 32
System.out.println(a - b); // 18
System.out.println(a * b); // 175
System.out.println(a / b); // 3（整数除法）
System.out.println(a % b); // 4（取余）
}
}
2.4 转义字符
java
public class EscapeChar {
public static void main(String[] args) {
System.out.println(“第一行\n第二行”); // \n 换行
System.out.println(“姓名\t年龄\t分数”); // \t 制表符
System.out.println(“C:\Program Files\Java”); // \ 表示反斜杠
System.out.println(““Hello””); // " 表示双引号
}
}
2.5 变量使用注意事项
同一作用域内不能定义重名变量

小作用域可以直接访问大作用域变量，反之不行

变量必须先赋值再使用

java
public class VariableNotice {
public static void main(String[] args) {
int x = 10;
// int x = 20; // 错误：重复定义
x = 30; // 重新赋值

    {
        int y = 50;
        System.out.println(x);  // 可以访问外层变量
        System.out.println(y);
    }
    // System.out.println(y);  // 错误：不能访问内层变量
    
    int z;           // 未初始化
    // System.out.println(z);  // 错误：未初始化不能使用
}

}
2.6 练习：定义学生信息
java
public class StudentInfo {
public static void main(String[] args) {
String name = “李华”;
char gender = ‘男’;
int age = 20;
double height = 1.75;
double weight = 68.5;

    System.out.println("姓名：" + name);
    System.out.println("性别：" + gender);
    System.out.println("年龄：" + age);
    System.out.println("身高：" + height);
    System.out.println("体重：" + weight);
}

}
第三章标识符
硬性规定：

不能是关键字

可包含字母、数字、_、$，不能以数字开头

软性建议：

类名：大驼峰式（每个单词首字母大写），如 StudentInfo

方法/变量名：小驼峰式（首字母小写，后续单词首字母大写），如 studentName

第四章数据类型转换
4.1 自动类型转换（小转大）
java
public class AutoConvert {
public static void main(String[] args) {
// int → long
long num = 100; // int自动转为long

    int a = 50;
    double b = 2.5;
    // int + double → double
    double sum = a + b;   // 52.5
    System.out.println(sum);
}

}
类型大小顺序：byte → short → int → long → float → double

4.2 强制类型转换（大转小）
java
public class ForceConvert {
public static void main(String[] args) {
double pi = 3.14159;
int intPi = (int) pi; // 强转，结果为3（精度损失）
System.out.println(intPi);

    long bigNum = 12345678900L;
    int smallNum = (int) bigNum;  // 可能溢出
    System.out.println(smallNum);
}

}
4.3 注意事项
java
public class ConvertNotice {
public static void main(String[] args) {
// byte/short 字面值不超范围时自动强转
byte b = 100; // 正常，JVM自动处理

    // byte参与运算自动提升为int
    byte b1 = 10;
    byte b2 = 20;
    // byte result = b1 + b2;  // 错误
    byte result = (byte)(b1 + b2);  // 需要强转
    
    // char转int（ASCII/Unicode）
    char ch = 'A';
    System.out.println(ch + 0);   // 65
    System.out.println('中' + 0);  // 20013
}

}
第五章运算符
5.1 算术运算符
符号说明

加法

减法

乘法
/ 除法
% 取模（取余）
java
public class ArithmeticDemo {
public static void main(String[] args) {
int x = 15;
int y = 4;
System.out.println(x + y); // 19
System.out.println(x - y); // 11
System.out.println(x * y); // 60
System.out.println(x / y); // 3
System.out.println(x % y); // 3
}
}
字符串拼接
java
public class StringConcat {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println(a + b + “”); // 30
System.out.println(“” + a + b); // 1020
System.out.println(“结果：” + (a + b)); // 结果：30
}
}
5.2 自增自减运算符
java
public class IncDecDemo {
public static void main(String[] args) {
// 单独使用
int i = 5;
i++;
System.out.println(i); // 6
```
// 混合使用
int j = 5;
int result1 = ++j;   // 先自增再赋值
System.out.println(result1);  // 6
System.out.println(j);        // 6

int k = 5;
int result2 = k++;   // 先赋值再自增
System.out.println(result2);  // 5
System.out.println(k);        // 6
```
}
}
5.3 赋值运算符
符号示例等价于
= a = 10 赋值
+= a += 3 a = a + 3
-= a -= 3 a = a - 3
*= a *= 3 a = a * 3
/= a /= 3 a = a / 3
%= a %= 3 a = a % 3
java
public class AssignDemo {
public static void main(String[] args) {
int num = 10;
num += 5; // num = 15
System.out.println(num);
```
byte b = 10;
b += 3;     // 自动强转，b = 13
System.out.println(b);
```
}
}
5.4 关系运算符
结果：boolean类型（true/false）

符号说明
== 相等
!= 不等

大于
< 小于
= 大于等于
<= 小于等于
java
public class CompareDemo {
public static void main(String[] args) {
int a = 25;
int b = 30;
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a > b); // false
System.out.println(a < b); // true
System.out.println(a >= 25); // true
System.out.println(a <= 24); // false
}
}
5.5 逻辑运算符
符号说明
&& 逻辑与（有假则假，短路）
|| 逻辑或（有真则真，短路）
! 逻辑非（取反）
^ 逻辑异或（相同false，不同true）
java
public class LogicDemo {
public static void main(String[] args) {
int score = 85;
// 判断成绩是否在60-90之间
boolean result = score >= 60 && score <= 90;
System.out.println(result); // true

    // 短路效果
    int a = 10;
    boolean r = (a++ > 100) && (a++ > 50);
    System.out.println(r);   // false
    System.out.println(a);   // 11（第二个条件未执行）
}

}
5.6 三元运算符
格式：条件 ? 表达式1 : 表达式2

java
public class TernaryDemo {
public static void main(String[] args) {
int age = 18;
String status = age >= 18 ? “成年” : “未成年”;
System.out.println(status); // 成年

    // 求两个数的最大值
    int x = 45, y = 78;
    int max = x > y ? x : y;
    System.out.println(max);  // 78
    
    // 求三个数的最大值
    int a = 45, b = 78, c = 62;
    int temp = a > b ? a : b;
    int max3 = temp > c ? temp : c;
    System.out.println(max3);  // 78
}

}
第六章键盘录入 Scanner
java
import java.util.Scanner;

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

    System.out.println("请输入一个整数：");
    int num = sc.nextInt();
    System.out.println("您输入的是：" + num);
    
    System.out.println("请输入一个字符串：");
    String str = sc.next();
    System.out.println("您输入的是：" + str);
}

}
第七章流程控制语句
7.1 switch语句
java
public class SwitchDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println(“请输入星期几(1-7)：”);
int day = sc.nextInt();

    switch (day) {
        case 1:
            System.out.println("星期一");
            break;
        case 2:
            System.out.println("星期二");
            break;
        case 3:
            System.out.println("星期三");
            break;
        case 4:
            System.out.println("星期四");
            break;
        case 5:
            System.out.println("星期五");
            break;
        case 6:
            System.out.println("星期六");
            break;
        case 7:
            System.out.println("星期日");
            break;
        default:
            System.out.println("输入错误");
            break;
    }
}

}
switch穿透性（合并case）
java
public class SwitchSeason {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println(“请输入月份：”);
int month = sc.nextInt();

    switch (month) {
        case 12:
        case 1:
        case 2:
            System.out.println("冬季");
            break;
        case 3:
        case 4:
        case 5:
            System.out.println("春季");
            break;
        case 6:
        case 7:
        case 8:
            System.out.println("夏季");
            break;
        case 9:
        case 10:
        case 11:
            System.out.println("秋季");
            break;
        default:
            System.out.println("月份无效");
            break;
    }
}

}
Java12+新特性
java
public class SwitchNew {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int month = sc.nextInt();

    // 使用 -> 不需要break
    String season = switch (month) {
        case 12, 1, 2 -> "冬季";
        case 3, 4, 5 -> "春季";
        case 6, 7, 8 -> "夏季";
        case 9, 10, 11 -> "秋季";
        default -> "无效月份";
    };
    System.out.println(season);
    
    // 使用yield返回结果
    String result = switch (month) {
        case 12, 1, 2 -> {
            yield "冷";
        }
        case 6, 7, 8 -> {
            yield "热";
        }
        default -> {
            yield "温和";
        }
    };
    System.out.println(result);
}

}
7.2 if语句
第一种格式：单分支
java
public class IfDemo1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int score = sc.nextInt();

    if (score >= 90) {
        System.out.println("优秀！");
    }
}

}
第二种格式：双分支
java
public class IfDemo2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();

    if (num % 2 == 0) {
        System.out.println("偶数");
    } else {
        System.out.println("奇数");
    }
}

}
第三种格式：多分支
java
public class IfDemo3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int score = sc.nextInt();

    if (score >= 90 && score <= 100) {
        System.out.println("等级A");
    } else if (score >= 80) {
        System.out.println("等级B");
    } else if (score >= 70) {
        System.out.println("等级C");
    } else if (score >= 60) {
        System.out.println("等级D");
    } else if (score >= 0) {
        System.out.println("等级E");
    } else {
        System.out.println("分数无效");
    }
}

}
练习：闰年判断
java
public class LeapYear {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int year = sc.nextInt();

    // 闰年：能被4整除但不能被100整除，或者能被400整除
    if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
        System.out.println(year + "年是闰年，2月有29天");
    } else {
        System.out.println(year + "年是平年，2月有28天");
    }
}

}
第八章循环结构
8.1 for循环
格式：

java
for (初始化; 条件判断; 步进表达式) {
循环体;
}
java
public class ForDemo {
public static void main(String[] args) {
// 输出10次"Hello"
for (int i = 0; i < 10; i++) {
System.out.println("Hello " + i);
}

    // 求1-100的和
    int sum = 0;
    for (int i = 1; i <= 100; i++) {
        sum += i;
    }
    System.out.println("1-100的和：" + sum);
    
    // 求1-100的奇数和
    int oddSum = 0;
    for (int i = 1; i <= 100; i += 2) {
        oddSum += i;
    }
    System.out.println("1-100奇数和：" + oddSum);
    
    // 统计1-100中能被3整除的数的个数
    int count = 0;
    for (int i = 1; i <= 100; i++) {
        if (i % 3 == 0) {
            count++;
        }
    }
    System.out.println("1-100中能被3整除的数有" + count + "个");
}

}
8.2 while循环
格式：

java
初始化;
while (条件判断) {
循环体;
步进;
}
java
public class WhileDemo {
public static void main(String[] args) {
// 1-100求和
int i = 1;
int sum = 0;
while (i <= 100) {
sum += i;
i++;
}
System.out.println(“1-100的和：” + sum);

    // 折纸问题：厚度0.1mm，折多少次超过珠穆朗玛峰高度(8848m=8848000mm)
    double paper = 0.1;
    int count = 0;
    while (paper < 8848000) {
        paper *= 2;
        count++;
    }
    System.out.println("需要折" + count + "次");
}

}
8.3 do-while循环
特点：至少执行一次循环体

java
public class DoWhileDemo {
public static void main(String[] args) {
int i = 0;
do {
System.out.println(“执行第” + (i + 1) + “次”);
i++;
} while (i < 3);
}
}
8.4 循环控制关键字
break：跳出整个循环

continue：跳过本次循环，进入下一次

java
public class BreakContinue {
public static void main(String[] args) {
// break示例：找到第一个能被7整除的数
for (int i = 1; i <= 100; i++) {
if (i % 7 == 0) {
System.out.println(“第一个能被7整除的数是：” + i);
break;
}
}

    // continue示例：输出1-10中不能被3整除的数
    for (int i = 1; i <= 10; i++) {
        if (i % 3 == 0) {
            continue;
        }
        System.out.print(i + " ");
    }
}

}
8.5 嵌套循环
java
public class NestedLoop {
public static void main(String[] args) {
// 打印乘法口诀表
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + “×” + i + “=” + (i * j) + “\t”);
}
System.out.println();
}

    // 打印矩形
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 8; j++) {
            System.out.print("* ");
        }
        System.out.println();
    }
}

}
第九章 Random随机数
java
import java.util.Random;

public class RandomDemo {
public static void main(String[] args) {
Random rand = new Random();

    // 随机整数（int范围）
    int r1 = rand.nextInt();
    System.out.println("随机整数：" + r1);
    
    // 0-9之间的随机数
    int r2 = rand.nextInt(10);
    System.out.println("0-9随机数：" + r2);
    
    // 1-10之间的随机数
    int r3 = rand.nextInt(10) + 1;
    System.out.println("1-10随机数：" + r3);
    
    // 50-100之间的随机数
    int r4 = rand.nextInt(51) + 50;
    System.out.println("50-100随机数：" + r4);
}

}
猜数字游戏
java
import java.util.Random;
import java.util.Scanner;

public class GuessNumber {
public static void main(String[] args) {
Random rand = new Random();
Scanner sc = new Scanner(System.in);

    // 生成1-100的随机数
    int target = rand.nextInt(100) + 1;
    int guess;
    int attempts = 0;
    
    System.out.println("猜数字游戏开始！数字范围1-100");
    
    while (true) {
        System.out.print("请输入你猜的数字：");
        guess = sc.nextInt();
        attempts++;
        
        if (guess > target) {
            System.out.println("猜大了！");
        } else if (guess < target) {
            System.out.println("猜小了！");
        } else {
            System.out.println("恭喜！猜对了！共用了" + attempts + "次");
            break;
        }
    }
}

}
第十章数组
10.1 数组定义
java
public class ArrayDefine {
public static void main(String[] args) {
// 动态初始化：指定长度
int[] arr1 = new int[5];
String[] arr2 = new String[3];

    // 静态初始化：直接赋值
    int[] arr3 = new int[]{10, 20, 30, 40};
    int[] arr4 = {5, 10, 15, 20, 25};  // 简化写法
    
    String[] names = {"张三", "李四", "王五", "赵六"};
}

}
10.2 数组操作
java
public class ArrayOperation {
public static void main(String[] args) {
int[] arr = new int[4];

    // 存储元素
    arr[0] = 25;
    arr[1] = 36;
    arr[2] = 49;
    arr[3] = 64;
    
    // 获取元素
    System.out.println(arr[0]);  // 25
    System.out.println(arr[1]);  // 36
    
    // 获取数组长度
    System.out.println("数组长度：" + arr.length);  // 4
    
    // 遍历数组
    for (int i = 0; i < arr.length; i++) {
        System.out.println("arr[" + i + "] = " + arr[i]);
    }
    
    // 直接输出数组名得到地址值
    System.out.println(arr);  // 如 [I@15db9742
}

}
10.3 常见异常
java
public class ArrayException {
public static void main(String[] args) {
// 索引越界异常
int[] arr = new int[3];
// System.out.println(arr[3]); // ArrayIndexOutOfBoundsException

    // 空指针异常
    arr = null;
    // System.out.println(arr.length);  // NullPointerException
}

}
10.4 数组练习
练习1：求数组最大值
java
public class ArrayMax {
public static void main(String[] args) {
int[] scores = {88, 92, 76, 95, 83, 79, 91};

    int max = scores[0];
    for (int i = 1; i < scores.length; i++) {
        if (scores[i] > max) {
            max = scores[i];
        }
    }
    System.out.println("最高分：" + max);
}

}
练习2：统计满足条件的个数
java
import java.util.Random;

public class ArrayCount {
public static void main(String[] args) {
// 生成20个0-50之间的随机数，统计能被3整除且大于10的个数
int[] nums = new int[20];
Random rand = new Random();

    for (int i = 0; i < nums.length; i++) {
        nums[i] = rand.nextInt(51);
    }
    
    int count = 0;
    for (int num : nums) {
        if (num > 10 && num % 3 == 0) {
            count++;
        }
    }
    System.out.println("满足条件的个数：" + count);
}

}
练习3：数组元素查找
java
public class ArraySearch {
public static void main(String[] args) {
int[] arr = {15, 28, 33, 47, 52, 68, 74, 89};
Scanner sc = new Scanner(System.in);

    System.out.print("请输入要查找的数：");
    int target = sc.nextInt();
    
    int index = -1;
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == target) {
            index = i;
            break;
        }
    }
    
    if (index != -1) {
        System.out.println("找到了！索引位置：" + index);
    } else {
        System.out.println("没有找到该元素");
    }
}

}
练习4：数组扩容
java
public class ArrayExpand {
public static void main(String[] args) {
int[] oldArr = {2, 4, 6, 8};
int[] newArr = new int[7];

    // 复制原数组元素
    for (int i = 0; i < oldArr.length; i++) {
        newArr[i] = oldArr[i];
    }
    
    // 新数组末尾添加元素
    newArr[4] = 10;
    newArr[5] = 12;
    newArr[6] = 14;
    
    // 指向新数组
    oldArr = newArr;
    
    // 遍历输出
    System.out.print("扩容后数组：");
    for (int num : oldArr) {
        System.out.print(num + " ");
    }
}

}
第十一章内存图解
Java内存分为5块：

栈(Stack)：存放方法调用和局部变量

堆(Heap)：存放new出来的对象/数组，有默认值

方法区(Method Area)：存放类的信息

本地方法栈(Native Method Stack)：存放native方法

程序计数器(PC Register)：记录执行位置

java
// 一个数组的内存图解
int[] arr = new int[3];
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
// arr变量在栈中，指向堆中的数组对象
java
// 两个数组指向同一内存
int[] arr1 = {1, 2, 3};
int[] arr2 = arr1; // arr2和arr1指向同一地址
arr2[0] = 100;
System.out.println(arr[0]) // 100

https://edu.csdn.net/learn/39067/627173?utm_source=2019755004

汇聚全球AI编程工具，助力开发者即刻编程。

更多推荐

深度 | Claude 11 天「验完」费马大定理：AI 没证明新数学，但把验算工业化了一脚

AI编程社区

图解 AI Agent：Agent = 模型 + Harness

—指围绕"模型该看到什么"做的系统性设计，是 Harness 工程里最核心的一块，Fowler 那篇文章的原文观点是：上下文工程就是把 guides 和 sensors 交付到 Agent 面前的手段[1]。它标准化的是 Harness 里"工具层"的接口，是 Harness 的一个零件，不是 Harness 本身。Claude Code、Codex、开源的 opencode，内核都是这个循环的工