JTree 在构造函数中动态构建

Question

我正在尝试在构造函数中动态创建一个 JTree，但遇到问题的方法与将 Vector 传递到 JTree 时的行为方式相同。 当其中一个根节点为空时，之前显示为文件夹的叶节点显示为叶（复选框），当我在这两个实例之间切换时：

    tree = new LabelCheckBoxTree(rootVector);     

和

    tree = new LabelCheckBoxTree();

关于可能导致这种情况的任何想法？ 这是代码：

复选框节点树示例：

import java.awt.BorderLayout;
import java.util.Vector;

import javax.swing.JFrame;
import javax.swing.JScrollPane;

public class CheckBoxNodeTreeSample 
{

    private CheckBoxTree tree;

    public static void main(String... s)
    {
        new CheckBoxNodeTreeSample();
    }

    public CheckBoxNodeTreeSample() 
    {
        JFrame frame = new JFrame("CheckBox Tree");
    
        Vector rootVector = new NamedVector("Root", 
            new Object[]
            {
                new NamedVector("Book 1", 
                    new CheckBoxNode[] {
                        new CheckBoxNode("Chapter 1", false),
                        new CheckBoxNode("Chapter 2", false),
                        new CheckBoxNode("Chapter 3", false),
                }),

                new NamedVector("Book 3", 
                new CheckBoxNode[] { }),
                    
                new NamedVector("Book 3", 
                    new CheckBoxNode[] {
                        new CheckBoxNode("Chapter 1", false),
                        new CheckBoxNode("Chapter 2", false),
                        new CheckBoxNode("Chapter 3", false),
                    new CheckBoxNode("Chapter 4", false),
                }),
            }
        );
    
        //tree = new LabelCheckBoxTree(rootVector);     
        tree = new LabelCheckBoxTree();

        JScrollPane scrollPane = new JScrollPane(tree);
        frame.getContentPane().add(scrollPane, BorderLayout.CENTER);
        frame.setSize(360, 300);
        frame.setVisible(true);
    }
}

复选框树：

import java.awt.Color;
import java.awt.Component;
import java.awt.Font;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.MouseEvent;
import java.awt.font.TextAttribute;
import java.util.Collections;
import java.util.EventObject;
import java.util.Vector;

import javax.swing.AbstractCellEditor;
import javax.swing.JCheckBox;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTree;
import javax.swing.UIManager;
import javax.swing.border.EmptyBorder;
import javax.swing.event.ChangeEvent;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.TreeCellEditor;
import javax.swing.tree.TreeCellRenderer;
import javax.swing.tree.TreePath;

public class CheckBoxTree extends JTree
{
    public CheckBoxTree()
    { 
    super();

        CheckBoxNodeRenderer renderer = new CheckBoxNodeRenderer();
        setCellRenderer(renderer);
        setCellEditor(new CheckBoxNodeEditor());
        setEditable(true);
    }

    public CheckBoxTree(Vector rootVector)
    {       
    super(rootVector);      

        CheckBoxNodeRenderer renderer = new CheckBoxNodeRenderer();
        setCellRenderer(renderer);
        setCellEditor(new CheckBoxNodeEditor());
        setEditable(true);
    }   
}

class CheckBoxPanel extends JPanel
{
    public JCheckBox checkBox;
    public JLabel label;

    public CheckBoxPanel() 
    { 
        super();

        checkBox = new JCheckBox();
        label = new JLabel();

        checkBox.setBorder(new EmptyBorder(0, 0, 0, 0));

        add(checkBox);
        add(label);
    }
}

class CheckBoxNodeRenderer implements TreeCellRenderer 
{
    private CheckBoxPanel leafRenderer = new CheckBoxPanel();

    private DefaultTreeCellRenderer nonLeafRenderer = new DefaultTreeCellRenderer();

    Color selectionBorderColor, selectionForeground, selectionBackground,
    textForeground, textBackground;

    protected CheckBoxPanel getLeafRenderer() {
        return leafRenderer;
    }

    public CheckBoxNodeRenderer() {
        Font fontValue;
        fontValue = UIManager.getFont("Tree.font");
        if (fontValue != null)
        {
            leafRenderer.checkBox.setFont(fontValue);
            leafRenderer.label.setFont(fontValue);

            //set the nonLeaf text to bold
            nonLeafRenderer.setFont(fontValue.deriveFont(Collections.singletonMap(TextAttribute.WEIGHT, TextAttribute.WEIGHT_BOLD)));
        }


        Boolean booleanValue = (Boolean) UIManager.get("Tree.drawsFocusBorderAroundIcon");
        leafRenderer.checkBox.setFocusPainted((booleanValue != null) && (booleanValue.booleanValue()));

        selectionBorderColor = UIManager.getColor("Tree.selectionBorderColor");
        selectionForeground = UIManager.getColor("Tree.selectionForeground");
        selectionBackground = UIManager.getColor("Tree.selectionBackground");
        textForeground = UIManager.getColor("Tree.textForeground");
        textBackground = UIManager.getColor("Tree.textBackground");
    }

    public Component getTreeCellRendererComponent(JTree tree, Object value,
            boolean selected, boolean expanded, boolean leaf, int row,
            boolean hasFocus) 
    {

        Component returnValue;
        if (leaf) 
        {

            String stringValue = tree.convertValueToText(value, selected,
                    expanded, leaf, row, false);

            leafRenderer.checkBox.setSelected(false);
            leafRenderer.label.setText(stringValue);

            leafRenderer.setEnabled(tree.isEnabled());

            if (selected) {
                leafRenderer.setForeground(selectionForeground);
                leafRenderer.setBackground(selectionBackground);
            } else {
                leafRenderer.setForeground(textForeground);
                leafRenderer.setBackground(textBackground);
            }

            if ((value != null) && (value instanceof DefaultMutableTreeNode)) {
                Object userObject = ((DefaultMutableTreeNode) value)
                        .getUserObject();
                if (userObject instanceof CheckBoxNode) {
                    CheckBoxNode node = (CheckBoxNode) userObject;                                        
                    leafRenderer.checkBox.setSelected(node.isSelected());
                    leafRenderer.label.setText(node.getText());
                }
            }
            returnValue = leafRenderer;
        } 
        else 
        {
            returnValue = nonLeafRenderer.getTreeCellRendererComponent(tree, value, selected, expanded, leaf, row, hasFocus);
        }
        return returnValue;
    }
}

class CheckBoxNodeEditor extends AbstractCellEditor implements TreeCellEditor {

    CheckBoxNodeRenderer renderer = new CheckBoxNodeRenderer();

    ChangeEvent changeEvent = null;

    public Object getCellEditorValue() {
        CheckBoxPanel checkBoxPanel = renderer.getLeafRenderer();
        CheckBoxNode checkBoxNode = new CheckBoxNode(checkBoxPanel.label.getText(),
                checkBoxPanel.checkBox.isSelected());
        return checkBoxNode;
    }

    public boolean isCellEditable(EventObject event) {
        boolean returnValue = false;

        if (event instanceof MouseEvent) {
            MouseEvent mouseEvent = (MouseEvent) event;

            JTree tree = (JTree)event.getSource();

            TreePath path = tree.getPathForLocation(mouseEvent.getX(),
                    mouseEvent.getY());
            if (path != null) {
                Object node = path.getLastPathComponent();
                if ((node != null) && (node instanceof DefaultMutableTreeNode)) {
                    DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode) node;
                    Object userObject = treeNode.getUserObject();
                    returnValue = ((treeNode.isLeaf()) && (userObject instanceof CheckBoxNode));
                }
            }
        }
        return returnValue;
    }

    public Component getTreeCellEditorComponent(JTree tree, Object value,
            boolean selected, boolean expanded, boolean leaf, int row) {

        Component editor = renderer.getTreeCellRendererComponent(tree, value,
                true, expanded, leaf, row, true);

        // editor always selected / focused
        ItemListener itemListener = new ItemListener() {
            public void itemStateChanged(ItemEvent itemEvent) {
                if (stopCellEditing()) {
                    fireEditingStopped();
                }
            }
        };

        if (editor instanceof CheckBoxPanel) 
        {
            ((CheckBoxPanel) editor).checkBox.addItemListener(itemListener);
        }

        return editor;
    }
}

class CheckBoxNode 
{
    String text;

    boolean selected;

    public CheckBoxNode(String text, boolean selected) 
    {
        this.text = text;
        this.selected = selected;
    }

    public boolean isSelected() { return selected; }

    public void setSelected(boolean newValue) { selected = newValue; }

    public String getText() { return text; }

    public void setText(String newValue) { text = newValue; }

    public String toString() { return getClass().getName() + "[" + text + "/" + selected + "]"; }
}

class NamedVector extends Vector 
{
    String name;

    public NamedVector(String name) 
    {
        this.name = name;
    }

    public NamedVector(String name, Object elements[]) 
    {
        this.name = name;
        for (int i = 0, n = elements.length; i < n; i++) 
        {
            add(elements[i]);
        }
    }

    public String toString() 
    {
        return "[" + name + "]";
    }
}

标签检查框树：

import java.util.Vector;

import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;

public class LabelCheckBoxTree extends CheckBoxTree
{
    public LabelCheckBoxTree()
    {
        super();
    
        DefaultTreeModel model = (DefaultTreeModel) getModel();
        DefaultMutableTreeNode root = (DefaultMutableTreeNode)model.getRoot();
        root.removeAllChildren();
        model.reload();
        model.setRoot(root);

        DefaultMutableTreeNode category = null;
        DefaultMutableTreeNode book = null;
    
        category = new DefaultMutableTreeNode(new NamedVector("Book 1"));
        root.add(category);
    
        category.add(new DefaultMutableTreeNode(new CheckBoxNode("Chapter 1", true)));
        category.add(new DefaultMutableTreeNode(new CheckBoxNode("Chapter 2", true)));
        category.add(new DefaultMutableTreeNode(new CheckBoxNode("Chapter 3", true)));
    

        category = new DefaultMutableTreeNode(new NamedVector("Book 2"));
        root.add(category);

        category = new DefaultMutableTreeNode(new NamedVector("Book 3"));
        root.add(category);

        category.add(new DefaultMutableTreeNode(new CheckBoxNode("Chapter 1", true)));
        category.add(new DefaultMutableTreeNode(new CheckBoxNode("Chapter 2", true)));
        category.add(new DefaultMutableTreeNode(new CheckBoxNode("Chapter 3", true)));
        category.add(new DefaultMutableTreeNode(new CheckBoxNode("Chapter 4", true)));

        setRootVisible(false);
    
        scrollPathToVisible(new TreePath(((DefaultMutableTreeNode)root.getChildAt(0)).getPath()));        
    }

    public LabelCheckBoxTree(Vector rootVector)
    {       
        super(rootVector);
    }
}