Minecraft 模组开发完全入门指南：Java 基础与 IDEA 使用

第一阶段：编程基础
├── Java 语法基础
│   ├── 变量、数据类型、运算符
│   ├── 控制流程（if/for/while）
│   ├── 方法（函数）的定义和调用
│   └── 数组和集合（List/Map）
├── 面向对象编程（OOP）
│   ├── 类与对象
│   ├── 封装、继承、多态
│   ├── 接口与抽象类
│   └── 泛型基础
└── 开发工具使用
    ├── IntelliJ IDEA 基本操作
    ├── 项目结构理解
    └── 调试技巧

第二阶段：Minecraft 模组开发
├── Gradle 构建系统
├── NeoForge 框架理解
├── 注册系统（Registry）
├── 事件系统（Event Bus）
├── 资源文件（JSON/PNG）
└── 数据生成（Data Generation）

第三阶段：进阶开发
├── Mixin 注入技术
├── 网络通信（Networking）
├── 配置文件系统
├── 兼容性处理
└── 性能优化

// HelloWorld.java
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, Minecraft Modding!");
    }
}

public class HelloWorld {

    public static void main(String[] args) {

        System.out.println("Hello, Minecraft Modding!");

// 整数类型
byte myByte = 127;           // 8位，范围 -128 到 127
short myShort = 32000;       // 16位，范围 -32768 到 32767
int myInt = 2147483647;      // 32位，最常用的整数类型
long myLong = 9223372036854775807L;  // 64位，注意末尾的 L

// 浮点类型
float myFloat = 3.14f;       // 32位，注意末尾的 f
double myDouble = 3.14159265359;  // 64位，默认的小数类型

// 字符类型
char myChar = 'A';           // 16位 Unicode 字符

// 布尔类型
boolean myBoolean = true;    // 只有 true 或 false

// 来自 Item.Properties 的示例
int maxStackSize = 64;           // 物品最大堆叠数量
int maxDamage = 250;             // 工具耐久度
boolean isFireResistant = true;  // 是否防火

// 字符串（最常用的引用类型）
String modId = "yourmod";
String itemName = "my_item";

// 数组
int[] numbers = {1, 2, 3, 4, 5};
String[] names = new String[10];  // 创建长度为 10 的数组

// 对象
Item myItem = new Item(new Item.Properties());

// 基本类型：直接存储值
int a = 10;
int b = a;    // 复制值
b = 20;       // 修改 b 不影响 a
// 结果：a = 10, b = 20

// 引用类型：存储对象的地址
Item item1 = new Item(new Item.Properties());
Item item2 = item1;  // 复制地址，指向同一个对象
// item1 和 item2 指向同一个 Item 对象

// 算术运算符
int sum = 10 + 5;        // 加法：15
int diff = 10 - 5;       // 减法：5
int product = 10 * 5;    // 乘法：50
int quotient = 10 / 5;   // 除法：2
int remainder = 10 % 3;  // 取模（余数）：1

// 比较运算符（返回 boolean）
boolean isEqual = (10 == 10);      // 等于：true
boolean notEqual = (10 != 5);      // 不等于：true
boolean greater = (10 > 5);        // 大于：true
boolean less = (5 < 10);           // 小于：true

// 逻辑运算符
boolean and = (true && false);     // 与：false
boolean or = (true || false);      // 或：true
boolean not = !true;               // 非：false

// 赋值运算符
int x = 10;
x += 5;   // 等价于 x = x + 5，结果：15
x -= 3;   // 等价于 x = x - 3，结果：12
x *= 2;   // 等价于 x = x * 2，结果：24
x /= 4;   // 等价于 x = x / 4，结果：6

int durability = 50;

if (durability > 100) {
    System.out.println("耐久度充足");
} else if (durability > 50) {
    System.out.println("耐久度一般");
} else {
    System.out.println("耐久度不足");
}

// 检查物品是否可以使用
@Override
public InteractionResultHolder<ItemStack> use(Level level, Player player, InteractionHand hand) {
    ItemStack stack = player.getItemInHand(hand);
    
    if (stack.getDamageValue() >= stack.getMaxDamage()) {
        // 物品已损坏
        return InteractionResultHolder.fail(stack);
    }
    
    // 物品可以使用
    return InteractionResultHolder.success(stack);
}

// 打印 0 到 9
for (int i = 0; i < 10; i++) {
    System.out.println(i);
}

// 遍历数组
String[] items = {"apple", "banana", "cherry"};
for (int i = 0; i < items.length; i++) {
    System.out.println(items[i]);
}

// 增强 for 循环（for-each）
for (String item : items) {
    System.out.println(item);
}

int count = 0;
while (count < 5) {
    System.out.println("Count: " + count);
    count++;
}

// 遍历玩家背包中的所有物品
for (int i = 0; i < player.getInventory().getContainerSize(); i++) {
    ItemStack stack = player.getInventory().getItem(i);
    if (!stack.isEmpty()) {
        // 处理每个物品
    }
}

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

public int add(int a, int b) {
    int sum = a + b;
    return sum;
}

// 无返回值的方法
public void printMessage(String message) {
    System.out.println(message);
}

// 无参数的方法
public String getModId() {
    return "yourmod";
}

int result = add(10, 20);        // 调用 add 方法，result = 30
printMessage("Hello");           // 调用 printMessage 方法
String modId = getModId();       // 调用 getModId 方法

// 静态工厂方法
public static DeferredRegister.Items createItems(String modid) {
    return new Items(modid);
}

// 实例方法
public <I extends T> DeferredHolder<T, I> register(String name, Supplier<? extends I> sup) {
    // 方法实现
}

// 定义一个类
public class Sword {
    // 属性（字段）
    private int damage;
    private int durability;
    
    // 构造函数
    public Sword(int damage, int durability) {
        this.damage = damage;
        this.durability = durability;
    }
    
    // 方法
    public void attack() {
        System.out.println("造成 " + damage + " 点伤害");
        durability--;
    }
    
    // Getter 方法
    public int getDamage() {
        return damage;
    }
    
    // Setter 方法
    public void setDamage(int damage) {
        this.damage = damage;
    }
}

// 创建对象
Sword ironSword = new Sword(7, 250);
ironSword.attack();  // 调用方法
int damage = ironSword.getDamage();  // 获取属性

public class Item {
    // 私有属性，外部无法直接访问
    private int maxStackSize;
    
    // 通过公开方法访问
    public int getMaxStackSize() {
        return maxStackSize;
    }
    
    // 通过公开方法修改，可以添加验证逻辑
    public void setMaxStackSize(int size) {
        if (size > 0 && size <= 64) {
            this.maxStackSize = size;
        } else {
            throw new IllegalArgumentException("堆叠数量必须在 1-64 之间");
        }
    }
}

// 父类
public class Item {
    protected int maxStackSize;
    
    public Item(Properties properties) {
        this.maxStackSize = properties.maxStackSize;
    }
    
    public int getMaxStackSize() {
        return maxStackSize;
    }
}

// 子类继承父类
public class SwordItem extends Item {
    private int attackDamage;
    
    public SwordItem(Properties properties, int attackDamage) {
        super(properties);  // 调用父类构造函数
        this.attackDamage = attackDamage;
    }
    
    // 子类特有的方法
    public int getAttackDamage() {
        return attackDamage;
    }
}

public class MyCustomItem extends Item {
    public MyCustomItem(Properties properties) {
        super(properties);
    }
    
    // 重写父类方法，实现自定义行为
    @Override
    public InteractionResultHolder<ItemStack> use(Level level, Player player, InteractionHand hand) {
        // 自定义逻辑
        return super.use(level, player, hand);
    }
}

// 父类引用指向子类对象
Item item1 = new Item(new Item.Properties());
Item item2 = new SwordItem(new Item.Properties(), 7);  // SwordItem 是 Item 的子类

// 调用方法时，会根据实际对象类型执行对应的方法
item1.use(level, player, hand);  // 执行 Item 的 use 方法
item2.use(level, player, hand);  // 执行 SwordItem 的 use 方法（如果重写了）

public class SwordItem extends Item {
    @Override  // 注解，表示这是重写父类方法
    public InteractionResultHolder<ItemStack> use(Level level, Player player, InteractionHand hand) {
        // 自定义实现
        player.sendSystemMessage(Component.literal("使用了剑！"));
        return InteractionResultHolder.success(player.getItemInHand(hand));
    }
}

// 定义接口
public interface ItemLike {
    Item asItem();  // 抽象方法，没有实现
}

// 实现接口
public class DeferredItem<T extends Item> implements ItemLike {
    @Override
    public Item asItem() {
        return this.get();  // 提供具体实现
    }
}

public class DeferredItem<T extends Item> extends DeferredHolder<Item, T> implements ItemLike {
    // 实现 ItemLike 接口
    @Override
    public Item asItem() {
        return this.get();
    }
}

// 定义泛型类
public class Box<T> {
    private T content;
    
    public void set(T content) {
        this.content = content;
    }
    
    public T get() {
        return content;
    }
}

// 使用泛型类
Box<String> stringBox = new Box<>();
stringBox.set("Hello");
String value = stringBox.get();  // 不需要类型转换

Box<Integer> intBox = new Box<>();
intBox.set(123);
Integer number = intBox.get();

// T 必须是 Item 或其子类
public class DeferredItem<T extends Item> {
    private T item;
    
    public T get() {
        return item;
    }
}

// 使用
DeferredItem<SwordItem> sword = new DeferredItem<>();  // 正确
// DeferredItem<String> invalid = new DeferredItem<>();  // 编译错误！String 不是 Item 的子类

public class DeferredRegister<T> {
    // T 是注册表类型（如 Item、Block）
}

public class Items extends DeferredRegister<Item> {
    // 固定 T = Item
}

// 传统写法：匿名内部类
Supplier<Item> supplier = new Supplier<Item>() {
    @Override
    public Item get() {
        return new Item(new Item.Properties());
    }
};

// Lambda 表达式写法
Supplier<Item> supplier = () -> new Item(new Item.Properties());

// 无参数
() -> expression
() -> { statements; }

// 一个参数
x -> expression
x -> { statements; }

// 多个参数
(x, y) -> expression
(x, y) -> { statements; }

// Lambda 表达式
Supplier<Item> supplier = () -> new Item(new Item.Properties());

// 方法引用（构造函数引用）
Function<Item.Properties, Item> constructor = Item::new;

// 静态方法引用
Function<String, Integer> parser = Integer::parseInt;

// 实例方法引用
String str = "hello";
Supplier<String> upperCase = str::toUpperCase;

// 注册物品时使用方法引用
public static final DeferredItem<MySword> MY_SWORD = 
    ITEMS.registerItem("my_sword", MySword::new, new Item.Properties());

// 等价于
public static final DeferredItem<MySword> MY_SWORD = 
    ITEMS.registerItem("my_sword", 
        props -> new MySword(props), 
        new Item.Properties());

import java.util.ArrayList;
import java.util.List;

// 创建列表
List<String> items = new ArrayList<>();

// 添加元素
items.add("apple");
items.add("banana");
items.add("cherry");

// 获取元素
String first = items.get(0);  // "apple"

// 遍历
for (String item : items) {
    System.out.println(item);
}

// 大小
int size = items.size();  // 3

// 删除元素
items.remove(0);  // 删除第一个元素
items.remove("banana");  // 删除指定元素

import java.util.HashMap;
import java.util.Map;

// 创建映射
Map<String, Integer> prices = new HashMap<>();

// 添加键值对
prices.put("apple", 10);
prices.put("banana", 5);
prices.put("cherry", 15);

// 获取值
int applePrice = prices.get("apple");  // 10

// 检查键是否存在
boolean hasApple = prices.containsKey("apple");  // true

// 遍历
for (Map.Entry<String, Integer> entry : prices.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

// 使用 Map 存储待注册的对象
private final Map<DeferredHolder<T, ? extends T>, Supplier<? extends T>> entries = new LinkedHashMap<>();

try {
    // 可能抛出异常的代码
    int result = 10 / 0;  // 会抛出 ArithmeticException
} catch (ArithmeticException e) {
    // 捕获并处理异常
    System.out.println("除数不能为零：" + e.getMessage());
} finally {
    // 无论是否发生异常都会执行
    System.out.println("清理资源");
}

// NullPointerException：空指针异常
String str = null;
// str.length();  // 会抛出 NullPointerException

// IllegalArgumentException：非法参数异常
public void setStackSize(int size) {
    if (size < 1 || size > 64) {
        throw new IllegalArgumentException("堆叠数量必须在 1-64 之间");
    }
}

// IOException：输入输出异常
try {
    Files.readString(Path.of("file.txt"));
} catch (IOException e) {
    e.printStackTrace();
}

// 工厂方法：创建 Items 类型的 DeferredRegister
public static DeferredRegister.Items createItems(String modid) {
    return new Items(modid);
}

// 工厂方法：创建 Blocks 类型的 DeferredRegister
public static DeferredRegister.Blocks createBlocks(String modid) {
    return new Blocks(modid);
}

// 不推荐：直接使用构造函数
DeferredRegister<Item> items = new DeferredRegister<>(Registries.ITEM, "yourmod");

// 推荐：使用工厂方法
DeferredRegister.Items items = DeferredRegister.createItems("yourmod");

public class ItemFactory {
    // 工厂方法：创建不同类型的物品
    public static Item createSimpleItem() {
        return new Item(new Item.Properties());
    }
    
    public static SwordItem createSword(int damage) {
        return new SwordItem(Tiers.DIAMOND, damage, -2.4f, new Item.Properties());
    }
    
    public static Item createFireResistantItem() {
        return new Item(new Item.Properties().fireResistant());
    }
}

// 使用工厂方法
Item item1 = ItemFactory.createSimpleItem();
SwordItem sword = ItemFactory.createSword(7);

// 建造者模式：链式调用设置属性
Item.Properties props = new Item.Properties()
    .stacksTo(16)              // 设置堆叠数量
    .durability(250)           // 设置耐久度
    .fireResistant()           // 设置防火
    .rarity(Rarity.RARE);      // 设置稀有度

// 创建物品
Item item = new Item(props);

// 如果不用建造者模式，构造函数会变成这样：
public Item(int maxStackSize, int maxDamage, boolean fireResistant, Rarity rarity) {
    // 参数太多，容易搞混顺序
}

// 调用时很难看懂每个参数的含义
Item item = new Item(16, 250, true, Rarity.RARE);  // 这些数字是什么意思？

public class Sword {
    private final int damage;
    private final int durability;
    private final boolean fireResistant;
    
    // 私有构造函数，只能通过 Builder 创建
    private Sword(Builder builder) {
        this.damage = builder.damage;
        this.durability = builder.durability;
        this.fireResistant = builder.fireResistant;
    }
    
    // 建造者类
    public static class Builder {
        private int damage = 5;           // 默认值
        private int durability = 100;     // 默认值
        private boolean fireResistant = false;
        
        public Builder damage(int damage) {
            this.damage = damage;
            return this;  // 返回自己，支持链式调用
        }
        
        public Builder durability(int durability) {
            this.durability = durability;
            return this;
        }
        
        public Builder fireResistant() {
            this.fireResistant = true;
            return this;
        }
        
        public Sword build() {
            return new Sword(this);
        }
    }
}

// 使用建造者
Sword sword = new Sword.Builder()
    .damage(10)
    .durability(500)
    .fireResistant()
    .build();

// Minecraft 的注册表就是单例
Registry<Item> itemRegistry = BuiltInRegistries.ITEM;  // 全局唯一的物品注册表

public class ConfigManager {
    // 私有静态实例
    private static ConfigManager instance;
    
    // 私有构造函数，防止外部创建实例
    private ConfigManager() {
        // 初始化配置
    }
    
    // 公开的获取实例方法
    public static ConfigManager getInstance() {
        if (instance == null) {
            instance = new ConfigManager();
        }
        return instance;
    }
    
    // 配置方法
    public void loadConfig() {
        // 加载配置
    }
}

// 使用单例
ConfigManager config = ConfigManager.getInstance();
config.loadConfig();

public class ConfigManager {
    // 使用枚举实现单例（推荐方式）
    private ConfigManager() {}
    
    private static class Holder {
        private static final ConfigManager INSTANCE = new ConfigManager();
    }
    
    public static ConfigManager getInstance() {
        return Holder.INSTANCE;
    }
}

// 事件（被观察的对象）
public class PlayerInteractEvent extends Event {
    private final Player player;
    private final ItemStack stack;
    
    // 事件数据
}

// 观察者（事件监听器）
@EventBusSubscriber(modid = "yourmod")
public class EventHandler {
    
    @SubscribeEvent
    public static void onPlayerInteract(PlayerInteractEvent event) {
        // 当事件发生时，这个方法会被调用
        System.out.println("玩家交互了！");
    }
}

// 观察者接口
interface ItemObserver {
    void onItemUsed(Item item);
}

// 被观察的对象
class ItemManager {
    private List<ItemObserver> observers = new ArrayList<>();
    
    // 注册观察者
    public void addObserver(ItemObserver observer) {
        observers.add(observer);
    }
    
    // 通知所有观察者
    public void useItem(Item item) {
        // 执行物品使用逻辑
        System.out.println("使用物品：" + item);
        
        // 通知所有观察者
        for (ItemObserver observer : observers) {
            observer.onItemUsed(item);
        }
    }
}

// 具体观察者
class Logger implements ItemObserver {
    @Override
    public void onItemUsed(Item item) {
        System.out.println("日志：物品被使用 - " + item);
    }
}

class Statistics implements ItemObserver {
    @Override
    public void onItemUsed(Item item) {
        System.out.println("统计：物品使用次数 +1");
    }
}

// 使用
ItemManager manager = new ItemManager();
manager.addObserver(new Logger());
manager.addObserver(new Statistics());
manager.useItem(myItem);  // 会通知所有观察者

// 不同的工具材料就是不同的策略
Tier diamondTier = Tiers.DIAMOND;  // 钻石策略
Tier ironTier = Tiers.IRON;        // 铁策略

// 使用不同的策略创建工具
SwordItem diamondSword = new SwordItem(diamondTier, 3, -2.4f, props);
SwordItem ironSword = new SwordItem(ironTier, 3, -2.4f, props);

// 策略接口
interface AttackStrategy {
    void attack(Player player, Entity target);
}

// 具体策略1：近战攻击
class MeleeAttack implements AttackStrategy {
    @Override
    public void attack(Player player, Entity target) {
        System.out.println("近战攻击！");
        target.hurt(player.getDamageSources().playerAttack(player), 5.0f);
    }
}

// 具体策略2：远程攻击
class RangedAttack implements AttackStrategy {
    @Override
    public void attack(Player player, Entity target) {
        System.out.println("远程攻击！");
        // 发射箭矢
    }
}

// 使用策略的类
class Weapon {
    private AttackStrategy strategy;
    
    public Weapon(AttackStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void setStrategy(AttackStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void performAttack(Player player, Entity target) {
        strategy.attack(player, target);
    }
}

// 使用
Weapon sword = new Weapon(new MeleeAttack());
sword.performAttack(player, zombie);

Weapon bow = new Weapon(new RangedAttack());
bow.performAttack(player, skeleton);

┌─────────────────────────────────────────────────────────────┐
│  菜单栏 (File, Edit, View, Navigate, Code, Refactor...)    │
├─────────────────────────────────────────────────────────────┤
│  工具栏 (运行、调试、构建按钮)                                │
├──────────┬──────────────────────────────────┬───────────────┤
│          │                                  │               │
│   项目   │        编辑器区域                   │   结构视图     │
│  目录树  │     (代码编辑主区域)               │   (可选)      │
│         │                                  │               │
│  (左侧)  │                                  │   (右侧)      │
│          │                                  │               │
├──────────┴──────────────────────────────────┴───────────────┤
│  底部工具窗口 (终端、运行、调试、TODO、问题等)                 │
└─────────────────────────────────────────────────────────────┘

场景：你想查看 Item 类的定义
操作：
1. 在代码中选中 "Item"
2. 按 Ctrl + B
3. IDEA 会跳转到 Item.class 文件

// 场景1：自动导入类
Item item;  // Item 显示红色波浪线
// 按 Alt + Enter → 选择 "Import class" → 自动添加 import 语句

// 场景2：创建缺失的方法
myObject.nonExistentMethod();  // 方法不存在
// 按 Alt + Enter → 选择 "Create method 'nonExistentMethod'" → 自动生成方法

// 场景3：实现接口方法
public class MyClass implements ItemLike {
    // 类显示红色波浪线（未实现接口方法）
    // 按 Alt + Enter → 选择 "Implement methods" → 自动生成所有接口方法
}

// 场景：重命名变量
int x = 10;  // 变量名不清晰
// 选中 "x" → 按 Shift + F6 → 输入新名称 "maxStackSize" → Enter
// IDEA 会自动更新所有使用 x 的地方

// 场景：提取方法
// 选中以下代码：
if (stack.getDamageValue() >= stack.getMaxDamage()) {
    return InteractionResultHolder.fail(stack);
}
// 按 Ctrl + Alt + M → 输入方法名 "isItemBroken" → Enter
// IDEA 会自动创建方法并替换选中代码

// 输入 "Sys" 然后按 Ctrl + Space
System.out.println();  // IDEA 会自动补全

// 输入 "sout" 然后按 Tab
System.out.println();  // Live Template 快速生成

// 输入 "fori" 然后按 Tab
for (int i = 0; i < ; i++) {
    
}  // 自动生成 for 循环

// 场景：需要传入 Item.Properties 参数
public void registerItem(Item.Properties props) { }

// 调用时输入：
registerItem(  // 光标在这里，按 Ctrl + Shift + Space
// IDEA 会智能建议：new Item.Properties()

// 场景：你想查看 DeferredRegister 的源码
DeferredRegister.Items ITEMS = DeferredRegister.createItems("yourmod");
// 选中 "DeferredRegister" → 按 Ctrl + B → 跳转到类定义
// 选中 "createItems" → 按 Ctrl + B → 跳转到方法定义

// 场景：你想知道 MY_ITEM 在哪里被使用
public static final DeferredItem<Item> MY_ITEM = ...;
// 选中 "MY_ITEM" → 按 Alt + F7 → 显示所有使用位置

// 场景：你想查看 Item 类的所有子类
public class Item { }
// 选中 "Item" → 按 Ctrl + H → 显示继承树

// 场景：重命名类
public class OldName { }  // 选中类名 → Shift + F6 → 输入新名称
// IDEA 会：
// 1. 重命名类
// 2. 重命名文件
// 3. 更新所有导入语句
// 4. 更新所有使用位置

// 原始代码：
public void processItem(ItemStack stack) {
    if (stack.getDamageValue() >= stack.getMaxDamage()) {
        player.sendSystemMessage(Component.literal("物品已损坏"));
        return;
    }
    // 其他逻辑
}

// 选中 if 块 → Ctrl + Alt + M → 输入方法名 "checkItemDurability"
// 结果：
public void processItem(ItemStack stack) {
    if (checkItemDurability(stack)) return;
    // 其他逻辑
}

private boolean checkItemDurability(ItemStack stack) {
    if (stack.getDamageValue() >= stack.getMaxDamage()) {
        player.sendSystemMessage(Component.literal("物品已损坏"));
        return true;
    }
    return false;
}

// 原始代码：
if (player.getInventory().getItem(0).getCount() > 10) { }

// 选中 "player.getInventory().getItem(0)" → Ctrl + Alt + V
// 结果：
ItemStack firstItem = player.getInventory().getItem(0);
if (firstItem.getCount() > 10) { }

for (int i = 0; i < 100; i++) {
    processItem(i);  // 在这行设置断点
}
// 右键断点 → 输入条件：i == 50
// 程序只会在 i 等于 50 时暂停

调试时的界面：
┌─────────────────────────────────────────┐
│  Variables（变量）                       │
│  ├─ this = MyClass@123                  │
│  ├─ i = 50                              │
│  └─ stack = ItemStack{item=apple}      │
├─────────────────────────────────────────┤
│  Watches（监视）                         │
│  ├─ stack.getCount() = 10               │
│  └─ player.getHealth() = 20.0           │
├─────────────────────────────────────────┤
│  Frames（调用栈）                        │
│  ├─ processItem:15                      │
│  ├─ use:42                              │
│  └─ main:8                              │
└─────────────────────────────────────────┘

// 调试暂停时，按 Alt + F8
// 输入：stack.getCount() * 2
// 查看结果：20（如果 stack.getCount() 是 10）

场景：你想找到所有使用 "DeferredRegister" 的地方
操作：Ctrl + Shift + F → 输入 "DeferredRegister" → Enter
结果：显示所有包含该文本的文件和位置

输入：Item
结果：显示所有名称包含 "Item" 的类
技巧：输入驼峰缩写 "DR" 可以找到 "DeferredRegister"

输入：build.gradle
结果：快速打开 build.gradle 文件

输入：format
结果：显示所有与格式化相关的操作

yourmod/
├── .gradle/              ← Gradle 缓存（自动生成）
├── .idea/                ← IDEA 配置（自动生成）
├── build/                ← 编译输出（自动生成）
├── gradle/               ← Gradle Wrapper
├── src/
│   ├── main/
│   │   ├── java/         ← Java 源代码
│   │   │   └── com/yourmod/
│   │   │       ├── YourMod.java
│   │   │       └── item/
│   │   │           └── ModItems.java
│   │   └── resources/    ← 资源文件
│   │       ├── META-INF/
│   │       │   └── neoforge.mods.toml
│   │       └── assets/yourmod/
│   │           ├── lang/
│   │           ├── models/
│   │           └── textures/
│   └── generated/        ← 数据生成输出
├── build.gradle          ← Gradle 构建脚本
├── gradle.properties     ← Gradle 配置
└── settings.gradle       ← Gradle 设置

// 包声明（必须是文件第一行）
package com.yourmod.item;

// 导入其他包的类
import net.minecraft.world.item.Item;
import net.neoforged.neoforge.registries.DeferredRegister;

public class ModItems {
    // 类内容
}

// 场景：批量修改变量名
int item1 = 1;
int item2 = 2;
int item3 = 3;

// 按住 Alt，点击三个 "item" → 同时编辑
// 输入 "stack" → 三个变量同时改名
int stack1 = 1;
int stack2 = 2;
int stack3 = 3;

// 场景：批量添加注释
public static final DeferredItem<Item> ITEM1 = ...;
public static final DeferredItem<Item> ITEM2 = ...;
public static final DeferredItem<Item> ITEM3 = ...;

// Alt + Shift + 拖动选择 "public" 前面的空白
// 输入 "// " → 批量添加注释

// TODO: 实现物品的特殊效果
public void specialEffect() {
    
}

// FIXME: 修复耐久度计算错误
public int getDurability() {
    return 0;
}

yourmod/
├── build.gradle          ← 主构建脚本（最重要！）
├── gradle.properties     ← 配置属性
├── settings.gradle       ← 项目设置
└── gradle/
    └── wrapper/          ← Gradle Wrapper（确保版本一致）
        ├── gradle-wrapper.jar
        └── gradle-wrapper.properties

// 应用插件
plugins {
    id 'java-library'
    id 'eclipse'
    id 'idea'
    id 'maven-publish'
    id 'net.neoforged.gradle.userdev' version '7.0.80'
}

// 项目版本和组
version = '1.0.0'
group = 'com.yourmod'

// Java 版本配置
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

// 依赖配置
dependencies {
    // NeoForge 依赖
    implementation "net.neoforged:neoforge:${neo_version}"
}

// 运行配置
runs {
    client {
        workingDirectory project.file('run')
        systemProperty 'forge.logging.console.level', 'debug'
    }
    server {
        workingDirectory project.file('run')
        systemProperty 'forge.logging.console.level', 'debug'
    }
}

# Gradle 配置
org.gradle.jvmargs=-Xmx4G
org.gradle.daemon=true
org.gradle.parallel=true

# Mod 信息
mod_id=yourmod
mod_name=Your Mod
mod_version=1.0.0
mod_group_id=com.yourmod
mod_author=YourName

# 依赖版本
minecraft_version=1.21
neo_version=21.0.167

# Windows
gradlew build

# Linux/Mac
./gradlew build

dependencies {
    // NeoForge（必需）
    implementation "net.neoforged:neoforge:${neo_version}"
    
    // 添加其他模组作为依赖（可选）
    // implementation fg.deobf("curse.maven:jei-238222:4567890")
}

git clone https://github.com/neoforged/MDK.git MyFirstMod
cd MyFirstMod

# Windows
gradlew build

# Linux/Mac
./gradlew build

BUILD SUCCESSFUL in 2m 15s

# 生成 IDEA 运行配置
gradlew ideaSyncTask

gradlew runServer

MyFirstMod/
├── .gradle/                    ← Gradle 缓存
├── .idea/                      ← IDEA 配置
├── build/                      ← 编译输出
│   └── libs/
│       └── myfirstmod-1.0.jar  ← 打包后的模组文件
├── gradle/                     ← Gradle Wrapper
├── run/                        ← 运行时目录（首次运行后生成）
│   ├── logs/                   ← 游戏日志
│   ├── saves/                  ← 存档
│   └── config/                 ← 配置文件
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/examplemod/
│   │   │       └── ExampleMod.java  ← 模组主类
│   │   └── resources/
│   │       ├── META-INF/
│   │       │   └── neoforge.mods.toml  ← 模组元数据
│   │       ├── pack.mcmeta     ← 资源包元数据
│   │       └── assets/examplemod/
│   │           └── ...         ← 资源文件
│   └── generated/              ← 数据生成输出
├── build.gradle                ← 构建脚本
├── gradle.properties           ← Gradle 配置
├── settings.gradle             ← 项目设置
└── README.md                   ← 说明文档

# 修改这些值为你的模组信息
mod_id=yourmod
mod_name=Your Mod Name
mod_version=1.0.0
mod_group_id=com.yourname.yourmod
mod_author=YourName
mod_description=A cool mod that does cool things

# src/main/resources/META-INF/neoforge.mods.toml

modLoader="javafml"
loaderVersion="[4,)"
license="MIT"

[[mods]]
modId="yourmod"
version="${file.jarVersion}"
displayName="Your Mod Name"
description='''
A cool mod that does cool things.
'''
authors="YourName"
displayURL="https://github.com/yourname/yourmod"

[[dependencies.yourmod]]
    modId="neoforge"
    type="required"
    versionRange="[21.0,)"
    ordering="NONE"
    side="BOTH"

[[dependencies.yourmod]]
    modId="minecraft"
    type="required"
    versionRange="[1.21,)"
    ordering="NONE"
    side="BOTH"

repositories {
    maven { url 'https://maven.aliyun.com/repository/public/' }
    mavenCentral()
}

# 重新生成运行配置
gradlew ideaSyncTask

org.gradle.jvmargs=-Xmx6G

// 场景：你想查看 Item 类的源码
Item myItem = new Item(new Item.Properties());
// 选中 "Item" → 按 Ctrl + B → 跳转到 Item.class

// 场景：你想知道 Item 有哪些子类
// 选中 "Item" → 按 Ctrl + H → 显示继承树

// 场景：你想知道某个方法在哪里被调用
// 选中方法名 → 按 Alt + F7 → 显示所有调用位置

/**
 * A helper class to aid in registering objects to modded and
 * {@linkplain BuiltInRegistries vanilla registries} and
 * provide deferred suppliers to access those objects.
 * 
 * <p>This class is designed to be used as a static field in your mod class.
 * ...
 */
public class DeferredRegister<T> {

// 在 DeferredRegister.java 中
public static DeferredRegister.Items createItems(String modid) {
    return new Items(modid);
}

// DeferredItem.java
protected DeferredItem(ResourceKey<Item> key) {
    super(key);
}

// DeferredRegister.java
public <I extends T> DeferredHolder<T, I> register(String name, Supplier<? extends I> sup) {
    // 实现
}

/**
 * Example usage:
 * <pre>{@code
 * private static final DeferredRegister.Items ITEMS = DeferredRegister.createItems(MODID);
 * public static final DeferredItem<Item> MY_ITEM = ITEMS.registerSimpleItem("my_item");
 * }</pre>
 */

public <I extends T> DeferredHolder<T, I> register(
    final String name, 
    final Supplier<? extends I> sup
)

// Supplier 可以用 Lambda 表达式
ITEMS.register("my_item", () -> new Item(new Item.Properties()));

// 或者方法引用
ITEMS.register("my_item", () -> new MySword(new Item.Properties()));

// 1. 你的代码
ITEMS.registerSimpleItem("my_item");

// 2. registerSimpleItem 调用 registerItem
public DeferredItem<Item> registerSimpleItem(String name) {
    return this.registerItem(name, Item::new);
}

// 3. registerItem 调用 register
public <I extends Item> DeferredItem<I> registerItem(String name, Function<Item.Properties, I> func) {
    return this.register(name, () -> func.apply(new Item.Properties()));
}

// 4. register 创建 DeferredHolder 并存储
public <I extends T> DeferredHolder<T, I> register(String name, Supplier<? extends I> sup) {
    DeferredHolder<T, I> ret = createHolder(this.registryKey, key);
    entries.putIfAbsent(ret, sup);
    return ret;
}

@Override  // 表示重写父类方法
public void use() { }

@Nullable  // 表示返回值可能为 null
public Item getItem() { }

@NotNull  // 表示参数不能为 null
public void setItem(@NotNull Item item) { }

@Deprecated  // 表示方法已过时，不推荐使用
public void oldMethod() { }

@Mod("yourmod")  // 标记模组主类
public class YourMod { }

@EventBusSubscriber  // 自动注册事件监听器
public class EventHandler { }

@OnlyIn(Dist.CLIENT)  // 仅在客户端执行
public void clientOnlyMethod() { }

注册表类型：
├── ITEM（物品）
├── BLOCK（方块）
├── ENTITY_TYPE（实体类型）
├── SOUND_EVENT（声音事件）
├── PARTICLE_TYPE（粒子类型）
└── ... 还有很多

格式：命名空间:路径
示例：minecraft:diamond
      yourmod:my_item

// 第一步：创建 DeferredRegister（模组加载时）
public static final DeferredRegister.Items ITEMS = DeferredRegister.createItems("yourmod");

// 第二步：注册对象（类加载时）
public static final DeferredItem<Item> MY_ITEM = ITEMS.registerSimpleItem("my_item");

// 第三步：将 DeferredRegister 绑定到事件总线（模组构造函数中）
public YourMod(IEventBus modEventBus) {
    ITEMS.register(modEventBus);
}

// 第四步：NeoForge 在正确的时间触发 RegisterEvent，实际创建对象

public static final DeferredItem<Item> MY_ITEM = ITEMS.registerSimpleItem("my_item");

// 在注册完成前
MY_ITEM.get();  // 可能返回 null 或抛出异常

// 在注册完成后
MY_ITEM.get();  // 返回实际的 Item 对象

// 在配方中引用物品
public void createRecipe(RecipeOutput output) {
    ShapedRecipeBuilder.shaped(RecipeCategory.TOOLS, MY_ITEM.get())
        .pattern("###")
        .pattern(" | ")
        .pattern(" | ")
        .define('#', Items.DIAMOND)
        .define('|', Items.STICK)
        .save(output);
}

@Mod("yourmod")
public class YourMod {
    public YourMod(IEventBus modEventBus) {
        // 监听注册事件
        modEventBus.addListener(this::onRegister);
        
        // 监听客户端设置事件
        modEventBus.addListener(this::onClientSetup);
    }
    
    private void onRegister(RegisterEvent event) {
        // 注册对象
    }
    
    private void onClientSetup(FMLClientSetupEvent event) {
        // 客户端初始化
    }
}

@EventBusSubscriber(modid = "yourmod")
public class EventHandler {
    
    @SubscribeEvent
    public static void onPlayerInteract(PlayerInteractEvent.RightClickItem event) {
        // 玩家右键物品时触发
        Player player = event.getEntity();
        ItemStack stack = event.getItemStack();
        
        if (stack.is(ModItems.MY_ITEM.get())) {
            player.sendSystemMessage(Component.literal("你使用了我的物品！"));
        }
    }
    
    @SubscribeEvent
    public static void onLivingHurt(LivingHurtEvent event) {
        // 实体受伤时触发
        if (event.getEntity() instanceof Player player) {
            // 玩家受伤时的逻辑
        }
    }
}

@SubscribeEvent(priority = EventPriority.HIGH)
public static void onPlayerInteract(PlayerInteractEvent event) {
    // 高优先级，会比其他监听器先执行
}