🚀 Understanding Method Overriding, Method Hiding, and Overloading in Java 🚀

Ravi Sarva — Mon, 01 Apr 2024 16:11:49 +0000

In Java, developers often encounter concepts like Method Overriding, Method Hiding, and Method Overloading. These concepts empower polymorphism, enhancing code clarity and flexibility. Let's explore each concept using examples:

Method Overriding:

Method overriding occurs when a subclass provides its specific implementation of a method inherited from its superclass. This enables altering method behavior while maintaining the method name and signature.

class P {
    public void m1() {
        System.out.println("P class m1 method is called");
    }

    class C extends P {
        @Override
        public void m1() {
            System.out.println("C class m1 method is called");
        }
    }
}

public class Test {
    public static void main(String[] args) {
        P p = new P();
        p.m1();

        P.C c = new P().new C();
        c.m1();

        P p1 = new P().new C();
        p1.m1();
    }
}

The output will be :
P class m1 method is called
C class m1 method is called
C class m1 method is called

Method Hiding:

Method hiding, on the other hand, occurs when a subclass defines a static method with the same signature as a static method in its superclass. Unlike method overriding, where the subclass method overrides the superclass method's behavior, in method hiding, the subclass method shadows the superclass method.

Let's consider an example:

class P {
    public static void m1() {
        System.out.println("P class m1 method is called");
    }
    class C extends P {
        public static void m1() {
            System.out.println("C class m1 method is called");
        }
    }
}

In this scenario, C class defines a static method m1() with the same signature as the static method m1() in class P. However, this is not method overriding; it's method hiding. When invoking static methods, Java binds the method call at compile time, unlike dynamic dispatch in method overriding.

The output will be :
P class m1 method is called
P class m1 method is called
P class m1 method is called

Conclusion:

Understanding method overriding, method hiding, and method overloading is essential for writing clean, flexible, and maintainable Java code. Method overriding enables subclass-specific behavior, method hiding allows subclass methods to shadow superclass methods, and method overloading provides flexibility in method invocation with different parameter lists. By mastering these concepts, Java developers can leverage the power of polymorphism and write efficient and expressive code.

🚀 Mastering Array Rotation in Java: Algorithms and Time Complexities 🕰️

Ravi Sarva — Tue, 03 Oct 2023 14:53:50 +0000

Are you ready to take your Java programming skills to the next level? Let's dive into the fascinating world of array manipulation as we tackle the "Rotate an Array" problem with finesse! 🌟

Problem Statement
Imagine you have an array of integers, and you want to perform a cyclic right rotation on it by a certain number of positions, say k. Sounds tricky? Don't worry; we've got some nifty Java solutions for you!

Example:
Given the input array [1, 2, 3, 4, 5, 6, 7] and k = 3, the expected output is [5, 6, 7, 1, 2, 3, 4]. Magic, right? 🪄

🌟 Solution 1: The Brute Force Approach 🌟
Time Complexity: O(n * k)
In this approach, we roll up our sleeves and rotate the array one step at a time for k steps. It might not be the most efficient solution, but it's a great way to start understanding the problem.

// Java code for rotating an array using brute force
    public void rotate(int[] nums, int k) {
        int n = nums.length;
        k = k % n; // handle cases where k > n
        for (int i = 0; i < k; i++) {
            int temp = nums[n - 1];
            for (int j = n - 1; j > 0; j--) {
                nums[j] = nums[j - 1];
            }
            nums[0] = temp;
        }
    }

🚀 Solution 2: Using Extra Space 🚀
Time Complexity: O(n)

// Java code for rotating an array using extra space
public void rotate(int[] nums, int k) {
    int n = nums.length;
    int[] result = new int[n];
    for (int i = 0; i < n; i++) {
        result[(i + k) % n] = nums[i];
    }
    System.arraycopy(result, 0, nums, 0, n);
}

Next up, we take a more space-efficient approach. We create a new array and elegantly copy the rotated elements to it. This solution offers a significant improvement in time complexity.

🌪️ Solution 3: Reversal Algorithm 🌪️
Time Complexity: O(n)

In this solution, we take a smart approach. We reverse the array in parts: first, the entire array, then the first k elements, and finally the remaining elements. This results in an efficient solution with an optimal time complexity.

// Java code for rotating an array using the reversal algorithm
public void rotate(int[] nums, int k) {
    int n = nums.length;
    k = k % n;
    reverse(nums, 0, n - 1);
    reverse(nums, 0, k - 1);
    reverse(nums, k, n - 1);
}

private void reverse(int[] nums, int start, int end) {
    while (start < end) {
        int temp = nums[start];
        nums[start] = nums[end];
        nums[end] = temp;
        start++;
        end--;
    }
}

🎉 Conclusion 🎉
You've just unlocked three powerful techniques to tackle the "Rotate an Array" problem in Java! Each solution comes with its own time complexity, allowing you to choose the best fit for your specific problem and performance requirements.

Brute Force Approach (Time Complexity: O(n * k)): Simple and intuitive.
Using Extra Space (Time Complexity: O(n)): Space-efficient and effective.
Reversal Algorithm (Time Complexity: O(n)): Smart and optimal.

Feel free to ask questions, share your thoughts, or dive deeper into these solutions in the comments section below! 🤓

Happy coding, and remember, the sky's the limit when you master your algorithms! ✨

DEV Community: Ravi Sarva

🚀 Understanding Method Overriding, Method Hiding, and Overloading in Java 🚀

Method Overriding:

Method Hiding:

Conclusion:

🚀 Mastering Array Rotation in Java: Algorithms and Time Complexities 🕰️