处理“java / awt / font / NumericShaper.class”时遇到问题

Question

我最近开始使用Android Studio IDE使用使用Gradle的LibGDX框架开发项目。 一切都运行得很好，直到我将一段代码分成一个新类。 自从我这样做以来，我一直收到以下错误：

处理“java / awt / font / NumericShaper.class”时遇到问题：在不构建核心库时，错误地使用或错误地使用了核心类（java。*或javax。*）。 这通常是由于在使用IDE（例如Eclipse）时无意中在应用程序的项目中包含了核心库文件。 如果你确定你不是故意定义一个核心类，那么这就是最可能的解释。 但是，您实际上可能正在尝试在核心命名空间中定义一个类，例如，您可能已从非Android虚拟机项目中获取该类。 这肯定是行不通的。 它至少会危害您的应用与该平台的未来版本的兼容性。 它的合法性通常也是有问题的。 如果您真的打算构建一个核心库 - 它只适合作为创建完整虚拟机分发的一部分，而不是编译应用程序 - 那么使用“--core-library”选项来抑制此错误消息。 如果你继续使用“--core-library”但实际上正在构建一个应用程序，那么预先警告你的应用程序仍然无法构建或运行，在某些时候。 请为愤怒的客户做好准备，例如，一旦升级操作系统，您的应用程序就会停止运行。 你应该为这个问题负责。 如果您合法地使用恰好位于核心软件包中的某些代码，那么最简单的安全替代方法是重新打包该代码。 也就是说，将有问题的类移动到您自己的包命名空间中。 这意味着它们永远不会与核心系统类冲突。 JarJar是一个可以帮助您完成这项工作的工具。 如果你发现自己无法做到这一点，那就表明你所走的道路最终将导致痛苦，痛苦，悲伤和悲伤。

我尝试在这里搜索，但所有可能的解决方案要么对我不起作用，要么使用Eclipse IDE。 我现在卡住了几个小时，无法理解为什么我的代码无法编译。 我没有添加任何可能导致此错误的额外导入。 这是我参与的最后一堂课：

package com.infiniterain.infinitecrawler.states.floor;

import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.TextureRegion;
import com.infiniterain.infinitecrawler.DisposablesHandler;
import com.infiniterain.infinitecrawler.states.Floor;

/*
Handles updating and rendering of the floor map.
*/

public class TileMap {
    // Floor fields
    private DisposablesHandler disposablesHandler;
    private Floor floor;

    // Textures
    private Texture tilesetTexture;
    private TextureRegion[] tileTexture;

    // Map properties
    private int[] floorSize;
    private int[] mapSize;

    // Tile properties
    private int[][] tileID;
    private int[][] tileRotation;

    // Constructor
    public TileMap(Floor floor) {
        // Floor fields
        this.floor = floor;
        disposablesHandler = floor.getDisposablesHandler();

        // Textures
        disposablesHandler.getTextures().put(
                "tilesetTexture",
                new Texture(floor.getFloorConfig().get("tilesetPath").asString()));
        tilesetTexture = (Texture) disposablesHandler.getTextures().get("tilesetTexture");
        tileTexture = new TextureRegion[tilesetTexture.getWidth() / 32 * tilesetTexture.getHeight() / 32];

        // Map properties
        floorSize = new int[]{
                floor.getFloorConfig().get("size").asIntArray()[0],
                floor.getFloorConfig().get("size").asIntArray()[1]};
        mapSize = new int[]{
                floorSize[0] * 10 + floorSize[0] - 1,
                floorSize[1] * 10 + floorSize[1] - 1};

        // Tile properties
        tileID = new int[mapSize[0]][mapSize[1]];
        tileRotation = new int[mapSize[0]][mapSize[1]];

        // Generating tile textures
        for (int x = 0, y = 0, count = 0; y < tilesetTexture.getHeight() / 32; y++, count++)
            for (x = 0; x < tilesetTexture.getWidth() / 32; x++, count++) {
                tileTexture[count] = new TextureRegion(tilesetTexture, x * 32, y * 32, 32, 32);
            }

        // Generating tilemap
        generateTilemap();
    }

    // Generates tilemap
    public void generateTilemap() {
        for (int x = 0; x < floorSize[0]; x++)
            for (int y = 0; y < floorSize[1]; y++) {
                tileID[x][y] = 0;
            }
        for (int dx = 0; dx < floorSize[0]; dx++)
            for (int dy = 0; dy < floorSize[1]; dy++) {
                // Building room
                for (int x = 0; x < 10; x++)
                    for (int y = 0; y < 10; y++) {
                        int cx = x + (dx * 10);
                        int cy = y + (dy * 10);
                        if (x == 0 && y == 0) {
                            tileID[cx][cy] = 0;
                            tileRotation[cx][cy] = 180;
                        } else if (x == 0 && y == 9) {
                            tileID[cx][cy] = 0;
                            tileRotation[cx][cy] = 90;
                        } else if (x == 9 && y == 0) {
                            tileID[cx][cy] = 0;
                            tileRotation[cx][cy] = 270;
                        } else if (x == 9 && y == 9) {
                            tileID[cx][cy] = 0;
                            tileRotation[cx][cy] = 0;
                        } else if ((y == 9) && (x != 0 && x != 9)) {
                            tileID[cx][cy] = 1;
                            tileRotation[cx][cy] = 0;
                        } else if ((x == 0) && (y != 0 && y != 9)) {
                            tileID[cx][cy] = 1;
                            tileRotation[cx][cy] = 90;
                        } else if ((x == 9) && (y != 0 && y != 9)) {
                            tileID[cx][cy] = 1;
                            tileRotation[cx][cy] = 270;
                        } else if ((y == 0) && (x != 0 && x != 9)) {
                            tileID[cx][cy] = 1;
                            tileRotation[cx][cy] = 180;
                        } else {
                            tileID[cx][cy] = 3;
                            tileRotation[cx][cy] = 0;
                        }
                    }
            }
    }

    // Renders the map
    public void render() {
        disposablesHandler.getSpriteBatch().begin();
        disposablesHandler.getSpriteBatch().setColor(1, 1, 1, 1);
        for (int x = 0; x < mapSize[0]; x++)
            for (int y = 0; y < mapSize[1]; y++) {
                disposablesHandler.getSpriteBatch().draw(tileTexture[tileID[x][y]], x * 32, y * 32);
            }
        disposablesHandler.getSpriteBatch().end();
    }
}

以及使用上述类的代码：

package com.infiniterain.infinitecrawler.states;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.utils.JsonReader;
import com.badlogic.gdx.utils.JsonValue;
import com.infiniterain.infinitecrawler.DisposablesHandler;
import com.infiniterain.infinitecrawler.states.floor.Room;
import com.infiniterain.infinitecrawler.states.floor.TileMap;

import java.util.ArrayList;
import java.util.Random;

public class Floor extends State {
    // Floor properties
    private JsonValue floorConfig;
    private int floorID;
    private int[] floorSize;

    // Necessary objects
    private TileMap tileMap;
    private Room room[][];
    private DisposablesHandler disposablesHandler;
    private Random random;

    public Floor(GameStateManager gameStateManager, int floorID) {
        // Loading floors.json config
        floorConfig = new JsonReader().parse(
                Gdx.files.internal("configs/floors.json")).get(String.valueOf(floorID));

        // Setting floor properties
        this.floorID = floorID;
        floorSize = new int[]{
                floorConfig.get("size").asIntArray()[0],
                floorConfig.get("size").asIntArray()[1]};

        // Instantiating necessary objects
        disposablesHandler = new DisposablesHandler(true, false, false, true);
        random = new Random();

        // Generating the floor
        generateFloor(floorID);
        tileMap = new TileMap(this);
    }

    public void generateFloor(int floor) {
        int[] startingPoint = new int[]{
                random.nextInt(floorSize[0]),
                random.nextInt(floorSize[1])
        };

        room = new Room[floorSize[0]][floorSize[1]];
        for (int x = 0; x < floorSize[0]; x++)
        for (int y = 0; y < floorSize[1]; y++) {
            room[x][y] = new Room(new int[]{x, y});
        }

        room[startingPoint[0]][startingPoint[1]].setAccessible(true);
        room[startingPoint[0]][startingPoint[1]].setActivated(true);

        for (int x = -1; x < 2; x++)
        for (int y = -1; y < 2; y++) {
            if (x == 0 || y == 0)
            if (startingPoint[0] + x < floorSize[0] && startingPoint[1] + y < floorSize[2]
                    && startingPoint[0] + x >= 0 && startingPoint[1] + y >= 0) {
                room[startingPoint[0]][startingPoint[1]].setActivated(true);
                room[startingPoint[0] + x][startingPoint[1] + y].setParentPosition(new int[]{startingPoint[0], startingPoint[1]});
            }
        }


        while (true) {
            ArrayList<Room> activatedRooms = new ArrayList<Room>();
            for (int x = 0; x < floorSize[0]; x++)
            for (int y = 0; y < floorSize[1]; y++) {
                if (room[x][y].isActivated() && !room[x][y].isAccessible()) {
                    activatedRooms.add(room[x][y]);
                }
            }

            if (!activatedRooms.isEmpty()) {
                Room randomRoom = activatedRooms.get(random.nextInt(activatedRooms.size()));
                Room parentRoom = room[randomRoom.getParentPosition()[0]][randomRoom.getParentPosition()[1]];
                if (parentRoom.getPosition()[0] < randomRoom.getPosition()[0]) {
                    randomRoom.getDoor().remove("left");
                    randomRoom.getDoor().put("left", true);
                    parentRoom.getDoor().remove("right");
                    parentRoom.getDoor().put("right", true);
                } else if (parentRoom.getPosition()[0] > randomRoom.getPosition()[0]) {
                    randomRoom.getDoor().remove("right");
                    randomRoom.getDoor().put("right", true);
                    parentRoom.getDoor().remove("left");
                    parentRoom.getDoor().put("left", true);
                } else if (parentRoom.getPosition()[1] < randomRoom.getPosition()[1]) {
                    randomRoom.getDoor().remove("down");
                    randomRoom.getDoor().put("down", true);
                    parentRoom.getDoor().remove("up");
                    parentRoom.getDoor().put("up", true);
                } else if (parentRoom.getPosition()[1] > randomRoom.getPosition()[1]) {
                    randomRoom.getDoor().remove("up");
                    randomRoom.getDoor().put("up", true);
                    parentRoom.getDoor().remove("down");
                    parentRoom.getDoor().put("down", true);
                }
                randomRoom.setAccessible(true);

                int roomX = randomRoom.getPosition()[0];
                int roomY = randomRoom.getPosition()[1];
                for (int x = -1; x < 2; x++) {
                    for (int y = -1; y < 2; y++) {
                        if (x == 0 || y == 0)
                        if (roomX + x < floorSize[0] && roomY + y < floorSize[1]
                                && roomX + x >= 0 && roomY + y >= 0) {
                            room[roomX + x][roomY + y].setActivated(true);
                            room[roomX + x][roomY + y].setParentPosition(new int[]{roomX, roomY});
                        }
                    }
                }
            } else {
                break;
            }
        }
    }

    @Override
    public void handleInput() {
        if (Gdx.input.justTouched()) {
            //generateFloor(1);
           // System.out.println("touched");
        }
    }

    @Override
    public void update(float deltaTime) {

    }

    @Override
    public void render(DisposablesHandler disposables) {
        tileMap.render();
    }

    @Override
    public void dispose() {
        disposablesHandler.dispose();
    }

    // Getters
    public DisposablesHandler getDisposablesHandler() {
        return disposablesHandler;
    }

    public JsonValue getFloorConfig() {
        return floorConfig;
    }

    public int getFloor() {
        return floorID;
    }

    public int[] getFloorSize() {
        return floorSize;
    }
}

我已经研究了我能做的一切，但我仍然无法弄清楚问题是什么，你们中的任何人都会很友好并帮助我解决这个小问题吗？