Java基础篇 - 技术栈

1. IDEA中：新建项目 → 新建包 → 新建java文件 → 写代码

1.1 "新建项目（New Project）"

1.2 新建包

一般采用倒写域名格式，顶级域名.公司名/组织名.项目名/模块名.子功能

用点号（.）分隔层级

包名全部小写字母。不能用数字开头（但可day01），不能用空格、特殊符号、java关键字

顶级域名表示地区，如 cn = 中国；com = 商业机构；

公司名/组织名如 itcast（传智播客）；

项目名/模块名如 basic（基础模块）。

baidu.com 倒写为 com.baidu ，完整包名如 com.baidu.shop.user

日常学习Java可直接用 study.basic，study.beginner，study.grammer，study.loop，study.arrayEnter后

Enter后IDEA自动按包名创建多层级文件夹。

1.3 新建java文件

输入类名，Enter。

1.4 写代码

键盘输入"psvm"回车，快捷生成

java 复制代码

public static void main(String[] args) {

}

键盘输入"sout"回车，快捷生成

java 复制代码

System.out.println();

1.4.1 注释

// 单行注释
/*多行注释*/
/**/中可嵌套//，/**/中不可嵌套/**/

1.4.2 解释输出代码

java 复制代码

package com.itheima.test; // 当前类定义在哪个包下

// 类是Java项目最基本的组成单位，Java所有代码必须写在类里面
// 修饰符 class 类名{java程序代码} 
public class HelloWorld {
    public static void main(String[] args) // java程序主入口
    {
        System.out.println("Hello World"); // 输出到控制台
    }
}

2. 字面量、变量、运算符

3. 语句

3.1 判断语句

3.1.1 if 语句

java 复制代码

// 单分支if：条件成立才执行
public class TestIf {
    public static void main(String[] args) {
        int score = 90;

        // 如果分数大于等于60，就执行大括号里的代码
        if (score >= 60) {
            System.out.println("成绩及格");
        }
    }
}

3.1.2 if...else 语句

java 复制代码

// 双分支：条件成立走if，不成立走else
public class TestIfElse {
    public static void main(String[] args) {
        int score = 50;

        if (score >= 60) {
            System.out.println("及格");
        } else {
            // 条件不满足时执行
            System.out.println("不及格");
        }
    }
}

3.1.3 if...else if...else 语句

java 复制代码

// 多分支：多个条件依次判断，只执行第一个满足的
public class TestIfElseIf {
    public static void main(String[] args) {
        int score = 85;

        if (score >= 90) {
            System.out.println("优秀");
        } else if (score >= 80) {
            System.out.println("良好");
        } else if (score >= 60) {
            System.out.println("及格");
        } else {
            // 以上都不满足时执行
            System.out.println("不及格");
        }
    }
}

3.2 选择语句

switch 语句

java 复制代码

// switch：根据表达式的值匹配对应分支
public class TestSwitch {
    public static void main(String[] args) {
        int num = 2;

        // 小括号里是要判断的值
        switch (num) {
            case 1:
                System.out.println("星期一");
                break; // 跳出switch，必须写
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            default:
                // 所有case都不匹配时执行
                System.out.println("未知");
                break;
        }
    }
}

3.3 循环语句

3.3.1 while 循环

java 复制代码

// while：先判断条件，条件成立才循环
public class TestWhile {
    public static void main(String[] args) {
        int i = 1;

        // 循环条件：i <= 5
        while (i <= 5) {
            System.out.println("第" + i + "次循环");
            i++; // 变量自增，避免死循环
        }
    }
}

3.3.2 do...while 循环

java 复制代码

// do...while：先执行一次，再判断条件
public class TestDoWhile {
    public static void main(String[] args) {
        int i = 1;

        do {
            // 先执行一次循环体
            System.out.println("第" + i + "次循环");
            i++;
        } while (i <= 5); // 后判断条件
    }
}

3.3.3 for 循环（最常用）

java 复制代码

// for：格式固定，适合已知次数的循环
public class TestFor {
    public static void main(String[] args) {
        // 格式：初始化; 判断条件; 步进
        for (int i = 1; i <= 5; i++) {
            System.out.println("第" + i + "次循环");
        }
    }
}

4. 数组

4.1 数组的声明与初始化

java 复制代码

// 数组的三种声明方式
int[] arr1;          // 推荐写法：数据类型[] 数组名
int arr2[];          // 另一种写法（C语言风格），不推荐
int[] arr3 = new int[5]; // 动态初始化：指定长度，元素默认值为0

// 静态初始化：声明时直接赋值
int[] arr4 = new int[]{1, 2, 3, 4, 5};
int[] arr5 = {6, 7, 8, 9, 10}; // 简化写法

// 输出数组长度
System.out.println("arr4的长度：" + arr4.length);

4.2 数组元素的访问与遍历

java 复制代码

int[] scores = {85, 92, 78, 90, 88};

// 通过索引访问（索引从0开始）
System.out.println("第一个元素：" + scores[0]); // 输出85
System.out.println("最后一个元素：" + scores[scores.length - 1]); // 输出88

// 普通for循环遍历
System.out.print("普通for遍历：");
for (int i = 0; i < scores.length; i++) {
    System.out.print(scores[i] + " ");
}
System.out.println();

// 增强for循环（foreach）遍历
System.out.print("增强for遍历：");
for (int score : scores) {
    System.out.print(score + " ");
}

4.3 数组的常见操作：查找最大值与平均值

java 复制代码

int[] numbers = {23, 45, 12, 67, 34, 89, 5};

// 查找最大值
int max = numbers[0];
for (int i = 1; i < numbers.length; i++) {
    if (numbers[i] > max) {
        max = numbers[i];
    }
}
System.out.println("最大值：" + max);

// 计算平均值
int sum = 0;
for (int num : numbers) {
    sum += num;
}
double average = (double) sum / numbers.length;
System.out.println("平均值：" + average);

5. 方法

方法是 Java 中可重复使用的代码块，专门用来完成单一固定功能，能大幅减少代码重复编写。

【与 C++ 类比】

Java 方法 = C++ 函数

Java static 方法 = C++ 全局函数 / 静态成员函数

Java 必须写在类里面，C++ 可以写类外

语法、参数、返回值、return 几乎完全一样

5.1 方法的基本定义与调用

java 复制代码

public class MethodDemo {
    public static void main(String[] args) {
        // 调用无参无返回值方法
        printHello();

        // 调用带参有返回值方法
        int result = add(10, 20);
        System.out.println("10 + 20 = " + result);
    }

    // 无参无返回值方法
    static void printHello() {
        System.out.println("Hello, Java!");
    }

    // 带参有返回值方法
    static int add(int a, int b) {
        return a + b; // 返回两个整数的和
    }
}

5.2 方法的参数传递：基本类型 vs 引用类型

【与 C++ 类比】

Java 基本类型传递 = C++ 值传递

Java 没有 & 引用符号 ，但数组/对象默认传地址，效果和 C++ 传指针一致

Java**"统一称为"值传递**，C++ 分值传递、引用传递

基本类型 （int/double/char 等）：传递的是变量的数值副本，方法内修改不会影响原变量；
引用类型 （数组 / 对象）：传递的是内存地址，方法内通过地址修改数据，会直接改变原数组 / 对象。

java 复制代码

public class ParameterPass {
    public static void main(String[] args) {
        // 基本类型传递（值传递）
        int x = 5;
        changeValue(x);
        System.out.println("x的值：" + x); // 输出5，未改变

        // 引用类型传递（传递数组的地址）
        int[] arr = {1, 2, 3};
        changeArray(arr);
        System.out.println("arr[0]的值：" + arr[0]); // 输出99，被修改
    }

    // 形参是基本类型，修改不会影响实参
    static void changeValue(int num) {
        num = 100;
    }

    // 形参是数组（引用类型），修改数组内容会影响实参
    static void changeArray(int[] array) {
        array[0] = 99;
    }
}

5.3 方法重载（Overloading）

【与 C++ 类比】

Java 方法重载 = C++ 函数重载

规则完全一样：同名、不同参数

C++ 能写的重载，Java 几乎都能直接照搬

唯一区别：由于Java 所有代码必须写在类里面，所以Java 重载必须在同一个类中

方法重载是 Java 的核心语法：同一个类中，允许定义多个方法名相同、但参数不同的方法。

作用：调用相同功能的方法时，不用记多个名字，编译器会自动根据参数匹配对应方法。

✅ 重载核心规则：

必须：方法名相同 + 参数列表不同（个数 / 类型 / 顺序）；
无关：返回值类型、修饰符不影响重载。

java 复制代码

public class OverloadDemo {
    public static void main(String[] args) {
        System.out.println(add(5, 10));          // 调用 int 版本
        System.out.println(add(2.5, 3.7));       // 调用 double 版本
        System.out.println(add(1, 2, 3));        // 调用三个参数版本
    }

    // 同名方法，参数列表不同（参数个数、类型或顺序）
    static int add(int a, int b) {
        return a + b;
    }

    static double add(double a, double b) {
        return a + b;
    }

    static int add(int a, int b, int c) {
        return a + b + c;
    }
}

5.4 数组作为方法参数和返回值

【与 C++ 类比】

Java 数组做参数 = C++ 数组名传参 / 指针传参

Java 数组做返回值 = C++ 返回指针（动态数组）

Java 不用写 int*、new[]、delete[]，自动管理内存

数组可以作为方法的参数，也可以作为方法的返回值：

数组作为参数：让方法批量处理一组数据；
数组作为返回值：让方法一次性返回多个结果（普通方法只能返回一个值）。这是 Java 中批量数据处理的常用方式。

java 复制代码

import java.util.Arrays;

public class ArrayMethod {
    public static void main(String[] args) {
        int[] original = {3, 1, 4, 1, 5};
        // 传递数组给方法
        int[] sorted = sortArray(original);
        System.out.println("排序后的数组：" + Arrays.toString(sorted));

        // 打印返回值数组
        int[] squares = getSquares(5);
        System.out.println("平方数组：" + Arrays.toString(squares));
    }

    // 接收数组参数，返回排序后的新数组
    static int[] sortArray(int[] arr) {
        int[] newArr = arr.clone(); // 复制原数组，避免修改原数组
        Arrays.sort(newArr);
        return newArr;
    }

    // 返回一个数组：生成1~n的平方数组
    static int[] getSquares(int n) {
        int[] result = new int[n];
        for (int i = 1; i <= n; i++) {
            result[i - 1] = i * i;
        }
        return result;
    }
}