CODEWITHSUNDEEP
java
Somebody
Somebody

Reputation: 9645

Java modifying class on the fly (adding new method)

Is there a way to modify class instance in Java? For example I want to provide custom callback method.

How is it possible to provide separate method/context/scope for each instance of a class?

In javascript it's easy to modify an existing class. It's easy to pass an anonymous function as callback to any method as well. With it's context and scope.

Or do I have to extend my custom class for every request if I need a different callback?

Upvotes: 1

Views: 535

Answers (3)

emecas
emecas

Reputation: 1586

You can get frustrated easily, due classic nonfunctional Java is not for those run time goals you have mentioned.

But indeed, you can implement callback in java by using an interface like this:

Ref: CALLBACK PATTERN IN JAVA ENVIRONMENT

For example, suppose you want to be notified when an event happens.

You can define an interface like this:

public interface SomeEvent{
    // A regular method, it can return something or take arguments
    public void someEventMethod();
}

Then, define a class that will signal/notify the event, It needs to expect objects that implement the SomeEvent interface and then invoke the someEventMethod() method as appropriate.

public class EventNotifier{
    private SomeEvent se;
    private boolean somethingHappened; 
    public EventNotifier (SomeEvent event){
         //Save the event object for later use.
         se = event; 
         // Nothing to report yet.
         somethingHappened = false;
    } 
    //...  
    public void doWork (){
        //Check the predicate, which is set elsewhere.
        if (somethingHappened){
             //Signal the even by invoking the interface's method
             se.someEventMethod();
        }
        //...
    } 
    // ...
}

Finally, write some code that expects to receive the event notification, it must implement the SomeEvent interface and just pass a reference to itself to the event notifier, like this:

public class CallMe implements SomeEvent{
    private EventNotifier en; 

    public CallMe (){
         //Create the event notifier and pass itself to it.
         en = new EventNotifier (this);
    } 

    //Define the actual handler for the event
    public void someEventMethod(){
         // Some event interesting must have occurred
         // Do something...
    } 
}

Upvotes: 0

abl
abl

Reputation: 5958

Java and Javascript are very different languages. You'll be very frustrated if you try to apply to one a programming paradigm that works in the other. I too was very frustrated with Javascript at the beginning, coming from Java, until I understood the fundamental differences between dynamic and static languages.

In this particular case I don't think it's a good idea to extend your class every time you need to use a different callback, as it would result in a large number of subclasses. If you need a lot of objects that differ only on a particular aspect, wouldn't it be better to have a class or interface that represents that particular aspect?

A possible solution (but not the only correct one by any means) would be to use the Strategy pattern: define an interface that represents a callback and implement the interface for every different callback you need. You can then pass those callbacks as parameters just as you do in Javascript, with the exception that those callbacks won't be able to access any non-public member of the class that calls them.

Also be sure to take a look at the Apache Commons Functor library, which is essentially about having objects that represent functions. I've never used it but, being Apache Commons, it sure would be my first stop if I had your requirements.

Upvotes: 1

Marcel Gwerder
Marcel Gwerder

Reputation: 8520

You can do it on instantiation like:

Whatever w = new Whatever("Something") {
    public void onWhateverDoThis() {
        //...
    }
};

So where I personally used it recently were callback methods of a modal:

ModalManager.show(new Modal("Title", "Text") {
    public void onDismiss() {
        //Do something on dismiss
    }

    public void onConfirm() {
        //Do something on confirm
    }
});

Upvotes: 5

Related Questions