19.6. Encapsulation: Arrays

Encapsulation is one of the four fundamental principles of object-oriented programming. It refers to the practice of keeping fields within a class private, so they can only be accessed through public methods. This is done to increase code security and flexibility. Let's understand this concept better through the use of arrays.

An array is a data structure that stores a collection of elements (values ​​or variables), each identified by at least one index or key. It is an essential tool for any programmer as it allows storing multiple values ​​in a single variable. This can be extremely useful when you want to store a large amount of data in an organized way.

Arrays can be one-dimensional (a single row of elements), two-dimensional (an array of elements), or multidimensional (an array of arrays). In the context of encapsulation, arrays can be used to store private data that can only be accessed through public methods.

Let's consider a simple example. Suppose we are creating a 'Student' class that contains information about a student's name, age, and grades. Notes are stored in a private array as we don't want them to be accessed directly. Instead, we provide public methods to add a grade, get the average grade, and check if the student passed or failed.

class Student {
  private String name;
  private int age;
  private int[] notes;

  public Student(String name, int age) {
    this.name = name;
    this.idade = age;
    this.notes = new int[10];
  }

  public void addGrade(int grade) {
    for (int i = 0; i < grades.length; i++) {
      if (notes[i] == 0) {
        notes[i] = note;
        break;
      }
    }
  }

  public double calculateAverage() {
    int sum = 0;
    for (int note : notes) {
      sum += note;
    }
    return (double) sum/notes.length;
  }

  public boolean verifyApproval() {
    return calculateAverage() >= 60;
  }
}

In this example, the 'notes' array is private, so it cannot be accessed directly. Instead, we provide 'addGrade', 'calculateAverage' and 'checkPass' methods to handle grades. This is an example of encapsulation as we are protecting the data and providing a secure way to access it.

Encapsulation with arrays is a common practice in object-oriented programming. It provides security as the data is protected from being accessed directly. Also, it provides flexibility as methods can be changed without affecting the rest of the code. For example, if we decide to change the way we calculate the mean, we just need to change the 'calculateAverage' method.

In summary, encapsulation is a fundamental principle of object-oriented programming that helps increase code security and flexibility. Arrays are a useful tool for implementing encapsulation, as they allow you to store multiple values ​​in a single variable. By making arrays private and providing public methods to access them, we can protect the data and provide a secure way to manipulate it.