Visual Studio Game - Find Sea Animals Assignment Sample

• Type Assignment
• Downloads684
• Pages4

Introduction: Visual Studio Game - Find Sea Animals

Get free samples written by our Top-Notch subject experts for taking online assignment services.

Design Justification

In "traditional" object-oriented programming, it has been shown to be effective to explicitly explain the data structure or functionality of objects by making use of templates, for instance in the form of classes. This has shown to be a successful approach. Because each object is an instance of a class, all of the fields, methods, events, and so on that are specified for that class are available to that object. This approach is often used with other aspects of object orientation, such as data encapsulation, inheritance, polymorphism, different patterns, interfaces, early or late binding, and so on.

In certain languages, such as JavaScript, PHP, and Python, it is possible to dynamically assign attributes, functions, or arrays to objects during the runtime. This is an alternative to the template-based type declaration that is available in other languages. Therefore, attributes like first name and last name in the sense of public string variables with values may be assigned at any time, modified whenever necessary, and evaluated once again whenever desired without the need for such fields to be declared in any template in advance. For a very long time, object orientation has been considered the standard practise for the creation of computer programmes.

This is true for all kinds of applications, but it is particularly important to remember this while developing business software. Nearly all of today's programming languages support the key qualities of this method, which was described earlier. As a result, having a firm grasp on this programming paradigm and being able to demonstrate that you can do so securely should be considered a fundamental need for potential developers. In the beginning of the essay, a general introduction to the concept of object-oriented programming and its history is provided. When one has this level of comprehension, it is much simpler to cope with the specifics.

We immediately investigate the implementation in the programming language C# given that it is most effective to learn from examples that are straightforward. This chapter of the article series will be finished up with a workout. Understanding the software in terms of objects that are influenced by the circumstances of the physical world is the foundation of object-oriented programming. These things have attributes that provide a more in-depth description of who and what they are, and they may also carry out a variety of actions. They are able to have conversations with one another and maintain certain kinds of relationships with one another. For instance, the same blueprint might be used for several identical items.

Weakness and Strengths of System

Every entity is an object that communicates with other things. Because of this, OO lays a significant emphasis on the objects, which is also reflected in the process of OO design known as verb/noun analysis. This is used in the process of designing object-oriented software. To do this, you will need to have specified use cases on hand and will need to mark all of the nouns and verbs that correspond to the defined use cases. It is therefore argued that all nouns become objects or classes, and that the verbs, which are subordinate, are tied to these objects as procedures. This explanation is a rough simplification. Because this is truly a subject that falls within the purview of software engineering, I'm not going to go into any more depth about it here. However, what we notice about this design technique is that the verbs are placed in a subordinate position to the nouns.

The first point of criticism, which is more philosophical in nature, is then also directed specifically at the lack of verbs: We have, for many years, adhered strictly to the OO design philosophy, which directs us to concentrate only on the objects and to construct our programme on the basis of how we may assign everything to specific objects. But this is precisely why verbs, which refer to activities or acts, have not lost any of their significance. However, the object-oriented paradigm compels us to do so, at least if you adhere to its tenets in an unwavering manner, which states that actions (verbs) can never take place independently.

Instead, they are constantly led by an item that is, so to say, attached to a leash. This forced coupling subsequently results in various points of criticism that may be attributed to the OO paradigm. Those criticisms can be found in the following sentences. For instance, the issue of which object certain actions (we'll refer to them as functions again) need to be associated with is brought up by some activities.

Which part of the structure should the "biggest common divider" function be attached to? Should it be a method that deals with integers? What about other objects that have the same characteristics as integers but do not inherit from the Integer class? Should she bring her own method for her to implement? What steps should someone take if they are thinking about developing a new algorithm that works with integers? It is not possible to simply add a method from the outside to an existing class that has been declared in C#. This whole situation is challenging. Because of this, the approach that is often selected to deal with this issue is classes that only have static methods.

However, you should never actually instantiate these classes since they simply act as containers for static methods. The class in C# is a perfect illustration of this principle since it encapsulates all of the fundamental mathematical operations. At this stage, the notions of the object-oriented paradigm are being abused in order to deceitfully go around the rules of object-oriented design, which are being purposefully avoided. This pattern, in which ideas that should be utilised in a different way are exploited to get around difficulties with the design principles, will be seen even more often in the future. Many times, we refer to these innovative approaches to a problem as design patterns and we publish books about them