In this blog, I’ll explain what Mojo is, why it’s important, and how it could shape the future of AI development.

So, What is Mojo?

Mojo is a programming language created by Modular, made especially for AI developers. It’s designed to be as easy to use as Python, but with the speed of C++. Mojo isn’t just another language, it’s built to work efficiently with modern AI hardware like GPUs (For those who don’t know: Graphics Processing Unit is a specialized processor designed to handle the complex calculations needed to render images and videos on a screen) and TPUs.

Here’s the best part: Mojo is compatible with Python, so you can use what you already know, while also gaining powerful features like better memory control, stronger typing, and multithreading when needed.

Why Mojo Stands Out ?

Pythonic Syntax

Mojo code looks and feels like Python. If you're comfortable writing Python, the learning curve for Mojo is surprisingly gentle.

Unmatched Performance

Mojo compiles down to machine code and leverages features like static typing (If u don’t know : datatype is defined when you write the code), zero-cost abstractions (a feature that allow us to write clean code without comprimising the performance) , and fine-grained hardware control. This makes it an ideal choice for developers looking to enhance their AI applications without sacrificing ease of use.

System Programming + AI

In the past, system programming and AI development were separate areas. Mojo connects these two, allowing you to write both low-level kernels and high-level model logic using one language.

Full Hardware Control

You will get direct access to GPUs, vector units, and custom AI chips, something Python doesn’t offer natively.

Have a look at this sample code

fn square(x: Int) -> Int:
    return x * x

print(square(5))  # Output: 25

#NB: this isn't Python

• fn indicates that you're defining a function.

• square is the name of the function.

• (x: Int) is the parameter. x is the input to the function, and Int specifies that x is expected to be an integer (a whole number).

• -> Int means the function will return an integer (specifically, the result of squaring x).

The function square takes an integer, multiplies it by itself, and returns the result. When you call square(5), it outputs 25 because 5 squared equals 25.

Where Mojo Fits In

• Creating fast machine learning kernels

• Improving model performance on edge devices(local computing devices)

• Running AI on special chips

• Replacing important performance parts of Python-based machine learning pipelines

Conclusion

Mojo may still be in its early days, but its potential is undeniable. With seamless Python compatibility, powerful hardware access, and lightning-fast performance, it’s primed to become the go-to language for AI development in the near future. The combination of simplicity and speed could truly reshape how we build and scale AI applications.The future of AI development is looking brighter than ever!

Thanks for reading, and stay tuned for more updates!

Authentication vs Authorization

Authentication is about confirming ‘who you are’. It's the process of verifying your identity, like when you log in to a website with a username and password. The system checks if you are who you say you are.

Authorization is about checking ‘what you are allowed to do’. After you're authenticated, the system checks if you have permission to access certain resources or perform specific actions, like viewing a page or editing a file.

JWT

JWT (JSON Web Token) is like a digital ID card. When you log in to a website or app, the server gives you this "ID card" (the JWT), which proves who you are.

• It's a small piece of information, made up of three parts: header, payload, and signature.

• You send this token every time you make a request (like visiting a new page or getting data) to prove you're logged in.

• The server doesn't need to look you up in a database every time—it just checks the token.

Think of JWT as a fast and secure way for the server to remember who you are and what you're allowed to do.

Parts of JWT

A JWT consists of three parts separated by periods ‘.’, which are base64url-encoded strings:

1. Header: The header typically consists of two parts;

   a. the token type (JWT)

   b. the signing algorithm being used, such as HMAC SHA256 or RSA.

   Example

    {
     "alg": "HS256",
     "typ": "JWT"
    }
   

2. Payload: The payload contains the claims, which are statements about the user or other data. Claims can be of three types: registered, public, and private claims.

   Example:

    {
      "sub": "user1",
      "name": "Sankarlal",
      "admin": true
    }
   

   Signature: To create the signature part, you need to take the encoded header, encoded payload, a secret, and the algorithm specified in the header, then sign that with the secret. The signature is used to verify that the sender of the JWT is who it says it is and to ensure that the message wasn’t changed along the way.

   Example (using HMAC SHA256):

3.   HMACSHA256(
       base64UrlEncode(header) + "." + base64UrlEncode(payload),
       secret
     )
   

Working of JWT

When a user logs in or attempts to access a protected resource, the server generates a JWT after successful authentication(login process).

The client then stores this token, usually in local storage or a cookie.

For every subsequent request that requires authentication, the client sends the JWT in the request headers.

The server checks the token to make sure it’s valid and that the user has the right permissions before allowing access.

ACCESS TOKENS

Access tokens are temporary keys that allow users to access specific resources after logging in. They contain user information and are sent with requests to verify permissions, usually expiring after a short time for added security.

REFRESH TOKENS

A refresh token is a special type of key that helps you get new access tokens. This way, you can use short-lived access tokens that expire quickly without needing to log in again each time one runs out.

Access tokens contain user information and are valid for a short time. Refresh tokens, on the other hand, are kept safe as HTTP-only cookies(a type of cookie that can only be accessed by the server and not by client-side scripts, such as JavaScript). They allow you to stay logged in longer without risking your sensitive information being accessed by client-side JavaScript.

Integrating Access and Refresh Tokens

Step 1: Setup Environment

• Install Dependencies: Make sure you have the necessary packages installed: dotenv, express, cookie-parser, and jsonwebtoken.

• Environment Variables: Set up your .env file with two secrets:

    ACCESS_TOKEN_SECRET=your_access_token_secret
    REFRESH_TOKEN_SECRET=your_refresh_token_secret
  

Step 2: Initialize Express App

• Create an Express Application: Use Express to handle HTTP requests.

• Middleware Configuration: Set up middleware to parse JSON and URL-encoded data, and to handle cookies.

•     const app = express();
      app.use(express.json());
      app.use(express.urlencoded({ extended: false }));
      app.use(cookieparser());
  

Step 3: Define User Credentials

• Simulated User Data: Create an object with sample user credentials for authentication.

•     const userCredentials = {
          username: 'sankar',
          password: 'sankarlal2024',
          email: 'sankarlal@gmail.com'
      }
  

Step 4: Implement Login Route

• Handle Login Requests: Create a POST endpoint /login to authenticate users.

• Check Credentials: Verify the provided username and password against the stored credentials.

•     app.post('/login', (req, res) => {
         // Destructuring username & password from body
          const { username, password } = req.body;
  
         // Checking if credentials match
          if (username === userCredentials.username &&
              password === userCredentials.password) {
  
        //creating a access token
             const accessToken = jwt.sign({
              username: userCredentials.username,
              email: userCredentials.email
               }, process.env.ACCESS_TOKEN_SECRET, { expiresIn: '10m' });
  
       // Creating refresh token not that expiry of refreh token
  
              const refreshToken = jwt.sign({
                  username: userCredentials.username,
              }, process.env.REFRESH_TOKEN_SECRET, { expiresIn: '1d' });
  
              // Assigning refresh token in http-only cookie 
              res.cookie('jwt', refreshToken, {
                  httpOnly: true,
                  sameSite: 'None', 
                  secure: true,
                  maxAge: 24 * 60 * 60 * 1000
              });
              return res.json({ accessToken });
          }
          else {
              // Return unauthorized error if credentials don't match
              return res.status(406).json({
                  message: 'Invalid credentials'
              });
          }
      })
  

Step 5: Implement Token Refresh Route

• Handle Refresh Requests: Create a POST endpoint /refresh to obtain a new access token using the refresh token.

• Verify Refresh Token: Check if the refresh token exists and is valid.

•     app.post('/refresh', (req, res) => {
          if (req.cookies?.jwt) {
  
       // Destructuring refreshToken from cookie
              const refreshToken = req.cookies.jwt;
  
        // Verifying refresh token
              jwt.verify(refreshToken, process.env.REFRESH_TOKEN_SECRET,
                  (err, decoded) => {
                      if (err) {
                          // Wrong Refesh Token
                  return res.status(406).json({ message: 'Unauthorized' });
                      }
                      else {
                          // Correct token we send a new access token
                          const accessToken = jwt.sign({
                              username: userCredentials.username,
                              email: userCredentials.email
                          }, process.env.ACCESS_TOKEN_SECRET, {
                              expiresIn: '15m'
                          });
                          return res.json({ accessToken });
                      }
                  })
          } else {
              return res.status(406).json({ message: 'Unauthorized' });
          }
      })
  

Step 6: Start the Server

• Run the Application: Listen on a specified port to start the server.

•     app.listen(6700, () => {
          console.log(`Server active on http://localhost:${6700}!`);
      });
  

So this code demonstrates how to use access tokens for immediate access and refresh tokens for prolonged authentication. The access token is short-lived and needs to be refreshed periodically using the refresh token stored securely in an HTTP-only cookie, ensuring better security and user experience.

What is Encapsulation?

Just imagine a capsule pill. The medicine inside the capsule is not exposed directly. Instead, it's encapsulated within a shell. You can only access the medicine by consuming the capsule. This ensures that the medicine is protected and delivered in the right way.

In the same way, in Java, encapsulation is like putting your data (variables) inside a protective shell (class) and controlling access to it through methods.

Now let's look at an Example.

Let's say we have a Studentclass. We want to keep the student's age private and control how it's accessed and modified.

1. Define the class with private fields:

   • We make the age field private so it cannot be accessed directly from outside the class.

2. Provide public methods to access and modify the age:

   • We create public getter and setter methods to access and update the age.

Let's look at the code illustration for this.

public class Student{
    // declare age as private field
    private int age;

    // a public method to get the age
    public int getAge() {
        return age;
    }

    // now, a public method to set the age with some validation
    public void setAge(int age) {
        if (age >= 0) { // Validating that age cannot be negative
            this.age = age;
        } else {
            System.out.println("Age cannot be negative");
        }
    }
}

Now, let's look how can we use the "Student" class

public class Main {
    public static void main(String[] args) {
        Student s1= new Student();

        // Set the age using the setter method
        s1.setAge(16);

        // Get the age using the getter method
        System.out.println("Student's age: " + s1.getAge());

        // Try to set an invalid age
        s1.setAge(-5); // This will print "Age cannot be negative"
    }
}

So, here we are implementing two things,

1. Setting the Age:

• s1.setAge(16);

• This line calls the setAgemethod on the Studentobject, passing "16" as an argument. The setAgemethod updates the private agefield with this value.

2. Getting the Name:

   • System.out.println("Student's age: " + s1.getAge());

   • This line calls the getAgemethod on the studentobject. The getAgemethod returns the value of the private agefield, which is then printed to the console.

1. Data Hiding : The age field is private, so it cannot be accessed directly from outside the Studentclass. This means the internal state of the Studentis hidden from the outside world.

2. Controlled Access : We provide public methods getAge() and setAge(int age) to access and modify the age field. This allows us to add validation logic inside the setAge() method to ensure that the age cannot be set to a negative value.

Why we use Encapsulation?

There are several advantages for using Encapsulation;

1. Data Protection: By making fields private, you can prevent external code from changing the state of the object in unexpected ways.

2. Controlled Access: By providing public getter and setter methods, you can control how the internal state of an object is accessed and modified. This allows you to add validation, logging, or other logic when the state is changed.

3. Easy to maintain: Encapsulation helps to keep the code modular. So that every class can be developed, tested and maintained independently.

4. Resuability: It encourages the creation of reusable components. By exposing only the necessary details through public methods, you can create classes that can be reused across different parts of an application.

Getter and Setter Methods

We have already mentioned about the getter and setter methods above. So now lets understand what are these in detail.

In Java, getter and setter methods are used to access and modify the private fields of a class from outside the class. They are part of the encapsulation concept.

• Getter Method: This method is used to read or "get" the value of a private field.

• Setter Method: This method is used to update or "set" the value of a private field.

Why we use these Getter and Setter methods?

Since fields in a class are often made private to protect them from direct access, getter and setter methods provide a way to access and update these private fields indirectly. This allows for controlled access and modification.

So, let's take the same example from above and explain it again. This will help beginners understand it with more clarity.

Imagine a simple class called Studentwith a private field name.

Step - 1

Define the class with a private field.

public class Student {
 private String name; // private field
}

Here, name is a private field, meaning it cannot be accessed directly from outside the Studentclass.

Step - 2

Create setter and getter methods - to access and modify the name field.

public class Student{
private String name;

//getter method
public String getName() // getter and setter are not predefined method names.
  {
   return name;
  }

//setter method
public String setName(){
    this.name= name
  }
}

Step -3

Now let's see how can we access and update the name field value in the above code.

public class Main {
    public static void main(String[] args) {
        Student s1= new Student();  // Create a new Student object

        // Set the name using the setter method
        s1.setName("Sankarlal");

        // Get the name using the getter method
        System.out.println("Student's name: " + s1.getName());  // Output: Student's name: Sankarlal
    }
}

1. Setting the Name:

   • s1.setName("Sankarlal");

   • This line calls the setName method on the studentobject, passing "Sankarlal" as an argument. The setName method updates the private name field with this value.

2. Getting the Name:

   • System.out.println("Student's name: " + s1.getName());

   • This line calls the getName method on the studentobject. The getName method returns the value of the private name field, which is then printed to the console.

I think now you have a good understanding of Encapsulation and how getter and setter methods work.

Current Date and Time

So the first thing is how to get the current date and time using JavaScript? It's very simple as we have a built-in Date object for that- "new Date()". We only need to call it.

let currentDate = new Date()
console.log(currentDate)

//OUTPUT
2024-02-19T16:32:30.069Z

Current Year

Next is how to get the current year. For that we have a method which can be used along with Date object. It is "getFullYear()".

const currentDate = new Date().getFullYear();
console.log(currentDate);

//OUTPUT
2024

Current Month(0-11)

To fetch the current month we have a built-in method called "getMonth()", which can be used with Date object. Here you should know that this will return the present month index number and it starts with 0 for "January" and ends with 11 for "December". In real time it's February now, so if I use this method it will return 1, and if i have used this in last month, which is January, then it would have returned 0, and 2 for March and it goes on.

const currentDate = new Date().getMonth();
console.log(currentDate);

//OUTPUT
1 // as it is February

If you want to return the current month in words, you can use like this;

const months = [
 "January", "February", "March", "April", "May", "June",
  "July", "August", "September", "October", "November", "December"
]

const currentMonth = new Date().getMonth();
const monthInWords = months[currentMonth];
console.log(monthInWords);

//OUTPUT
February

Current Date(1- 31)

If you want to get just the current day in number, you can use the "getDate()" method along with Date object. You will get a value between 1-31 based on which date is today.

const currentDate = new Date().getDate();
console.log(currentDate);

//OUTPUT
19

Current Day of the Week(0-6)

For that we use "getDay()" method. This will return a number between 0 to 6, where 0 indicates "Sunday" and 6 indicates "Saturday".

const currentDate = new Date().getDate();
console.log(currentDate);

//OUTPUT
1 // as today is Monday

Hours, Minutes, Seconds and Milliseconds

For fetching these you can use these methods respectively; getHours(), getMinutes(), getSeconds(), getMilliseconds():

const currentDate = new Date().getHours();
console.log(currentDate);

//OUTPUT
22

What is Date.now( ) ?

It is a static method of Date object. It returns current time in milliseconds. It actually returns number of milliseconds elapsed since January 1, 1970, 00:00:00 UTC, according to the system clock.

const currentDate = Date.now();
console.log(currentDate);

//OUTPUT
1708363554396

Usage: This provides a high-resolution timestamp that is useful for precise timing calculations.

Date.UTC( ) - Important

When dealing with dates, sometimes we may encounter inaccuracies in time due to changes in local time zones. In such cases, you can use "Date.UTC( )" to retrieve the exact time, ensuring precision and consistency regardless of local time zone variations.

Before looking at the you need to understand what is UTC. You all might have heard about GMT(Greenwich Mean Time). It is a time standard that is often used as a reference point for timekeeping.

• It is based on the mean solar time at the Prime Meridian (0° longitude) located in Greenwich, London, UK.

• Historically, GMT was used as the international civil time standard before being replaced by Coordinated Universal Time (UTC).

So, UTC(Coordinated Universal Time) is a time standard that is essentially a successor to GMT. It is more precisely defined and does not vary with Earth's irregular rotation.

Now, let's write a code to fetch the first date of the current month using "Date.UTC()".

const currentDate = new Date();
const firstDateOfMonth = new Date(Date.UTC(currentDate.getFullYear(), currentDate.getMonth(), 1));
console.log(firstDateOfMonth);


//OUTPUT
2024-02-01T00:00:00.000Z

and if i write the same code without Date.UTC( ) for getting the first date of the month, then the output is like this.

const currentDate = new Date();
const firstDateOfMonth = new Date(currentDate.getFullYear(), currentDate.getMonth(), 1);
console.log(firstDateOfMonth);

//OUTPUT
2024-01-31T18:30:00.000Z

There is a difference by some hours between two outputs.

Formatting Dates

This is one of the most common requirements in almost all applications. When we fetch dates using the Date object, they typically come in the format 'YYYY-MM-DDTHH:mm:ss.sssZ'. However, in the user interface (UI) of our application, we often need to display dates in a more readable format. To achieve this, we can use date formatting.

1. toLocaleDateString( )

   If you want dates in this format "Monday, February 19, 2024" instead of "2024-02-19T16:32:30.069Z", we can use "toLocaleDateString( )" method. So, let's see how it works.

   So, in short it provides a way to format date according to the locale(refers to a set of parameters that define the user's language, region, and cultural preferences in computing and software applications) of the user's browser.

//SYNTAX

const formattedDate = date.toLocaleDateString(locale, options);

• locale: It's optional. It's a string representing the locale used for formatting dates (e.g., "en-US" for English (United States), "fr-FR" for French (France)).

• options: It's also optional. It's an object containing options for formatting the date, such as weekday, year, month, day, hour, minute, second, timeZone, etc.

Now let's go in detail with examples.

const currentDate = new Date();
const dateFormatted = currentDate.toLocaleDateString("en-US", {
  weekday: "long",
  day: "numeric",
  month: "long",
  year: "numeric",
});
console.log(dateFormatted);

//OUTPUT
Monday, February 19, 2024

1. moment.js

   This is a javaScript library which can be used for parsing, validating, manipulating, and formatting dates.

//Before using Install it in the terminal using the following command
npm install moment

// AND INCLUDE USING moment.js
const moment = require('moment'); // this is for Node.js

Now, let's look at an example how we can format dates using moment.js

const moment = require("moment");
const formattedDate = moment().format("MMMM Do YYYY, h:mm:ss a");
console.log(formattedDate);

//OUTPUT
February 19th 2024, 1:16:23 pm

Moment.js allows for extensive customization of date formatting using format strings. For example:

• "MMMM": Month in full name

• "Do": Day of the month with ordinal (e.g., "1st", "2nd", "3rd", etc.)

• "YYYY": Full year

• "h:mm:ss a": Hour, minutes, seconds, and AM/PM specification.

Time Zone Customization

In moment.js time zones can be customized using "moment-timezone" extension. This extension allows you to work with time zones and convert dates between different time zones.

//Before using Install it in the terminal using the following command
npm install moment moment-timezone

Let's look at the syntax with an example

const moment = require('moment');
require('moment-timezone');

// Create a Moment.js object
const date = moment();

// Display the current date and time in a specific time zone
const formattedDate = date.tz('America/New_York').format('YYYY-MM-DD HH:mm:ss');

console.log(formattedDate);

//OUTPUT
2024-02-19 03:29:48

ISO Date

The ISO 8601 format is an internationally accepted standard for representing dates and times in a way that is easily readable and sortable. It was developed by the International Organization for Standardization (ISO).

The basic format for dates and times in ISO 8601 is as follows:

• Date: YYYY-MM-DD (e.g., 2024-02-19)

• Time: HH:mm:ss (e.g., 12:30:00)

• Combined Date and Time: YYYY-MM-DDTHH:mm:ss (e.g., 2024-02-19T12:30:00)

The extended format allows for more precision and includes additional components:

• Date: YYYY-MM-DD (e.g., 2024-02-19)

• Time: HH:mm:ss.sss (e.g., 12:30:00.000)

• Time Zone Offset: ±HH:mm or ±HHmm (e.g., +05:00, -0800)

• Combined Date and Time with Time Zone Offset: YYYY-MM-DDTHH:mm:ss.sssZ±HH:mm (e.g., 2024-02-19T12:30:00.000Z).

So, in short this is a standardized and efficient way to represent dates.

Converting dates to ISO format.

Sometimes, we need to convert dates into ISO String format in our projects or applications. So for that we use the "toISOString( )" method.

const date= new Date();
const isoDate = date.toISOString();
console.log(isoDate);

//OUTPUT
2024-02-19T12:30:00.000Z

So these all are the main things I would like to explain in this article related to Dates in JavaScript.

In the previous articles, we delve deep into the 2 pillars of OOPs, i.e. Inheritance and Polymorphism. In this, we will understand the important things related to another important pillar of OOPs, i.e. Abstraction. So the first question is;

What's meant by Abstraction in Java?

It is a concept in OOPs, that allows us to hide the complex implementation and show only the essential features of an object or class.

Now if you read this, and go for a real-time example, you will get confused. In many places on the internet, we can see examples of Facebook or WhatsApp, and it says abstraction is like hiding the codes or implementation and just showing what is needed.

So, here there is a possibility that beginners may get confused, they may think that if abstraction is not there we may be able to see the backend codes of applications like Facebook or WhatsApp. But this is not that, abstraction has nothing to do with the end-users of these apps, instead, this is a concept to help the programmers to reduce code complexity and thereby improve the code readability.

Now let's look at a code-based example of Abstraction. Here I'm gonna show you what actually abstraction help us to achieve. We are going to see both the normal method implementation and abstract method implementation.

// NORMAL CLASS
class Animal {
    // Normal method with implementation
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal a1 = new Animal(); 
        // Call the normal method
        a1.makeSound(); // Output: Dog barks
    }
}

The code provided above demonstrates the implementation of a normal class. In the Animal class, there is a method called makeSound() which has an implementation (means it actually explains what that function do, here it has a statement to print "Dog barks"). In the Main class, an instance a1 of the Animal class is created, and we call the makeSound() method using a1.makeSound().

Now let's have a look at the implementation of an abstract class.

// Abstract class
abstract class Animal {
    // Abstract method (no implementation)
    public abstract void makeSound();
}

// Concrete subclass
class Dog extends Animal {
    // Implementing the abstract method
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        // Create an instance of Dog
        Dog d1 = new Dog();

        // Call the abstract method
        d1.makeSound(); // Output: Dog barks
    }
}

"In the example provided above, the Animal class is declared as abstract using the abstract keyword. Inside the abstract class, you can observe the presence of an abstract method, makeSound().

Since this method is abstract, it lacks a direct implementation. It is merely declared without a concrete implementation (without any body). This demonstrates the concept of hiding the code implementation, as mentioned earlier.

In the code, a normal class named Dog is created, and the makeSound() method is implemented within it. It's because, you cannot create an instance of an abstract class directly, which means that Animal a1 = new Animal() is not possible.

Instead, we extend a normal class to create a subclass, as shown in the above program. You can see that in the code, an instance of the Dog class is created using Dog d1 = new Dog(). This instance is then used to call the makeSound() method."

Advantages of Abstraction

1. It improves code readability.

2. It hides the code complexity, by declaring methods as abstract.

3. It supports code reusability, as multiple classes can implement the same interface or extend the same abstract class.

4. It simplifies the code by breaking it into smaller and manageable parts.

Now, we have an idea about the concept of Abstraction in OOPs, now lets have a close look at the Abstract methods.

What is an Abstract Method?

Now we have an idea about abstract class as we have gone through the concept of abstraction. So, abstract method is a method which is declared in a class, but it doesn't have any instructions or details on how it should work, so in short, a method without a body.

It doesn't have an implementation, it only contains the method declaration.

It is also important to note that you have to use the keyword abstract before any abstract method.

NB: When you have an abstract method in a class, you can't create an object directly from that class. You have to create a new class that "extends" the abstract class(subclass) and provides the implementation of your abstract method in that new class(subclass).

So let's see how to create an abstract method as per above instructions;

abstract class Cars {
    // Abstract method without implementation
    abstract void Ferrrari();

    // Regular method with an implementation
    void Audi() {
        System.out.println("This is an Audi car");
    }
}

Now if you want to implement this we have to create a subclass extending the main class called Cars . Let's see how to implement this abstract class called Ferrari .

class SUV extends Cars {
    // Implementation of the abstract method
    void Ferrari() {
        System.out.println("This is the red Ferrari");
    }
}

So here we have created a subclass called SUV and implemented the abstract method Ferrari() . So this is how we implement an abstract method.

Now if you want to create more subclasses and implement the method, you can do that. So let's create another subclass Sedan and implement the same abstract method Ferrari() .

class Sedan extends Cars {
    // Implementation of the abstract method
    void Ferrari() {
        System.out.println("This is the New Sedan model of Ferrari");
    }
}

Let's have a look at the implementation of this.

public class Main {
    public static void main(String[] args) {
        // Creating objects of the concrete classes
        SUV theSuv = new SUV();
        Sedan theSedan = new Sedan();

        // Calling the abstract method and the regular method
        theSuv.Ferrari();  // Output: This is the red Ferrari
        theSuv.Audi();      // Output: This is an Audi car.

        theSedan.Ferrari();  // Output: This is the New Sedan model of Ferrari
        theSedan.Audi();      // Output: This is an Audi car
    }
}

In the Main class, objects of both SUV and Sedan are created and used to call both the abstract method and the regular method.

How to achieve Abstraction in Java?

There are mainly 2 ways to achieve abstraction in Java;

1. using Abstract Class(0 to 100% abstraction).

2. using Interfaces.

You already saw how can we achieve abstraction using an abstract class. So the main things to be noted while creating an abstract class is that you have to use an abstract keyword. You can use both abstract and non-abstract methods in an abstract class. It cannot be instantiated. Also you need to extend a subclass for implementing an abstract method in an abstract class.

So now let's see how to achieve abstraction using Interfaces.

Abstraction using Interfaces

What is an interface?

In simple words we can say its a set of rules. It's more like an agreement, that is if you want to be part of that agreement you must be ready to follow the set of rules provided in the agreement.

In interfaces, all the methods are abstract by default which means in interface we can only declare the methods, there will be no definitions or implementations for that method within the interface.

interface Vehicle {
    void drive();  // Just says: "Hey, you must have a drive() method!"
}

So the next question is, then how will we implement these abstract methods in interfaces?

So, for implementing the methods in an interface, we need to define a class using the keyword 'implements' and then implement those methods which we declare in the interfaces inside that class.

interface Vehicle {
    void drive();  
}

class Road implements Vehicles {
    // We HAVE to provide the implementation for draw() because we said we implement Drawable
    public void drive() {
        System.out.println("Always Drive Carefully");
    }
}

So, this is how we use interfaces to implement abstraction. You can take the example of implementing multiple inheritances in Java as an illustration of interfaces using the concept of abstraction to achieve multiple inheritance in Java.

Is it necessary to have at least one abstract method in an Abstract Class?

No, its is not necessary that an abstract class should contain at least one abstract method. An abstract class can exist without any abstract methods. Abstract classes can also contain concrete methods (methods with a complete implementation), fields, and constructors.

An abstract class provides 0% to 100% abstraction, which means that it can either contain only non-abstract methods (concrete methods), resulting in 0% abstraction, or it can consist entirely of abstract methods, achieving 100% abstraction. It is also possible for an abstract class to contain both abstract and non-abstract methods simultaneously.

Polymorphism is one of the 4 major pillars of OOPs. The other three are Inheritance, Abstraction and Encapsulation.

"Polymorphism" is derived from 2 Greek words, where 'poly' means "many" and 'morphs' means "forms", so in turn polymorphism means "many forms".

So in Java, it's the way of performing a task in different ways, i.e., the same object or method can perform different things in different scenarios.

Now, let me take an example to explain it in a much easier way. The most simple and commonly stated example is that of Shapes. Imagine you have a drawing program that can draw different shapes like circles, squares, and triangles. Each shape can be drawn on the screen, but they have their unique ways of drawing.

So let's see how this works in code.

// this is a common Shape interface
interface Shape {
    void draw();
}

// Let's create specific shape classes that implement Shape
class Triangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Triangle");
    }
}

class Oval implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Oval");
    }
}

class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Rectangle");
    }
}

public class Main {
    public static void main(String[] args) {
        // Im just creating an array of different shapes
        Shape[] shapes = new Shape[3];
        shapes[0] = new Triangle();
        shapes[1] = new Oval();
        shapes[2] = new Rectangle();

      // here we are using polymorphism to draw different shapes
        for (int i = 0; i < shapes.length; i++) {
         Shape shape = shapes[i];
         shape.draw();
       }
    }
}

So if I explain the above example;

1. So here we have a common interface Shape with a method draw().

2. We create specific shape classes (Triangle, Oval, Rectangle) that implements the Shape interface and provide their unique draw() implementations.

3. In the Main class, we create an array of different shapes, each instantiated as a different type of shape (polymorphism).

4. We use a for loop to call the draw() method on each shape, and even though we're using the same method name, each shape draws itself the respective shape based on its specific implementation.

So now you have got an idea about the purpose of Polymorphism. Now let's look at the different ways to achieve this.

1. Method Overloading

2. Method Overriding

Method Overloading

In method overloading, we can use the method with the same name but different parameters within a single class. So in one class, you can have many methods with the same name but different types or different numbers of parameters.

It is also called compile time polymorphism because in the compile time java determines which method to be called based on the number or type of arguments used for method calling.

NB: Parameters of a method is also called method signature.

NB: Return type is not considered while we overload a method, which means 2 methods within a class can have the same or different return types.

NB: Minimum number of classes required to overload a method is 1.

Let's now look at a simple example of method overloading in Java.

public class Calculator {
    // a method to add two numbers
    public int add(int a, int b) {
        return a + b;
    }

    // a method to add three numbers
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    // a method to add two double type numbers
    public double add(double a, double b) {
        return a + b;
    }

    public static void main(String[] args) {
        Calculator c1 = new Calculator();

        int result1 = c1.add(7, 11);
        int result2 = c2.add(4, 3, 9);
        double result3 = c3..add(6.5, 1.9);

        System.out.println("method1= " + result1); // output: method1= 18
        System.out.println("method2= " + result2); // output: method1= 16
        System.out.println("method3= " + result3); // output: method1= 8.4
    }
}

In the above example, the class Calculator used the method with the name add more than once within the class with different numbers and different types of parameters.

If you look at the method you can see an object with name c1 is created and it is used to invoke the methods. Also, it's very important to note that, you have to send the arguments matching the parameters when we call those methods. If you provide arguments of incorrect type or number it will result in a "compilation error".

But if you look at the return type we have used the same as well as different return types. So it's clear that return type is not important in method overloading.

Method Overriding

In method overriding we can use the method with the same name and the same parameters in different classes. So it allows the child class to provide a specific implementation of a method that is already defined in the parent class.

It is important to note that when the child class overrides the method, it provides a new implementation for that method with the same name, parameter and return type.

It is also an example of rum time polymorphism.

NB: For overriding, we require at least 2 classes.

NB: The child class cannot use more restrictive access modifiers than the parent class, which means if the parent class method is public, then child class method should be either public or protected. It cannot be "private".

NB: The overriding method should have the same method name, parameters and return types.

Now let's have a look at an example of overriding.

class ParentCalculator {
    int add(int a, int b) {
        return a + b;
    }
}

class ChildCalculator extends ParentCalculator {
    // Method overriding for add
    @Override
    int add(int a, int b) {
        return a + b + 10; // Adds 10 more than the base class, 
                           // because we can make changes only in this portion.
    }
}

public class Main {
    public static void main(String[] args) {
        ParentCalculator c1 = new ParentCalculator();
        ChildCalculator c2 = new ChildCalculator();

        int result1 = c1.add(7, 11);         // Calls the base class method
        int result2 = c2.add(4, 16);         // Calls the overridden method

        System.out.println("Result1: " + result1); // Result1: 18
        System.out.println("Result2: " + result2); // Result2: 30
    }
}

In this example, we have a ParentCalculator class with an add a method that adds two numbers. The ChildCalculator class extends ParentCalculator and overrides the add a method to add '2' to the result.

When we create instances of ParentCalculator and ChildCalculator and call the add method, you can see how method overriding works.

One of the important questions is that is it possible to override a static method. And the answer is "NO", it's not possible to override a static method as it is bound by a class. Like that we cannot override a main method. Because it's a static method.

So this is how method overloading and method overriding work in Java.

Java does not support multiple inheritance of classes, where a class inherits from more than one class. However, it supports multiple inheritance through interfaces.

Attempting to inherit a child class from two parent classes is not allowed in Java due to potential ambiguity for the compiler.

class Class1 {
    void display(){
        System.out.println("Hello");
}
}

class Class2 {
    void display(){
       System.out.println("Hi");
}
}

// This would result in a compilation error because it tries to inherit from both Class1 and Class2.
class MyClass extends Class1, Class2 {
    // MyClass code
}

For instance, consider two parent classes, Parent Class 1 and Parent Class 2, both containing a method named "void display()."

When you call this method on an object of the child class, the compiler faces a difficult situation in determining which version of "void display()" to execute, leading to confusion and, therefore, Java prohibits inheriting from multiple parent classes simultaneously.

So how can we solve this issue? That's where Interface comes into play. Using interfaces we can easily resolve this issue.

So the next question is why there is no ambiguity for the compiler when we use Interfaces instead of Classes?

The answer to this is straightforward: in interfaces, all methods are abstract by default, meaning they are declared without any method body. To illustrate this concept, let me provide you with an example to clear all confusion.

// Define two interfaces
interface Interface1 {
    void display();
}

interface Interface2 {
    void display();
}

// Implement the interfaces in a class
class MyClass implements Interface1, Interface2 {
    @Override
    public void display() {
        System.out.println("Hello");
    }
}

public class Main {
    public static void main(String[] args) {
        // Create an object of the class
        MyClass myObj = new MyClass();

        // Call methods from the implemented interfaces
        myObj.display();
    }
}

In this example:

1. We define two interfaces, Interface1 and Interface 2, each with a single abstract method.

2. We create a class MyClass that implements both Interface1 and Interface2.

3. Inside MyClass, we provide implementations for the methods defined in both interfaces. Here since both methods are the same, we only need to implement the method once.

4. In the Main class, we create an object of MyClass and call the methods from both interfaces.

This demonstrates that a class can implement multiple interfaces in Java. Thus there won't be any ambiguity for the compiler here.

NB: If the parent classes have methods with different names, then you would need to provide the method implementations for both methods inside MyClass, just as we did for the method void display().

NB: Interface is also a user-defined data type in Java similar to that of class.

Now let's move on to the Hybrid Inheritance.

Hybrid Inheritance

It refers to the combination of different types of inheritance within a program.

It involves multiple inheritance, along with some other type of inheritance such as single inheritance or multilevel inheritance.

But Java doesn't directly support this kind of inheritance as it uses multiple inheritance and this will lead to one of the potential complications called "diamond problem".

(The diamond problem refers to a situation where a class inherits from 2 parent classes with a common ancestor)

In Java, we can achieve this form of inheritance by combining a single inheritance of classes and multiple inheritance through interfaces. This will resolve code complexity and ambiguity issues.

Let's look at an example, of how we solve the diamond problem in inheritance using interfaces.

// Define a grandparent interface
interface Grandparent {
    void grandparentMethod();
}

// Define two parent interfaces
interface Parent1 {
    void parent1Method();
}

interface Parent2 {
    void parent2Method();
}

// Implement the grandparent and parent interfaces in a class
class MyClass implements Grandparent, Parent1, Parent2 {
    @Override
    public void grandparentMethod() {
        System.out.println("Grandparent method implementation");
    }

    @Override
    public void parent1Method() {
        System.out.println("Parent 1 method implementation");
    }

    @Override
    public void parent2Method() {
        System.out.println("Parent 2 method implementation");
    }

    void childMethod() {
        System.out.println("Child method implementation");
    }
}

public class Main {
    public static void main(String[] args) {
        // Create an object of MyClass
        MyClass myObj = new MyClass();

        // Call methods from all interfaces
        myObj.grandparentMethod();
        myObj.parent1Method();
        myObj.parent2Method();
        myObj.childMethod();
    }
}

In the above code,

1. We define a Grandparent interface with one method, grandparentMethod.

2. We define two parent interfaces, Parent1 and Parent2, each with one method.

3. The MyClass class implements all three interfaces, providing implementations for all methods.

4. Additionally, we define a childMethod specific to the MyClass class.

While this example does not directly demonstrate hybrid inheritance with multiple classes, it does show a scenario with one grandparent interface and two parent interfaces, which provides a similar structural concept to what you might see in hybrid inheritance situations.

Inheritance

So what's meant by Inheritance in Java?

If I take an example from real life, inheritance means a child acquires some characteristics or behaviour of their parents. Right? It's almost the same in the case of Java.

In Java, inheritance is a mechanism that allows a class to inherit or acquire the properties and behaviour(attributes and methods) of another class. Here a new class (the child or subclass) can reuse and extend the attributes and methods of an existing class (the parent or superclass).

Advantages of Inheritance

Code reusability- We don't need to rewrite or duplicate code that already exists in the parent class.

Easy Maintenance- When we make some changes in the parent class, that will be automatically inherited by all the child classes.

Extensibility- We can extend the behaviour of the existing child classes by adding new fields and methods or by modifying existing ones.

Consistency- It provides consistency for the code base, which makes it easier to understand and maintain.

Types of Inheritance in Java

1. Single Inheritance

2. Multilevel Inheritance

3. Hierarchical Inheritance

Java also provide support for other 2 inheritances, i.e. Multiple inheritance and Hybrid Inheritance, but not directly instead it supports it through interfaces.

Single Inheritance

Single inheritance means that a class can inherit from only one superclass. In other words, a subclass can have only one immediate parent class.

class Parent {
  // Parent class code
}

class Child extends Parent {
  // Child class inherits from Parent
}

Multilevel Inheritance

Multilevel inheritance occurs when a class inherits from another class, and that class is further inherited by another class. So it's a chain of inheritance.

class Grandparent {
  // Grandparent class code
}

class Parent extends Grandparent {
  // Parent class inherits from Grandparent
}

class Child extends Parent {
  // Child class inherits from Parent
}

Hierarchical Inheritance

Hierarchical inheritance happens when multiple classes inherit from a single superclass, which means that multiple child classes will have a common parent class.

class Parent {
  // Parent class code
}

class Child1 extends Parent {
  // Child1 class inherits from Parent
}

class Child2 extends Parent {
  // Child2 class inherits from Parent
}

So these are the 3 types of inheritance supported by Java. Now we have two more, Multiple inheritance and Hybrid Inheritance. One crucial aspect worth noting is multiple inheritance, a concept achieved in Java through the use of interfaces. I will delve into this topic extensively in the upcoming article.

It is a programming paradigm based on the concept of "objects".

(So what is meant by a Programming paradigm? These are nothing but different ways or styles in which a given program or programming language can be organized)

OOPs follow a bottom-up approach.

(See, in the bottom-up approach we solve smaller problems and then integrate them into a complete solution, whereas in the top-down approach, we break up the problem into smaller parts and then solve it.)

OOPs is based on real-world entities, which means that they just bring, the way we think and conceptualize things into the software design.

C++, Java, Python, C#... etc. are examples of OOPs based programming languages.

Advantages of OOPs

1. Code Reusability- Once we write a code, it can be reused multiple times and this is achieved mainly with the help of a key concept called Inheritance.

2. Security- with the help of Encapsulation, we can bind data(attributes) and methods into a single unit called class and can control the access to these using access specifiers like "Private", "Protected", and "Public.

3. Flexibility- In Java Polymorphism allows us to create multiple classes that can be reused, also it allows us to reuse the methods with "the same name and same parameter" in different classes and "methods with the same name and different parameters" in the same classes. ie. overriding & overloading respectively.

4. Improves Readability - when we use Abstraction, we can create abstract methods, which help in data hiding as well as improve the code readability for the user(here user means a programmer).

Disadvantages of OOPs

1. Complexity- the length of the programs will be larger than the ones written using procedural-oriented programming.

2. Memory Usage- Object-oriented programs tend to consume more memory than the procedural-oriented approach.

3. The overhead of abstraction - excessive use of abstraction may lead to complex code that is difficult to navigate, in such cases, it will be a challenge for the developer to understand how the data and methods are connected.

So these are all the major advantages and disadvantages of OOPs in Java. While stating the disadvantages I have mentioned procedural-oriented programming. So what is that? How is it different from the object-oriented programming approach? Come let's have a look.

OOPs vs. POPs(Procedural-Oriented Programming)

Now, let's have a look at the 2 important features of OOPs, Class and Object.

CLASS

So, what's a class in Java?

In simple words, it's a template or a blueprint for creating "objects". So we can say a class decides the structure and behavior of the object, a class will have.

Example: Car Class

Imagine you are designing a computer program to manage information about cars. In Java, you would create a "Car" class. Here's how you can relate it to real life:

1. Class: Car

   • A class named "Car" represents the blueprint for all cars.

2. Attributes (Data):

   • In our "Car" class, you can define attributes such as:

     • Make (e.g., Audi, BMW)

     • Model (e.g., Q8, 7series)

     • Year (e.g., 2022, 2023)

     • Colour (e.g., Black, Blue)

3. Methods (Behavior):

   • You can also define methods to perform actions, such as:

     • Start the engine

     • Stop the engine

Now, when you create objects from the "Car" class, each object will have its specific values for the attributes (e.g., one car might be a black Audi from 2022, another may be an Ambassador from 1977), and you can use methods to perform actions on those individual cars (e.g., start the engine of a particular car).

So, in this real-life example, the "Car" class serves as a blueprint that defines the structure (attributes) and behaviour (methods) of cars, just like how car manufacturers have blueprints for designing and producing different car models.

NB: But when we speak in technical terms, Class in Java is a user-defined datatype that encapsulates data and behaviour related to a specific concept or entity.

Now let's have a look at Objects in Java.

// Define the Car class
class Car {
    // Attributes
    String make;
    int year;

    // Constructor method
    public Car(String make, int year) {
        this.make = make;
        this.year = year;
    }

    // Methods
    public void startEngine() {
        System.out.println("Engine Started");
    }

    public void stopEngine() {
        System.out.println("Engine Stopped");
    }
}

public class CarExample {
    public static void main(String[] args) {
        // Create instances (objects) of the Car class
        Car car1 = new Car("Audi", 2022);
        Car car2 = new Car("Ambassador", 1977);

        // Use the methods of the Car class
        car1.startEngine();
        car2.accelerate();
    }
}

OBJECT

In Java, an object is an instance of a Java class, meaning it is a copy of a specific class.

It has 3 primary characteristics: identity, state, and behaviour.

Identity: It is a unique identifier like a memory address or a unique name.

State: It controls aspects of an object; in the case of describing a fan, you could have on, off, low, medium, or high state options.

Behaviour: It is used to describe what an object can do, such as a fan turning on or off or changing speeds.

Class Cars{
Cars c1 = new Cars() // an object is created
} 
// Cars - class name
// c1 is the object reference variable
// new keryword(Dynamic Memory Allocator) -  It allocates memory for the object and initializes it.
// Cars() - Constructor call, these are special methods within a class that are used to initialize objects.

So if "Cars" is the class, then "Audi Q8", "Ferrari 296 GTS", "Honda Jazz" etc. will be the objects. So in short the class just instructs how the object should be.

So now let's have a look at the difference between Classes and Objects in Java.

So thats all about the OOPs, Class and Object. Now in the next part, we can look deep into the four main pillars of OOPs, i.e. Inheritance, Polymorphism, Abstraction and Encapsulation.