然后用java在不使用模板情况下实现通用数据的储存

您好，我可以回答这个问题。在 Java 中，可以使用 Object 类型来实现通用数据的存储。由于 Object 类是所有类的父类，因此可以将任何类型的数据存储在 Object 类型的变量中。例如，可以使用 Object[] 数组来存储不同类型的数据。当需要使用存储的数据时，可以使用强制类型转换将 Object 类型转换为实际类型。

相关问题

用java写二分搜索树实现Insert()，visit(),search()方法 实现通用，不能使用模板实现 ，实现处理异常使用嵌套类优化， 实现通用数据的储存

好的，我可以回答这个问题。对于二分搜索树的Insert()方法，我们可以先判断根节点是否为空，如果为空，则直接将新节点作为根节点。如果不为空，则比较新节点和当前节点的大小关系，如果小于当前节点，则递归调用Insert()方法，将新节点插入当前节点的左子树中，否则递归调用Insert()方法，将新节点插入当前节点的右子树中。

对于Visit()方法，我们可以采用中序遍历的方式，先访问左子树，再访问当前节点，最后访问右子树。

对于Search()方法，我们可以先判断当前节点是否为空，如果为空，则返回null。如果不为空，则比较当前节点和目标节点的大小关系，如果相等，则返回当前节点。如果小于当前节点，则递归调用Search()方法，在当前节点的左子树中查找目标节点。如果大于当前节点，则递归调用Search()方法，在当前节点的右子树中查找目标节点。

至于通用数据的储存，我们可以使用泛型来实现。具体实现可以参考以下代码：

public class BinarySearchTree<T extends Comparable<T>> {
    private Node root;

    private class Node {
        T data;
        Node left;
        Node right;

        public Node(T data) {
            this.data = data;
        }
    }

    public void insert(T data) {
        if (root == null) {
            root = new Node(data);
        } else {
            insert(root, data);
        }
    }

    private void insert(Node node, T data) {
        if (data.compareTo(node.data) < ) {
            if (node.left == null) {
                node.left = new Node(data);
            } else {
                insert(node.left, data);
            }
        } else {
            if (node.right == null) {
                node.right = new Node(data);
            } else {
                insert(node.right, data);
            }
        }
    }

    public void visit() {
        visit(root);
    }

    private void visit(Node node) {
        if (node != null) {
            visit(node.left);
            System.out.print(node.data + " ");
            visit(node.right);
        }
    }

    public Node search(T data) {
        return search(root, data);
    }

    private Node search(Node node, T data) {
        if (node == null) {
            return null;
        } else if (data.compareTo(node.data) == ) {
            return node;
        } else if (data.compareTo(node.data) < ) {
            return search(node.left, data);
        } else {
            return search(node.right, data);
        }
    }
}

至于异常处理，我们可以使用try-catch语句来捕获异常。具体实现可以参考以下代码：

public class BinarySearchTree<T extends Comparable<T>> {
    ...

    public void insert(T data) {
        try {
            if (root == null) {
                root = new Node(data);
            } else {
                insert(root, data);
            }
        } catch (Exception e) {
            System.out.println("Insert failed: " + e.getMessage());
        }
    }

    private void insert(Node node, T data) throws Exception {
        if (data == null) {
            throw new Exception("Data cannot be null");
        }
        if (data.compareTo(node.data) < ) {
            if (node.left == null) {
                node.left = new Node(data);
            } else {
                insert(node.left, data);
            }
        } else {
            if (node.right == null) {
                node.right = new Node(data);
            } else {
                insert(node.right, data);
            }
        }
    }

    public void visit() {
        try {
            visit(root);
        } catch (Exception e) {
            System.out.println("Visit failed: " + e.getMessage());
        }
    }

    private void visit(Node node) throws Exception {
        if (node != null) {
            visit(node.left);
            System.out.print(node.data + " ");
            visit(node.right);
        }
    }

    public Node search(T data) {
        try {
            return search(root, data);
        } catch (Exception e) {
            System.out.println("Search failed: " + e.getMessage());
            return null;
        }
    }

    private Node search(Node node, T data) throws Exception {
        if (data == null) {
            throw new Exception("Data cannot be null");
        }
        if (node == null) {
            return null;
        } else if (data.compareTo(node.data) == ) {
            return node;
        } else if (data.compareTo(node.data) < ) {
            return search(node.left, data);
        } else {
            return search(node.right, data);
        }
    }
}

用java写二分搜索树实现Insert()，visit(),search()方法 实现通用，不能使用模板实现如boolean insert(comparable obj); ，实现处理异常使用嵌套类优化， 实现通用数据的储存，不能采用链表，树等已有库

好的，我可以回答这个问题。对于二分搜索树的实现，我们可以先定义一个节点类，包含节点的值、左右子节点等信息。然后再定义一个二分搜索树类，包含根节点、插入节点、遍历节点、查找节点等方法。

具体实现时，我们可以使用递归的方式实现插入、遍历和查找节点的方法。对于异常处理，我们可以使用嵌套类来实现，将异常类嵌套在二分搜索树类中，方便处理异常情况。

至于通用数据的储存，我们可以使用数组来实现，将节点的值存储在数组中，通过数组下标来访问节点。这样既可以实现通用数据的储存，又可以避免使用链表、树等已有库。

当然，这只是一个简单的实现方式，具体实现还需要根据具体需求进行调整和优化。