2. Choose  Rounded Rectangle Tool (Shift+U), make a vertical rectangle with color #2E69FF.

3. Choose Blending Option of the layer with the rectangle with the folowing settings:

4. Make the transparency of the Layer (Fill) to 20%.

5. Make a new layer. Keeping Ctrl, click the left button of the layer “shape”; pour selection with black and press Ctrl + D to deselect.

6. Go to Filter – Render – Lens Flare with settings Movie Prime and Brightness around 180, press OK.

7. Place the Blending Mode to screen.

8. You are ready

Made by RozerWebArt

2. Select the image using the appropriate tool according to it’s complicity.

3. Copy the selected object at new layer from the Layer – New  – Layer via Copy (Ctrl+J).

4. Turn it vertiсal using Edit – Transform – Flip Vertiсal.

5. Use Move Tool (V) to move the figure at the bottom of the page.

6. Add a Layer Mask by clicking on the third little icon at the Layers Panel.

7. Use Gradient Tool with Linear style and colors from black to white.

8. Do bottom – up line by holding Shift to make a straight line.

9. Low down the Opacity to  60%:

10. You are ready

Made by RozerWebArt

2. Select the clothes which color you want to change. You can use each one of the selection tools. I will use Select - Color Range.

3. Select the color you are going to change and using the Fuzziness slider control the range of the selection. Finish by pressing OK.

4. Take the Quick Selection Tool and precise the selection where it needs.

5. Go to Image – Image Adjustments – Hue Saturation.

6. You can choose the new color from the Hue slider.

7. When you are satisfied with the new color press OK and CTR+D to remove the selection.

8. You are ready.

Made by rozerWebArt

2. You must first unlock the Layer. Yow will do this by double clicking on the padlock located at Layer Palette.

3. Now select the Rectangular Marquee Tool and select an object of the picture you want to apply the effect.

4. Now choose the Gradient Tool and make a line from the upper right corner to bottom left. Colors must be from black to white. Remove selections with Ctr + D.

5. Go to  Edit – Transform - Warp.

6. Hold the bottom left corner and pull towards the middle. When you are ready press Enter.

7. You are ready

Made by rozerWebArt

2. Select Image – Adjustment – Desaturate (Shift+Ctrl+U), to turn it into a black and white image.

3. Go to Filter – Other – High Pass and change the Radius in range of 3 to 6 pixels. Changing the radius depends on the depth and the size of the picture.

4. Duplicate the layer (Ctrl+J) and change Blending Mode from Normal to Color Dodge.

5. You picture must look like that:

6. Go to Image – Adjustmet – Birghtness/Contrast to increase the contrast and to sharpen the contours.

7. You are ready

Made by RozerWebArt

2. Choose Filter – Render –  LightingEffects.

3. Select for Omni for Light type, move the slider of the Intensity to 50, change the color to ff7608 by clicking on the default color (box on the right of the slider with intensity).

4. Change the size of the light source by pulling the levers of a circle you see in the left window where image is located.

5. Make a new layer.

6. Take the Rectangular marquee tool and draw a rectangle at the end of the beach with color ff7608.

7. Change  Blending Mode to Overlay and low the Opacity to 44%.

8. Choose Filter – Blur – Motion Blur and set the following values Angel – 45, Distance – 129.

9. Use Edit – Free Transform to place it the way you feel it should be.

10. Your sunset is ready.

2. Make a new layer.

3. Take the  Gradient Tool. Choose the style  Linear Gradient – TransparentRainbow.

4. While pressing down the Shift key, make short vertical stroke in the middle of the picture. The direction should be from top to bottom.

5. Choose  Filter - Distort - Polar Coordinates. Tick Rectangular to Polar and pres OK.

6. To move the figures use the Edit – Free Transform (Ctrl + T). This way you can reduce or increase its size and move it to the appropriate location according to your picture.

7. Choose Filter - Blur - Gaussian Blur with Radius: 4.5px

8. Change  Blending Mode to Screen and low the Opacity to 80%.

9. Take a large soft round Brush with Hardness 0 and delete where you think it is necessary.

10. Your rainbow is ready.

2. Choose foreground and background color and with Gradient tool make something like
this:

3. Take Type tool and write the text you want

4. Right click on text in layer palette and choose blending option. In the window that will appear make the following settings.

5. Make a new layer and selection like this:

6. Now make another gradient with gradient tool with little different colors.

7. Press CTR+T for Free transform then right click and choose warp. From tool option choose flag and pres enter to apply the transformation.

8. With big soft brush in low opacity delete little from both sides to soften the edges.

9. From Window choose Animation to open the animation palette.

10. Now move line to the left with Move tool till it hide completely and then click Duplicates selected frames button in animation palette.

11. Move line with Move tool to the right so it hides again. Now select both frames in the animation palette (Ctr+click) and press tween.

12. In the window that will appear make following settings.

13. Select all frames in animation palette (select first frame, hold Shift and click on the last frame) then choose 0 sec. for delay and click on forever.

14. Now you are ready to save it. Choose File-Save for web and devices. In the window that will appear select Gif and press save.

15. New window will appear. Choose where do you want to save it and for Save as type select Images only (gif).

16. Open it in your web browser to see the result.

We have not created the Mediator class yet, but at least we know that the Layer class has two methods to send message and notify the sender. These abstract methods are implemented in the Application and Database classes. Notice how sending the message is not happening directly, but instead it is using the mediator to do so. This is the key in this pattern. We are using the ‘this’ keyword as a second parameter to know which class is sending the message.

Now, let’s look at the Mediator and ConcreteMediator classes:

Since the mediator needs to know which classes it is mediating, we need to have instances for the Application class and the Database class. Then inside the SendMessage() method, we need to determine the type of layer to be able to send the correct notification.

Now that all the classes have been created, we can look at the main() method to see how the calls are taking place:

We create instances of the three classes. We pass the mediator to the Application and the Database. We also used properties to set the application and database for the mediator. Finally, we send the messages. Here is the output:

2.      Observer: When developing applications, you most likely ran into cases when a change in the data store (database, xml file…) needs to be reflected in the UI. Say you have added a new account type and you need to update the account type drop down list. Or, when you are writing a game application, all the soldiers on the screen need to be aware of an enemy appearing from behind a tank. These examples have something in common: dependency. When one object changes state, other objects need to be notified to take action. This is the purpose of the observer pattern. As the name implies, an observer is an object “watching” other objects. As soon as these objects change somehow, the observer alerts the objects in its list about the change. The example we are going to tackle is about a list of employees that need to be notified when a meeting changes. So, let’s start by creating the Employee class and its interface:

As you can see, the Employee class has a Meeting class as a member (this will be declared soon).  The Update method will be called every time there is as update.

Here is the declaration for the Meeting class:

The key point here is that the Meeting class has a list of employees that can be notified of the change. The When property, upon a change (set), will notify this list. We can add and remove employees to be notifies using the methods Attach() and Detach(). The method Notify() will loop over the list and call the Update method. The BudgetMeeting class is nothing more than a concrete meeting.

Let’s see how we can use these classes:

You notice that we create a meeting, attach some employees, and change the time using When. Here is how the output will look like:

3.      Strategy: In this design pattern, you are looking at many algorithms to solve a certain problem. Any of these algorithms is a standalone solution that can be easily pluggable to get the job done. We can exchange any of these algorithms with minimal or no impact on the client that uses it. Let’s take, for example, the case of displaying students’ grades. We have different strategies on how these grades will be displayed (we can display them in ascending order, descending order, letters or numeric, and so on…). We will implement different strategies for that. Then, we will use these strategies in different contexts to get the ultimate job of displaying the grades.

In the first set of code, we will look at the different strategies, then the context, and finally, how to put the whole thing together in the main method. Here are the different strategies:

As you can see, we start with the abstract GradeStrategy that defines the skeleton. Then we move into the strategy that displays the grades in the ascending order. We passed a lambda expression to the ForEach loop. For every g (a grade that is) we print its value on the console. We do not have to define what g is. It is understood from the context. You could simply use a for loop and print the values without using lambda expressions, of course. Then, we move into defining the other strategies:

The other strategies follow the same pattern. But notice how I am using  the ConvertAll() method that takes a method that accepts number grades and covert them to letter grades.

After defining the strategies, we need to create a context that we can use to switch between the strategies depending on our needs. Here is how this class will look like:

This class is simple. It contains a GradeStrategy that we can set, and a list of grades that we can populate. Calling DisplayGrades() will call the method of the appropriate strategy that we already set. Now, the main method will make use of the context and the strategies as follows:

From the main method, you can notice that core concept behind this pattern: see how we can easily switch between strategies to get the job done. Finally, the output will be as such:

4.      Visitor: In this pattern, we have an operation that needs to be performed on the elements of a certain object. The terminology here is that the first object will “accept” a visitor, and the second object “visits” the first and performs some operation. The key point to keep in mind here is that you do not need the two objects to be tightly coupled. To illustrate, we look at the example of having a list of books. This list will accept a reviewer and a publisher. So, we have a book (with different variations like programming and database and such), a collection of these books, a reviewer visitor and a publisher visitor.

We start first by creating the books:

You notice that we create a Book, Programming, Database, and Design. The Book inherits from Publication, and accepts a Visitor (that we have not created yet). We passed ‘this’ into the Visit() method because the visitor is visiting the current class we are implementing. Everything else in the code is straightforward.

Before we look at the visitor classes, we need to create the book collection:

Here, we have added the flexibility of attaching and detaching books, and also adding the Accept() method so the visitor can visit the books in the collection one at a time.

Next, let’s look at the visitor classes:

The reviewer visits the book and simulates the review process, and the publisher visits the book and simulates the publishing process.

The main method puts them together nicely:

Now you can see how we attached a list of books to the books collection, and how the books collection then accepts two visitors (a reviewer and a publisher).

Conclusion: As the applications are getting more and more complex, the importance for design patterns is becoming more and more apparent. Every design pattern we experimented with in this article has its use in software development. As developers, we try to keep an eye on our applications and requirements to see where one of those design patterns would fit. Having said that, it is important to understand that just because these patterns are handy and well structured, it does not mean that we have to plug them all over the place. Selecting the appropriate design pattern for a specific scenario requires knowledge and experience. But when the correct pattern is used, you will definitely realize that your application is well structured and flexible to changes in user requirements to say the least.


Part 1 – Part 2 – Part 3 – Part 4