OOP - Encapsulation

What ???

Encapsulation is the process of bundling data & functions into a single unit (i.e., capsule), it can also limit access to some of the data/methods.

It is one of the four pillars of OOP, along with Inheritance, Polymorphism, and Data Abstraction.

Why ?

It's easier to take a blind assumption and proceed using encapsulation at all places, but its important to understand the why so you could use it the right way.

Let's try to understand the why(s) by looking at an example task.

Task:

Build a student result calculator that should,

• Calculate the average mark
• Determine if a student is failed or passed
• Throw error if any of the subjects mark is invalid ( 100)

Solution 1: the non-encapsulated way

The idea is to just to solve the problem, so I have chosen the Procedural programming way of achieving it which I believe could show a good contrast and make the problem seem more obvious.

type Subject = "english" | "maths";

interface IStudent {
  name: string;
  marks: Record<subject number>;
}

// Receive Input
const studentInput: IStudent = {
  name: "John",
  marks: {
    english: 100,
    maths: 100,
  },
};

// Step1: Validate the provided marks
Object.keys(studentInput.marks).forEach((subjectName) => {
  const mark = studentInput.marks[subjectName as Subject];
  if (mark > 100 || mark 
    studentInput.marks[current as Subject] + accumulator,
  0
);

// Step3: find the average
const average = totalMarks / Object.keys(studentInput.marks).length;

// Step4: find the result
const boolResult = average > 40;

// Step 5: print result
console.log(boolResult);
console.log(average);

</subject>

Problems with Solution 1:

This definitely achieves the expected result but there are several problems associated to it. To name a few,

1. Every implementation here is globally accessible and there is no control over its usage by future contributors.
2. Data & operations are separate making it hard to trace which functions affect the data. You would have to carefully go through every piece of code to understand what is called and part of an execution.
3. Functions become harder to manage as the logic scales. Changes can break unrelated code due to tight coupling.

How to solve the problem ?

By incorporating Encapsulation or make it more obvious by doing the below two steps,

1. Controlled Access to Data & functions
2. Bundling Data with Behaviour

Solution 2: The Encapsulated way

type SubjectNames = "english" | "maths";

interface IStudent {
  name: string;
  marks: Record<subjectnames number>;
}

class ResultCalculator {
  protected student: IStudent;
  constructor(student: IStudent) {
    this.student = student;
  }

  isPassed(): boolean {
    let resultStatus = true;
    Object.keys(this.student.marks).forEach((subject: string) => {
      if (this.student.marks[subject as SubjectNames]  {
      if (
        this.student.marks[subject as SubjectNames]  100
      ) {
        throw new Error(`invalid mark`);
      }
    });
  }

  private totalMarks() {
    return Object.keys(this.student.marks).reduce(
      (acc, curr) => this.student.marks[curr as SubjectNames] + acc,
      0
    );
  }

  private subjectCount() {
    return Object.keys(this.student.marks).length;
  }
}

// Receive Input
const a: IStudent = {
  name: "jingleheimer schmidt",
  marks: {
    english: 100,
    maths: 100,
  },
};

// Create an encapsulated object
const result = new ResultCalculator(a);

// Perform operations & print results
console.log(result.isPassed());
console.log(result.getAverage());

</subjectnames>

notice in the above solution,

1. Methods totalMarks, subjectCount, validateMarks & the member variable student are not exposed and can only be used by the class object.

2.the data student is bundled with every behaviour of it.

The above is the detailed content of OOP - Encapsulation. For more information, please follow other related articles on the PHP Chinese website!