Is there any way to use an interface non staticly

Question

I'm trying to implement extended collections as an interface and the method of keep sending me "Non-static method 'of(java.util.Collection<ELEMENT_TYPE>)'" cannot be referenced from a static context"

I know it has been answered on other threads but all those answers don't solve my problem.

thanks in advance.

The compiler tell me

**

Error:(22, 54) java: non-static method <ELEMENT_TYPE>of(java.util.Collection<ELEMENT_TYPE>) cannot be referenced from a static context

Error:(31, 62) java: non-static method <ELEMENT_TYPE>of(java.util.Collection<ELEMENT_TYPE>) cannot be referenced from a static context

Error:(22, 63) java: cannot find symbol
  symbol:   method map(this::mapper)
  location: interface java.util.Collection

Error:(31, 71) java: cannot find symbol
  symbol:   method toMap((it)->it.s[...]0, 2))
  location: interface java.util.Collection

Error:(40, 64) java: cannot find symbol
  symbol:   method toSet()
  location: interface java.util.Collection

Error:(40, 55) java: non-static method <ELEMENT_TYPE>of(java.util.Collection<ELEMENT_TYPE>) cannot be referenced from a static context
**

I precise that i don't have the right to edit the test file

Edit:

I rewrite switch to:

static <ELEMENT_TYPE> ExtendedCollection<ELEMENT_TYPE> of(Collection<ELEMENT_TYPE> list)
    {
        ExtendedCollection<ELEMENT_TYPE> c = new Collection<ELEMENT_TYPE>();
        list.forEach(e -> c.add(e));
        return (ExtendedCollection<ELEMENT_TYPE>) c;
    }

and it almost works now I don't know how to instantiate an Extended collection as it is an interface

Answer 1

Trying to extend collection is the wrong thing to do.

You'll only be able to invoke these methods on a thing that implements the interface, meaning you can't, say, reuse existing, battle-tested implementations of collection like java.util.ArrayList.

Just define static helper methods, and pass in the collection if needed.

In fact, this is what your "interface" is actually doing: you could define the of method like:

static  <ELEMENT_TYPE> Collection<ELEMENT_TYPE> of(Collection<ELEMENT_TYPE> list)
{
    Collection<ELEMENT_TYPE> c = new ArrayList<ELEMENT_TYPE>();
    list.forEach(e -> c.add(e));
    return c;
}

Or, easier:

static  <ELEMENT_TYPE> Collection<ELEMENT_TYPE> of(Collection<ELEMENT_TYPE> list)
{
    return new ArrayList<>(list);
}

Or just inline that code directly. It's clearer what you're actually getting, it's standard, and it's more flexible (you can gain the same flexibility by changing the parameter type to Collection<? extends ELEMENT_TYPE> though).

Answer 2

You're calling the non static method, of (which you define on your ExtendedCollection interface) from a static context (i.e., not calling it on an instance of ExtendedCollection).

If you're using java 8 or later, you can define static methods on interfaces. In which case all you need to do is change the of method declaration by removing the default modifier and adding static.

If you're using pre java 8, then this is why java has classes like Collections, Executors, etc. You can define a utility class which has static methods to return items of the interface types.

Answer 3

The error message means that you are using the non-static method of() in a static context. A static context is when you use ClassName.methodName(). There are two ways to fix the problem:

1. Create an instance that has the method you want to call. Since you declare the method in an interface, you need to create a class that implements the interface first:

   public class ExtendedList<T> implements ExtendedCollection<T> {
   }
   

   Now you can create an instance:

   ExtendedCollection<String> c = new ExtendedCollection<>();
   final List<Integer> ints = c.of(list).map(this::mapper);
   

2. Change your interface to a class and declare the method as static:

   static <ELEMENT_TYPE> Collection<ELEMENT_TYPE> of(Collection<ELEMENT_TYPE> list) {
       Collection<ELEMENT_TYPE> c = new ArrayList<ELEMENT_TYPE>();
       list.forEach(e -> c.add(e));
       return c;
   }
   

For what you are trying to accomplish here, declaring the methods as static probably makes the most sense.

Answer 4

The problem here is you are trying to use a non static method in a static context. Your method ExtendedCollection#of() is not marked static, but you are trying to use it statically. This means that instead of calling ExtendedCollection.of(list), you need to create an instance of ExtendedCollection before you do so. (ExtendedCollection collection = new ExtendedCollection();.

But, since it is an interface, you will need to instantiate a subclass. (Though, I don't see why you can't make ExtendedCollection a class instead of an interface. It only seems to add default methods and not any without implementation. Also, as Andy Turner suggested, you might want to make this class a static helper/utility class instead, where you pass the collection, then transform it.

Answer 5

changing the method of by:

static <ELEMENT_TYPE> Collection<ELEMENT_TYPE> of(Collection<ELEMENT_TYPE> list)
    {
        Collection<ELEMENT_TYPE> c = new ArrayList<ELEMENT_TYPE>();
        list.forEach(e -> c.add(e));
        return c;
    }

the errors switch to: ** Error:(22, 63) java: cannot find symbol symbol: method map(this::mapper) location: interface java.util.Collection

Error:(31, 71) java: cannot find symbol symbol: method toMap((it)->it.s[...]0, 2)) location: interface java.util.Collection

Error:(40, 64) java: cannot find symbol symbol: method toSet() location: interface java.util.Collection

Error:(46, 64) java: cannot find symbol symbol: method toList() location: interface java.util.Collection **

Answer 6

1. You declared of as non static method but try to access it statically.
   • Solution a: Call of on an instance.
   • Solution b(preferred): Declare of static (just replace default <ELEMENT_TYPE> Collection<ELEMENT_TYPE> of... by static <ELEMENT_TYPE> Collection<ELEMENT_TYPE> of...)
2. see 1.
3. toMap is not defined for Collection, probably best solution: Make of return ExtendedCollection (instead of "normal" Collection;)
4. and 5. are related to/will be fixed by 3. - 6. by 1.

---

Yes, changing the return type to ExtendedCollection is not "that simple": here at least you have to initialize/provide one implementation, and yes if you don't choose a base class, which already provides add, you'd have to implement it:

static <ELEMENT_TYPE> ExtendedCollection<ELEMENT_TYPE> of(Collection<ELEMENT_TYPE> list)
{
   ExtendedCollection<ELEMENT_TYPE> c = new MyExtendedCollectionImpl<>();
   list.forEach(e -> c.add(e));
   return c;
}

with:

class MyExtendedCollectionImpl<T>
  extends java.util.ArrayList<T> /* e.g. ...  https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html */
  implements ExtendedCollection<T> { 
     // implement/override ExtendedCollection methods, if any
     // done!
}