Overview #

In this tutorial we work on the implementation of the basic observer pattern from Part 1 of this tutorial series. The tutorial is intended for Java®¹ beginners and hence also explains some basic concepts of the Java language in the context of this scenario.

Video #

Implementation #

Project #

We begin with “Create Java Project”, choose “No build tools”, select the location of the project in the file system, and give the project the name “Observer”.

Packages #

Within the src folder of the Java project we create a package with the name com.example.newsbroker.

The package serves as the namespace for our Java classes. By convention, packages in Java are prefixed with the reverse domain name of an organization and are all lowercase. This helps to keep namespaces unique across organizations and avoid conflicts with classes. Each dot separated element in a package name is represented as an own directory, i.e., the package com.example.newsbroker is represented in the file system as folder hierarchy

com
└── example
    └── newsbroker

Classes #

Next, we create the Java classes NewsAgency and NewsChannel in the previously created package. By convention, Java class names use camel case notation beginning with an uppercase letter.

The fully qualified name of a class is assembled in Java with the package name and the class name. Hence, a class NewsAgency residing in the package com.example.newsbroker has a fully qualified name of com.example.newsbroker.NewsAgency. It is represented in the filesystem as a file within the package directory.

com
└── example
    └── newsbroker
        └── NewsAgency.java

In Java, each class needs to reside in exactly one file. In other words, no two classes can reside in one single file. The first statement in a class file needs to be the package the class belongs to.

package com.example.newsbroker;

public class NewsAgency {

}

Constructors #

To create an instance of a class, constructors are needed in Java. Constructors are named after the class name, do not have a return type, and initialize the class instance that is to be created. Class instances are also referred to as objects of a class. In our model, each class gets a private property name that helps to identify our objects. By convention, properties of a class use camel case notation beginning with a lower case letter. In the constructor, we initialize the private property name with the name parameter from the constructor’s arguments. Members of an object, i.e., owned properties, methods and the like, are accessed with the this keyword in Java. So the private property name is accessed and initialized in the constructor with this.name = name.

...

public class NewsAgency {

    ...

    private final String name;

    public NewsAgency(String name) {
        this.name = name;
    }

    ...

}

...

All classes in Java have a standard constructor that has no arguments. In case where no special implementation of a constructor is needed, the declaration of the constructor can be omitted. Every declared constructor implicitly calls the no-arguments super constructor of a class. Hence, calling the no arguments super constructor can be omitted. Above declaration is qual to an explicit call of the super constructor.

...

public class NewsAgency {

    ...

    private final String name;

    public NewsAgency(String name) {
        super();
        this.name = name;
    }

}

...

Having name as a private property and initialize it within the constructor allows to give an object an identity at object creation which cannot be altered by non-members of the object. Making the property final also protects name from being altered by members of the object.

In general, final properties can be initialized in the constructor only once and become immutable after initialization. It is considered good practice to make properties - also referred to as member variables - final in case they do not need to be altered during the lifetime of the object.

Inheritance #

In addition to our class diagram we also implement the toString() method which overrides the standard implementation of the toString() method in the super class. In Java, every class implicitly inherits from the java.lang.Object class, the root class of all Java classes.

By convention, method of a class use camel case notation beginning with a lower case letter.

    ...

    @Override
    public String toString() {
        return this.name;
    }

    ...

The toString() method is always called by the Java runtime when a stringified version of an object is required. This allows to use an object directly as an argument to, e.g., System.out.println() calls. The standard implementation of the toString() method returns a string comprising of the fully qualified class name and the object reference separated by an @, e.g., newsbroker.NewsChannel@15db9742. It can be useful during debugging sessions because the returned string uniquely identifies an object.

Please recognize the @Override annotation to the toString() method. Annotations in Java are flexible metadata to a specific Java construct - as in our case - an overridden method. It explicitly marks the method of a class to override a method in it’s super class. While @Override is not mandatory for overridden methods, it helps to improve readability. Moreover, it also serves as a hint to the compiler. When applied to a method that does not have an implementation in the super class, the compiler issues an error. Conversely, when not applied to an overridden method, the compiler issues a warning.

Methods #

We continue with the implementation of the subscribe and unsubscribe methods of the NewsAgency class according to the class diagram. The NewsAgency class uses a property channels of type List from the java.util package of the standard library to remember the subscribed NewsChannels. The channels property is initialized in the constructor of the class. It is the implementation of the modeled association between the NewsAgency class and the NewsChannel class.

To make the java.util.List class available in the current class implementation, it needs either be referenced by the fully qualified class name or imported into the scope of the current package with the import java.util.List; statement directly after the package declaration.

package com.example.newsbroker;

import java.util.List;

...

public class NewsAgency {

    ...

    private final List<NewsChannel> channels;

    public NewsAgency(String name) {
        
        ...

        this.channels = new ArrayList<NewsChannel>();
    }

    public void subscribe(NewsChannel channel) {
        this.channels.add(channel);
    }

    public void unsubscribe(NewsChannel channel) {
        this.channels.remove(channel);
    }

    ...

}

...

List is a generic container class which can be declared to contain a list of objects of specific classes by adding the respective class between angle brackets. In our case, channels contains objects of class NewsChannel and hence the property is declared as type List<NewsChannels>. Using generics allow Java to enforce it’s strong type systems in classes of generic purpose such as the container classes of the standard library.

Finally, we implement the broadcast method of the NewsAgency class. It iterates over all the subscribed NewsChannel objects in the channels list using a for loop. The for loop reads as “for each channel of type NewChannel in the list of channels, run the statements in the curly brackets. In our case we call the notify method of each subscribed NewsChannel object.

...

public class NewsAgency {

    ...

    private final List<NewsChannel> channels;

    ...

    public void broadcast(String news) {
        for (NewsChannel channel : channels) {
            channel.notify(news);
        }
    }

    ...

}

...

The notify method of the NewsChannel class simply prints the notified news to the console.

...

public class NewsAgency {

    ...

    public void notify(String news) {
        System.out.println(news);
    }

    ...

}

...

With that accomplished we now have implemented the basic observer pattern.

Program Entry #

Now, we implement the main method of our App and instantiate the NewsChannel and NewsAgency classes to take the observer into operation.

...

import com.example.newsbroker.NewsChannel;

...

public class App {

    ...

    public static void main(String[] args) throws Exception {

        ...

        // instantiate the news agencies
        var apa = new NewsAgency("APA");
        var reuters = new NewsAgency("reuters");

        // instantiate the news channels
        var orf = new NewsChannel("orf.at");
        var nzz = new NewsChannel("nzz.ch");
        var nytimes = new NewsChannel("nytimes.com");

        ...

        // subscribe to APA
        apa.subscribe(orf);
        apa.subscribe(nzz);

        // subscribe to Reuters
        reuters.subscribe(nytimes);
        reuters.subscribe(nzz);

        ...

        // broadcast news
        apa.broadcast("Auf der Suche nach der nächsten Regierung");
        reuters.broadcast("Harris campaign raises $55 mln over two weekend events, campaign official says");

    }

    ...

}

...

In Java, the entry point to an application is the main method. The main method is a class method that can be called without an instance of the class. The static keyword declares a method as a class method.

Class methods do not have access to instance members such as properties or instance methods using this, because the scope of a static method is the class and not an object. However, class methods have access to static class properties.

The runtime hands over the command-line argument to the main via the args parameter. The argsparameter is of type String[] which is an array of strings. The main method may throw and Exception. More on exceptions will follow in a later tutorial.

Objects respectively instances of classes are created with the new keyword followed by the class that shall be instantiated. During instantiation, the Java runtime calls the constructor of the class and initializes the class. Every property that is not explicitly initialized is initialized with its null value. After instantiation, the methods on the instance can be called.

When main returns, the program exits and all processes and reserved memory is released again.