面向对象编程——封装

什么？？？

封装是将数据和函数捆绑到一个单元（即胶囊）中的过程，它还可以限制对某些数据/方法的访问。

它是 OOP 的四大支柱之一，其他三者分别是继承、多态性和数据抽象。

为什么？

采取盲目假设并在所有地方继续使用封装会更容易，但了解原因很重要，这样您才能以正确的方式使用它。

让我们尝试通过查看示例任务来理解原因。

任务：

构建一个学生成绩计算器，

• 计算平均分
• 确定学生是否失败或通过
• 如果任何主题标记无效（ 100），则抛出错误

方案一：非封装方式

这个想法只是为了解决问题，所以我选择了过程式编程实现它的方式，我相信它可以显示出很好的对比并使问题看起来更明显。

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);

解决方案 1 的问题：

这确实达到了预期的结果，但也存在一些与之相关的问题。仅举几例，

1. 这里的每个实现都是全局可访问的，并且未来贡献者无法控制其使用。
2. 数据和操作是分开的，因此很难追踪哪些函数影响数据。您必须仔细检查每一段代码才能了解调用的内容以及执行的一部分。
3. 随着逻辑的扩展，函数变得更难管理。由于紧密耦合，更改可能会破坏不相关的代码。

如何解决问题？

通过合并封装或通过执行以下两个步骤使其更加明显，

1. 对数据和功能的受控访问
2. 将数据与行为捆绑

解决方案2：封装方式

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());

注意上述解决方案，

1. 方法totalMarks、subjectCount、validateMarks 和成员变量student 不公开，只能由类对象使用。

2.数据学生与其每一个行为都捆绑在一起。

以上是面向对象编程——封装的详细内容。更多信息请关注PHP中文网其他相关文章！