Java 焦点遍历以跳过非焦点字段

我在屏幕上有许多文本字段（比代码显示的要多）

在某个条件下（即用户在屏幕上标记复选框），我希望从焦点中删除txtPhone2和txtPhone2Text。但是，如果我在onClick事件中显式地说将这两个字段设置为Focusable false，那么当我在字段间切换时，我的光标只是停留在txtPhone1Text，而不会转到Fax1字段，跳过我设置为non Focusable的字段

---

想知道我是否遗漏了什么。如有任何提示/建议，我们将不胜感激。如果有必要，我会使用NetBeans IDE。

阅读上的Swing教程。它提供了一个如何创建自定义焦点遍历策略的示例。不幸的是，这个示例不是很完整，因为它也有与您的代码相同的问题，因为它总是假设一个组件能够有焦点

我修改了示例中的类，以确保组件是可聚焦的：

public static class MyOwnFocusTraversalPolicy extends FocusTraversalPolicy
{
    Vector<Component> order;

    public MyOwnFocusTraversalPolicy(Vector<Component> order)
    {
        this.order = new Vector<Component>(order.size());
        this.order.addAll(order);
    }

    public Component getComponentAfter(Container focusCycleRoot,
                                       Component aComponent)
    {
//      int idx = (order.indexOf(aComponent) + 1) % order.size();
//      return order.get(idx);

        int idx = order.indexOf(aComponent);

        for (int i = 0; i < order.size(); i++)
        {
            idx = (idx + 1) % order.size();
            Component next = order.get(idx);

            if (canBeFocusOwner(next)) return next;
        }

        return null;
    }

    public Component getComponentBefore(Container focusCycleRoot,
                                        Component aComponent)
    {
/*
        int idx = order.indexOf(aComponent) - 1;
        if (idx < 0) {
            idx = order.size() - 1;
        }
        return order.get(idx);
*/
        int idx = order.indexOf(aComponent);

        for (int i = 0; i < order.size(); i++)
        {
            idx = (idx - 1);

            if (idx < 0)
            {
                idx = order.size() - 1;
            }

            Component previous = order.get(idx);

            if (canBeFocusOwner(previous)) return previous;
        }

        return null;
    }

    public Component getDefaultComponent(Container focusCycleRoot) {
//      return order.get(0);
        return getFirstComponent( focusCycleRoot );
    }

    public Component getLastComponent(Container focusCycleRoot) {
//      return order.lastElement();

        Component c = order.lastElement();

        if (canBeFocusOwner(c))
            return c;
        else
            return getComponentBefore(focusCycleRoot, c);
    }

    public Component getFirstComponent(Container focusCycleRoot)
    {
//      return order.get(0);

        Component c = order.get(0);

        if (canBeFocusOwner(c))
            return c;
        else
            return getComponentAfter(focusCycleRoot, c);
    }

    private boolean canBeFocusOwner(Component c)
    {
        if (c.isEnabled() && c.isDisplayable() && c.isVisible() && c.isFocusable())
        {
            return true;
        }

        return false;
    }

}

公共静态类MyOwnFocusTraversalPolicy扩展了FocusTraversalPolicy
{
向量顺序；
公共政策（矢量顺序）
{
this.order=新向量（order.size（））；
this.order.addAll（订单）；
}
公共组件getComponentAfter（容器焦点），
组件（组件）
{
//intidx=（order.indexOf（aComponent）+1）%order.size（）；
//退货订单.get（idx）；
int idx=order.indexOf（一个组件）；
对于（int i=0；i

阅读上的Swing教程。它提供了一个如何创建自定义焦点遍历策略的示例。不幸的是，这个示例不是很完整，因为它也有与您的代码相同的问题，因为它总是假设一个组件能够有焦点

我修改了示例中的类，以确保组件是可聚焦的：

public static class MyOwnFocusTraversalPolicy extends FocusTraversalPolicy
{
    Vector<Component> order;

    public MyOwnFocusTraversalPolicy(Vector<Component> order)
    {
        this.order = new Vector<Component>(order.size());
        this.order.addAll(order);
    }

    public Component getComponentAfter(Container focusCycleRoot,
                                       Component aComponent)
    {
//      int idx = (order.indexOf(aComponent) + 1) % order.size();
//      return order.get(idx);

        int idx = order.indexOf(aComponent);

        for (int i = 0; i < order.size(); i++)
        {
            idx = (idx + 1) % order.size();
            Component next = order.get(idx);

            if (canBeFocusOwner(next)) return next;
        }

        return null;
    }

    public Component getComponentBefore(Container focusCycleRoot,
                                        Component aComponent)
    {
/*
        int idx = order.indexOf(aComponent) - 1;
        if (idx < 0) {
            idx = order.size() - 1;
        }
        return order.get(idx);
*/
        int idx = order.indexOf(aComponent);

        for (int i = 0; i < order.size(); i++)
        {
            idx = (idx - 1);

            if (idx < 0)
            {
                idx = order.size() - 1;
            }

            Component previous = order.get(idx);

            if (canBeFocusOwner(previous)) return previous;
        }

        return null;
    }

    public Component getDefaultComponent(Container focusCycleRoot) {
//      return order.get(0);
        return getFirstComponent( focusCycleRoot );
    }

    public Component getLastComponent(Container focusCycleRoot) {
//      return order.lastElement();

        Component c = order.lastElement();

        if (canBeFocusOwner(c))
            return c;
        else
            return getComponentBefore(focusCycleRoot, c);
    }

    public Component getFirstComponent(Container focusCycleRoot)
    {
//      return order.get(0);

        Component c = order.get(0);

        if (canBeFocusOwner(c))
            return c;
        else
            return getComponentAfter(focusCycleRoot, c);
    }

    private boolean canBeFocusOwner(Component c)
    {
        if (c.isEnabled() && c.isDisplayable() && c.isVisible() && c.isFocusable())
        {
            return true;
        }

        return false;
    }

}

公共静态类MyOwnFocusTraversalPolicy扩展了FocusTraversalPolicy
{
向量顺序；
公共政策（矢量顺序）
{
this.order=新向量（order.size（））；
this.order.addAll（订单）；
}
公共组件getComponentAfter（容器焦点），
组件（组件）
{
//intidx=（order.indexOf（aComponent）+1）%order.size（）；
//退货订单.get（idx）；
int idx=order.indexOf（一个组件）；
对于（int i=0；i