OOP – Kapselung

Was???

Kapselung ist der Prozess der Bündelung von Daten und Funktionen in einer einzigen Einheit (d. h. Kapsel), sie kann auch den Zugriff auf einige der Daten/Methoden einschränken.

Es ist neben Vererbung, Polymorphismus und Datenabstraktion eine der vier Säulen von OOP.

Warum?

Es ist einfacher, eine blinde Annahme zu treffen und an allen Stellen Kapselung zu verwenden, aber es ist wichtig, das Warum zu verstehen, damit Sie es richtig verwenden können.

Versuchen wir, das Warum zu verstehen, indem wir uns eine Beispielaufgabe ansehen.

Aufgabe:

Erstellen Sie einen Rechner für Schülerergebnisse, der Folgendes tun sollte:

• Berechnen Sie die Durchschnittsnote
• Stellen Sie fest, ob ein Schüler durchgefallen oder bestanden ist
• Wird einen Fehler auslösen, wenn eine der Betreffmarkierungen ungültig ist ( < 0 || > 100)

Lösung 1: der nicht gekapselte Weg

Die Idee besteht lediglich darin, das Problem zu lösen, daher habe ich die prozedurale Programmierung gewählt, um dies zu erreichen, was meiner Meinung nach einen guten Kontrast bieten und das Problem offensichtlicher erscheinen lassen könnte.

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 < 0) {
    throw new Error(`invlid mark found`);
  }
});

// Step2: find the total marks
const totalMarks = Object.keys(studentInput.marks).reduce(
  (accumulator: number, current: string) =>
    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);

Probleme mit Lösung 1:

Damit wird definitiv das erwartete Ergebnis erzielt, es sind jedoch mehrere Probleme damit verbunden. Um nur einige zu nennen:

1. Jede Implementierung hier ist weltweit zugänglich und es gibt keine Kontrolle über ihre Verwendung durch zukünftige Mitwirkende.
2. Daten und Vorgänge sind getrennt, sodass es schwierig ist, nachzuvollziehen, welche Funktionen sich auf die Daten auswirken. Sie müssten jeden Codeabschnitt sorgfältig durchgehen, um zu verstehen, was aufgerufen wird und Teil einer Ausführung ist.
3. Funktionen werden mit zunehmender Logik schwieriger zu verwalten. Änderungen können aufgrund der engen Kopplung dazu führen, dass nicht verwandter Code beschädigt wird.

Wie kann das Problem gelöst werden?

Indem Sie Encapsulation integrieren oder es deutlicher machen, indem Sie die folgenden zwei Schritte ausführen,

1. Kontrollierter Zugriff auf Daten und Funktionen
2. Daten mit Verhalten bündeln

Lösung 2: Der gekapselte Weg

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] < 40) {
        resultStatus = false;
      }
    });
    return resultStatus;
  }

  getAverage(): number {
    this.validateMarks();
    return this.totalMarks() / this.subjectCount();
  }

  private validateMarks() {
    Object.keys(this.student.marks).forEach((subject: string) => {
      if (
        this.student.marks[subject as SubjectNames] < 0 ||
        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());

Beachten Sie in der obigen Lösung,

1. Die Methoden „totalMarks“, „subjectCount“, „validateMarks“ und die Mitgliedsvariable „student“ werden nicht verfügbar gemacht und können nur vom Klassenobjekt verwendet werden.

2.Der Datenschüler wird mit jedem Verhalten davon gebündelt.

Das obige ist der detaillierte Inhalt vonOOP – Kapselung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!