Java-如何在类定义中检查对象是否是类的实例

Question

Code:

public class Composite extends Component implements Iterable<Component>{

    private List<Component> caseComponents = new ArrayList<Component>();


    @Override
    public Iterator<Component> iterator(){
        return new CompIterator();
    }



    private class CompIterator implements Iterator{
        int index = 0;

        @Override
        public boolean hasNext(){
            if(index<caseComponents.size()){
                return true;
            }
            return false;
        }

        @Override
        public Object next() {
            if(this.hasNext()){
                return caseComponents.get(index++);
            }
            return null;
        }
    }


    public String breadthFirst() {
        Queue<Component> q = new LinkedList<Component>();
        StringBuilder stringRep = new StringBuilder();
        q.add(this);

        while(q.element()!=null){
            Component first = q.remove();
            System.out.println(first.name);

            for(Component c : first.caseComponents){
                q.add(c);
            }
        }
    }

I'm trying to do a breadth first print of a tree of the Composite design pattern. I have declared a method that is supposed to be called by the "root" of the tree. In the tree, there will be objects of the classes Composite and Leaf . These both inherit from Component , but are of course different. Composite is a container objects as well as an object itself, while Leaf is just one object. I want to change my code so that the line for(Component c : first.caseComponents) is only executed if first is an instance of Composite , otherwise it would try to iterate over a Leaf which is not possible. How can I make it so that the for statement is only entered if first is a Composite ?

Answer 1

Use instanceof to check if comp is an instance of Composite .

eg:

if (comp instanceof Composite) { 
    //do something
}

Answer 2

You can restructure your code to apply the visitor pattern:

public interface ComponentVisitor {
  void visitComposite(Composite composite);
  void visitLeaf(Leaf leaf);
}

public interface Component {
  void acceptVisitor(ComponentVisitor visitor);
}

public class Composite implements Component {
  @Override public void acceptVisitor(ComponentVisitor visitor) {
    visitor.visitComposite(this);
  }
}

public class Leaf implements Component {
  @Override public void acceptVisitor(ComponentVisitor visitor) {
    visitor.visitLeaf(this);
  }
}

The visitor pattern is a compile-time safe alternative to runtime checks and casts and can also help static analysis of your code. The program code will look like

public class ComponentPrinter implements ComponentVisitor {

  public void printComponent(Component component) {
    component.acceptVisitor(this);
  }

  @Override public void visitComposite(Composite composite) {
    for (Component child : composite) {
      printComponent(component);
    }
  }

  @Override public void visitLeaf(Leaf leaf) {
    System.out.println("Found leaf: " + leaf);
  }
}

_{Incidentally, the demo program does a depth-first print, but you can of course use a queue to accumulate components and then print breadth-first}

Answer 3

I would get rid of both Composite and Leaf altogether, and introduce a Node class that can have children. If it does, it's an intermediate node; if not, it's a leaf. As this property can change any time, it is violently inappropriate to use different classes to express it.