001

• public：访问修饰符，意思是 “这个类可以被其他类访问”（零基础先记：写类时常用 public 开头）。
• class：Java 里定义 “类” 的关键字，类是 Java 程序的基本单位（可以理解成一个 “代码盒子”，装着要执行的逻辑）。
• EqualSign：类的名字（自定义的，这里叫 “等号”，因为代码讲赋值运算），类名要和文件名一致（比如文件叫 EqualSign.java）。

public static void：

• 第 2 行是主方法 main，它必须是 void（无返回值），不能改返回类型！原因：Java 规定 main 是程序入口，JVM 调用它时不接收返回值，所以语法上强制要求 void。
• public：主方法能被外部访问；
• static：主方法属于类本身，不用创建对象就能执行；static 是让 “成员（变量 / 方法）属于类本身，而不是属于类的对象”。
• void：主方法执行完不返回任何值。
• main：Java 程序的入口方法，程序运行时，JVM（Java 虚拟机）会先找 main 方法开始执行。
• (String[] args)：主方法的参数（零基础先记：固定写法，暂时不用管它的作用）。
• int：Java 的基本数据类型，代表 “整数”（比如 1、2、11 这种没有小数的数）。
• a, b, c：定义 3 个整型变量（变量就是存数据的 “小盒子”，名字分别叫 a、b、c）。
• c = 11：给变量 c 赋值，把数字 11 放进 c 的 “小盒子” 里。

注意： Java 里变量必须先赋值才能用，后面会给它们赋值

• System.out.println()：Java 里的 “输出语句”，作用是把括号里的内容打印到控制台（屏幕上）。
• "a = "：字符串（用双引号括起来的文字，原样输出）。
• +：这里是 “字符串拼接”，把字符串 "a = " 和变量 a 的值（32）拼在一起。

什么时候用 static？（3 个核心场景）

场景 1：需要 “全类共享” 的变量 / 常量

当某个数据所有对象都共用、不需要每个对象单独一份时，用 static。

例子：统计 Car 类造了多少辆车

public class Car {
    // static 变量：全类共享，所有 Car 对象共用这一个 count
    public static int count = 0;

    // 构造方法：造对象时自动执行
    public Car() {
        count++; // 每造一辆车，count 加1
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        Car c1 = new Car(); // count 变成1
        Car c2 = new Car(); // count 变成2
        // 直接用类名访问 static 变量（不用造对象）
        System.out.println(Car.count); // 输出2
    }
}

✅ 为什么用 static？count 是 “总车辆数”，不是某一辆车的属性，所以全类共享，用 static。

场景 2：不需要 “对象状态” 的工具方法

当一个方法只做通用功能，不需要访问对象的非 static 成员时，用 static。这类方法叫 “工具方法”，比如数学计算、字符串处理、格式转换等。

例子：写一个 “计算两数之和” 的工具方法

public class MathUtil {
    // static 方法：工具方法，不用造对象就能用
    public static int add(int a, int b) {
        return a + b;
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        // 直接用类名调用 static 方法（不用 new MathUtil()）
        int sum = MathUtil.add(3, 5);
        System.out.println(sum); // 输出8
    }
}

✅ 为什么用 static？add 方法只做 “加法计算”，不需要依赖某个对象的状态（比如不需要知道 “这是哪辆车的加法”），所以用 static，调用更方便。

场景 3：程序入口 main 方法（必须用 static）

Java 程序运行时，JVM 还没创建任何对象，所以入口方法 main 必须是 static——这样 JVM 可以直接通过类名调用 main，不用先造对象。

这就是代码里 public static void main(...) 必须加 static 的原因！

static 的 2 个关键规则（必记）

1. 访问规则：

• • static 成员（变量 / 方法），可以直接用类名访问（比如 Car.count、MathUtil.add()），也可以用对象访问（但不推荐）。
  • 非 static 成员，必须用对象访问（比如 new Car().color）。

1. 互相访问规则：

• • static 方法 / 代码块 → 不能直接访问 非 static 成员（因为 static 属于类，非 static 属于对象，类加载时对象还没造出来）。
  • 非 static 方法 → 可以直接访问static 成员（因为对象存在时，类肯定已经加载了）。

对于 “包含 main 方法的类”（程序入口类）

前两行通常会写成：

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

这是最常见的写法，原因是：

• public class：如果这个类要被其他类（或 JVM）访问（比如作为程序入口），需要用 public 修饰；
• public static void main(...)：程序入口方法必须是 public static void + 固定参数，否则 JVM 找不到入口。

总结

• 类是 Java 程序的 “容器”，main 是程序的 “入口”。
• int 是整数类型，变量是存数据的 “小盒子”。
• = 是赋值（把右边的值给左边），不是数学的 “等于”。
• 赋值运算从右往左算，c = b = a + 4 等价于先算 b = a+4，再算 c = b。
• System.out.println() 是打印输出，+ 可以拼接字符串和变量。

002

import java.util.Scanner;

• import：导入关键字，用来引入 Java 官方提供的工具类。
• java.util.Scanner：这是 Java 提供的 “扫描器” 工具类，作用是从控制台读取用户输入的内容。
• 你可以把它理解成：“我要借一个叫 Scanner 的工具，用来接收用户在键盘上输入的数字”。

Scanner sc = new Scanner(System.in);

• Scanner sc：声明一个 Scanner 类型的变量，名字叫 sc（可以理解为 “我准备了一个叫 sc 的扫描器”）。
• new Scanner(System.in)：创建一个 Scanner 对象，System.in 表示 “从键盘输入” 作为扫描的来源。
• 整行的意思：“创建一个扫描器 sc，专门用来读取用户从键盘输入的内容”。
• 只有在创建对象类型的变量时才需要用 new 这样写，创建基本数据类型（比如 int、double）的变量时不用。

Java的两种数据类型

Java 里的变量分为两大类，创建方式完全不同：

1. 基本数据类型

（8 种：byte、short、int、long、float、double、char、boolean）

• 这类变量存的是直接值（比如数字、字符、布尔值）。
• 创建时直接赋值，不需要 new。
• 例子：

int a = 10;       // 直接存数字10
double num1 = 3.14; // 直接存小数3.14
boolean flag = true; // 直接存布尔值true

2. 引用数据类型

（除了 8 种基本类型，剩下的都是，比如 Scanner、String、自定义类等）

• 这类变量存的是对象的内存地址（相当于 “指向对象的指针”）。
• 创建时需要先用 new 关键字创建对象，再把对象的地址赋值给变量。
• 例子：

// 创建Scanner对象，把对象地址存到sc变量里
Scanner sc = new Scanner(System.in);

// 创建String对象，把对象地址存到str变量里
String str = new String("hello");

第 4 行 Scanner sc = new Scanner(System.in); 为什么要这样写？

• Scanner 是引用数据类型（它是 Java 提供的一个类），所以需要用 new 来创建对象。
• Scanner sc：声明一个 Scanner 类型的变量 sc（相当于准备一个 “盒子”）。
• new Scanner(System.in)：调用 Scanner 的构造方法，创建一个 Scanner 对象（相当于造一个 “扫描器工具”）。
• =：把这个新创建的对象的内存地址，赋值给变量 sc（相当于把 “工具” 放进 “盒子” 里）。

double num1 = sc.nextDouble();

• double：这是 Java 里的 “双精度浮点数” 类型，可以存带小数点的数字（比如 3.14、5.6 等）。
• num1：我们声明的变量名，用来存储用户输入的第一个数字。
• sc.nextDouble()：调用扫描器 sc 的 nextDouble() 方法，从键盘读取一个 double 类型的数字。
• 整行的意思：“从用户输入中读取第一个数字，把它存到变量 num1 里”。

总结

• Scanner 是用来读取用户输入的工具，需要先 import 才能用。
• double 类型可以存小数，适合做需要精度的计算。
• sc.nextDouble() 会按空格或回车键分割输入，所以用户输入 3.5 6.2 时，num1 会得到 3.5，num2 会得到 6.2。
• 记得用完 Scanner 后要调用 sc.close() 关闭它，养成好习惯。

位移运算

1. 左移运算（<<）

• 规则：不管是正数还是负数，左移时右边空出来的位，一律补 0。
• 左移的本质是 “乘以 2 的 n 次方”（n 是移动的位数），所以右边补 0 是固定的。
• 例子：

int a = 5;      // 二进制：0000 0101
int b = a << 1; // 左移1位：0000 1010 → 结果是 10

2. 右移运算（两种）

（1）有符号右移（>>）

• 规则：最高位是符号位（正数为 0，负数为 1），右移时左边空出来的位，补原来的符号位。
• 正数右移：左边补 0

int a = 10;     // 二进制：0000 1010
int b = a >> 1; // 右移1位：0000 0101 → 结果是 5

• 负数右移：左边补 1

int a = -10;    // 二进制：1111 0110（补码表示）
int b = a >> 1; // 右移1位：1111 1011 → 结果是 -5

（2）无符号右移（>>>）

• 规则：不管是正数还是负数，右移时左边空出来的位，一律补 0。
• 这种移位会把负数当成正数来处理，所以结果总是非负的。
• 例子：

int a = -10;     // 二进制：1111 0110
int b = a >>> 1; // 右移1位：0111 1011 → 结果是 123

总结

• 左移只补 0。
• 有符号右移补符号位（正数补 0，负数补 1）。
• 无符号右移只补 0。

左移赋值运算符

<<= 是 Java 里的左移赋值运算符，它是左移运算（<<）和赋值运算（=）的结合，意思是 “先把变量左移指定位数，再把结果赋值给变量本身”。

int a = 5; // 二进制：0000 0101
a <<= 1;   // 等价于 a = a << 1
// 左移1位后：0000 1010 → 十进制是 10
// 所以执行后 a 的值变成 10

三元运算符

三元运算符是 Java 里唯一需要三个操作数的运算符，也叫 “条件运算符”，可以把它看作是 if-else 语句的简化版。

基本语法

条件表达式 ? 表达式1: 表达式2;

执行逻辑

1. 1. 先判断 条件表达式 的结果是 true 还是 false。
   2. 如果是 true，就执行并返回 表达式1 的值。
   3. 如果是 false，就执行并返回 表达式2 的值。

// 判断 a 是否大于 b，返回较大的那个数
int a = 5;
int b = 10;
int max = a > b ? a : b;
// 执行逻辑：a > b 是 false，所以返回 b 的值 → max = 10