Java anonymous classes constructor

Java Anonymous Class

In java, we can create a class inside another class called a nested class, and we can create a class with no name,i.e called an Anonymous Class.

In simple terms, a nested class with no name and only one object is created, said as Anonymous Class.

Note: It must be defined in another class.

Looking at the diagram, we see that anonymous classes along with local and nonstatic member ones form the so-called inner classes. Together with static member classes, they form the nested classes.

In the anonymous class we can declare the following:

// AnonymousClass = interface,abstract/concrete class. AnonymousClass c = new AnonymousClass() class TUFOuterClass < // defining anonymous class object1 = new Type(parameterList) < // body of the anonymous class >; >

Note: Anonymous classes are defined inside an expression. So, the semicolon is used at the end of anonymous classes to indicate the end of the expression.

Example of Anonymous Class:

Java Code

abstract class CheckClass < abstract void check(); >class TUF < public static void main(String args[]) < // defining anonymous class CheckClass p = new CheckClass() < // body of anonymous class void check() < System.out.println("Hello there Anonymous here!"); >>; p.check(); > >

Output: Hello there Anonymous here!

Ways to create Anonymous Class:

By Extending Class:

Java Code

//Program to illustrate Anonymous Inner class by extending other class class Tuf < public void display() < System.out.println("Inside the TUF class"); >> class AnonymousDemo < public void createClass() < // creation of anonymous class extending class Tuf Tuf p1 = new Tuf() < public void display() < System.out.println("Inside an anonymous class."); >>; p1.display(); > > class TestAnnonymousInner < public static void main(String[] args) < AnonymousDemo an = new AnonymousDemo(); an.createClass(); >>

Output: Inside an anonymous class

By Implementing Interface:

Java Code

//Program to illustrate Anonymous Inner class by implementing interface class TUF < public static void main(String[] args) < //Anonymous Inner class that implements interface Runnable r = new Runnable() < public void run() < System.out.println("Child!"); >>; Thread t = new Thread(r); t.start(); System.out.println("Parent!"); > >

Output:
Parent!
Child!

Difference Between Regular and Anonymous Inner Class

• A general class can implement any no. Of interfaces at a time. Anonymous inner class can implement only one interface at a time.
• With anonymous we cannot write a constructor because the anonymous inner class does not have a name and the name of the constructor should be the same as the class name.

Important point:

• Anonymous class has no name
• It can be instantiated only once
• It is usually declared inside a method or a code block, with curly braces ending with a semicolon.
• It is accessible only at the point where it is defined.
• It does not have a constructor simply because it does not have a name
• It cannot be static

Special thanks to Amisha Kumari for contributing to this article on takeUforward. If you also wish to share your knowledge with the takeUforward fam, please check out this article

Источник

Anonymous Classes

Anonymous classes enable you to make your code more concise. They enable you to declare and instantiate a class at the same time. They are like local classes except that they do not have a name. Use them if you need to use a local class only once.

This section covers the following topics:

Declaring Anonymous Classes

While local classes are class declarations, anonymous classes are expressions, which means that you define the class in another expression. The following example, HelloWorldAnonymousClasses , uses anonymous classes in the initialization statements of the local variables frenchGreeting and spanishGreeting , but uses a local class for the initialization of the variable englishGreeting :

public class HelloWorldAnonymousClasses < interface HelloWorld < public void greet(); public void greetSomeone(String someone); >public void sayHello() < class EnglishGreeting implements HelloWorld < String name = "world"; public void greet() < greetSomeone("world"); >public void greetSomeone(String someone) < name = someone; System.out.println("Hello " + name); >> HelloWorld englishGreeting = new EnglishGreeting(); HelloWorld frenchGreeting = new HelloWorld() < String name = "tout le monde"; public void greet() < greetSomeone("tout le monde"); >public void greetSomeone(String someone) < name = someone; System.out.println("Salut " + name); >>; HelloWorld spanishGreeting = new HelloWorld() < String name = "mundo"; public void greet() < greetSomeone("mundo"); >public void greetSomeone(String someone) < name = someone; System.out.println("Hola, " + name); >>; englishGreeting.greet(); frenchGreeting.greetSomeone("Fred"); spanishGreeting.greet(); > public static void main(String. args) < HelloWorldAnonymousClasses myApp = new HelloWorldAnonymousClasses(); myApp.sayHello(); >>

Syntax of Anonymous Classes

As mentioned previously, an anonymous class is an expression. The syntax of an anonymous class expression is like the invocation of a constructor, except that there is a class definition contained in a block of code.

Consider the instantiation of the frenchGreeting object:

HelloWorld frenchGreeting = new HelloWorld() < String name = "tout le monde"; public void greet() < greetSomeone("tout le monde"); >public void greetSomeone(String someone) < name = someone; System.out.println("Salut " + name); >>;

The anonymous class expression consists of the following:

• The new operator
• The name of an interface to implement or a class to extend. In this example, the anonymous class is implementing the interface HelloWorld .
• Parentheses that contain the arguments to a constructor, just like a normal class instance creation expression. Note: When you implement an interface, there is no constructor, so you use an empty pair of parentheses, as in this example.
• A body, which is a class declaration body. More specifically, in the body, method declarations are allowed but statements are not.

Because an anonymous class definition is an expression, it must be part of a statement. In this example, the anonymous class expression is part of the statement that instantiates the frenchGreeting object. (This explains why there is a semicolon after the closing brace.)

Accessing Local Variables of the Enclosing Scope, and Declaring and Accessing Members of the Anonymous Class

Like local classes, anonymous classes can capture variables; they have the same access to local variables of the enclosing scope:

• An anonymous class has access to the members of its enclosing class.
• An anonymous class cannot access local variables in its enclosing scope that are not declared as final or effectively final.
• Like a nested class, a declaration of a type (such as a variable) in an anonymous class shadows any other declarations in the enclosing scope that have the same name. See Shadowing for more information.

Anonymous classes also have the same restrictions as local classes with respect to their members:

• You cannot declare static initializers or member interfaces in an anonymous class.
• An anonymous class can have static members provided that they are constant variables.

Note that you can declare the following in anonymous classes:

• Fields
• Extra methods (even if they do not implement any methods of the supertype)
• Instance initializers
• Local classes

However, you cannot declare constructors in an anonymous class.

Examples of Anonymous Classes

Anonymous classes are often used in graphical user interface (GUI) applications.

Consider the JavaFX example HelloWorld.java (from the section Hello World, JavaFX Style from Getting Started with JavaFX). This sample creates a frame that contains a Say ‘Hello World’ button. The anonymous class expression is highlighted:

import javafx.event.ActionEvent; import javafx.event.EventHandler; import javafx.scene.Scene; import javafx.scene.control.Button; import javafx.scene.layout.StackPane; import javafx.stage.Stage; public class HelloWorld extends Application < public static void main(String[] args) < launch(args); >@Override public void start(Stage primaryStage) < primaryStage.setTitle("Hello World!"); Button btn = new Button(); btn.setText("Say 'Hello World'"); btn.setOnAction(new EventHandler() @Override public void handle(ActionEvent event) System.out.println("Hello World!"); > >); StackPane root = new StackPane(); root.getChildren().add(btn); primaryStage.setScene(new Scene(root, 300, 250)); primaryStage.show(); > >

In this example, the method invocation btn.setOnAction specifies what happens when you select the Say ‘Hello World’ button. This method requires an object of type EventHandler . The EventHandler interface contains only one method, handle. Instead of implementing this method with a new class, the example uses an anonymous class expression. Notice that this expression is the argument passed to the btn.setOnAction method.

Because the EventHandler interface contains only one method, you can use a lambda expression instead of an anonymous class expression. See the section Lambda Expressions for more information.

Anonymous classes are ideal for implementing an interface that contains two or more methods. The following JavaFX example is from the section Customization of UI Controls. The highlighted code creates a text field that only accepts numeric values. It redefines the default implementation of the TextField class with an anonymous class by overriding the replaceText and replaceSelection methods inherited from the TextInputControl class.

import javafx.application.Application; import javafx.event.ActionEvent; import javafx.event.EventHandler; import javafx.geometry.Insets; import javafx.scene.Group; import javafx.scene.Scene; import javafx.scene.control.*; import javafx.scene.layout.GridPane; import javafx.scene.layout.HBox; import javafx.stage.Stage; public class CustomTextFieldSample extends Application < final static Label label = new Label(); @Override public void start(Stage stage) < Group root = new Group(); Scene scene = new Scene(root, 300, 150); stage.setScene(scene); stage.setTitle("Text Field Sample"); GridPane grid = new GridPane(); grid.setPadding(new Insets(10, 10, 10, 10)); grid.setVgap(5); grid.setHgap(5); scene.setRoot(grid); final Label dollar = new Label("$"); GridPane.setConstraints(dollar, 0, 0); grid.getChildren().add(dollar); final TextField sum = new TextField() @Override public void replaceText(int start, int end, String text) if (!text.matches("[a-z, A-Z]")) super.replaceText(start, end, text); > label.setText("Enter a numeric value"); > @Override public void replaceSelection(String text) if (!text.matches("[a-z, A-Z]")) super.replaceSelection(text); > > >; sum.setPromptText("Enter the total"); sum.setPrefColumnCount(10); GridPane.setConstraints(sum, 1, 0); grid.getChildren().add(sum); Button submit = new Button("Submit"); GridPane.setConstraints(submit, 2, 0); grid.getChildren().add(submit); submit.setOnAction(new EventHandler() < @Override public void handle(ActionEvent e) < label.setText(null); >>); GridPane.setConstraints(label, 0, 1); GridPane.setColumnSpan(label, 3); grid.getChildren().add(label); scene.setRoot(grid); stage.show(); > public static void main(String[] args) < launch(args); >>

Источник

How to declare a constructor inside of anonymous class?

posted 11 years ago

How to declare a constructor inside of anonymous class?

Bartender

posted 11 years ago

• 1

A constructor is declared using the class’s name. An anonymous class, by definition, does not have a name.

What you can do, however, is declare an instance initializer, just like you might do in a named class.

Marshal

posted 11 years ago

• 1

You can’t declare a constructor for an anonymous class, because the name for a constructor must be the same as the name of the class. And since the class in question has no name, you can’t declare a constructor for the class.

But let me answer the question which might have led to this question: how do I initialize the state of an object which is an instance of an anonymous class? And the answer is to use an instance initializer. Like this:

posted 11 years ago

Why do you need a constructor in your anonymous class anyways? Can’t you do your initialization outside your anonymous class?.

posted 11 years ago

Jayesh A Lalwani wrote: Why do you need a constructor in your anonymous class anyways? Can’t you do your initialization outside your anonymous class?.

I dont need.
Just had a question about the language.
I’ve thought that it was not possible, and would just like a confirmation.

posted 11 years ago

• 1

posted 11 years ago

Jayesh A Lalwani wrote: Why do you need a constructor in your anonymous class anyways? Can’t you do your initialization outside your anonymous class?.

Explaining how the question had been originated, I had the following situation:

Class AA had two constructors, a default constructor and one with a String argument.

Creating an anonymous class, subclass of AA, i wish to call super(«Hello!!») within the constructor of the anonymous class, without to pass a parameter to the subclass instantiated.

The code above prints «default». So how to print «Hello!!», Invoking the constructor with arguments ?
The code below prints «Hello!!»

Now, how to do prints «Hello!!» invoking super(«Hello!!»)? I would need a constructor in anonymous class.

Thus arose the question raised, and the final conclusion was that this is not possible.

Источник