DEV Community: Mukesh

Abstraction in Java Explained: Abstract Classes vs Interfaces

Mukesh — Mon, 28 Jul 2025 18:27:27 +0000

Understanding Abstraction in Java

In the world of object-oriented programming, abstraction plays a vital role in simplifying complex systems. It allows developers to focus on what an object does rather than how it does it.

What is Abstraction?

Abstraction is the process of hiding internal implementation details and exposing only the essential functionality of an object. It helps reduce programming complexity and effort by providing a cleaner and more focused interface.

In simple terms:
Abstraction lets you focus on the "what" instead of the "how".

For example, when you drive a car, you interact with the steering wheel, pedals, and dashboard. You don’t need to know how the engine works internally—that’s abstraction.

Achieving Abstraction in Java

Java provides two primary ways to achieve abstraction:

1. Abstract Class (0% to 100% Abstraction)

An abstract class in Java is a class that cannot be instantiated and may contain abstract methods (without a body) as well as concrete methods (with a body).

Key Points:

Declared using the abstract keyword.
Can have both abstract and non-abstract methods.
Can include constructors, static, and final methods.
Meant to be extended by subclasses which implement abstract methods.

abstract class Vehicle {
    abstract void start(); // abstract method
    void stop() {
        System.out.println("Vehicle stopped.");
    }
}

Abstract Method:

A method without implementation, declared using the abstract keyword.

abstract void printStatus(); // no body

If a class contains even one abstract method, class must be declared as abstract, or it will result in a compile-time error.

2. Interface (100% Abstraction)

An interface in Java is like contract or blueprint. It defines what should be done, but not how.

Key Points:

Contains only abstract methods and static constants (before Java 8).
Cannot have method bodies (until Java 8).
Supports multiple inheritance.
Promotes loose coupling between components.
Interfaces represent the "IS-A" relationship.

interface Drawable {
    void draw(); // abstract method
}

Enhancements Since Java 8 and 9:

Java 8: Interfaces can have default and static methods.
Java 9: Interfaces can also have private methods.

interface Shape {
    default void log() {
        System.out.println("Logging Shape");
    }
    static void show() {
        System.out.println("Static method in Interface");
    }
}

When to Use What?

Use abstract classes when:
- You want to provide common functionality to all subclasses.
- You want to define non-static or non-final fields.
Use interfaces when:
- You need to implement multiple inheritances.
- You want to define a contract that multiple unrelated classes can implement.

Conclusion

Abstraction is one of the four pillars of object-oriented programming. Whether you choose abstract classes or interfaces depends on your design needs, but both serve the same fundamental purpose: to hide complexity and expose simplicity.

Understanding Covariant Return Types in Java

Mukesh — Sat, 19 Jul 2025 18:50:31 +0000

In Java, polymorphism allows method to be overridden in subclass with different implementation. However, when overriding methods, the return type of the method must usually match exactly. This is where Covariant Return Type comes into play.

What is Covariant Return Type?

The covariant return type specifies that the return type of overridden method in subclass may vary in the same direction as the subclass. In simple terms, if the superclass method returns a type A, then the overridden method in the subclass can return B (where B is a subclass of A).

This feature was introduced in Java 5 and helps make code cleaner, safer, and more readable.

Example of Covariant Return Type in Java

class A {    
    A get() {
        return this;
    }    
}    

class B1 extends A {    
    @Override  
    B1 get() {  // Return type changed to subclass type
        return this;
    }    

    void message() {
        System.out.println("Welcome to covariant return type");
    }    

    public static void main(String args[]) {    
        new B1().get().message();    
    }    
}

Output

Welcome to covariant return type

Explanation

In the above example:
- The get() method in class A returns an object of type A.
- The get() method in subclass B1 overrides this method but changes the return type to B1.
This is valid because B1 is-a A (inheritance).
Both methods are considered overridden, even though they return different types. This behavior is called Covariant Return Type.

Why is Covariant Return Type Useful?

Before covariant return types, we had to perform explicit type casting to access subclass-specific methods after overriding.

With covariant return types:

Avoids confusing type casts in class hierarchies.
Makes the code more readable and maintainable.
In method overriding, it provides the liberty to return more specific types.
Prevents ClassCastException at runtime when handling returned objects.

Key Advantages

Code becomes cleaner and easier to understand.
Reduces boilerplate and explicit type casting.
Improves type safety at compile time.

Polymorphism in Java – Understanding Compile-time and Runtime Behavior

Mukesh — Thu, 17 Jul 2025 19:46:31 +0000

Polymorphism in Java is one of the core concepts of Object-Oriented Programming (OOP). It allows us to perform a single action in different ways. Polymorphism means "many forms". In simple terms, it allows one interface to be used for multiple implementations, making our code flexible and reusable.

Types of Polymorphism in Java

In Java, polymorphism is classified into two main types:

Compile-time Polymorphism (Method Overloading)
Runtime Polymorphism (Method Overriding)

1. Compile-time Polymorphism (Method Overloading)

Compile-time polymorphism occurs when the method call is resolved at compile time. The most common example of this is Method Overloading.

What is Method Overloading?

If a class has multiple methods with the same name but different parameter lists (different number or type of parameters) it is called Method Overloading.

Example:

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

    double add(double a, double b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(5, 10)); // calls int version
        System.out.println(calc.add(5.5, 10.2)); // calls double version
    }
}

Why use it?

Increases readability of the program
Same method name with different argument list is easy to remember

Ways to Achieve Overloading

By changing the number of arguments
By changing the data type of arguments

2. Runtime Polymorphism (Method Overriding)

Runtime polymorphism, also known as Dynamic Method Dispatch, is achieved through Method Overriding. In this case, the method call is resolved at runtime, not at compile time.

What is Method Overriding?

If a subclass (child class) provides specific implementation of method that is already defined in its parent class, it is called Method Overriding.

Rules for Overriding:

The method in the child class must have the same name, return type, and parameters as in the parent class.
It requires inheritance (using extends).

Example:

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal a = new Dog(); // Upcasting
        a.sound();  // Output: Dog barks (resolved at runtime)
    }
}

Why use it?

To provide a specific implementation in the child class
To achieve runtime polymorphism.

Conclusion

Polymorphism makes Java programs more flexible, extensible, and easier to maintain.
Use Overloading for compile-time decisions and code clarity.
Use Overriding for dynamic behavior and runtime flexibility.

Mastering Inheritance in Java: A Beginner’s Guide to Code Reusability

Mukesh — Sun, 13 Jul 2025 06:47:08 +0000

Inheritance in Java – Reusing Code the Right Way

Inheritance is one of the core pillars of Object-Oriented Programming (OOP), and Java provides robust support for it. In simple terms, inheritance allows one class to acquire properties and behaviors (methods and fields) of another class, promoting reusability and cleaner code design.

What is Inheritance?

In Java, inheritance means when one object (or class) inherits or acquires all the features (fields and methods) of another object. This leads to the formation of an IS-A relationship — for example a Dog IS-A Animal.

This relationship is also known as a parent-child or superclass-subclass relationship.

class Animal {
    void eat() {
        System.out.println("This animal eats food");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Dog barks");
    }
}

Here, Dog inherits from Animal, so it can eat() and bark().

Why Use Inheritance in Java?

Java supports inheritance to promote:

Code Reusability
Common logic can be written once in a parent class and reused in child classes.
Method Overriding
Child classes can override parent class methods to implement runtime polymorphism, enabling flexible behavior at runtime.

Syntax: Using the `extends` Keyword

Inheritance in Java is enabled using the extends keyword.

class Child extends Parent {
    // additional fields and methods
}

Types of Inheritance in Java

Java supports several forms of inheritance:

1. Single Inheritance

One class inherits from one other class.

class A {
    void display() {}
}

class B extends A {
    void show() {}
}

2. Multilevel Inheritance

A chain of inheritance.

class A {
    void display() {}
}

class B extends A {
    void show() {}
}

class C extends B {
    void print() {}
}

3. Hierarchical Inheritance

Multiple classes inherit from a single parent class.

class A {
    void greet() {}
}

class B extends A {}
class C extends A {}

What about Multiple Inheritance?

Java does not support multiple inheritance with classes to avoid ambiguity issues (like the Diamond Problem). But it does support multiple through interfaces:

interface Printable {
    void print();
}

interface Showable {
    void show();
}

class Demo implements Printable, Showable {
    public void print() {}
    public void show() {}
}

Conclusion

Inheritance makes Java code cleaner, reusable, and extensible. It's a powerful feature that, when used wisely, helps build robust OOP-based systems.

Mastering Inheritance in Java: A Beginner’s Guide to Code Reusability

Mukesh — Sun, 13 Jul 2025 06:47:08 +0000

Inheritance in Java – Reusing Code the Right Way

What is Inheritance?

This relationship is also known as a parent-child or superclass-subclass relationship.

class Animal {
    void eat() {
        System.out.println("This animal eats food");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Dog barks");
    }
}

Here, Dog inherits from Animal, so it can eat() and bark().

Why Use Inheritance in Java?

Java supports inheritance to promote:

Code Reusability
Common logic can be written once in a parent class and reused in child classes.
Method Overriding
Child classes can override parent class methods to implement runtime polymorphism, enabling flexible behavior at runtime.

Syntax: Using the `extends` Keyword

Inheritance in Java is enabled using the extends keyword.

class Child extends Parent {
    // additional fields and methods
}

Types of Inheritance in Java

Java supports several forms of inheritance:

1. Single Inheritance

One class inherits from one other class.

class A {
    void display() {}
}

class B extends A {
    void show() {}
}

2. Multilevel Inheritance

A chain of inheritance.

class A {
    void display() {}
}

class B extends A {
    void show() {}
}

class C extends B {
    void print() {}
}

3. Hierarchical Inheritance

Multiple classes inherit from a single parent class.

class A {
    void greet() {}
}

class B extends A {}
class C extends A {}

What about Multiple Inheritance?

Java does not support multiple inheritance with classes to avoid ambiguity issues (like the Diamond Problem). But it does support multiple through interfaces:

interface Printable {
    void print();
}

interface Showable {
    void show();
}

class Demo implements Printable, Showable {
    public void print() {}
    public void show() {}
}

Conclusion

Inheritance makes Java code cleaner, reusable, and extensible. It's a powerful feature that, when used wisely, helps build robust OOP-based systems.

Mastering super Keyword in Java: A Beginner's Guide to Inheritance

Mukesh — Tue, 08 Jul 2025 18:36:55 +0000

Understanding the `super` Keyword in Java

When working with inheritance in Java, super keyword plays key role in accessing members (variables, methods, and constructors) of parent class. It helps avoid confusion when subclass and superclass share similar names for methods or variables.

What is `super` in Java?

In Java, super is reference variable used to refer to immediate parent class object. Whenever you create an instance of subclass, an instance of its superclass is also created, and super points to it.

Common Uses of `super` in Java

Java allows you to use the super keyword in three main ways:

1. Accessing Parent Class Variables

If subclass has a variable with the same name as the parent class, use super to refer to the parent’s variable.

class Parent {
    int x = 10;
}

class Child extends Parent {
    int x = 20;

    void display() {
        System.out.println("Child x: " + x);
        System.out.println("Parent x: " + super.x);
    }
}

2. Calling Parent Class Methods

If method is overridden in the subclass, you can still access the parent class version using super.

class Parent {
    void show() {
        System.out.println("This is Parent");
    }
}

class Child extends Parent {
    void show() {
        System.out.println("This is Child");
        super.show(); // Call parent method
    }
}

3. Invoking Parent Class Constructor

Use super() to call the constructor of the parent class. It must be the first statement in the child class constructor.

class Parent {
    Parent() {
        System.out.println("Parent Constructor");
    }
}

class Child extends Parent {
    Child() {
        super(); // Must be first
        System.out.println("Child Constructor");
    }
}

Mastering final Keyword in Java: Variables, Methods & Classes Explained

Mukesh — Sat, 05 Jul 2025 14:50:45 +0000

Understanding the `final` Keyword in Java

In Java, the final keyword is powerful tool used to restrict modification. Whether applied to variables, methods, or classes, final enforces immutability and prevents unexpected behavior, making your code more robust and secure.

In this blog, will break down how final keyword works in Java covering final variables, final methods, and final classes along with examples.

What Does `final` Do?

final keyword can be used in three main contexts:

Final variables
Final methods
Final classes

1. Final Variables

When variable is declared as final, its value cannot be changed once initialized. Trying to reassign final variable will result in compile-time error.

Example:

final int x = 10;
x = 20; // Compile Time Error: cannot assign value to final variable

Blank Final Variable

You can declare a final variable without assigning value this is called a blank final variable. It must be initialized either in the constructor or during object creation.

class A {
    final int speed;

    A() {
        speed = 100; // Initialized in constructor
    }
}

Static Blank Final Variable

static final variable that isn’t initialized during declaration is known as static blank final variable. It must be initialized in static block.

class A {
    static final int data; // static blank final variable

    static {
        data = 50;
    }

    public static void main(String[] args) {
        System.out.println(A.data);
    }
}

2. Final Methods

When a method is declared as final, it cannot be overridden by any subclass. This is especially useful when you want to prevent modification of critical functionality.

class Bike {
    final void run() {
        System.out.println("Running...");
    }
}

class Honda extends Bike {
    // void run() { System.out.println("Running safely"); } // Compile Time Error
}

3. Final Classes

If class is declared as final, it cannot be extended. This is often done for security or to prevent alteration of core behavior.

final class Vehicle {
    void start() {
        System.out.println("Vehicle started");
    }
}

// class Car extends Vehicle {} // Compile Time Error

Conclusion

final keyword helps enforce immutability, security, and clarity in Java code. Whether you are preventing variables from being modified, methods from being overridden, or classes from being extended, final plays a crucial role in writing clean, error-free code.

Mastering this Keyword in Java: 5 Essential Uses Explained

Mukesh — Thu, 03 Jul 2025 19:10:57 +0000

Understanding `this` Keyword in Java

Java provides a powerful reference variable called this, which plays crucial role in object-oriented programming. It refers to current object — the instance on which a method or constructor is invoked. In this blog post, we will explore six common usages of this keyword each illustrated with examples

1. Refer Current Class Instance Variable

When local variables (method parameters or other variables) share the same name as instance variables, this helps to differentiate between them.

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        // Without 'this', the parameters shadow the fields
        this.name = name;  // Refers to the instance variable
        this.age = age;
    }

    public void printInfo() {
        System.out.println("Name: "+this.name+", Age: "+this.age);
    }
}

Here this.name and this.age refer to the objects fields, while name and age on right-hand side refer to constructor parameters.

2. Invoke Current Class Method (Implicitly)

You can use this to call another method of the same class. Although implicit calls normally work without this, using it can improve code readability or resolve naming conflicts.

public class Calculator {
    public int square(int x) {
        return x * x;
    }

    public int sumOfSquares(int a, int b) {
        // Explicitly using 'this' to call square()
        return this.square(a) + this.square(b);
    }
}

In the example above, this.square() clearly indicates that square is a method on the current object.

3. Invoke Current Class Constructor (`this()`)

You can chain constructors within the same class using this(). It can call the default constructor or a parameterized one, simplifying object initialization.

public class Box {
    private int length, width, height;

    // Default constructor
    public Box() {
        this(1, 1, 1);  // Calls the parameterized constructor
    }

    // Parameterized constructor
    public Box(int length, int width, int height) {
        this.length = length;
        this.width = width;
        this.height = height;
    }
}

Notice that this(1, 1, 1) must be the first statement in default constructor.

4. Pass `this` as an Argument in Method Call

Sometimes we need to pass current object to another method or class. We can achieve this by passing this.

public class Event {
    public void registerListener(Listener listener) {
        listener.onEvent(this);
    }
}

public interface Listener {
    void onEvent(Event e);
}

Here, this refers to the Event instance being registered.

5. Pass `this` as an Argument in Constructor Call

Similarly, you can pass the current object to another object's constructor.

public class Engine {
    private Car car;

    public Engine(Car car) {
        this.car = car;
    }
}

public class Car {
    private Engine engine;

    public Car() {
        engine = new Engine(this); // Passes the current Car instance
    }
}

In this snippet, Car instance is passed to Engine constructor.

Conclusion

The this keyword in Java provides clarity and control when working with object instances. It helps in differentiating between variables and chaining constructors. Using this enhances code readability and robustness.

Mastering the static Keyword in Java: The Ultimate Guide

Mukesh — Wed, 02 Jul 2025 15:52:35 +0000

Understanding the `static` Keyword in Java

In Java, static keyword is powerful feature used primarily for memory management. It is one of those small keywords with big implications—allowing us to create members that belong to class rather than instances of class.

This post explores how static works with variables, methods, blocks, and nested classes, along with examples.

What is `static` Keyword?

The static keyword indicates that a particular member belongs to the class itself and not to instances of the class. That means:

Static variables and methods are shared among all instances.
Static blocks execute once, at the time of class loading.
Static members can be accessed without creating object of class.

This makes static especially useful for scenarios where you want to store or manipulate common/shared data.

1. Static Variable (Class Variable)

A static variable is also known as a class variable. Unlike instance variables (which get memory each time an object is created), a static variable:

Gets memory only once at the time of class loading.
Is shared by all objects of the class.
Saves memory and promotes consistency in shared data.

Example Use Case:

collegeName for all students
companyName for all employees

Benefits:

Saves memory
Easy to maintain shared values

class Employee {
    static String company = "ABC";
    int id;
    String name;

    Employee(int id, String name) {
        this.id = id;
        this.name = name;
    }

    void display() {
        System.out.println(id + " " + name + " " + company);
    }
}

2. Static Method

A static method:

Belongs to the class, not to an object.
Can be called without creating an instance.
Can only access static data members and static methods.

When to Use:

Utility/helper methods like Math.max()
Factory methods

class Utility {
    static int cube(int x) {
        return x * x * x;
    }
}

3. Static Block

A static block is used to initialize static variables. It's executed once, when the class is loaded before the main() method runs.

Example:

class Demo {
    static {
        System.out.println("Static block executed.");
    }

    public static void main(String args[]) {
        System.out.println("Main method executed.");
    }
}

Output:

Static block executed.
Main method executed.

Conclusion

The static keyword allows memory sharing and promotes consistent behavior across all objects, helping reduce redundancy and boost performance. It's especially useful when building utility classes, caching shared data, or initializing configurations during class loading.

Advanced JavaScript: Exploring the Event Loop

Mukesh — Sat, 20 Jul 2024 08:41:43 +0000

Introduction

JavaScript is a powerful and widely-used programming language in web development. One of its most interesting aspect is its concurrency model, which allows it to handle multiple tasks efficiently despite being single-threaded. Understanding the event loop is crucial for writing performant and bug-free JavaScript code, especially in complex applications.

Understanding JavaScript's Concurrency Model

Single-Threaded Nature

JavaScript is single-threaded, meaning it executes code sequentially, one operation at a time. This is in contrast to languages that are multi-threaded, where multiple threads can run concurrently. However, JavaScript uses an event-driven, non-blocking architecture to manage concurrency and handle asynchronous tasks efficiently.

Concurrency Model

JavaScript uses a concurrency model based on an event loop, which allows it to perform non-blocking operations. This model is essential for handling tasks like I/O operations, network requests, and user interactions without freezing the user interface.

The Event Loop Explained

What is the Event Loop?

The event loop is the mechanism that JavaScript uses to coordinate the execution of code, handle events, and manage asynchronous tasks. It continuously checks the call stack to see if there’s any function that needs to run, and processes tasks in the callback queue when the stack is empty.

Components of the Event Loop

1. Call Stack

The call stack keeps track of function calls. When a function is invoked, it's added to the stack, and when it completes, it's removed.

Example:

function greet() {
  console.log('Hello');
}

function sayGoodbye() {
  console.log('Goodbye');
}

greet();
sayGoodbye();

greet() is called and added to the stack.
console.log("Hello") is executed.
greet() is removed from the stack.
sayGoodbye() is called and added to the stack.
console.log("Goodbye") is executed.
sayGoodbye() is removed from the stack.

2. Web APIs

Web APIs are provided by the browser (or Node.js) and include features like setTimeout, DOM events, fetch, etc. They are used to perform tasks that are outside the main execution thread.

Example:

console.log('Start');

setTimeout(() => {
  console.log('Timeout');
}, 1000);

console.log('End');

console.log("Start") is executed and logged immediately.
setTimeout is called and its callback is sent to the web API environment.
console.log("End") is executed and logged immediately.
After 1 second, the callback from setTimeout is pushed to the callback queue.
Once the call stack is empty, the event loop pushes the callback to the stack, and console.log("Timeout") is executed.

3. Callback Queue (Task Queue)

The callback queue holds messages with callbacks to be processed. The event loop takes tasks from the queue and adds them to the call stack for execution when the stack is empty.

4. Microtask Queue

The microtask queue is used for tasks that need to run immediately after the current operation completes. Promises and mutation observers are handled here.

console.log('Start');

setTimeout(() => {
  console.log('Timeout');
}, 0);

Promise.resolve().then(() => {
  console.log('Promise');
});

console.log('End');

console.log("Start") is executed and logged.
setTimeout callback is sent to the callback queue with zero delay.
A promise is resolved, and its callback is added to the microtask queue.
console.log("End") is executed and logged.
The event loop processes the microtask queue and logs console.log("Promise").
The callback queue is processed, logging console.log("Timeout").

JavaScript ES6+ Features: A Complete Overview

Mukesh — Sat, 13 Jul 2024 11:25:17 +0000

Introduction

JavaScript is constantly evolving, and keeping up with the latest features is crucial for modern web development. Since ES6, JavaScript has introduced new features that make coding more efficient.

Understanding and utilizing the latest JavaScript features can greatly enhance your productivity and code quality, making your applications more robust and maintainable.

In this blog, will provide overview of the key features introduced in ES6 and beyond, including let and const, arrow functions and more.

Key Features Introduced in ES6+

1. let and const

JavaScript introduced two new ways to declare variables let and const. These provide better scoping and more control over how variables are used in your code compared to the traditional var.

let

let is used to declare variables that can be reassigned. Unlike var, let has block scope, meaning it is only accessible within the block (curly braces {}) where it is defined.

Example

if (true) {
    let x = 10;
    console.log(x); // Output: 10
}
console.log(x); // Error: x is not defined

The if statement checks if the condition true is met (which it always is in this case).
When the condition is true, the code block { ... } executes.
let x = 10; declares a variable x with block scope (scoped to the nearest curly braces { ... }).
x is assigned the value 10.
console.log(x); outputs the value of x, which is 10, to the console.
The output displayed is 10.
console.log(x); attempts to output the value of x to the console.
However, x is not accessible outside the block where it was defined (if block).
JavaScript throws an error: ReferenceError: x is not defined.
This error occurs because let variables are block-scoped and exist only within the block (curly braces) where they are defined.

const

const is used to declare variables that should not be reassigned. Like let, const has block scope. Once a variable is assigned a value using const, it cannot be changed.

const y = 20;
console.log(y); // Output: 20
y = 30; // Error: Assignment to constant variable.

const declares a constant variable named y.
Constants (const) are variables that cannot be reassigned once their value is set.
y is initialized with the value 20.
console.log(y); outputs the value of y, which is 20, to the console.
The output displayed is 20.
Attempts to reassign the value of y to 30.
However, constants (const) in JavaScript cannot be reassigned after their initial assignment.
JavaScript throws an error: TypeError: Assignment to constant variable.
This error occurs because y is declared as a constant (const), and you cannot change its value once it's set.

2. Arrow Functions

Description:
Arrow functions provide a concise syntax for writing function expressions. They do not have their own this context, making them particularly useful for callbacks.

Example

// Traditional function expression
var add = function(a, b) {
    return a + b;
};

// Arrow function expression
const add = (a, b) => a + b;

var add declares a variable named add. This variable will store a function.
The function(a, b) part creates an anonymous function (a function without a name) that takes two parameters, a and b.
Inside the curly braces {}, the function body contains a single statement: return a + b;. This means the function will add the two parameters a and b and return the result.
The function is assigned to the variable add. Now, add can be used to call the function and perform the addition.
When add(2, 3) is called, the function adds 2 and 3 and returns 5.
const add declares a constant variable named add. This means the variable add cannot be reassigned to a different value or function.
The (a, b) => a + b part is an arrow function. It is a shorter and more concise way to write a function.
(a, b) lists the parameters of the function, just like in the traditional function expression.
The a + b part is the body of the function. Since there are no curly braces {}, this function has an implicit return, meaning it automatically returns the result of a + b.
When add(2, 3) is called, the arrow function adds 2 and 3 and returns 5.

3. Template Literals

Template literals let us create strings that can span multiple lines and include variables easily. Use template literals for embedding variables and expressions in strings.

Example:

const name = 'John';
const greeting = `Hello, ${name}!`;
console.log(greeting); // Hello, John!

const declares a constant variable named name.
'John' is assigned as the value of name.
Constants const are variables that cannot be reassigned once their value is set.
Template literals (enclosed in backticks) allow embedding expressions inside strings.
${name} within ${} is an expression that gets replaced with the value of the name variable.
${name} evaluates to 'John', so greeting becomes 'Hello, John!'.
console.log() outputs the value of greeting to the console.
The output displayed in the console is Hello, John!.

4. Destructuring Assignment

Destructuring allows you to unpack values from arrays or properties from objects into distinct variables. Use destructuring to simplify the extraction of values from arrays and objects.

Example:

const user = { name: 'John', age: 30 };
const { name, age } = user;
console.log(name); // John
console.log(age); // 30

const declares a constant variable named user.
user is an object with two properties: name with value 'John' and age with value 30.
Object destructuring allows you to extract specific properties from an object into variables with the same names.
{ name, age } on the left-hand side of = declares two new variables (name and age).
These variables are assigned the values of user.name and user.age, respectively.
console.log(name); outputs the value of the variable name to the console.
The output displayed in the console is John.
console.log(age); outputs the value of the variable age to the console.
The output displayed in the console is 30.

5. Default Parameters

Default parameters allow you to set default values for function parameters if no value or undefined is passed. Use default parameters to ensure functions have default values.

Example:

function greet(name = 'Guest') {
    console.log(`Hello, ${name}!`);
}
greet(); // Hello, Guest!

function greet(...) declares a function named greet.
name = 'Guest' is a parameter with a default value of 'Guest'. This means if no argument is passed to greet(), name will default to 'Guest'.
Template literals (enclosed in backticks `) allow embedding expressions inside strings.
${name} within ${} is an expression that gets replaced with the value of the name parameter passed to the function.
If no name parameter is provided, it defaults to 'Guest'.
greet() calls the greet function without passing any arguments.
Since no argument is passed, name defaults to 'Guest'.
The function then logs 'Hello, Guest!' to the console.

6. Rest and Spread Operators

The rest operator (...) allows you to represent an indefinite number of arguments as an array. The spread operator (...) allows an iterable to be expanded in places where zero or more arguments or elements are expected. Use rest operator in function parameters to handle various arguments. Use spread operator to expand arrays and objects.

Example:

function sum(...numbers) {
    return numbers.reduce((a, b) => a + b, 0);
}
console.log(sum(1, 2, 3)); // 6

const arr1 = [1, 2];
const arr2 = [...arr1, 3, 4];
console.log(arr2); // [1, 2, 3, 4]

function sum(...numbers) declares a function named sum that uses a rest parameter ...numbers.
The rest parameter ...numbers allows the function to accept any number of arguments and gathers them into an array named numbers.
numbers.reduce(...) applies the reduce method on the numbers array.
The reduce method iterates over each element in the numbers array and accumulates a single value (a + b).
(a, b) => a + b is an arrow function that adds two numbers a and b.
0 is the initial value of a in the reduction process.
sum(1, 2, 3) calls the sum function with three arguments: 1, 2, and 3.
The function calculates the sum of these numbers (1 + 2 + 3) using reduce.
The result 6 is logged to the console.
const arr1 declares a constant variable arr1 initialized with an array [1, 2].
...arr1 spreads the elements of arr1 into the new array arr2.
[...arr1, 3, 4] creates a new array arr2 by combining the elements of arr1 (1 and 2) with 3 and 4.
console.log(arr2) outputs the contents of arr2 to the console.
The output displayed is [1, 2, 3, 4], which is the combined array with elements from arr1 and additional elements 3 and 4.

7. Classes

Classes provide a more intuitive and simpler syntax for creating objects and dealing with inheritance in JavaScript. Use classes to create objects and establish inheritance hierarchies.

Example:

class Person {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }

    greet() {
        console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
    }
}

const john = new Person('John', 30);
john.greet(); // Hello, my name is John and I am 30 years old.

class Person declares a new class named Person.
Classes in JavaScript provide a way to define blueprints for creating objects with shared methods and properties.
The constructor method is a special method for creating and initializing objects created with a class.
constructor(name, age) defines parameters name and age.
this.name = name; assigns the value of name passed to the constructor to the name property of the object being created (this refers to the current instance of the Person class).
this.age = age; assigns the value of age passed to the constructor to the age property of the object being created.
greet() defines a method greet within the Person class.
Methods in classes are functions that can be called on instances of the class.
Template literals (enclosed in backticks `) allow embedding expressions inside strings.
${this.name} and ${this.age} are expressions that are replaced with the values of name and age properties of the current object (this refers to the current instance of Person).
new Person('John', 30) creates a new instance of the Person class.
The constructor method is automatically called with arguments 'John' and 30, initializing the name and age properties of the john object.
john.greet() calls the greet method on the john object.
The method logs "Hello, my name is John and I am 30 years old." to the console, using the values stored in john.name and john.age.

8. Promises

Promises provide a way to handle asynchronous operations more gracefully than callbacks. Use promises for handling asynchronous operations such as API calls.

Example:

const fetchData = () => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('Data fetched');
        }, 1000);
    });
};

fetchData().then(data => {
    console.log(data); // Data fetched
});

const fetchData declares a constant variable fetchData initialized with an arrow function () => { ... }.
Arrow functions provide a concise way to write functions in JavaScript.
new Promise(...) creates a new Promise object.
The Promise constructor takes a function with resolve and reject parameters.
Inside this function:
- setTimeout(..., 1000) schedules a function to be executed after a delay of 1000 milliseconds (1 second).
- The arrow function () => { resolve('Data fetched'); } is executed after the timeout.
- resolve('Data fetched') fulfills the promise with the value 'Data fetched'.
fetchData() calls the fetchData function, which returns a Promise.
.then(data => { ... }) attaches a callback function to handle the resolved value (data) when the promise is fulfilled.
The arrow function data => { console.log(data); } is executed once the promise is resolved successfully (resolve('Data fetched')).
console.log(data) outputs the value of data ('Data fetched') to the console.

9. Async/Await

Async/await allows you to write asynchronous code in a more synchronous and readable manner.Use async/await for clearer and more readable asynchronous code.

Example:

const fetchData = () => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve('Data fetched');
        }, 1000);
    });
};

async function getData() {
    const data = await fetchData();
    console.log(data); // Data fetched
}

getData();

const fetchData declares a constant variable fetchData initialized with an arrow function () => { ... }.
Arrow functions provide a concise way to define functions in JavaScript.
new Promise(...) creates a new Promise object.
The promise executor function takes two parameters: resolve and reject.
Inside the executor function:
- setTimeout(..., 1000) schedules a function to be executed after a delay of 1000 milliseconds (1 second).
- The arrow function () => { resolve('Data fetched'); } is executed after the timeout completes.
- resolve('Data fetched') fulfills the promise with the value 'Data fetched'.
async function getData() declares an asynchronous function named getData.
Async functions allow you to write asynchronous code in a synchronous-like manner, making it easier to work with promises and other asynchronous operations.
await fetchData() pauses the execution of getData until the promise returned by fetchData settles (fulfills or rejects).
Once fulfilled, await returns the resolved value ('Data fetched') and assigns it to the variable data.
console.log(data); outputs the value of data ('Data fetched') to the console.
getData() calls the getData function, initiating the execution of asynchronous operations defined inside getData.

Conclusion

ES6+ features provide powerful tools for writing modern JavaScript. By understanding and using these features, developers can write more efficient, readable, and maintainable code.

Mastering Asynchronous JavaScript: Promises, Async/Await, and Callbacks

Mukesh — Sun, 07 Jul 2024 07:15:15 +0000

Many operations in the real world, such as retrieving data from a server or reading a file, take time to finish. If these operations were synchronous, then we need to wait until the entire task is completed, resulting in a bad user experience. Asynchronous operations enable the program to continue executing other tasks while these operations are complete.

1. Understanding Callbacks

Callbacks are functions passed as arguments to other functions, which are then invoked when the task is complete.

// Example of a callback function
function fetchData(callback) {
    setTimeout(() => {
        callback("Data fetched from server");
    }, 2000);
}

// Using the callback
fetchData((message) => {
    console.log(message); // Outputs: Data fetched!
});

Code Explanation

Function Definition:

The function fetchData is defined to accept one argument, callback.
callback is expected to be a function that will be called once the asynchronous operation inside fetchData is complete.

setTimeout:

Inside fetchData, there is a call to setTimeout.
setTimeout is a built-in JavaScript function that executes a function after a specified delay in milliseconds.
it is used to simulate a delay of 2000 milliseconds (2 seconds) to mimic an asynchronous operation like fetching data from a server.

Callback Invocation:

After the 2-second delay, the anonymous function passed to setTimeout is executed.
This function calls callback with the argument "Data fetched from server".
This means after the delay, the callback function will be executed with the provided message.

Calling fetchData:

fetchData is called with an anonymous function as its argument. This anonymous function takes one parameter, message.
The anonymous function is the callback function that will be executed once the data is "fetched" (after the 2-second delay).

Callback Execution:

After 2 seconds, setTimeout triggers the execution of the callback with the message "Data fetched from server".
The callback function logs the message to the console.

2. Working with Promises

A promise is an object representing the eventual completion or failure of an asynchronous call. It provides methods to handle asynchronous results and handle errors. It provide a consistent way to handle errors using .catch().

function fetchData() {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve("Data fetched from server");
        }, 2000);
    });
}

fetchData()
    .then((message) => {
        console.log(message); // Outputs: Data fetched!
    })
    .catch((error) => {
        console.error(error);
    });

Code Explanation

Function Definition:

The fetchData function is defined to return a new promise.
A promise is an object that represents an asynchronous operation that will eventually complete or fail.

Creating the Promise:

Inside fetchData, a new promise is created using new Promise((resolve, reject) => {...}).
The promise constructor takes a function with two parameters, resolve and reject. These are functions that you call when the asynchronous operation completes successfully (resolve) or fails (reject).

Simulating an Asynchronous Operation:

The setTimeout function is used to simulate a delay of 2000 milliseconds (2 seconds), representing an asynchronous operation like fetching data from a server.
After the 2-second delay, the resolve function is called with the message "Data fetched from server".
This means the promise is successfully fulfilled after 2 seconds with the specified message.

Calling fetchData:

The fetchData function is called, which returns a promise.

Handling the Promise:

The .then() method is chained to the promise returned by fetchData.
The function passed to .then() is called when the promise is resolved successfully. It receives the message "Data fetched from server" and logs it to the console.

Error Handling:

The .catch() method is chained to handle any errors if the promise is rejected.
If there were an error (for example, if reject were called inside the promise), the function passed to .catch() would be called to log the error.

3. Async/Await: Modern Asynchronous JavaScript

Async and Await are powerful keywords used for handling asynchronous operations using promises. Async functions returns a promise and await pauses the execution until Promise is resolved. It simplify asynchronous code and improve readability by making it appear synchronous.

async function fetchData() {
    try {
        let message = await new Promise((resolve) => {
            setTimeout(() => {
                resolve("Data fetched from server");
            }, 2000);
        });
        console.log(message); // Outputs: Data fetched!
    } catch (error) {
        console.error(error);
    }
}

fetchData();

Code Explanation

Async Function:

The fetchData function is declared with the async keyword. This means it can use await inside it and it returns a promise.

Try-Catch Block:

The try block contains code that might throw an error. If an error occurs, the control moves to the catch block to handle the error.
The catch block catches and handles any errors that occur inside the try block.

Awaiting a Promise:

Inside the try block, we have an await expression. It waits for the promise to resolve before moving to the next line of code.
The promise is created using new Promise((resolve) => {...}).
The setTimeout function is used to simulate a delay of 2000 milliseconds (2 seconds), representing an asynchronous operation like fetching data from a server.
After 2 seconds, the promise is resolved with the message "Data fetched from server", and this message is assigned to the message variable.

Logging the Message:

After the promise is resolved, the message is logged to the console using console.log(message).

Error Handling:

If an error occurs while waiting for the promise or during any operation in the try block, the control moves to the catch block.
The error is logged to the console using console.error(error).

Calling the Async Function:

The fetchData function is called. Since it's an async function, it runs asynchronously.

Comparison Summary

Callbacks are simple and direct but can lead to messy code and inconsistent error handling.

Promises offer a more structured way to handle asynchronous operations and provide better error handling.

Async/Await builds on promises to provide even cleaner, more readable, and maintainable asynchronous code.

DEV Community: Mukesh

Abstraction in Java Explained: Abstract Classes vs Interfaces

Understanding Abstraction in Java

What is Abstraction?

Achieving Abstraction in Java

1. Abstract Class (0% to 100% Abstraction)

Key Points:

Abstract Method:

2. Interface (100% Abstraction)

Key Points:

Enhancements Since Java 8 and 9:

When to Use What?

Conclusion

Understanding Covariant Return Types in Java

What is Covariant Return Type?

Example of Covariant Return Type in Java

Output

Explanation

Why is Covariant Return Type Useful?

Key Advantages

Polymorphism in Java – Understanding Compile-time and Runtime Behavior

Types of Polymorphism in Java

1. Compile-time Polymorphism (Method Overloading)

What is Method Overloading?

Ways to Achieve Overloading

2. Runtime Polymorphism (Method Overriding)

What is Method Overriding?

Conclusion

Mastering Inheritance in Java: A Beginner’s Guide to Code Reusability

Inheritance in Java – Reusing Code the Right Way

What is Inheritance?

Why Use Inheritance in Java?

Syntax: Using the extends Keyword

Types of Inheritance in Java

1. Single Inheritance

2. Multilevel Inheritance

3. Hierarchical Inheritance

What about Multiple Inheritance?

Conclusion

Mastering Inheritance in Java: A Beginner’s Guide to Code Reusability

Inheritance in Java – Reusing Code the Right Way

What is Inheritance?

Why Use Inheritance in Java?

Syntax: Using the extends Keyword

Types of Inheritance in Java

1. Single Inheritance

2. Multilevel Inheritance

3. Hierarchical Inheritance

What about Multiple Inheritance?

Conclusion

Mastering super Keyword in Java: A Beginner's Guide to Inheritance

Understanding the super Keyword in Java

What is super in Java?

Common Uses of super in Java

1. Accessing Parent Class Variables

2. Calling Parent Class Methods

3. Invoking Parent Class Constructor

Mastering final Keyword in Java: Variables, Methods & Classes Explained

Understanding the final Keyword in Java

What Does final Do?

1. Final Variables

Example:

Blank Final Variable

Static Blank Final Variable

2. Final Methods

3. Final Classes

Conclusion

Mastering this Keyword in Java: 5 Essential Uses Explained

Understanding this Keyword in Java

1. Refer Current Class Instance Variable

2. Invoke Current Class Method (Implicitly)

3. Invoke Current Class Constructor (this())

4. Pass this as an Argument in Method Call

5. Pass this as an Argument in Constructor Call

Conclusion

Mastering the static Keyword in Java: The Ultimate Guide

Understanding the static Keyword in Java

What is static Keyword?

1. Static Variable (Class Variable)

Example Use Case:

Syntax: Using the `extends` Keyword

Syntax: Using the `extends` Keyword

Understanding the `super` Keyword in Java

What is `super` in Java?

Common Uses of `super` in Java

Understanding the `final` Keyword in Java

What Does `final` Do?

Understanding `this` Keyword in Java

3. Invoke Current Class Constructor (`this()`)

4. Pass `this` as an Argument in Method Call

5. Pass `this` as an Argument in Constructor Call

Understanding the `static` Keyword in Java

What is `static` Keyword?