Overloading simply refers to defining multiple methods in a class, that have the same name, but differ in the number of parameters, the type of parameters, or a combination of both. Consider the following java methods below in the Product class, for instance, which compute and return the product of a number:

To merge rows from two or more tables according to a shared column, SQL joins are utilized. This facilitates data analysis and manipulation by enabling you to access data from numerous tables in a single query.

Here are the main types of SQL joins:

1. INNER JOIN

• Definition: Combines rows from two tables based on a common column but only returns the rows where there is a match in both tables.

• Syntax:

  SELECT columns
  FROM table1
  INNER JOIN table2
  ON table1.column = table2.column;
  

• Example: If we have Customers and Orders tables, an INNER JOIN will return only customers who have placed orders.

  SELECT Customers.Name, Orders.OrderID
  FROM Customers
  INNER JOIN Orders
  ON Customers.CustomerID = Orders.CustomerID;
  

2. LEFT JOIN (or LEFT OUTER JOIN)

• Definition: Returns all rows from the left table (the first table), and the matching rows from the right table (the second table). If there is no match, NULL values are returned for the right table columns.

• Syntax:

  SELECT columns
  FROM table1
  LEFT JOIN table2
  ON table1.column = table2.column;
  

• Example: A LEFT JOIN between Customers and Orders will return all customers, even if they haven't placed any orders.

  SELECT Customers.Name, Orders.OrderID
  FROM Customers
  LEFT JOIN Orders
  ON Customers.CustomerID = Orders.CustomerID;
  

3. RIGHT JOIN (or RIGHT OUTER JOIN)

• Definition: Similar to the LEFT JOIN, but returns all rows from the right table (the second table), and the matching rows from the left table (the first table). If there is no match, NULL values are returned for the left table columns.

• Syntax:

  SELECT columns
  FROM table1
  RIGHT JOIN table2
  ON table1.column = table2.column;
  

• Example: A RIGHT JOIN between Customers and Orders will return all orders, even if they weren't placed by any customer.

  SELECT Customers.Name, Orders.OrderID
  FROM Customers
  RIGHT JOIN Orders
  ON Customers.CustomerID = Orders.CustomerID;
  

4. FULL JOIN (or FULL OUTER JOIN)

• Definition: Returns all rows when there is a match in either the left table or the right table. If there is no match, NULL values are returned for the missing side.

• Syntax:

  SELECT columns
  FROM table1
  FULL JOIN table2
  ON table1.column = table2.column;
  

• Example: A FULL JOIN between Customers and Orders will return all customers and all orders, even if there is no match.

  SELECT Customers.Name, Orders.OrderID
  FROM Customers
  FULL JOIN Orders
  ON Customers.CustomerID = Orders.CustomerID;
  

5. CROSS JOIN

• Definition: Returns the Cartesian product of the two tables, i.e., all possible combinations of rows between the two tables. No ON condition is used here.

• Syntax:

  SELECT columns
  FROM table1
  CROSS JOIN table2;
  

• Example: If Customers has 3 rows and Orders has 2 rows, a CROSS JOIN will return 6 rows (3 * 2).

  SELECT Customers.Name, Orders.OrderID
  FROM Customers
  CROSS JOIN Orders;
  

6. SELF JOIN

• Definition: A self join is a join where a table is joined with itself. It is useful for hierarchical or recursive relationships within the same table.

• Syntax:

  SELECT a.columns, b.columns
  FROM table a
  JOIN table b
  ON a.column = b.column;
  

• Example: A table of employees with a manager reference could be joined with itself to show each employee and their manager.

  SELECT e.EmployeeName, m.EmployeeName AS Manager
  FROM Employees e
  LEFT JOIN Employees m
  ON e.ManagerID = m.EmployeeID;
  

Key Takeaways:

• INNER JOIN: Returns only matching rows.
• LEFT JOIN: Returns all rows from the left table, and matched rows from the right table.
• RIGHT JOIN: Returns all rows from the right table, and matched rows from the left table.
• FULL JOIN: Returns all rows when there is a match in either table.
• CROSS JOIN: Returns the Cartesian product of two tables (no condition).
• SELF JOIN: Joins a table with itself.

Overriding refers to rewriting a method in a subclass that is already provided by its respective superclass. If the method in the subclass is said to have the same name as the method in its respective superclass, AND the same parameters or method signature, AND the same return type, the method in the subclass is said to "override" the method in the superclass. Overriding is one of the fundamental concepts in polymorphism. Consider the following example:

// Java program to demonstrate
// method overriding in java

// Base Class
class SuperClass {
    void show() { System.out.println("SuperClass's show."); }
}

// Inherited class
class SubClass extends SuperClass {
    // This method overrides show() of SuperClass
    @Override void show()
    {
        System.out.println("SubClass's show()");
    }
}

// Driver class
class Main {
    public static void main(String[] args)
    {
        // If a SuperClass type reference refers
        // to a SuperClass object, then SuperClass's
        // show is called
        SuperClass obj1 = new SuperClass();
        obj1.show();

        // If a SuperClass type reference refers
        // to a SubClass object, then SubClass's show()
        // is called. This is called RUN TIME
        // POLYMORPHISM.
        SuperClass obj2 = new SubClass();
        obj2.show();
    }
}

JavaScript is another programming language that is considered to be "interpreted", meaning that the source code you write is executed directly by the interpreter line-by-line, rather than being compiled into machine code ahead of time. JavaScript is primarily used in the frontend development, such as creating interactive elements in websites and other web applications. However, it is also used widely for backend development, which involves server-side programming, thanks to Node.js.