In this article I will introduce some of the most useful samples of object -based design. Design samples are solutions to common problems that appear repeatedly. These problems will appear in many different contexts, but the root is always the same problem.
A design pattern tries to explain the effective solution to the problem in a general way so that it can be applied to a specific set of conditions.
I will use Java to create an example of every pattern. I am assuming that you have some program of programming in Java. In particular, you should be familiar with the concepts of inheritance and polymorphism (at least somewhat). These design samples really show the power of inheritance and multilateral, so if you are just learning about these topics, this is a great opportunity to dig deep.
What if you are not a Java programmer? If you are familiar with any object -based language, you will probably still find a lot of examples. Give him a shot!
Code Playbox
LI to make design samples more accessible, I developed an interactive tutorial that uses interpreted Code Playbox Step phased phases to run through the key design pattern.
The sample of each design is presented as a playback that shows how a program changes with my explanation about what is happening in the program over time. This format helps you focus on the reasoning behind code changes.
You can access Code Playbacks’ Free ‘Book’:
OO design samples with JavaBy Mark Mahoni (this I am)
To view the code playback, click the comments in the left panel. Each comment updates the code in the editor and highlights any changes. Read the explanation and study the code. If you get stuck, use like an AI assistant tutor to help explain what is happening in the code.
More information about Code Playbacks, You can see a short demo here.
https://www.youtube.com/watch?v=uybhqcnjvdm
Key design samples you should know
The sample of the strategy
The sample of the strategy The algorithm is used to describe the ‘family’, to surround everyone and to discuss them. Software developers use a strategy style when they find out that there are many different ways to complete some behaviors. Instead of adding all different methods to the same class, they separate them into individual classes and plug them when necessary.
This program creates some classes to keep the ranks of students. Some instructors want to adjust the whole course rank to make them high. Some instructors do so except for each student’s lowest party. Other teachers ‘curve’ every assignment. Since there are numerous different options, so I will use it The sample of the strategy Let them isolated and choose the client who prefers them.
Start by seeing AssignmentFor, for, for,. StudentAnd Course Class Once you are familiar with basic classes, see when I change the code to enforce two different views Curved Grade using The sample of the strategy:
Singlon pattern
There are also times when you need to make sure that there is only one example of the class and it is accessible everywhere in your code. This is the problem Singlon pattern Solution
In this program, I will create a class that produces random numbers. I will trust Java’s built -in Random But when the test is in the form of a ‘test form’, it will be able to reproduce the same sequence of random numbers. I will ensure that there is only one example of this random number generator Singlon pattern:
Comprehensive sample
Often, we will create the entire/Part Containment Tree structure. For example, the file system has easy files. I call these simple elements, Ancient. We can group ancient people to form mass Composites. Files can be groups in directories. These composite (director) can still be groups in major composites, etc.
We can behave differently with composite and ancients. But often it is understandable to treat them alike. The difference in the types of objects makes the application more complicated.
Comprehensive sample Explains how to use a recipe recipe so that clients do not need to distinguish it.
This program creates a class to print using a rating reservoir of files and directories Comprehensive sample:
Decorator patterns
Sometimes we want to include responsibilities in individual items, not the whole class. Decorator patterns Allows us to make Decoration Providing a flexible alternative to inheritance to enhance the class.
In this program, I create an interface for login messages while running a program. I use the interface to make one ConsoleLogger Which prints the log messages on the screen. Then I began to add decorator objects that surround, or wrap ConsoleLogger. I add this to the date, the writer’s name and the time to attach the log messages in the log messages Decorator patterns:
State Sample
Sometimes there are systems that react differently on the basis of ‘state’ in which they are. Is enforced using this state -based behavior State Sample.
Let me show you how to transmit the characters in the string and analyze it to calculate the prices within it. For example, the following strings:
"hamburgers chips 'hot dogs' pickles 'french fries'"
Can be divided into such a combination:
("hamburgers", "chips", "hot dogs", "pickles", "french fries")
There are some ways to meet it in Java, but I will show a state -based approach. I will use it as an event and move it into different states when they face a single quote inside a wire State Sample:
Observer pattern
Observer pattern It is used when the refreshing of the same piece of data in one item is required to be stored in other items.
For example, when a cell value changes in the spreadsheet, many other cells may need to be notified of this change so they can update themselves. Likewise, when a user posted in a social network application, all their friends need to be notified so that their feeds can be updated. These two are basically the same problem Observer pattern Solution
This program creates a class that is called a time in a day called MyTime. Then I create two different types of Observers When time changes, it will be notified. Both observers will display each time again when it changes using Observer pattern:
Proxy pattern
Sometimes we design a set of items that have a client/server relationship, but later decide that both items should not directly interact. This program shows how to be used Proxy pattern Keeping some new functionality between the two classes that first cooperate.
I create a Card And Deck Class for card games. Deck Begins to host on the same machine as Driver. Then I divided Driver And Deck Class so that they can run on different machines using them Proxy pattern:
Factory pattern
Factory pattern Provides a procedure for the ‘family’ of fittings that without explaining their solid classes. In an application, sharpening of solid items makes it difficult to replace these items later.
In this program, I will develop two different classes of classes for the help system for two different computing platforms Factory pattern:
Visitors’ sample
Visitors’ sample It allows you to add functionality to classes without changing its interface.
The main reason for this is that there are times when we cannot change the current classification of classes. Maybe I’m using a classification of classes about which I am not in control but I want to add some new functionality to it anyway. This is the place where Visitors’ sample It comes in.
In this program, I would add functionality to this File And Directory Class University The program I wrote earlier in these classes with minimal changes.
I create a Minister To count the number of files and directory in a highest directory. Then I write a Minister Only to submit file names in a directory that includes its sub -directory Visitors’ sample:
Visitors’ sample Adding functionality to classes rating (file and directory)
Conclusion
I hope you enjoyed learning about object -based design patterns. If you are interested in other programming parables, you can see some of my other ‘books’. Here.
Questions and feedback are always welcomed: mark@playbackpress.com
If you want to support my work and help keep the playback press free for everyone, consider donating using Gut hub sponsors. I use all these donors to host the cost. Your help helps me continue to create such educational content. Thank you!