btec level 5 hnd diploma in computing unit 20 advanced programming4

It''''s worth noting that the MakeSound function in the Animal class is declared as virtual, allowing it to be overridden by child classes such as Cat.. We have an abstract Animal class wit

ASSIGNMENT 1 FRONT SHEET Qualification BTEC Level 5 HND Diploma in Computing

Unit number and title Unit 20: Advanced Programming

Re-submission Date 8/6/2023 Date Received 2nd submission

❒ Summative Feedback: ❒❒ Resubmission Feedback:

Lecturer Signature:

I Introduction

Advanced programming is a subject that encompasses all programming language paradigms and techniques Object-oriented programming (OOP) is a programming language model based on objects rather than procedures and data rather than reasoning Historically, a program was thought to be a logical method that takes input data, processes it, and outputs data

In this project, I was asked to create a software system for my organization; but, before I could do so, I needed to learn advanced programming concepts, be able to build patterns, and understand object-oriented programming solutions In addition, I will investigate the essential components of the object-oriented programming paradigm and study design pattern types In addition, I use a UML tool to develop and design class diagrams for certain design patterns Finally, I will examine the link between the object-oriented paradigm and design patterns and incorporate the findings into my paper

II Object-oriented programming and the various class relationships (P1)

1 Object-oriented programming

Object-oriented programming (OOP) is a vital programming method in today's world It is useful in the majority of commercial construction applications Object-oriented programming is supported by the majority of prominent programming languages and frameworks, including Java, C#, and.NET Most programmers have studied object-oriented programming in college, but the fundamental concepts of object-oriented programming do not always teach how to abuse the erroneous programming philosophy

Definition of OOP: Object-oriented programming is a programming method that allows programmers to design code objects that abstract real-world items This strategy is presently quite effective and has become one of the software development templates, particularly for corporate applications

We shall define classes to model actual objects while designing applications with OOP These classes will be initialized as objects in the program, and the methods of these objects will be called when the application is running

What is the class that defines the object? Methods and attributes are included An object is simply a class instance Classes communicate with one another via the public API's collection of methods and public attributes

2 Characteristics of OOP

a Abstraction

Abstraction is a non-specific attribute in Java that just names the problem It is the technique of concealing the inner workings of a thing and just displaying its vital characteristics to the user If a person uses his phone to send a message, he will enter the message's text and the recipient's details, and then push the send button When he started sending the message, he had no idea what was going on during the procedure and only knew if the message had been successfully sent to the receiver In the above instance, the process of sending the message has been concealed and only reveals the functions that the user requires, which are the function of inputting the message content, the recipient information, and the result of successfully or unsuccessfully sending the message That is an example of abstraction

Advantages of using abstractions in programming:

o Abstraction helps programmers reduce the complexity of an object by just providing the object's required properties and methods in programming, boosting system maintainability

o Abstraction allows us to focus on the basic core of the thing and not how it operates

o When used with polymorphism and inheritance in object-oriented programming, abstraction enables numerous expanded functionalities

Example:

In this case, an interface called IAnimal defines a single method called MakeSound The MakeSound method is a universal behavior shared by all animals Then there are two classes, Dog and Cat, that implement the Animal interface and have their own implementation of the MakeSound method

Finally, in the Main method, we create an array of Animal objects and populate it with a Dog and a Cat object Then we iterate through the array, calling the MakeSound method on each object Because the MakeSound method is implemented differently in the Dog and Cat classes, the output of the MakeSound method differs for each object

b Encapsulation

Definition: This property does not allow the user to modify an object's intrinsic state Only the object's internal methods enable it to be changed Allowing the external world to influence an object's internal data is totally up to the person writing the code This is a property that ensures an object's integrity Encapsulation allows a collection of attributes, methods, and other components to be treated as a unified unit or object

Implementation:

o Public: Access to all code in the program

o Private: Access to only members of the same class

o Protected: Access to members of the same class and its derived classes

o Internal: Access to the current assembly

Example:

In this example, we have a Car class that represents a car Model and speed are two private fields in the class These fields are marked as private to prevent unauthorized access

Instead, we make these fields available to the public via two public properties: Model and Speed These properties allow other objects to read the car's model and speed but not directly modify them

We can ensure that the internal details of the Car class are hidden from the outside world by using encapsulation in this way, and that any changes to the car's model and speed are made in a controlled and consistent manner Therefore, the class more user-friendly and less vulnerable to errors or misapplication

c Inheritance

Definition: This feature lets an object inherit the attributes that other objects already have Objects can now share or enhance accessible features without having to redefine them This trait, however, is not shared by all object-oriented languages Multi-level hierarchy: Although a derived class can only have one direct base class, inheritance is transitive ClassC inherits

the members declared in ClassB and ClassA if it is derived from ClassB, and ClassB is derived from ClassA Example:

In this example, the parent class is Animal, and the child class is Cat, which inherits from Animal The Cat class inherits the Animal class's Name and Age attributes, and it overrides the MakeSound() function to offer its own implementation When we create a new Cat object in the main application, we can access its inherited Name and Age attributes, as well as execute the MakeSound() function to generate Cat-specific output It's worth noting that the MakeSound() function in the Animal class is declared as virtual, allowing it to be overridden by child classes such as Cat

Protected Access Modifier:

o The protected access modifier protects the data members that are declared using this modifier o The protected access modifier is specified using the protected keyword

o Variables or methods that are declared as protected are accessed only by the class in which they are declared or by a class that is derived from this class

Base keyword: The base keyword allows you to do the following:

o Access variables and methods of the base class from the derived class o Re-declare the methods and methods defined in the base class o Invoke the derived class data members

o Access the base data using the "base" keyword

d Polymorphism

Another fundamental concept in object-oriented programming (OOP) is polymorphism, which refers to an object's ability to take on multiple forms Polymorphism in C# is accomplished through inheritance, interfaces, and method overloading

Below is an example in C#:

We have an abstract Animal class with an abstract MakeSound method in this example The MakeSound method is marked as abstract to indicate that any derived class must implement it

Dog and Cat are derived classes that override the MakeSound method to produce different sounds

Finally, in the Main method, we create an array of Animal objects and populate it with a Dog and a Cat object Then we iterate through the array, calling the MakeSound method on each object Because the MakeSound method is implemented differently in the Dog and Cat classes, the output of the MakeSound method differs for each object

This is an example of polymorphism in action: the same method (MakeSound) is called on multiple objects (Dog and Cat), but the results vary depending on the object

3 Class relationships

a Association relationship

Definition: Association is one of the fundamental connections in object-oriented programming (OOP) and is used to describe a link or relationship between two or more classes In an association connection, one class is associated to another class in some manner This relationship can be one- -one, one- -many, many- -one, or many- -many to to to to Example:

In this example, we'll make a new Teacher object called johnDoe, as well as two new Course objects called mathCourse and scienceCourse By setting the instructor attribute of each Course object to johnDoe, we assign both courses to the johnDoe instructor We then use the Add method of the List<Course> class to add both courses to the Courses field of the johnDoe instructor object

Finally, we loop through the johnDoe teacher object's Courses collection, displaying the title of each course as well as the name of the instructor who teaches it

b Unary relationship

In object-oriented programming, a unary association is a sort of relationship between two objects in which one object has a unique link with another It is a one- -one relationship between two items in which one is dependent on the other for its existence toor operation

Example:

The Owner class and the Car class have a unary relationship in this case The Owner class contains a CarOwned member variable of type Car that represents the owner's car The CarOwned reference allows the Owner class to access and use the Car class's properties and methods

We create an instance of the Car class representing a car object in the Main function and send it to the Owner class constructor when generating an instance of the Owner class This establishes a connection between the owner and the vehicle The CarOwned reference within the Owner class then allows us to access the car's attributes (model and year)

c Binary relationship

In object-oriented programming, a binary relationship is a relationship between two classes where one class has a reference to the other class This relationship is typically expressed through a property or field in one class that holds an instance of the other class This allows the two classes to interact with each other and exchange information

Binary relationships can be one- -one, one- -many, or many- -many In a one- -one relationship, each instance of one class to to to tois associated with exactly one instance of the other class In a one- -many relationship, each instance of one class is associated towith one or more instances of the other class In a many- -many relationship, each instance of one class is associated with one toor more instances of the other class, and vice versa

Binary relationships are commonly used in software development to model real-world relationships between objects For example, in a customer order system, an order may be associated with a single customer, and a customer may have multiple orders This can be modeled using a binary relationship between the Order class and the Customer class, where the Order class has a reference to the Customer class

In this example, there is a binary relationship between the Order class and the Customer class An order belongs to one customer and a customer can have multiple orders This is a one- -many relationship to

In the main method, we create two Customer instances and three Ord instances and link them together to create the relationship erbetween customers and orders We then print out the orders for each customer

d Aggregation relationship

In object-oriented programming, aggregation is a type of binary relationship between two classes where one class contains a reference to another class, but the contained class can exist independently of the containing class This means that the contained class may belong to other objects or may exist on its own

example of a class that has an aggregation relationship with another class in C#:

To represent this in a UML diagram, we can use an aggregation relationship with a hollow diamond symbol on the Library class end of the relationship:

In this example, the Library class has an aggregation relationship with the Book class The Library class has a list of Book objects as a property, represented by the Books property The Book objects can exist independently of the Library class and may be shared by multiple Library objects

In the main method, we create three Book objects and add them to a List<Book> object, which is then set as the value of the Books property of a Library object We then print out the details of each book in the library using a foreach loop

e Composition relationship

In object-oriented programming, composition is a type of binary relationship between two classes where one class is composed of one or more instances of another class Unlike aggregation, the contained class cannot exist independently of the containing class and is considered part of the containing class

Here is an example in C#:

In this example, we have two classes: Engine and Car Engine has a method Start() that starts the engine, and Car has a private member variable engine of type Engine

By creating an instance of Engine inside Car, we are using composition to create a "has-a" relationship between Car and Engine This means that a Car object has an Engine object as a member variable, and can call the Start() method of the Engine object to start the engine

In the Car class's own Start() method, it calls engine.Start() start the engine, and then has its own code to start the car This todemonstrates how composition allows us to create complex objects by combining simpler objects, and reuse code across multiple classes

III OOP scenario (P2)

2 Use-case diagram

According to the UCD, there are two categories of customers: those who are new to the app (unregistered users) and those who have registered and used it for a certain amount of time

Unregistered users can only register, read music details, listen to a sample of the music, and do a restricted number of song searches

Registered users may manage their profiles, download songs, place preorders, and place orders

There is also a system administrator who is directly in control of all system operations They will be in charge of maintaining client transaction data, updating customer information, and approving content before it is submitted to the system