针对有若干重要场所的某一区域设计一个交通指南系统，指导前来咨询者以最低的票价（或者最少的时间）从区域中的某一个场所到达另一个场所，用一个带权有向图表示某一个区域的公交线路，这个区域的重要场所至少有10个，若有人咨询，只需提供起始点和目的地，咨询结果是一条公交线路，提供重要区域的信息查询功能，包括场所名称、经过的公交线路等信息。 要求使用图相关Java知识实现。

这是一个典型的图论问题，我们可以使用Java中的图相关类来实现。首先，我们需要定义一个类来表示图中的节点，节点应该至少包含自身的名称和相邻节点的列表。代码如下：

public class Node {
    private String name;
    private List<Node> neighbors;

    public Node(String name) {
        this.name = name;
        this.neighbors = new ArrayList<>();
    }

    public String getName() {
        return name;
    }

    public List<Node> getNeighbors() {
        return neighbors;
    }

    public void addNeighbor(Node neighbor) {
        neighbors.add(neighbor);
    }
}

接下来，我们需要定义一个类来表示整个图，该类应该具有添加节点和边的方法，以及查找从一个节点到另一个节点的最短路径的方法。代码如下：

public class Graph {
    private Map<String, Node> nodes;

    public Graph() {
        this.nodes = new HashMap<>();
    }

    public void addNode(String name) {
        nodes.put(name, new Node(name));
    }

    public void addEdge(String from, String to) {
        Node fromNode = nodes.get(from);
        Node toNode = nodes.get(to);
        fromNode.addNeighbor(toNode);
    }

    public List<Node> shortestPath(String startName, String endName) {
        Node startNode = nodes.get(startName);
        Node endNode = nodes.get(endName);

        Map<Node, Node> previousNodes = new HashMap<>();
        Map<Node, Integer> distances = new HashMap<>();
        PriorityQueue<Node> queue = new PriorityQueue<>(Comparator.comparingInt(distances::get));
        Set<Node> visited = new HashSet<>();

        distances.put(startNode, 0);
        queue.offer(startNode);

        while (!queue.isEmpty()) {
            Node current = queue.poll();

            if (visited.contains(current)) {
                continue;
            }

            visited.add(current);

            if (current == endNode) {
                break;
            }

            for (Node neighbor : current.getNeighbors()) {
                int distance = distances.get(current) + 1;
                if (!distances.containsKey(neighbor) || distance < distances.get(neighbor)) {
                    distances.put(neighbor, distance);
                    previousNodes.put(neighbor, current);
                    queue.offer(neighbor);
                }
            }
        }

        if (!previousNodes.containsKey(endNode)) {
            return null;
        }

        List<Node> path = new ArrayList<>();
        Node current = endNode;
        while (current != startNode) {
            path.add(current);
            current = previousNodes.get(current);
        }
        path.add(startNode);
        Collections.reverse(path);

        return path;
    }
}

在这个类中，我们使用了Dijkstra算法来查找最短路径。在Dijkstra算法中，我们需要维护一个距离Map，表示从起点到该节点的距离，以及一个前缀节点Map，用于记录每个节点的前一个节点。我们还需要使用一个优先队列，按照距离从小到大排序，以便我们能够快速找到距离最小的节点。最后，我们使用前缀节点Map来构建最短路径。

现在我们可以使用这个图类来解决我们的问题。我们可以在程序中创建一个Graph对象，并使用addNode和addEdge方法添加节点和边。然后，我们可以使用shortestPath方法来查找从起点到终点的最短路径。以下是一个示例程序：

public class Main {
    public static void main(String[] args) {
        Graph graph = new Graph();

        // 添加节点
        graph.addNode("A");
        graph.addNode("B");
        graph.addNode("C");
        graph.addNode("D");
        graph.addNode("E");
        graph.addNode("F");

        // 添加边
        graph.addEdge("A", "B");
        graph.addEdge("A", "C");
        graph.addEdge("B", "D");
        graph.addEdge("C", "D");
        graph.addEdge("C", "E");
        graph.addEdge("D", "F");
        graph.addEdge("E", "F");

        // 查找最短路径
        List<Node> path = graph.shortestPath("A", "F");

        // 输出路径
        if (path == null) {
            System.out.println("No path found");
        } else {
            System.out.print("Path: ");
            for (Node node : path) {
                System.out.print(node.getName() + " ");
            }
            System.out.println();
        }
    }
}

在这个示例程序中，我们创建了一个包含6个节点和7条边的图，并查找从节点A到节点F的最短路径。输出结果应该为“Path: A B D F”。