Please explain working of this code (Item 16 of Effective Java book Edition#1)

[Piyush Porwal]

 
import java.util.*;

public class IntArrays {
    static List<Integer> intArrayAsList(final int[] a) {
        if (a == null)
            throw new NullPointerException();
         return new AbstractList<Integer>() { // Line 1
            public Integer get(int i) {
                return a[i];  // Autoboxing (Item 5)
            }

            @Override public Integer set(int i, Integer val) {
                int oldVal = a[i];
                a[i] = val;     // Auto-unboxing
                return oldVal;  // Autoboxing
            }

            public int size() {
                return a.length;
            }
        };
    }   

This code is from Item 16 - Prefer interfaces to abstract classes (Effective Java Ed#1) - Page# 86

I am kind of puzzled by looking at this code. I have several doubts and by looking at the sun docs, I could answer few of them. Please help for the rest:

1. Is the code in the return statement over ridding the get/set/size methods - YES (got the answer after I checked the API docs and it says that these methods must be overridden). But I do not see extends anywhere?
2. AbstractList is an abstract class as per the API docs, how can a new be done on it without extending? (Line 1)
3. When and where the values from int[] a, gets assigned to Integer List? Within the object of AbstractList, where are these values kept? (May be I am posting a non-sense question, as not sure what is the behavior)

Probably after the explanation, I would also get why this implementation is termed as Adapter patter in the para below the code.

[Rob Spoor]

Do a search on anonymous classes. That should get you quite far already.

[Piyush Porwal]

wonderful, looked deeper than my normal understanding of anonymous classes and found the answer for point 1 and 2. Thanks.
Some info is discussed here: http://forums-beta.sun.com/thread.jspa?messageID=715086

I am yet to find answer for point 3, any further pointers?

[Rob Spoor]

The AbstractList subclass uses an implicit instance variable to the array.

You can really see this if you decompile the inner class file (IntArray$1.class), for instance using JAD (comments are mine):

static class IntArrays$1 extends AbstractList
{
    public Integer get(int i)
    {
        return Integer.valueOf(val$a[i]); // val$a is the replacement of a
    }

    public Integer set(int i, Integer integer)
    {
        int j = val$a[i]; // oldVal is renamed to j by JAD
        val$a[i] = integer.intValue(); // auto unboxing
        return Integer.valueOf(j); // auto boxing
    }

    public int size()
    {
        return val$a.length;
    }

    // the following two methods are probably created to "solve" the generics issue
    // also no idea where the volatile comes from - that's a field-only modifier
    public volatile Object set(int i, Object obj)
    {
        return set(i, (Integer)obj);
    }

    public volatile Object get(int i)
    {
        return get(i);
    }

    final int val$a[]; // and there is the implicit variable itself

    // implicit constructor that sets the variable. Notice how the call to super() is too late - you couldn't compile this code this way
    IntArrays$1(int ai[])
    {
        val$a = ai;
        super();
    }
}

[Piyush Porwal]

Thanks much for your effort. Didn't know java does so much for you!!
Although extending anonymous classes this way seems natural and common, but not sure when should this way of implicit instance variable should be used. Let me read bit more on this and if I found any good link will post here.

[Rob Spoor]

You already used the implicit variable, by using array "a' in your anonymous class.