You can create a Python class to find a pair of elements in an array whose sum equals a specific target number using a dictionary to keep track of the elements you've seen so far. Here's a sample implementation:

class TwoSumFinder:
    def __init__(self,numbers,target):
        self.numbers = numbers
        self.target = target
        self.indices = {}

    def find_indices(self):
        for i, num in enumerate(numbers):
            complement = target - num
            if complement in self.indices:
                return [self.indices[complement], i]
            self.indices[num] = i
        return None

# Example usage
if __name__ == "__main__":
    numbers = [10, 20, 10, 40, 50, 60, 70]
    target = 50

    finder = TwoSumFinder(numbers,target)
    result = finder.find_indices()

    if result:
        print(f"Output: {result[0]}, {result[1]}")
    else:
        print("No pair found with the given target sum.")

In this code, we define a `TwoSumFinder` class with an `__init__` method to initialize array (`self.numbers`), target number(`self.target`) and an empty dictionary (`self.indices`). The `find_indices` method iterates through the elements of `numbers` list. For each element, it calculates the complement needed to reach the target sum and checks if that complement exists in the dictionary. If it does, it returns the indices of the two elements that add up to the target sum. If no such pair is found, it returns `None`.
The example usage at the end demonstrates how to create an instance of the `TwoSumFinder` class and use it to find the indices of the pair of elements that add up to the target sum. In this case, it would print "Output: 3, 4" as specified in your example input and output.

Additionaly, there are also some alternative functions which provides same functionality.
* Method 1: Brute Force (Nested Loop)

    def find_indices_bruteforce(numbers, target):
        n = len(numbers)
        for i in range(n):
            for j in range(i+1, n):
                if numbers[i] + numbers[j] == target:
                    return [i, j]
        return None

This method uses a nested loop to compare each pair of elements in the array. It has a time complexity of O(n^2).
* Method 2: Sorting and Two Pointers

    def find_indices_sorted(numbers, target):
        sorted_numbers = sorted(enumerate(numbers), key=lambda x: x[1])
        left, right = 0, len(numbers) - 1

        while left < right:
            current_sum = sorted_numbers[left][1] + sorted_numbers[right][1]
            if current_sum == target:
                return [sorted_numbers[left][0], sorted_numbers[right][0]]
            elif current_sum < target:
                left += 1
            else:
                right -= 1

        return None

This method involves sorting the array and then using two pointers to find the pair. It has a time complexity of O(n log n) due to the sorting step.
* Method 3: Using a Set

    def find_indices_set(numbers, target):
        seen = {}
        for i, num in enumerate(numbers):
            complement = target - num
            if complement in seen:
                return [seen[complement], i]
            seen[num] = i
        return None

This method is similar to the dictionary-based approach but uses a set to store the seen elements. It has a time complexity of O(n).