Add drafts folder and a blogpost

Author: gauravkukade

_drafts/2022-11-03-method-overriding-in-java.md

@@ -0,0 +1,9 @@
+---
+layout: post  
+title: "Method Overriding In Java"  
+author: gaurav
+categories: [Java, Java Interview Questions]
+toc: false
+description: "In this tutorial, we will see the method overriding in Java."
+---
+

_posts/java-programs/2022-10-31-java-reverse-array.md renamed to _drafts/2022-11-07-java-reverse-array.md

@@ -104,7 +104,14 @@ If *one task is performed in different ways*, it is known as polymorphism.
 
 The word ***poly*** means ***many*** and ***morphs*** means ***forms or ways***.
 
-In Java, we use method overloading and method overriding to achieve polymorphism.
+In Java, we use [method overloading](/method-overloading-in-java/) and [method overriding](/method-overriding-in-java/) to achieve polymorphism.
+
+There are two types of polymorphism in Java: 
+
+1. Compile-time Polymorphism
+2. Runtime Polymorphism.
+
+Compile-time polymorphism can be achieved by [**overloading the static method**](/method-overloading-in-java/). While Runtime Polymorphism can be achieved by [**overriding the parent class method in the child class**](/method-overriding-in-java/).
 
 ## Conclusion
 
@@ -115,7 +122,7 @@ In Java, we use method overloading and method overriding to achieve polymorphism
 2. Encapsulation is the **process of grouping data members and corresponding methods in a single unit**. Ex. Java Class
 
 3. In inheritance, **a child class inherits all the properties and behaviour of parent class**. It can be done by extending the parent class. Ex. `class Dog extends Animal{...}`
-4. **Doing one task in many ways** is called polymorphism. In java, polymorphism can be done using **method overloading and method overriding**.
+4. **Doing one task in many ways** is called polymorphism. In java, polymorphism can be done using [method overloading](/method-overloading-in-java/) and [method overriding](/method-overriding-in-java/).
 
 ---
 

_posts/java-interview-questions/2022-10-20-difference-between-abstract-class-and-interface.md renamed to _posts/java-interview-questions/core-java-interview-questions/2022-10-20-difference-between-abstract-class-and-interface.md

@@ -0,0 +1,91 @@
+---
+layout: post  
+title: "Method Overloading In Java"  
+author: gaurav
+categories: [Java, Java Interview Questions]
+toc: false
+description: "In this tutorial, we will see the method overloading in Java."
+---
+
+In this tutorial, we will see the method overloading in Java.
+
+## Introduction
+
+It is known as **Method Overloading** when a class has the same name but a different method signature.
+
+For example, when we have a method `add()`,  we can have it in multiple forms.
+
+For example `add(int a, int b)` or `add(int a, int b, int c)` or `add(double a, double b)`
+
+---
+
+> **What Is Method Signature In Java**
+>
+> In Java, method signature contains method name and type of arguments.
+>
+> <method-name>(<argument-type-1>, <argument-type-2>...)
+>
+> Ex. `getData(int, String)`
+>
+> **Note:** In java, the method signature does not include the name of parameter, it only includes it's datatype.
+
+---
+
+Compile-time polymorphism can be achieved by Method overloading.
+
+In Java, there are two ways to overload the method.
+
+1. By changing number of arguments
+2. By changing the data type of arguments
+
+## 1. By changing number of arguments
+
+We can overload a method **by changing the number of arguments i.e parameters it receives**.
+
+As shown in the example from the introduction, we can overload the method `add(int a, int b)`  by making the parameters three. i.e `add(int a, int b, int c)`
+
+```java
+public class Operation{
+    
+    public static int add(int a, int b){
+        return a+b;
+    }
+    
+    public static int add(int a, int b, int c){
+        return a+b+c;
+    }
+    
+}
+```
+
+## 2. By changing the data type of arguments
+
+We can overload a method **by changing the data type of the arguments i.e parameters it receives**.
+
+As shown in the example from the introduction, we can overload the method `add(int a, int b)`  by changing the data type of the parameters. i.e `add(double a, double b)`
+
+```java
+public class Operation{
+    
+    public static int add(int a, int b){
+        return a+b;
+    }
+    
+    public static double add(double a, double b){
+        return a+b;
+    }
+    
+}
+```
+
+Method overloading improves the readability of the code.
+
+## Conclusion
+
+It is known as **Method Overloading** when a class has the same name but a different method signature.
+
+We can overload the method by changing the number of arguments or changing the data type of arguments.
+
+---
+
+Please write your thoughts in the comment section below.

_posts/java-interview-questions/2022-10-23-java-oops-concepts.md renamed to _posts/java-interview-questions/core-java-interview-questions/2022-10-23-java-oops-concepts.md

@@ -0,0 +1,24 @@
+---
+layout: post  
+title: "ArrayList VS LinkedList"  
+author: gaurav
+categories: [Java, ArrayList, Java Interview Questions]
+toc: false
+description: "In this article, we will see the difference between ArrayList and LinkedList."
+---
+
+In this article, we will see the difference between ArrayList and LinkedList.
+
+## ArrayList Vs LinkedList
+
+{:class="table table-bordered"}
+| Property                                   | ArrayList                                                    | LinkedList                                                   |
+| ------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
+| Internal Implementation                    | ArrayList internally uses a **dynamic array** to store the elements. | LinkedList internally uses a **doubly linked list** to store the elements. |
+| Preference                                 | ArrayList is **preferred for storing and retrieving the data** from the list. | LinkedList is **preferred for inserting and deleting the data** in a list. |
+| Store and Retrieve Data                    | Storing and retrieving the data from the ArrayList is faster since it uses a **dynamic array** to store the elements.<br /><br /><br /> Time complexity for retrieving an element by id from the ArrayList is **O(1)**. | Storing and retrieving the data from the LinkedList is slower in comparison since it uses  a **doubly linked list** to store the elements.<br /><br /><br /> Time complexity for retrieving an element by id from the LinkedList is **O(n)**. |
+| Data Manipulation ( Insert or delete data) | Manipulation with ArrayList is **slower** because it internally uses an array. <br />In case of removing an element from array or inserting an element in between array, all the other elements are shifted in memory. | Manipulation with LinkedList is **faster** than ArrayList because it uses a doubly linked list, so no bit shifting is required in memory. |
+| Interface implementation                   | An ArrayList class can **act as a list** only because it implements List interface only.<br /><br />`ArrayList implements List` | LinkedList class can **act as a list and queue** both because it implements List and Deque interfaces.<br /><br />`LinkedList implements List, Deque` |
+| Memory Location                            | The memory location for the elements of an ArrayList is **contiguous**. | The location for the elements of a linked list is **not contagious**. |
+| Default Capacity                           | On initialisation, a **default capacity of 10** is assigned to the ArrayList. | There is no case of default capacity in a LinkedList. An empty list is created when a LinkedList is initialized. |
+