Arrays And Oop

Overview

Arrays are contiguous collections of elements accessed by index. In object-oriented programming (OOP), arrays often serve as fundamental building blocks inside classes and interfaces. You will frequently encapsulate arrays within objects, expose safe views or iterators, maintain invariants (like sorted order), and leverage polymorphism through element types.

Arrays Across OOP Languages

• Java/C#: Arrays are objects with a fixed length; bounds are checked at runtime. Higher-level collections (e.g., Java's ArrayList, C#'s List<T>) wrap dynamic arrays.
• C++: Built-in arrays have fixed size and minimal runtime checks; std::array<T, N> (fixed) and std::vector<T> (dynamic) are preferred in OOP designs.
• Python/JavaScript: Built-in lists/arrays are dynamic and commonly used as the default sequence type.

Designing with Arrays in OOP

• Encapsulation: Keep raw arrays private. Provide methods for safe access (getters, iterators) and operations (add, remove, sort).
• Invariants: Maintain constraints (e.g., no nulls, sorted order, fixed capacity) within your class methods.
• Defensive copying: Avoid exposing internal arrays directly. Return copies or read-only views to prevent unintended mutation.
• Immutability: For thread-safety and simplicity, consider making array-backed objects immutable.

Typing, Polymorphism, and Variance

Arrays carry an element type. How that type interacts with inheritance varies by language:

• Covariant arrays (e.g., Java, C#): A Cat[] can be treated as an Animal[], but storing a Dog into that array causes a runtime error. Convenient but potentially unsafe.
• Generics/templates: Collections like List<T> (in Java/C#) or std::vector<T> (in C++) are usually invariant by default, catching more errors at compile time.
• Duck typing (Python, JS): Emphasis is on behavior; arrays/lists can hold mixed types, so testing and runtime checks are important.

Fixed vs. Dynamic Arrays

• Fixed-size: Known capacity, often more predictable performance and memory.
• Dynamic arrays: Grow by allocating a larger backing array and copying; appends are amortized O(1). Examples: ArrayList, List<T>, std::vector<T>, Python list.

Common Patterns and APIs

• Index-based access: Provide get(i), set(i, v) with bounds checks.
• Iteration: for/foreach loops; expose iterators or generator methods instead of raw arrays.
• Bulk operations: fill, copy, slice, sort, map/filter/reduce (language-dependent).

Performance Considerations

• Contiguity and cache locality: Arrays are cache-friendly; iteration is fast.
• Bounds checks: Some languages insert bounds checks; hot loops may need careful structure to help the optimizer.
• Copying vs. views: Copies are safe but can be expensive; consider views/slices when available, but be mindful of aliasing.
• Multidimensional data: Choose between true 2D arrays and arrays of arrays (jagged) based on access patterns.

Error Handling and Contracts

• Validate indices and sizes; document whether methods throw on invalid input or clamp values.
• Clarify ownership: who can modify the data and when.
• Define equality: element-wise (deep) vs. reference (shallow) equality.

Example: Encapsulating an Array (Java)

public final class IntSeries {
    private final int[] data;

    public IntSeries(int[] values) {
        this.data = java.util.Arrays.copyOf(values, values.length); // defensive copy
    }

    public int size() { return data.length; }
    public int get(int i) { return data[i]; }

    public int sum() {
        int s = 0;
        for (int v : data) s += v;
        return s;
    }

    public int[] toArray() {
        return java.util.Arrays.copyOf(data, data.length); // do not leak internal array
    }
}

// Usage:
// IntSeries s = new IntSeries(new int[]{1,2,3});
// int total = s.sum();

Example: Python Wrapper Over a List (Dynamic Array)

class Grades:
    def __init__(self, scores):
        self._scores = list(scores)  # defensive copy

    def average(self):
        return sum(self._scores) / len(self._scores) if self._scores else 0.0

    def add(self, score):
        self._scores.append(score)

    def to_list(self):
        return list(self._scores)  # return a copy

Example: C++ Class Backed by std::vector

class Buffer {
    std::vector<int> data_;
public:
    explicit Buffer(std::size_t n) : data_(n) {}
    int& operator[](std::size_t i) { return data_[i]; }
    const int& operator[](std::size_t i) const { return data_[i]; }
    std::size_t size() const { return data_.size(); }
};

Testing and Maintenance

• Test edge cases: empty arrays, single-element arrays, boundaries, and large sizes.
• Use language utilities for equality and hashing (e.g., Java Arrays.equals, Arrays.hashCode).
• Benchmark critical paths that traverse or copy arrays.

When to Use Arrays vs. Other Collections

• Use arrays for fixed-size, performance-critical, or memory-sensitive code.
• Prefer higher-level collections for frequent resizing, insertion/removal in the middle, or when richer APIs improve readability and safety.

Next Topic