[noob]Doubt regarding Interfaces

[mmu2643]

Can someone please explain the following code snippet I found on the
Swing tutorial site. Thanks!

Runnable doHelloWorld = new Runnable() {
public void run() {
System.out.println("Hello World on " +
Thread.currentThread());
}
};

Is doHelloWorld now an object or is it an abstract class or is it
something altogether different?

 

[VisionSet]

Can someone please explain the following code snippet I found on the
Swing tutorial site. Thanks!

Runnable doHelloWorld = new Runnable() {
public void run() {
System.out.println("Hello World on " +
Thread.currentThread());
}
};

Is doHelloWorld now an object or is it an abstract class or is it
something altogether different?

All variables are either primitives or a reference to an Object.
If they are a reference to an Object as in the case above then they can have
a type of 1 or many.
In the example above doHelloWorld is a reference to a concrete Object with
an interface Type of Runnable.
It has been created using an Annoymous class, since there is no class
declaration. If the class was not annoymous then the Object would also have
the Type of that class.

Runnable // the Type you are assigning
doHelloWorld // the variable you are assigning it to
= // assignment
new // instantiation
Runnable() {...} // annoymous class definition
.... // contents of class

this bit :
Runnable() {...} // annoymous class definition

you can think of expanding to:

private class AnnoymousClass implements Runnable {
....
}

HTH

 

[VisionSet]

If they are a reference to an Object as in the case above then they can have
a type of 1 or many.

If they are a reference to an Object as in the case above then they can have
1 or many types.
Yes, all at the same time.
Google "run time type identification" and "polymorphism"

 

[Roedy Green]

Runnable doHelloWorld = new Runnable() {
public void run() {
System.out.println("Hello World on " +
Thread.currentThread());
}
};

Is doHelloWorld now an object or is it an abstract class or is it
something altogether different?

it is an instance of an inner anonymous class. see
http://mindprod.com/jgloss/anonymousclasses.html

 

[John C. Bollinger]

All variables are either primitives or a reference to an Object.
If they are a reference to an Object as in the case above then they can have
a type of 1 or many.

I'm not sure what you mean by that, but perhaps it's that the class of
an object can be compatible with any positive number of types. It is
necessary here to be clear about the difference between class and type.
Every object has exactly one class. Every variable and expression has
exactly one type. A non-primitive types is expressed in terms of class
names, and it serves the purpose of describing to the compiler the
possible classes of the object that its value (a reference) refers to.

In the example above doHelloWorld is a reference to a concrete Object with
an interface Type of Runnable.

More precisely, doHelloWorld is a variable of type Runnable, which as
the result of the assignment holds a reference to an object whose class
implements Runnable and has Object as its direct superclass.

It has been created using an Annoymous class, since there is no class
declaration.

Quibbling a bit here, but there *is* a class declaration -- an anonymous
one. The syntax is a bit different from that for a named class
declaration, but that doesn't make it any less a declaration.

If the class was not annoymous then the Object would also have
the Type of that class.

Sorry, but that's nonsense. In the first place, Object is a superclass
of the anonymous class, therefore references to its instances are
assignment-compatible with type Object. *Every* class has Object as a
superclass, and therefore *every* reference is assignment-compatible
with type Object. In the second place, classes do not have types. They
have superclasses, and they have interfaces implemented; these determine
which types their instances are compatible with. They do not have types.

Runnable // the Type you are assigning Runnable // the type of ...
doHelloWorld // the variable you are assigning it to

doHelloWorld // the variable you are assigning a value to

= // assignment
new // instantiation
Runnable() {...} // annoymous class definition

Which one could also call an anonymous class declaration.

[...]

this bit :
Runnable() {...} // annoymous class definition

you can think of expanding to:

private class AnnoymousClass implements Runnable {
...
}

Yes, that's quite right. More right, in fact, than the idea that the
class in question really has no name. The Java source code assigns no
name to it, but the Java compiler invents one at compile time. The VM
doesn't have any concept of a class that doesn't have a name; "anonymous
class" really means something more like "class whose name I don't know
and don't care about."

 

[mmu2643]

Thanks everyone for your replies!

I have a basic question - in the above instance Runnable is an
interface and interfaces cannot be instantiated. So something like 'new
Runnable()' seems puzzling to me. Is this syntax for instantiating an
object of the Anonymous class?

Also, is the above snippet similar to the following in the end result:

class ac implements Runnable{
public void run() {
System.out.println("Hello World on " +
Thread.currentThread());
}
};

ac doHelloWorld = new ac();

 

[zero]

(e-mail address removed) wrote in @g47g2000cwa.googlegroups.com:

Thanks everyone for your replies!

I have a basic question - in the above instance Runnable is an
interface and interfaces cannot be instantiated. So something like 'new
Runnable()' seems puzzling to me. Is this syntax for instantiating an
object of the Anonymous class?

Also, is the above snippet similar to the following in the end result:

class ac implements Runnable{
public void run() {
System.out.println("Hello World on " +
Thread.currentThread());
}
};

ac doHelloWorld = new ac();

That's basically it yes.

new Runnable() {...} creates a new anonymous class that implements
interface Runnable and has whatever variables/methods you define between
the brackets.

This is often used to implement a simple event listener, for example for a
button:

Button b = new Button();

b.addActionListener(new ActionListener()
{
JOptionFrame.showMessageDialog("button clicked");
});

Note how the whole class definition is inside the parentheses of the
addActionListener method, and it is ended - like any statement - with a
semi-colon.

 

[Thomas Hawtin]

b.addActionListener(new ActionListener()
{

public void actionPerformed(ActionEvent event) {

JOptionFrame.showMessageDialog("button clicked"); }
});

Note how the whole class definition is inside the parentheses of the
addActionListener method, and it is ended - like any statement - with a
semi-colon.

Well, the class ends with the closing }. The enclosing expression
carries on as normal.

Tom Hawtin