Java 表达式的类型必须是数组类型，但已解析为双精度

当我使用此代码时：

    switch (1.$SwitchMap$org$bukkit$Material[block.getType().ordinal()])

我得到一个错误：

表达式的类型必须是数组类型，但已解析为double

我正在编写一个Minecraft Bukkit插件

这是我的全部代码：

package me.TheTrain2000.Smelter;

import java.util.Iterator;
import java.util.List;
import org.bukkit.Material;
import org.bukkit.Server;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockPhysicsEvent;
import org.bukkit.event.entity.EntityExplodeEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.plugin.PluginManager;
import org.bukkit.plugin.java.JavaPlugin;

public class Main
  extends JavaPlugin
  implements Listener
{
  private static byte MAGIC_BYTE = 15;

  public void onEnable()
  {
    getServer().getPluginManager().registerEvents(this, this);
  }

  @EventHandler(priority=EventPriority.LOW, ignoreCancelled=true)
  public void onEntityExplode(EntityExplodeEvent event)
  {
    if (event.blockList().isEmpty()) {
      return;
    }
    for (Iterator<Block> i = event.blockList().iterator(); i.hasNext();)
    {
      Block block = (Block)i.next();
      if ((block.getData() == MAGIC_BYTE) && (shouldBreak(block)))
      {
        simulateBreak(block);
        i.remove();
      }
    }
  }

  @EventHandler(priority=EventPriority.LOWEST, ignoreCancelled=true)
  public void onBlockBreak(BlockBreakEvent event)
  {
    Block block = event.getBlock();
    if ((block.getData() == MAGIC_BYTE) && (shouldBreak(block)))
    {
      simulateBreak(block);
      event.setCancelled(true);
    }
  }

  @EventHandler(ignoreCancelled=true)
  public void onBlockPhysics(BlockPhysicsEvent event)
  {
    Block block = event.getBlock();
    Block block1 = block.getRelative(BlockFace.DOWN);
    Block block2 = block1.getRelative(BlockFace.DOWN);

    boolean aboveLava = (block1.getType() == Material.LAVA) || (block1.getType() == Material.STATIONARY_LAVA);
    boolean aboveCoveredLava = (block1.getType() == Material.GLASS) && ((block2.getType() == Material.LAVA) || (block2.getType() == Material.STATIONARY_LAVA));
    if (((aboveLava) || (aboveCoveredLava)) && (nextToPiston(block))) {
      smeltBlock(block);
    }
    if ((block.getData() == MAGIC_BYTE) && (block1.getType() == Material.WATER)) {
      simulateBreak(block);
    }
  }

  private void smeltBlock(Block block)
  {
    int newType = getNewType(block).getId();
    if (newType != 0) {
      block.setTypeIdAndData(newType, MAGIC_BYTE, true);
    }
  }

  private boolean shouldBreak(Block block)
  {
    switch (1.$SwitchMap$org$bukkit$Material[block.getType().ordinal()])
    {
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    }
    return false;
  }

  private Material getNewType(Block block)
  {
    switch (1.$SwitchMap$org$bukkit$Material[block.getType().ordinal()])
    {
    case 5:
      return Material.STONE;
    case 6:
      return Material.IRON_BLOCK;
    case 7:
      return Material.GOLD_BLOCK;
    case 8:
      return Material.GLASS;
    case 9:
      return Material.BRICK;
    }
    return Material.AIR;
  }

  private void simulateBreak(Block block)
  {
    Material dropItem = getDrop(block);
    if (dropItem == null) {
      return;
    }
    block.getWorld().dropItemNaturally(block.getLocation(), new ItemStack(dropItem, 1));
    block.setType(Material.AIR);
  }

  private boolean nextToPiston(Block block)
  {
    return (block.getRelative(BlockFace.EAST).getType() == Material.PISTON_EXTENSION) || (block.getRelative(BlockFace.WEST).getType() == Material.PISTON_EXTENSION) || (block.getRelative(BlockFace.NORTH).getType() == Material.PISTON_EXTENSION) || (block.getRelative(BlockFace.SOUTH).getType() == Material.PISTON_EXTENSION) || (block.getRelative(BlockFace.UP).getType() == Material.PISTON_EXTENSION);
  }

  private Material getDrop(Block block)
  {
    switch (1.$SwitchMap$org$bukkit$Material[block.getType().ordinal()])
    {
    case 2:
      return Material.STONE;
    case 3:
      return Material.IRON_INGOT;
    case 4:
      return Material.GOLD_INGOT;
    case 1:
      return Material.GLASS;
    case 10:
      return Material.BRICK;
    }
    return null;
  }
}

包me.TheTrain2000.melter；
导入java.util.Iterator；
导入java.util.List；
导入org.bukkit.Material；
导入org.bukkit.Server；
导入org.bukkit.World；
导入org.bukkit.block.block；
导入org.bukkit.block.BlockFace；
导入org.bukkit.event.EventHandler；
导入org.bukkit.event.EventPriority；
导入org.bukkit.event.Listener；
导入org.bukkit.event.block.BlockBreakEvent；
导入org.bukkit.event.block.BlockPhysicsEvent；
导入org.bukkit.event.entity.EntityExplodeEvent；
导入org.bukkit.inventory.ItemStack；
导入org.bukkit.plugin.PluginManager；
导入org.bukkit.plugin.java.JavaPlugin；
公共班机
扩展JavaPlugin
实现侦听器
{
专用静态字节MAGIC_byte=15；
public void onEnable（）
{
getServer（）.getPluginManager（）.registerEvents（这个，这个）；
}
@EventHandler（priority=EventPriority.LOW，ignoreCancelled=true）
公共void onEntityExplode（实体爆炸事件）
{
if（event.blockList（）.isEmpty（））{
返回；
}
for（迭代器i=event.blockList（）.Iterator（）；i.hasNext（）；）
{
Block=（Block）i.next（）；
if（（block.getData（）==MAGIC_BYTE）&&（shouldBreak（block）））
{
模拟破裂（块）；
i、 删除（）；
}
}
}
@EventHandler（priority=EventPriority.lower，ignoreCancelled=true）
BlockBreak上的公共无效（BlockBreakEvent事件）
{
Block=event.getBlock（）；
if（（block.getData（）==MAGIC_BYTE）&&（shouldBreak（block）））
{
模拟破裂（块）；
event.setCancelled（true）；
}
}
@EventHandler（ignoreCancelled=true）
BlockPhysics上的公共无效（BlockPhysicsEvent事件）
{
Block=event.getBlock（）；
Block block1=Block.getRelative（BlockFace.DOWN）；
Block block2=block1.getRelative（BlockFace.DOWN）；
布尔值高于熔岩=（block1.getType（）==Material.LAVA）| |（block1.getType（）==Material.stational|LAVA）；
布尔值UpperCoveredLava=（block1.getType（）==Material.GLASS）和（（block2.getType（）==Material.LAVA）| |（block2.getType（）==Material.stational|LAVA））；
如果（（熔岩上方）| |（熔岩上方））&&（下一个活塞（块）））{
块（块）；
}
if（（block.getData（）=MAGIC_BYTE）&&（block1.getType（）=Material.WATER））{
模拟破裂（块）；
}
}
私人大厦（大厦）
{
int newType=getNewType（block.getId（）；
如果（newType！=0）{
setTypeIdAndData（newType，MAGIC_字节，true）；
}
}
专用布尔值shouldBreak（块）
{
开关（1.$SwitchMap$org$bukkit$Material[block.getType（）.ordinal（）]））
{
案例1：
案例2：
案例3：
案例4：
返回true；
}
返回false；
}
私有材料getNewType（块）
{
开关（1.$SwitchMap$org$bukkit$Material[block.getType（）.ordinal（）]））
{
案例5：
返回材料。石头；
案例6：
返回材料。铁块；
案例7：
返回材料。黄金块；
案例8：
返回材料。玻璃；
案例9：
返回材料。砖；
}
返回物料。空气；
}
专用void模拟器破裂（块）
{
物料投放项目=获取投放（块）；
if（dropItem==null）{
返回；
}
block.getWorld（）.dropItemNaturally（block.getLocation（），newItemStack（dropItem，1））；
块。设置类型（材料。空气）；
}
专用布尔型活塞（块）
{
return（block.getRelative（BlockFace.EAST）.getType（）==材料.活塞扩展名）| |（block.getRelative（BlockFace.WEST）.getType（）==材料.活塞扩展名）| |（block.getRelative（BlockFace.SOUTH）.getType（）==材料.活塞扩展名）| |（block.getRelative（BlockFace.UP）.getType（）=材料.活塞\u扩展）；
}
私人材料getDrop（块）
{
开关（1.$SwitchMap$org$bukkit$Material[block.getType（）.ordinal（）]））
{
案例2：
返回材料。石头；
案例3：
返回材料。铁锭；
案例4：
返回材料。金锭；
案例1：
返回材料。玻璃；
案例10：
返回材料。砖；
}
返回null；
}
}

这是：

switch (1.$SwitchMap$org$bukkit$Material[block.getType().ordinal()])

显然是反编译代码，不是有效的Java源代码。您需要将其替换为原始调用，可能是：

switch(block.getType())

---

然后，您需要将所有case语句从它们的序数值转换为它们表示的枚举。

您的整个代码是什么？您打算如何处理该switch语句？