We saw the power of rapidly being able to implement the pattern

by looping through subscribers using our parameter as list.

Well there is, in fact, a growing movement to make that even quicker.

Functional programming has been around for a long time, but

it's relatively new to the Java world.

So there are newer patterns forming that are leaning on this powerful,

succinct approach.

Let's give it a whirl.

If you haven't played around with Java 8's functional programming side of things,

I hope that this example will encourage you to explore it a bit.

Now our final project for this workshop is going to explore an Olympics tracking app.

So we have a class called GoldMedalReporter.

Let's open that up.

So under gold-watcher here, there's GoldMedalReporter, and

it's a pretty bare bones class, right?

It's just for demo purposes,

it has a single method, it's called reportWin, and basically,

it just says the gold medal was awarded to whatever country was best at it, right?

So, we have all these other tools that we would like to integrate with this, right?

So, over here under tools, we have this, what is a Twitter client called Tweeter.

You can imagine that this can x out to the API, but basically,

it takes whatever message was passed out and sends it to Twitter.

There's also an LED light bulb that's here and you pass in an array of colors.

It's using this var args pattern, so what happens is an array will come in here, and

then we're going to use a Java 8 stream to collect and

make it comma-separated, basically.

More in the teachers notes on that if you're interested.

And finally, we have one of these huge screens that gets fans all worked up,

called a MegaTron.

And basically,

whatever you pass in, it says, Let's hear it for whatever was passed in.

Yeah, MegaTron.

Such a funny name for that, that that stuck, MegaTron.

So, anyway, the method here just roots for whatever you give it, right?

So, what we want, we want all these different tools to do their

thing when a gold medal happens, right?

When one of these wins are reported, we want these tools to do their thing.

Now it's a fairly specific to the tool type of method that we want to

take off, right?

Now we could do this by creating a base class, and

maybe we could mix in the adapter pattern and make them all look similar.

Or we could create a specific function for our use case.

So let's try that first.

So In the GoldMedalReporter, right,

we want to first create a way to add an observer-like function.

Okay, so let's do that, let's just say

public void, and we'll say addObserver.

The observer that's gonna be added here is like we just talked about,

it's a specific function.

So Java 8 introduced the concept of functional interfaces,

which allows you to specify an expected method signature.

So what we're gonna do is we're gonna use a functional interface that expects

a single string pattern and returns nothing.

So that type of interface is called a consumer, and

its type here that you specify is what the first parameter is.

So that was a string, and we'll call this observer.

Now we want to provide an easy way to remove these, so

the typical implementation in removing these is by passing in the observer.

But, we are going to be providing probably a lambda or

an anonymous function, so removing it by value is gonna be a little tricky.

So let's have the registering of observers need to add a key as well.

So we'll say String key.

So you'll name it and

then pass in the function, so it's like naming an anonymous function.

So we have a key and a value that we want to store.

That sounds pretty much like a map to me.

So let's add a new class up here, we'll say private map, and it's gonna be String,

which is the name of the function that we're going to give it, and Consumer.

This is the values, right?

So the value is going to be Consumer that we talked about.

It is a Java util map, and we'll call it observers.

And we'll say new HashMap.

Cool.

So now in our addObserver what that looks like is observers.put,

and we'll pass in the key and the observer.

Here we go.

So now our map is of name to function.

And we could very easily now remove as well.

Right, so we'll say public void removeObserver(String key) and

we'll say observers.remove, and you pass it a key.

And now we've got registering and unregistering of functions.

Now we need to notify the observer.

Let's make it clear, right?

Let's let people know that we're using the observer pattern.

So we'll say, notifyObservers.

And that's gonna take the country, right?

That's the string that we wanna pass in.

We're gonna pass in a country.

And all right, so we have a map.

And the values of the map are functions, right?

So observers.values.

And for each of those, so we'll get back a function.

And we want to call the method that was passed in, and

for a consumer, that's called accept, right.

And the reason why it's called accept is because it accepts the value that

was passed in, which in our case is gonna be country.

So in our reportWin, let's just go ahead and we'll say notifyObservers,

and we'll also pass in the country there.

Cool, so again, this is gonna loop through each of the functions that were passed in,

for each of the functions that's going to call the function, passing it the country.

Awesome, so let's do the Twitter one first.

So let's pop back into the examples here, and we have a reporter object,

so I'm gonna say reporter.addObserver, and let's call this observer tweet.

I think that makes the most sense.

So we could get that key out later.

And now it's asking for a consumer, and remember,

a consumer is a method that takes a string and returns nothing.

So we should be able to just say country.

Now because this is a lambda,

there is only one value we don't need to parentheses.

We're gonna say Tweeter.tweet and let's see,

we'll say country, Just won the Gold!

#olympics.

And it doesn't know what Tweeter is, so there we go.

Let's see if we can make this a prettier.

Screen is pretty tiny, let's do this, too.

Bring that up on one line here, and we'll put a semicolon at the end.

Okay, awesome.

So we've added observer, that will take a country and then call the tweet.

So let's do the next one.

Let's do the Megatron.

So the key is definitely gonna be megatron,

addObserver megatron.

And basically all we want to do, remember, this one just cheers for

whatever was passed in.

Basically, all we want to do is just pass in country to this method, right?

So because the method signature of that display method is actually a consumer,

right, it's actually the same.

A method that returns nothing and

accepts the string, we can just use the method reference, right?

So if I do megaTron:: that says,

I'm talking about a specific method, and the method is display.

So what that will do is it will, when it's observed,

it will pass the value into this instance.

Pretty cool, right?

Okay, and finally let's go ahead and

add an observer for our lights, LED light.

So, it's gonna take a country.

And we have a lights variable here.

So I wanna say light.flashColors.

And we need to access another method that's outside of this,

but that's okay, right?

We can call methods from inside of a lambda, so

we'll call colorsByCountry.get country,

and we'll hope that whatever is passed matches.

Right now it's only USA and Brazil.

Other countries do matter, I just didn't take the time to fill that out.

Just so you know, everybody, you matter.

And I just wanted to point out that these methods could be as complicated

as we need.

But most of the time, they would probably end up looking a lot like this, right?

They're pretty small little methods.

No new classes, very light interface, and

we did a good job of conveying that these are in fact observers, right.

We have all this addObserver language.

Let's go ahead and let's run this.

So I'm gonna click this Run 'Example.main()', and boom,

the gold medal has been awarded to the USA.

Let's hear it for the USA.

USA won the gold, #olympics, flashing red, white and blue.

Awesome, right?

We just went for the gold and we won.

So keep your eye out for

more patterns being applied in this more declarative style.

Do remember that these functions are closures, right?

So any value that's put in here will be captured, will be closed over.

So this approach, as well as the last one, will keep objects alive and

safe from garbage collectors.

So it's very possible to cause a memory leak if you aren't careful,

of removing observers when they're no longer needed.

So what do you think?

Pretty quick to implement, isn't it?

So now that you've seen the evolution of this pattern over time,

I hope you've got a really solid understanding of why you should use it,

as well as how to make the magic happen.