Object Orientated Programming Level 5 Case Study

Introduction - Implementing Java for Data Management

The term Object-oriented programming refers to that type of programming model that organizes the design of the software around the objects, or data rather than the logic and functions. An object gets defined as a data field that has unique behavior and attributes. This particular approach to programming is very well-suited for programs that are complex, large, and actively maintained. This incorporates programs for design, manufacturing, and mobile applications. The organization of the object-oriented program makes the methods beneficial for collaborative development, wherein the projects get divided into several groups. Moreover, other benefits incorporate code reusability, efficiency, and scalability. The initial step within OOP is to gather all the objects required for manipulation and identification as to how they are related to one another.

Once any object gets known, it gets labeled with the class of several objects which defines the type of data it houses and any of the logic sequences which could manipulate it. In respect of this assignment, there are three specific tasks that are taken into consideration for the purpose of being properly completed. The STEM system is designed to add student data, store student data and book appointments. The programming language known as “Java” has been taken into account in this case within the software platform known by the name “NetBeans”. The tasks have been completed successfully which incorporates the creation of the UML class and objective diagram, a java program to show the base classes and further justify the variables. Furthermore, the other task also included the mini project which in turn consisted of the concerned hierarchy implementation in java, implantation of the interaction in question within java and also demonstration of the entire functionality of the abstract method implemented through java respectively.

Background

Here, the sole objective is to develop a specific application that aims to create the departments such as technology, science, engineering as well as mathematics schools. Each of the schools offers weekly online lectures for part-time students, in addition to face-to-face, full-time lectures across all the schools (Krishnamurthi et al. 2019). These hours are to be posted online, where the students can easily book appointments during all these hours. Each of the students gets a limited 15 minutes session for enabling many students to obtain support every week. The application in question has got the provision for insertion, modification, deletion, and representation of student and staff records on the whole. This includes the details like the anime, email, sex, age, phone number, course, address, salaries for staff, and fees for students respectively.

• Principles of Object-Oriented Programming: Fundamentally, there exist four primary principles which make any language “object” oriented. These are data abstraction, encapsulation, inheritance, and polymorphism respectively (Munthe et al. 2020). These are known as the four ‘pillars” of OOP on the whole.
• Inheritance: Inheritance essentially expresses the “is-a” as well as ‘has-a” relationship between the two objects. By way of utilizing inheritance, one can easily reuse the “code” of the editing “super” classes as fast as the derived classes are concerned (Nusantara et al. 2019). In the case of the programming language called Java, the concept called “is-a” is predicated on the interface implementation or class inheritance. There exists a parent class and child classes which share the same variables and methods as the parent class. This helps to reuse code and perform various computations with the help of the different methods in the classes. Inheritance is an integral feature of object-oriented programming and enhances the effectiveness of the classes and objects.
• Interface: This term called “interface” refers to the “contract” between itself as well as any class which implements it. The interface can easily have methods, events, or even properties respectively. Moreover, it also includes the declaration of all its members, and the implementation of the members is given by that “class” which executes the interface (Sharma et al. 2020). This “interface” makes it very easy for maintaining the concerned program. The specified “terms” of the interface are mentioned below;
  
  • Any interface gets refined by way of utilizing an interface “keyword” in particular
  • By default, all of the members related to an interface are essentially public.
  • Interface does not have any private members.
  • There are two separate ways by which interface can be implemented, and these are explicit, and implicit respectively
  • Interface enforces tow the class for the prior for executing its “members” within a class.
• Abstract Classes: In this context, an abstract class within OOP is nothing but c “class” which could not be instantiated. In simple words, one cannot construct an “object” by utilizing this abstract class. The abstract class also refers to that generic class utilized as the basis for constructing a set of particular objects which conform to the protocols and series of operations that it supports (Sulistiani et al. 2021). Because of Java, an “object” could not be formed from the “java” abstract class in particular. Moreover, attempting to instantiate the abstract class produces “compiler” errors in this regard. This abstract class can only be declared by way of the keyword named “abstract” for that matter.
• Techniques of modelling in Object-Oriented Design and Analysis: When it comes to the object-oriented analysis phase of software development, the requirements of the system are determined. Moreover, the classes also get recognized along with existing relationships among the classes (Tokui et al. 2019). There exist three techniques of analysis that are utilized in sync with each other to perform the object-oriented analysis. These are dynamic modelling, functional modelling, and object modelling respectively.
• Dynamic Modelling: The sole process of this type of modelling gets visualized by way of these following steps:
  
  • Identification of the state’s pertaining to each of the objects
  • Identification of the events along with analysing the applicability of the actions
  • Construction of the dynamic model diagram which consist of the diagrams for state transition
  • Expression of each of the states in terms of the objective attributes
  • Validation of the drawn state-transition diagrams
• Functional Modelling: The swallowing steps are the one through which this process of the functional modelling can easily be visualized
  
  • Identification of all of the outputs and inputs
  • Construction of the diagram of data flow that show the functional dependencies
  • Mentioning of the purpose pertaining to each of the functions
  • Identification of the constraints
  • Specification of the optimization criteria
• Object Modelling: The underneath are all the steps by which the object modelling gets visualized:
  
  • Identification of the object and the group into the classes
  • Identification of the relationships amongst the classes
  • Creation of the object model diagram of the user
  • Definition of the user object characteristics
  • Definition of the operations which are to be performed upon the classes

Task 1 - UML

UML Class Diagram

The ‘class” diagram generally depicts the static view pertaining to the application in question. It represents all the object types that reside within the system along with the present connection between them (Wang et al. 2019). A class generally comprises its objects and it might inherit from the other classes as well. This class diagram gets utilized for describing, visualizing, and documenting the different aspects belonging to the systems as well as constructing executable codes in general. It thoroughly showcases the classes, attributes, relationships, and functions for rendering an overview in respect of the entire software system. It incorporates the attributes, class names, and functions within an individual compartment which assist in the development process. As it is nothing but the amalgamation of the classes, associations, interfaces, constraints, and collaborations get termed the structural diagram. The figure below is the representation of the class diagram of this program.

Figure 1: UML Class Diagram of the Application

The class diagram of this application is composed of 8 classes: University, Department, School, Lecturer, Student, SupportHour, Bootcamp, and TechnologyBootcamp. Each class has specific attributes and methods that are necessary for the application's functionality. The University class has attributes such as name and address, and methods such as getName () and setName (). The Department class inherits from the University class and has an additional attribute, the department name (). The School class inherits from the Department class and has an additional attribute, the school name.

The Lecturer class has attributes such as lecturer name, email, phone number, subject, and salary, and methods such as getLecturerName () and setLecturerName (). The Student class has attributes such as student name, age, email, phone number, sex, course, and fees, and methods such as getStudentName () and setStudentName (). The SupportHour class has attributes such as lecturer name, day, and time, and methods such as getLecturerName () and setLecturerName (). The Boot camp class is an abstract class with a single attribute, fees, and a single abstract method, set discount (). Finally, the TechnologyBootcamp class inherits from the Boot Camp class and has an implemented method set discount (). The class diagram represents the hierarchical relationship between classes and the attributes and methods that are used to implement the functionality of the application.

Purpose

• It helps in designing as well as analysing the applications’ static view.
• It properly dictates the primary responsibilities in relation to the system in question
• It forms a base for the deployment and component diagrams
• It essentially incorporates the reverse and forward engineering techniques.

Benefits

• It can properly showcase the object model regarding the complex systems
• It helps in bringing down the time of maintenance by rendering an overview as to how the application is structured before executing the aspect of coding
• It renders a fundamental schematic of the application for the objective of better understanding
• It showcases a very detailed chart by highlighted the concerned codes that get programmed

UML Object Diagram

The object diagram is derived from the class diagram which makes the former dependent upon the latter in this regard. These object diagrams generally represent an instance of the class diagram (Wu et al. 2019). This type of diagram also showcases the concerned system’s static view in particular. But this kind of “static” view is nothing but a snapshot of a system at a particular moment.

Figure 2: UML Object Diagram of the Application

The image in the above section is the UML object diagram of the application which is developed in this assignment (Kaur et al. 2019). The object diagram is generated based on the class diagram which is mentioned in the earlier section. The UML object diagram of the application can give a clear view of the features and their purpose in the application developed in this assignment. A total of eight objects are given for this in this diagram and linked with each other to determine the relationship between the different features and their objective in the application.

Purpose

All the purposes of the object diagram are somewhat similar to that of the class diagrams. The underlying difference is that the “class” diagram showcases an “abstract” model which consists of the classes along with their relationships (Wu et al. 2020). However, the object diagram displays an instance in a specific moment that is “concrete” in its nature. It mentions the fact the “object” diagram is very much closer to the system’s actual behavior in particular. The objective is nothing but to capture the “static” view of the system on the whole.

The underlying purposes of the object diagram concerning the concerned system

• Object relationship regarding the concerned system
• Reverse and forward engineering
• Static view regarding and interaction
• Understanding of the object behavior along with their relationship form the practical perspective

Task 2:- Application and Testing

Here, a java program is being written to code the “UML” diagram concerning the “Task 1” in this regard. This in turn is to showcase the base classes in particular, as this gets further developed in Task 3. Moreover, the operations and the attributes also get justified and described for each of the classes that are taken into consideration (Alsolai et al. 2020). The appropriate methods get set for getting the instance “variables” within the classes in question. The table below is the representation of the testing result performed for this program.

Table 1: Testing Result

All of the tests have been successful in this case with respect to the proper functioning of the apparition in question (Adams et al. 2020). The above figure shows the set of inputs and outputs obtained while testing the program. The program has been tested using these test cases and the program is checked to give appropriate outputs. The test cases are important as they form the document which assures the client who wants to own the application developed using Java programming language. It is proof that the program has been executed successfully on a range of data input to the program.

Task 3:(Mini Project)

In the context of this project, a java application is being created by way of applying all the pertinent OOP methodologies. This in turn is to display the various queries on the individual within the university in question, like lecturers and the students on the whole (Lang et al. 2019) this mini project fundamentally has a sum total of three separate parts that constitute the whole.

a.

As the object and class diagram is constructed with respect to the task “1a’, the appropriate class is also selected in the form of a base class (Sejati, 2019). The corresponding code in java is written for this particular base class and also up to “three” derived classes in this regard. The aforementioned hierarchy is implemented in java as well.

b.

In view of this particular task, the database which has been considered has got many array lists in general. This also incorporates the dummy data which showcases the entire details of the staff, student as well as staff horse to support. In the case of the staff a minimum of “15” records are considered which includes at least “3” lectures for that matter (Babuji et al. 2019). As far as the students are concerned a minimum of “15” records are essentially considered in this case. The available horse for the purpose of support considers one single record for one specific lecture in essence. One single example regarding the “functionality” of a student has been demonstrated which selects a “15” minute slot regarding one of the lecturers. This particular interaction has been implemented within Java. This in turn is tested by thoroughly printing the name of the student, student’s ID, appointment details, and the name of the lecturer.

Figure 3: Implementation of ArrayList for Storing Data

In this program, ArrayList is used to store and manage multiple records of students, lecturers, and support hours. ArrayList is a class in Java that implements the List interface and provides a dynamic array, which can grow or shrink as needed. The ArrayList class allows the program to create an array of objects with a variable size, which is useful for managing a large number of records. In this program, the ArrayList class is used to store the records of students, lecturers, and support hours in three separate ArrayList objects: student List, lecturer List, and support Hour List. These ArrayList objects are used to store the records of students, lecturers, and support hours in a way that allows the program to easily add, remove or access the records as needed.

c.

Here, the fees in question have been set for the “boot” camp for the external students as “£500” by availing of a discount of “25%” in particular. The aforementioned scenario exists if the students enroll in a full-time course in particular (Bilberg et al. 2019). This specific functionality gets selected in the form of an abstract method, which gets defined within an abstract interface or class for that matter. The programming language of “Java” has also been implemented in this case, for the sole objective of demonstrating the manner in which the entire functionality of this particular abstract method gets implemented within the software platform. The figure below is the representation of the class responsible for calculating the fees for Bootcamp.

use my discount

Figure 4: TechnologyBootcamp Class

The above code is the implementation of the TechnologyBootcamp class, which is a concrete class that inherits from the Bootcamp class. The TechnologyBootcamp class has two attributes: fees, which are inherited from the Bootcamp class, and isEnrolledInFullTimeCourse, which is a Boolean variable that represents whether the student is enrolled in a full-time course. The class also has two methods: getFees () and set Fees ().

Figure 5: System features

The get Fees() method is an override of the method inherited from the Bootcamp class. It calculates the final fee for the Bootcamp by applying a 25% discount if the student is enrolled in a full-time course. The set Fees () method is also an override of the method inherited from the Bootcamp class and it sets the value of the fees to attribute. This class is used to demonstrate the full functionality of the abstract method of the Bootcamp class.

Figure 6: Output of the system

The program uses the ArrayList class to store and manage the records of students, lecturers, and support hours, this allows the program to efficiently manage and retrieve the records as well as add new records as needed, making the program more effective and efficient.

Conclusion

Here, all of the tasks have been suitably completed by way of the language of programming known as Java and the platform of software named NetBeans respectively. The developed application is solely meant for serving the students and lectures of the concerned university. This application has turned out to be extremely useful for all of the students to interact with the respective lectures through their online classes.

Various object oriented programming features have been utilized and implemented in the current assignment to display specific skill sets pertaining to programming. The entire assignment is individually separated into three respective tasks on the whole. In the first one, the object and class diagrams are drawn and designed respectively. In the case of the second task, the initial applications have been written within java by way of the appropriate OOP methodologies. In the final task, the concerned applications developed further, relating to the students and initial staff of this university which in turn has culminated in the form of a mini-project.

References

Adams, B., Bohnhoff, W., Dalbey, K., Ebeida, M., Eddy, J., Eldred, M., Hooper, R., Hough, P., Hu, K., Jakeman, J. and Khalil, M., 2020. Dakota, A Multilevel Parallel Object-Oriented Framework for Design Optimization, Parameter Estimation, Uncertainty Quantification, and Sensitivity Analysis: Version 6.13 User's Manual (No. SAND2020-12495). Sandia National Lab.(SNL-NM), Albuquerque, NM (United States).

Alsolai, H. and Roper, M., 2020. A systematic literature review of machine learning techniques for software maintainability prediction. Information and Software Technology, 119, p.106214.

Babuji, Y., Woodard, A., Li, Z., Katz, D.S., Clifford, B., Kumar, R., Lacinski, L., Chard, R., Wozniak, J.M., Foster, I. and Wilde, M., 2019, June. Parsl: Pervasive parallel programming in python. In Proceedings of the 28th International Symposium on High-Performance Parallel and Distributed Computing (pp. 25-36).

Bilberg, A. and Malik, A.A., 2019. Digital twin driven human–robot collaborative assembly. CIRP annals, 68(1), pp.499-502.

Kaur, A. and Dhiman, G., 2019. A review on search-based tools and techniques to identify bad code smells in object-oriented systems. Harmony search and nature inspired optimization algorithms, pp.909-921.

Krishnamurthi, S. and Fisler, K., 2019. 13 Programming Paradigms and Beyond. The Cambridge handbook of computing education research, p.377.

Lang, M., Binder, M., Richter, J., Schratz, P., Pfisterer, F., Coors, S., Au, Q., Casalicchio, G., Kotthoff, L. and Bischl, B., 2019. mlr3: A modern object-oriented machine learning framework in R. Journal of Open Source Software, 4(44), p.1903.

Munthe, I.R., Rambe, B.H., Pane, R., Irmayani, D. and Nasution, M., 2020. UML Modeling and Black Box Testing Methods in the School Payment Information System. Jurnal Mantik, 4(3), pp.1634-1640.

Nusantara, F.A., Fatimah, D.D.S. and Rahayu, S., 2019. Perancangan Sistem Informasi Pembayaran Sumbangan Pendidikan di Sekolah Menengah Kejuruan Darussalam Tarogong Kaler. Jurnal Algoritma, 16(2), pp.270-277.

Sejati, P.L., 2019. PRATIWI LINTANG 165100079 UAS pemanfaatan delphi 7 untuk object oriented programming pada masyarakat.

Sharma, N. and Yalla, P., 2020. Mapping and Visualization of Source Code: A Survey. International Journal of Simulation--Systems, Science & Technology, 21(4).

Sulistiani, H., Yuliani, A. and Hamidy, F., 2021. Perancangan Sistem Informasi Akuntansi Upah Lembur Karyawan Menggunakan Extreme Programming. Technomedia Journal, 6(1 Agustus), pp.1-14.

Tokui, S., Okuta, R., Akiba, T., Niitani, Y., Ogawa, T., Saito, S., Suzuki, S., Uenishi, K., Vogel, B. and Yamazaki Vincent, H., 2019, July. Chainer: A deep learning framework for accelerating the research cycle. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining (pp. 2002-2011).

Wang, H., Wang, P., Ding, Y., Sun, M., Jing, Y., Duan, R., Li, L., Zhang, Y., Wei, T. and Lin, Z., 2019, November. Towards memory safe enclave programming with rust-sgx. In Proceedings of the 2019 ACM SIGSAC Conference on Computer and Communications Security (pp. 2333-2350).

Wu, B., Hu, Y., Ruis, A.R. and Wang, M., 2019. Analysing computational thinking in collaborative programming: A quantitative ethnography approach. Journal of Computer Assisted Learning, 35(3), pp.421-434.

Wu, N., Kenway, G., Mader, C.A., Jasa, J. and Martins, J.R., 2020. pyOptSparse: A Python framework for large-scale constrained nonlinear optimization of sparse systems. Journal of Open Source Software, 5(54), p.2564.