Java匿名内部类List

Question

I want to attach a method to a LinkedList object at run time via an anonymous inner class. Is this possible?

For example:

    LinkedList<String> paths = new LinkedList<String>() {
        void addAllIfNotNull(Collection<String> c) {
            if(c != null) {
                addAll(c);
            }
        }
    };
    paths.add(list1);
    paths.add(list2);
    paths.add(list3);
    ...
    paths.add(listN);

Without having to do a if(list_i is not null) addAll(list_i) ?

This doesn't look like it is possible because the LinkedList does not have an AddAllIfNotNull method. Is there a way to make this work?

Answer 1

This is not possible via an anonymous inner class. It can be done with a non-anonymous inner class or a stand-alone class, but not anonymous since the compiler will have no way of recognizing the method since to the compiler the variable is of type LinkedList , and if you wanted to cast the variable, what would you cast it to since the type you want is anonymous?

Question for you: what happens when you try this? Does it compile when you try to call the method?

eg,

import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;

public class LinkedListFoo {
   public LinkedListFoo() {
      List<String> list = new ArrayList<>();

      MyLinkedList<String> paths = new MyLinkedList<>();
      paths.addAllIfNotNull(list);     
   }

   // non-anonymous inner class
   private class MyLinkedList<T> extends LinkedList<T> {
      void addAllIfNotNull(Collection<T> c) {
         if(c != null) {
             addAll(c);
         }
     }
   }
}

Answer 2

You can't add a new method with a new signature, since the type stays LinkedList<String> .

The way to do what you want, is to overide the existing method addAll() from LinkedList<T> , this way :

    LinkedList<String> paths = new LinkedList<String>() {
        public boolean addAll(Collection<? extends String> c) {
            System.out.println("In overiden addAll");
            if(c != null) {
                return super.addAll(c);
            }
            return false;
        }
    };
    // This now works
    paths.addAll(null);

Answer 3

I think Hovercraft's answer should be accepted, but another option for you is to override some method on LinkedList<T> --say, boolean addAll(Collection<? extends E> c) , in which you could do the null check before calling super.addAll(c) (effectively preventing it from throwing NullPointerException ). That way you can call addAll and still use an anonymous class. However, this technique should be used cautiously. java.util.LinkedList#addAll can be reasonably expected to throw the exception given a null parameter. Using a named class avoids that confusion.

Answer 4

This is not possible and you should not do this. Instead, make it a static method.