如何绕过 Java 无法从多个类扩展

Question

I think I have a design problem in my Java app, but I cannot figure out how to solve or bypass it.

Say I have an interface and an abstract class implementing it as follows:

public interface IntegerCollection extends Collection<Integer> {
  public int sum();     
}

public abstract class AbstractIntegerCollection
                extends AbstractCollection<Integer> implements IntegerCollection {
  public int sum() {
    // fancy code to calculate the sum of all collection members (just an example)
  }
}

Now I would want to make this class instantiable by using the existing implementations of Collection (eg, LinkedList); something like this:

public class IntegerLinkedList extends AbstractIntegerCollection, LinkedList<Integer> {

}

IntegerCollection ic = new IntegerLinkedList();

However, this does not work because Java does not support extending several classes. Also it looks quite ugly to me, as there is a mixture of hierarchies.

Of course, I could let IntegerLinkedList implement IntegerCollection instead of letting it extend AbstractIntegerCollection. But then, I would have to repeat the code for sum() in all other implementations (eg, IntegerArrayList).

Is there a better way to do this?

Answer 1

I'm not sure what exactly, you are trying to achieve, but rather you could implements List instead of extending LinkedList

public class IntegerLinkedList 
             extends AbstractIntegerCollection 
             implements List<Integer>
 {

 }

But, you need to implements all abstract method of List .

Answer 2

Since java 8 it has been possible to include implementations in an interface by using the default keyword. Therefore you don't need AbstractIntegerCollection - all the common code can be put in the interface. Here is an example:

import java.util.Collection;
import java.util.LinkedList;

public class Main {

    interface IntegerCollection extends Collection<Integer> {

        default int sum() {
            int sum = 0;
            for (int a : this)
                sum += a;
            return sum;
        }
    }

    static class IntegerLinkedList extends LinkedList<Integer> implements IntegerCollection {

    }

    public static void main(String[] args) {
        IntegerCollection list = new IntegerLinkedList();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list.sum());     // Prints 6
    }
}

This works, but I'm not sure it's a good idea. I'd think very carefully before extending a class like LinkedList . Some people also consider it an anti-pattern to extend generic classes with non-generic ones.

Another thing to be aware of is that it is not possible to write default methods for the methods of Object like equals and toString etc.

Since you are using Java 7, the above solution is not available. However, with a load of tedious forwarding methods, you can do it using composition rather than inheritance. Josh Bloch's book Effective Java gives a very good explanation of why composition is preferable anyway. Here is an (incomplete) example - you'll need to add a few more forwarding methods to avoid UnsupportedOperationException s when you try doing other things with the list.

import java.util.*;

public class Main {

    abstract static class AbstractIntegerCollection extends AbstractCollection<Integer> {

        public int sum() {
            int sum = 0;
            for (int a : this)
                sum += a;
            return sum;
        }
    }

    static class IntegerLinkedList extends AbstractIntegerCollection implements List<Integer> {

        private final List<Integer> list = new LinkedList<>();

        @Override
        public Iterator<Integer> iterator() {
            return list.iterator();
        }

        @Override
        public int size() {
            return list.size();
        }

        @Override
        public boolean addAll(int index, Collection<? extends Integer> c) {
            return list.addAll(index, c);
        }

        @Override
        public Integer get(int index) {
            return list.get(index);
        }

        @Override
        public Integer set(int index, Integer element) {
            return list.set(index, element);
        }

        @Override
        public boolean add(Integer element) {
            return list.add(element);
        }

        @Override
        public void add(int index, Integer element) {
            list.add(index, element);
        }

        @Override
        public Integer remove(int index) {
            return list.remove(index);
        }

        @Override
        public int indexOf(Object o) {
            return list.indexOf(o);
        }

        @Override
        public int lastIndexOf(Object o) {
            return list.lastIndexOf(o);
        }

        @Override
        public ListIterator<Integer> listIterator() {
            return list.listIterator();
        }

        @Override
        public ListIterator<Integer> listIterator(int index) {
            return list.listIterator(index);
        }

        @Override
        public List<Integer> subList(int fromIndex, int toIndex) {
            return list.subList(fromIndex, toIndex);
        }

        // More of these
    }

    public static void main(String[] args) {
        IntegerLinkedList list = new IntegerLinkedList();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list.sum());     // Prints 6
    }
}

This solution is far from perfect. For one thing, it would be better if IntegerLinkedList extended AbstractList<Integer> rather than just AbstractCollection<Integer> , but then you couldn't extend AbstractIntegerCollection too.