Java 17 OCP: why is anonymous class called anonymous

[Nico van de Kamp]

Hello,

Earlier Java 8 was this a thing what I don't understand.

Normally straightforward you make an instance of class:

ClassX classX = new ClassX();

right, the type is ClassX, reference name classX, but there is not a class name, or did I already missed something?

public class Chapter7AnonymousClass {

    abstract class SaleTodayOnly {
        abstract int dollarsOff();
    }

    public int admission(int basePrice) {
        SaleTodayOnly sale = new SaleTodayOnly() {             // define anonymous class, instantiëren abstract class
            @Override
            int dollarsOff() {                                                        // default access
                return 3;
            }
        };                                                                                     

        return basePrice - sale.dollarsOff();
    }

    public static void main(String[] args) {
        Chapter7AnonymousClass chapter7AnonymousClass = new Chapter7AnonymousClass();
        System.out.println(chapter7AnonymousClass.admission(10));
    }

}

sale is Local variable in admission of the type SaleTodayOnly.

What is meant by anonymous class doesn't have a name? The abstract class does have a name:  "SaleTodayOnly".
The situation that a class does have name is that meant by:

public class ClassName {}

?

[Stephan van Hulst]

In your first code snippet, ClassX is a concrete class. Its name is "ClassX".

In your second code snippet, SaleTodayOnly also has a name: "SaleTodayOnly". However, that's not the concrete type that you're instantiating on line 8. After all, you can't directly instantiate an abstract class.

Instead, you're instantiating a concrete subclass of SaleTodayOnly. That concrete subtype doesn't have a name. In other words, its anonymous.

Try adding a constructor to the body of your anonymous class. You can't, because what would the name of the constructor be?

[Nico van de Kamp]

Thanks Stephan, it's maybe stupid but it is still hard for me to understand.
I know that it is not possible to instantiate an abstract class, but how does Java interpret\determine,  to instantiate a subclass?

If I change it to a concrete class like this:

class SaleTodayOnlyConcreteClass {
    int dollarsOff() {
        return 5;
    }
}

public class Chapter7AnonymousClass {
 
    public int admissionConcreteClass(int basePrice) {
        SaleTodayOnlyConcreteClass sale = new SaleTodayOnlyConcreteClass() {           // define van anonymous class, instantiating concrete class, but what is anonymous?
            @Override
            int dollarsOff() {                      
                return 3;
            }
        };                                         

        return basePrice - sale.dollarsOff();
    }
 
    public static void main(String[] args) {
        Chapter7AnonymousClass chapter7AnonymousClass = new Chapter7AnonymousClass();

        System.out.println("Concrete class: " + chapter7AnonymousClass.admissionConcreteClass(33));
    }
 
}

Now it is a concrete class instantiating, which has a name and is assigned to a local variable. Why is it still called anonymous? How can I compare with what have name in an other situation and now not?

Maybe stupid, what do I not see?

[Stephan van Hulst]

Nico van de Kamp wrote:Now it is a concrete class instantiating, which has a name and is assigned to a local variable.

No. You're still instantiating an anonymous class. This time it's a nameless subclass of SaleTodayOnlyConcreteClass.

When you add a class body next to a constructor call, that syntax is what determines that a nameless subclass is defined.

[Piet Souris]

Your IDE (in my case NetBeans) can illustrate this nicely. I use an interface for brevity.

interface I {
    int rebate();
}

public static void main(String... args) {
    I i = () -> 3;   // everyone writes this without further thinking
    var j = (I) () -> 3;
    var k = new I() {
        @Override
        public int rebate() {
            return 3;
        }
    };
    var s = (Supplier<Integer>) () -> 3;
    var t = new Supplier<Integer>() {
        @Override
        public Integer get() {
            return 3;
        }
    };
}

If you ask the IDE to replace the vars with their real types, then j and s are reported as I and Supplier<Integer>, but it does not give types for k and t. Meaning that their real types are unknown? k instanceof I is true, by the way.