Introduce Object Orientation

In this chapter, we will learn about Object Orientation (OO) and explore the benefits it brings in the software system development process.

Why do we need Object Orientation (OO) in Software Development?

To answer this question, let's first look (briefly) at how software systems are designed using the Structured Programming method (also known as Functional Programming).

1. Structured Programming:

In Structured Programming, the general method is to analyze the problem and break it down into functions to perform specific tasks. Most of these functions need a data type to process. Data in a functional system is typically stored in a database or may be held in memory as global variables.

Let's take a simple example of a school management system. This system stores details of all students and lecturers in the school. At the same time, it also manages information about courses offered at the school and tracks which students are taking which courses.

The system needs to store information about Student, Teacher, Exam and Course, and is designed with functions such as:

• add_student
• enter_for_exam
• check_exam_marks
• issue_certificate
• expel_student

From there, we can build a diagram of data, functions and dependencies as follows:

The problem with this approach is that if the problem we are solving becomes too complex, the system will become increasingly difficult to maintain. Taking the example above, what if a request changes the way Student handles data, such as converting "year of birth" from two words numbers to four digits? Just this small change can lead to unforeseen side effects and cause serious problems. The data of Exam, Course and Teacher all depend on the data of Student. Additionally, we may have broken the add_student, enter_for_exams, issue_certificate, and expel_student functions. For example, add_student will definitely not work anymore, because it will need two-digit data for "year of birth" instead of four digits.

From the above example, we can see some disadvantages of Structured Programming, including interdependence between functions and data, leading to difficult to maintain, difficult to expand and easy to encounter unexpected problems when changing data. To solve these problems, we need a new approach, and that is Object Oriented (OO).

2. Object Oriented:

2.1. Concept:

Object: can be understood as a specific entity, consisting of 2 main components:

• Attributes: Is the information and characteristics of the object.

• Methods: Are operations and actions that an object can perform.

From the example of the problem school management system above, we can have the following objects:

Class: is a data type that includes pre-defined properties and methods that objects will have. We can understand class as a template to create objects.

For example: Class Student is a common definition template for all students, including common properties and methods such as name, year of birth and other act like enrolling in school. The subject is a specific student named Nguyen Van A born in 2004 with the characteristics of class Student

2.2. Basic principles of OOP:

Encapsulation

Encapsulation is the grouping of related properties and methods into the same class, for the purpose of effective management and use. This reduces complexity and increases security, while also making the code easy to maintain and extend.

public class Student {
    private String name;
    private String dateOfBirth;


    public void registerForCourse(Course course) {
        course.addStudent(this);
    }
}

Student information will be encapsulated in the Student class, and actions related to Student will be performed through methods in this class.

Inheritance

Inheritance allows a child class to inherit the properties and methods of the parent class to optimally reuse source code and easily extend functionality.

public class Person {
    private String name;
    private String dateOfBirth;
}

public class Student extends Person {
    private double gpa;
}

public class Teacher extends Person {
    private String department;
}

Student and Teacher both inherit from the Person class, helping to reuse common properties. Each subclass can add separate properties or methods.

Polymorphism

Polymorphism allows a method to be implemented in many different ways, i.e. the method can be redefined in a subclass with different behavior.

public class Person {
    public void introduce() {
        System.out.println("I am a person.");
    }
}

public class Student extends Person {
    @Override
    public void introduce() {
        System.out.println("I am a student.");
    }
}

public class Teacher extends Person {
    @Override
    public void introduce() {
        System.out.println("I am a teacher.");
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        Person student = new Student();
        Person teacher = new Teacher();

        person.introduce(); // I am a person.
        student.introduce(); // I am a student.
        teacher.introduce(); // I am a teacher.
    }
}

The introduce method is defined in the Person class and overridden in the Student and Teacher subclasses. Even though the Person type is used, when calling the introduce method, the system will use the appropriate method of the actual object (Student or Teacher), exhibits polymorphism.

Abstraction

Abstraction is a method of working with general concepts without focusing too much on specific implementation details, increasing flexibility and reducing complexity.

public class Student {
    private String name;
    private String dateOfBirth;


    public void registerForCourse(Course course) {
        course.addStudent(this);
    }
}

With Abstraction, we define an abstract class (Course) with generic methods (startCourse()). Subclasses such as MathCourse and ScienceCourse implement these methods in detail, making the system easy to extend and customize.

3. Advantages of object-oriented programming:

• Thanks to inheritance, classes can be extended without repeating code, minimizing redundancy and increasing efficiency.
• Save time and increase productivity.
• The concept of classes and objects helps simulate real-world entities more naturally and clearly on computers, while overcoming the limitations of structure-oriented programming.

The above is the detailed content of Introduce Object Orientation. For more information, please follow other related articles on the PHP Chinese website!