Object-Oriented Programming Principles (OOP) Report Format

Name: Ron Ahmeti

Kompjuterikë 2

Date of Submission: 26.12.2023

Introduction:

Object-Oriented Programming (OOP) revolutionizes software development by introducing key

principles: encapsulation, inheritance, polymorphism, and abstraction. OOP leverages the concept of
"objects," encapsulating data and behavior for modular, scalable, and maintainable code.

Exercise 1:Class Hierarchy for School

Model the classes (in terms of OOP) along with their attributes and operations define the class
hierarchy and create a class diagram with Visual Studio.

Solution Approach:

Implementation:
public class Person
{
public string FirstName { get; set; }
public string LastName { get; set; }
}

public class Student : Person

{
public int StudentNumber { get; set; }
}

public class Teacher : Person

{
public List<Course> CoursesTaught { get; set; } = new List<Course>();
}

public class Course

{
public string Name { get; set; }
public int NumberOfClasses { get; set; }
public int NumberOfExercises { get; set; }
}

public class Class

{
public string Identifier { get; set; }
public List<Student> Students { get; set; } = new List<Student>();
public List<Teacher> Teachers { get; set; } = new List<Teacher>();
}

internal class Program

{
private static void Main()
{
Student student = new Student { FirstName = "John", LastName = "Doe", StudentNumber = 123 };
Teacher teacher = new Teacher { FirstName = "Jane", LastName = "Smith" };
Course course = new Course { Name = "Math", NumberOfClasses = 3, NumberOfExercises = 10 };
Class schoolClass = new Class { Identifier = "ClassA" };
 student.FirstName = "John";
teacher.CoursesTaught.Add(course);
schoolClass.Students.Add(student);
schoolClass.Teachers.Add(teacher);

Console.WriteLine($"Student: {student.FirstName} {student.LastName}, Number: {student.StudentNumber}");

Console.WriteLine($"Teacher: {teacher.FirstName} {teacher.LastName}, Courses Taught:
{teacher.CoursesTaught.Count}");
Console.WriteLine($"Class: {schoolClass.Identifier}, Students: {schoolClass.Students.Count}, Teachers:
{schoolClass.Teachers.Count}");
}
}

Testing & Output:

- Student: John Doe, Number: 123

Teacher: Jane Smith, Courses Taught: 1

Class: ClassA, Students: 1, Teachers: 1

Exercise 2:Human, Student, and Worker Classes

Write appropriate constructors for each class, and encapsulate data using properties.

Implementation:
public class Human
{
public string FirstName { get; set; }
public string LastName { get; set; }
}

public class Student : Human

{
public int Mark { get; set; }
}

public class Worker : Human

{
public decimal Wage { get; set; }
public int HoursWorked { get; set; }

public decimal CalculateHourlyWage()

{
return HoursWorked != 0 ? Wage / HoursWorked : 0;
}
}

// Testing
internal class Program
{
private static void Main()
{
Student student = new Student { FirstName = "Alice", LastName = "Johnson", Mark = 95 };
Worker worker = new Worker { FirstName = "Bob", LastName = "Smith", Wage = 1500, HoursWorked = 40 };
 Console.WriteLine($"Student: {student.FirstName} {student.LastName}, Mark: {student.Mark}");
Console.WriteLine($"Worker: {worker.FirstName} {worker.LastName}, Hourly Wage:
{worker.CalculateHourlyWage()}");
}
}

Testing & Output:

- Student: Alice Johnson, Mark: 95

Worker: Bob Smith, Hourly Wage: 37.5

Exercise 3:Sorting Students by Mark

Initialize an array of 10 students and sort them by mark in ascending order. Use the interface
System.IComparable<T>.

Implementation:
public class Human
{
public string FirstName { get; set; }
public string LastName { get; set; }
}

public class Worker : Human

{
public decimal Wage { get; set; }
public int HoursWorked { get; set; }

public decimal CalculateHourlyWage()

{
return HoursWorked != 0 ? Wage / HoursWorked : 0;
}
}

public class Student : Human, IComparable<Student>

{
public int Mark { get; set; }

public int CompareTo(Student other)

{
return Mark.CompareTo(other.Mark);
}
}

internal class Program

{
private static void Main()
{
Student[] students = new Student[10];
Random random = new Random();

for (int i = 0; i < students.Length; i++)

{
students[i] = new Student
{
FirstName = $"Student{i + 1}",
 LastName = "Last",
Mark = random.Next(0, 101)
};
}

Array.Sort(students);

foreach (var student in students)

{
Console.WriteLine($"Student: {student.FirstName} {student.LastName}, Mark: {student.Mark}");
}
}
}

Testing & Output:

- Student: Student10 Last, Mark: 10

Student: Student4 Last, Mark: 26

Student: Student1 Last, Mark: 37

Student: Student5 Last, Mark: 53

Student: Student6 Last, Mark: 53

Student: Student9 Last, Mark: 56

Student: Student2 Last, Mark: 74

Student: Student7 Last, Mark: 79

Student: Student3 Last, Mark: 91

Student: Student8 Last, Mark: 96

Reflection & Learning:

Exercise 4: Sorting Workers by Salary

Initialize an array of 10 workers and sort them by salary in descending order.

Implementation:
public class Human
{
public string FirstName { get; set; }
public string LastName { get; set; }
}

public class Student : Human, IComparable<Student>

{
public int Mark { get; set; }

public int CompareTo(Student other)

 {
return Mark.CompareTo(other.Mark);
}
}

public class Worker : Human, IComparable<Worker>

{
public decimal Wage { get; set; }
public int HoursWorked { get; set; }

public decimal CalculateHourlyWage()

{
return HoursWorked != 0 ? Wage / HoursWorked : 0;
}

public int CompareTo(Worker other)

{
return other.CalculateHourlyWage().CompareTo(CalculateHourlyWage());
}
}

internal class Program

{
private static void Main()
{
Worker[] workers = new Worker[10];
Random random = new Random();

for (int i = 0; i < workers.Length; i++)

{
workers[i] = new Worker
{
FirstName = $"Worker{i + 1}",
LastName = "Last",
Wage = random.Next(10, 50) * 100,
HoursWorked = random.Next(30, 50)
};
}

Array.Sort(workers);

foreach (var worker in workers)

{
Console.WriteLine($"Worker: {worker.FirstName} {worker.LastName}, Hourly Wage:
{worker.CalculateHourlyWage()}");
}
}
}
Testing & Output:

- Worker: Worker3 Last, Hourly Wage: 141.17647058823529411764705882

Worker: Worker4 Last, Hourly Wage: 125

Worker: Worker5 Last, Hourly Wage: 88.88888888888888888888888889

Worker: Worker10 Last, Hourly Wage: 87.5

Worker: Worker8 Last, Hourly Wage: 83.72093023255813953488372093

Worker: Worker7 Last, Hourly Wage: 61.363636363636363636363636364

Worker: Worker9 Last, Hourly Wage: 60.526315789473684210526315789

Worker: Worker2 Last, Hourly Wage: 55.555555555555555555555555556

Worker: Worker6 Last, Hourly Wage: 51.162790697674418604651162791

Worker: Worker1 Last, Hourly Wage: 26.315789473684210526315789474

Exercise 5 : Abstract Class Shape and CalculateSurface

Create an array of different shapes and calculate the area of each shape in another array.

Implementation:
public abstract class Shape
{
public double Width { get; set; }
public double Height { get; set; }

public abstract double CalculateSurface();

}

public class Triangle : Shape

{
public override double CalculateSurface()
{
return 0.5 * Width * Height;
}
}

public class Rectangle : Shape

{
public override double CalculateSurface()
{
return Width * Height;
}
}

public class Circle : Shape

{
public Circle(double radius)
{
Width = radius;
Height = radius;
}

public override double CalculateSurface()

{
return Math.PI * Width * Width;
}
}

internal class Program

{
private static void Main()
{
Shape[] shapes = new Shape[3];
 shapes[0] = new Triangle { Width = 5, Height = 8 };
shapes[1] = new Rectangle { Width = 4, Height = 6 };
shapes[2] = new Circle(3);

foreach (var shape in shapes)

{
Console.WriteLine($"Area: {shape.CalculateSurface()}");
}
}
}

Testing & Output:

- Area: 20

Area: 24

Area: 28.274333882308138