Question

I have instantiated an object like this:

GraphMatrixDirected<String, Integer> g

g is passed to a function like this:

floyd(g);

floyd’s signature looks like this:

public void floyd(GraphMatrixDirected<V,E> g) 

Eclipse gives me an error saying:

The method floyd(GraphMatrixDirected<V,E>) in the type GraphMatrix<V,E> is not applicable for the arguments (GraphMatrixDirected<String,Integer>)

What do I need to do to fix it?

Edit1:

abstract public class GraphMatrix<V,E> extends AbstractStructure<V> implements Graph<V,E>

Edit2:

public interface Graph<V,E> extends Structure<V>

public abstract class AbstractStructure<E> implements Structure<E>

public interface Structure<E> extends Iterable<E>
/* JDT added extension of Iterable for Java 5 */

Edit 3:
Note: Funtion was changed from floyd to AllPairsShortestPath.

public void AllPairsShortestPath(GraphMatrixDirected<V,E> g) 
// post: g contains edge (a,b) if there is a path from a to b 
{
    Iterator<V> witer = g.iterator();
    while (witer.hasNext()) 
    {
        Iterator<V> uiter = g.iterator();
        V w = witer.next(); 

        while (uiter.hasNext())
        {
            Iterator<V> viter = g.iterator(); 
            V u = uiter.next(); 

            while (viter.hasNext()) 
            {
                V v = viter.next(); 

                if (g.containsEdge(u,w) && g.containsEdge(w,v)) 
                {
                    Edge<V,E> leg1 = g.getEdge(u,w);
                    Edge<V,E> leg2 = g.getEdge(w,v); 

                    Integer leg1Dist = (Integer)leg1.label(); 
                    Integer leg2Dist = (Integer)leg2.label(); 
                    Integer newDist = (Integer)leg1Dist+leg2Dist;

                    E newDistE = (E)newDist;

                    if (g.containsEdge(u,v)) 
                    {
                        Edge<V,E> across = g.getEdge(u,v);
                        Integer acrossDist = (Integer)across.label(); 

                        if (newDist < acrossDist)
                        {
                            across.setLabel(newDistE);
                        } 
                    } 
                    else 
                    {
                        g.addEdge(u,v,newDistE);
                    }
                }
            }
        }
    }
}

Answer 1

Perhaps you meant floyd to be a generic method?

public <V,E> void floyd(GraphMatrixDirected<V,E> g)

Otherwise, whatever generic type floyd is a member of need to have <V,E> parameterized as <String,Integer>.

If it’s true that floyd belongs to a generic type, and yet floyd also needs to be a generic method with its own type parameters, you may want to choose different names, so as not to hide one another.

References

• Java Tutorials/Generics
• Angelika Langer’s Java Generic FAQs
  • Generic Types and Generic Methods

---

On generic type vs generic methods

The choice between which solution route to take depends on what floyd does and other things. One essential question is this: do you consider floyd to be a method that belongs specifically to the generic type GraphMatrixDirected<V,E> (answer is probably no) or is it rather a generic utility method that works with any Graph<V,E>? (answer is probably yes).

For example and guidance, we can also take a look at how Java Collections Framework is structured:

• interface List<E> – a generic type that defines basic functionality for the type
  • specifies boolean add(E e), E get(int index), etc
• class Collections – provides static utility generic methods
  • static void shuffle(List<?> list)
  • static <T extends Comparable<? super T>> void sort(List<T> list)
  • static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)

Assuming that floyd is indeed an implementation of Floyd-Warshall all-pairs shortest path algorithm, I’d argue that it should be a static utility method to say a Graphs class, and works with any Graph<V,E>.

See also, Effective Java 2nd Edition

Generic types vs methods:

• Item 26, Favor generic types
• Item 27, Favor generic methods

Interfaces:

• Item 18, Prefer interfaces to abstract classes
• Item 19, Use interfaces only to define types
• Item 52, Refer to objects by their interfaces