Is this inheritance?

I was hoping someone could set me straight on this inheritance / abstract class question. (Courtesy of Bruce Eckels Thinking in Java, again).

I have a private abstract static class Tester as an inner class in my ListPerformance class. As another variable, I have an array of Tester objects which receieve new anonymous classes as parameters.

Since you cannot instantiate an abstract class, when I say new Tester() and implement the abstract method test() in these anonymous classes, does that mean I am extending the Tester class without using the keyword extends?

Thoughts appreciated.

public class ListPerformance {
    
    private static int reps = 10000;
    private static int quantity = reps / 10;
    // this is an abstract class, so it cannot be instantiated
    private abstract static class Tester {
        private String name;
        Tester(String name) { this.name = name; }
        abstract void test(List a);  
    }
    private static Tester[] tests = { 
// You can't instantiate an abstract class, right?        
// So does this anonymous Tester inherit the attributes from Tester?
        new Tester("get") { 
            void test(List a) {
                for(int i=0; i<reps; i++) {
                    for(int j=0; j<quantity; j++)
                        a.get(j);
                }
            }
        },
        new Tester("iteration") { 
            void test(List a) {
                for(int i=0; i<reps; i++) {
                    Iterator it = a.iterator();
                    while(it.hasNext())
                        it.next();
                }
            }
        },
        new Tester("insert") { 
            void test(List a) {
                int half = a.size()/2;
                String s = "test";
                ListIterator it = a.listIterator(half);
                for(int i=0; i<reps*10; i++) {
                    it.add(s);
                }
            }
        },
        new Tester("remove") { 
            void test(List a) {
                ListIterator it = a.listIterator(3);
                while(it.hasNext()) {
                    it.next();
                    it.remove();
                }
            }
        },
    };
    
    public static void test(List a) {
        System.out.println("\nTesting "+ // remove the package identifiers
                a.getClass().getName().replaceAll("\\w+\\.", "")); 
        // loop through all the tests.
        for(int i=0; i<tests.length;i++) {
            Collections2.fill(a, Collections2.countries.reset(), quantity);
            // print out the name of the mini test
            System.out.print(tests[i].name); 
            long t1 = System.currentTimeMillis();
             // run each mini-test
            tests[i].test(a);
            long t2 = System.currentTimeMillis();
            // print out the time taken to run the test
            System.out.println(": "+(t2-t1));
        }
    }
    
    public static void  testArrayAsList(int reps) {
        System.out.println("Testing array as list");
        // Can only do first two tests on an array:
        for(int i=0; i<2;i++) {
            String[] sa = new String[quantity];
            Arrays2.fill(sa, Collections2.countries.reset());
            List a = Arrays.asList(sa);
            System.out.print(tests[i].name);
            long t1 = System.currentTimeMillis();
            tests[i].test(a);
            long t2 = System.currentTimeMillis();
            System.out.println(": "+(t2-t1));
        }
    }
    
    public static void main(String[] args) {
        // Choose a different number of repetitions via the command line
        if(args.length > 0)
            reps = Integer.parseInt(args[0]);
        System.out.println(reps+" reps");
        testArrayAsList(reps);
        test(new ArrayList());
        test(new LinkedList());
        test(new Vector());
    }
}

Yes.

So would it be correct to say: Each of the anonymous classes in the array is a subclass of the abstract Tester class, but since they are anonymous they don't need an explicit name or the keyword extends?

Yes again...