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!