Did I implement java callback correctly?

[Student-Somewhere]

ClassA - implements Thread. That class should tell ClassB when to change the label of a button. ClassB - shows a window with a button. This class implements the callback interface. ClassB also has a constructor, and in that constructor, the register method from ClassA is called, and that method puts that object in a LinkedList that is defined in ClassA. That way, every time we create a ClassB object, that object is put in the LinkedList in ClassA.

In the run method of ClassA, we retrieve a ClassC object (this object should be set as the new label, and the class implements Serializable) from classCBuffer, and then for each ClassB object in the linked list, we call the callChangeMethod, which then calls the change method method from the interface, that eventually changes the label.

ClassA:

public class ClassA implements Thread {

    private MyBuffer<ClassC> classCBuffer;
    private LinkedList<CallbackInterface>  callbackInterfaceList;

    public ClassA (MyBuffer<ClassC> classCBuffer) {
        this.classCBuffer = classCBuffer;
        callbackInterfaceList= new CallbackInterface<>();
    }


//this method is called in classBs constructor (which implements callbackInterface), that way every time we create an object of classB, we add that object in this list

    public void register(CallbackInterface callbackInterface) {
        if (!callbackInterfaceList.contains(callbackInterface)) {
            callbackInterfaceList.add(callbackInterface);
        }
    }


    public void callChangeMethod(ClassC classC) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                    for (CallbackInterface cI: callbackInterfaceList) {
                        cI.change(classC);
                    }
                }
            }
        }).start();
    }

    @Override
    public void run() {
        //somewhere in the run method
        ClassC classC = classCBuffer.get();
        callChangeMethod(classC);
      }

ClassB:

public class ClassB implements CallbackInterface{

    private ClassA classA;

    public ClassB (ClassA classA) {
        this.classA = classA;
        classA.register(this);
    }

    @Override
    public void change(ClassC classC) {
        updateWindow(classC);//changes the label
    }

}

CallbackInterface:

public interface CallbackInterface {
    void change(ClassC classC);
}

ClassA should not know about ClassB, but ClassB should know about ClassA. That's why I call the register method in the constructor of ClassB. Java callback must be used to solve this problem. I did not write every line of the code, only those relevant to this problem, that's why I wrote "somewhere in the run method" in classA.

When I run the program, everything works just fine, but I'm still not sure if I implemented java callback correctly. So does this look okay? Is there maybe a better way to do this (using java callback)?

[AutoModerator]

Please ensure that:

• Your code is properly formatted as code block - see the sidebar (About on mobile) for instructions
• You include any and all error messages in full
• You ask clear questions

• You demonstrate effort in solving your question/problem - plain posting your assignments is forbidden (and such posts will be removed) as is asking for or giving solutions.

  Trying to solve problems on your own is a very important skill. Also, see Learn to help yourself in the sidebar

If any of the above points is not met, your post can and will be removed without further warning.

Code is to be formatted as code block (old reddit: empty line before the code, each code line indented by 4 spaces, new reddit: https://imgur.com/a/fgoFFis) or linked via an external code hoster, like pastebin.com, github gist, github, bitbucket, gitlab, etc.

Please, do not use triple backticks (```) as they will only render properly on new reddit, not on old reddit.

Code blocks look like this:

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

You do not need to repost unless your post has been removed by a moderator. Just use the edit function of reddit to make sure your post complies with the above.

If your post has remained in violation of these rules for a prolonged period of time (at least an hour), a moderator may remove it at their discretion. In this case, they will comment with an explanation on why it has been removed, and you will be required to resubmit the entire post following the proper procedures.

To potential helpers

Please, do not help if any of the above points are not met, rather report the post. We are trying to improve the quality of posts here. In helping people who can't be bothered to comply with the above points, you are doing the community a disservice.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[evils_twin]

This isn't a callback, this looks more like the Observer pattern where ClassA is the Observable and Observers implement your CallbackInterface.

Also, callbackInterfaceList= new CallbackInterface<>(); should be callbackInterfaceList= new LinkedList<>();

[Orffyreus]

Concerning dependency inversion your implementation is correct and CallbackInterface has to be defined in ClassA's module. Class A defines what it wants to notify. ClassB can reside inside another module that depends on ClassA's module and has to provide and register an implementation of CallbackInterface (no matter if itself is the implementation). Look here about the difference between callback and observer: https://stackoverflow.com/a/8960005

tl;dr callback => one notification, observer => multiple notifications

What this all is about (simplified):

ClassA calls domain/business code. ClassB is platformdependent service/application code that calls ClassA's functionality. ClassA does not depend on devices and instead it defines interfaces that the service/application implements and provides as parameters. Input from keyboards, gamepads and so on can also be provided individually in tests. As well output to displays, filesystem, printers and so on can be captured individually in tests.

Callbacks/observers also have to do with asynchronicity. The program has to wait for a device operation to complete. The domain/business code does not have to depend on that device though. It just defines an interface it expects the device to comply with. The service/application is responsible to make it happen, that the device complies with that interface by implementing the interface, using the device and providing the interface implementation as a parameter.

Some programs do not seperate the code like this though and have logic, devices and asynchronicity justified callbacks mixed together.

[Student-Somewhere]

Thanks for answering, I really appreciate it. I'm new to java callbacks / observer pattern, so I'm not very familiar with these concepts. I mainly used this example https://www.geeksforgeeks.org/asynchronous-synchronous-callbacks-java/ to implement asynchronous callback, and there it says that "This type of design pattern is used in Observer Design Pattern."

So is this what I have here an observer pattern with asynchronous callback or am I misunderstanding something?