DEV Community: Asitha Lakshan

Can you find the Output of this Java Code

Asitha Lakshan — Tue, 07 Jan 2025 13:08:45 +0000

In Java programs, it always follows specific execution orders for various code blocks. From this article, I am going explore how different components in Java (static blocks, instance initializer blocks, constructors, methods, etc.) are executed with the help of the following example.

Before continuing reading, try to determine the output of the following Java code by yourself and comment it on below before you go any further.

public class Execute {
    public Execute() {
        System.out.println("Hello from constructor");
    }

    public void method() {
        System.out.println("Hello from method");
    }

    static {
        System.out.println("Hello from static block");
    }

    {
        System.out.println("Hello from instance initializer block");
    }

    public static void main(String[] args) {
        System.out.println("Hello from main");
        Execute obj = new Execute();
        obj.method();
    }
}

Output

I assume now that you at least tried once to determine the output order.

So the output of the above Java code will be:

Hello from static block
Hello from main
Hello from instance initializer block
Hello from constructor
Hello from method

Did you able to determine it correctly?

Now let's check why Java gives an output like the above.

Explanation

When we run the above Java code, the execution order is as below

Static Blocks
The main Method
Instance Initializer Block
Constructor
Method Execution

Now let's look at these steps one by one

1. Static Blocks

static {
    System.out.println("Hello from static block");
}

A static block in Java is a block of code that is executed once when the class is loaded into memory by the JVM (Java virtual machine). This happens before the main method or any other instance-related code is executed.

This is mostly used for static initialization, such as setting up static variables, or performing any necessary setup when the class is first used.

In this code, the first line of output is by the static block:

Hello from static block

2. The main Method

public static void main(String[] args) {
    System.out.println("Hello from main");
    Execute obj = new Execute();
    obj.method();
}

The main method is the entry point of any Java application. It is where the program begins its execution when it is run.

After the static block has been executed, the JVM begins executing the code inside the main method.

In this code, the second line of output is by the main method:

Hello from main

3. Instance Initializer Block

{
    System.out.println("Hello from instance initializer block");
}

An Instance Initializer block in Java is a code block that is defined within a class but outside any method, constructor, or static block. It is executed every time an instance of the class is created, right before the constructor of the class is executed

When we create an object with Execute obj = new Execute();, the instance block runs before the constructor. This block is useful for initializing common properties of objects.

In this code, the third line of output is by the Instance Initializer block:

Hello from instance initializer block

4. Constructor

public Execute() {
    System.out.println("Hello from constructor");
}

The constructor is a special method used to initialize objects and is called automatically when a new object is created. It must have the same name as the class and It does not have a return type, not even void.

It is executed immediately after the instance initializer block when an object is created. It’s typically used to initialize instance variables or perform any startup logic specific to that object.

In this code, the fourth line of output is by the constructor:

Hello from constructor

5. Method Execution

public void method() {
    System.out.println("Hello from method");
}

public static void main(String[] args) {
....
    Execute obj = new Execute();
    obj.method();
}

In Java, method execution refers to the process of invoking or calling a method to perform a specific task. Methods are blocks of code that perform operations, and their execution is initiated by calling the method from within the program.

After the object is created and initialized, we explicitly call the method() function. This runs the code inside the method body.

In this code, the last line of output is by the method execution:

Hello from method

Why is the Execution Order this Important?

Understanding the execution order in which different blocks execute is important for debugging and writing efficient Java programs. For an example:

Static blocks are ideal for initializing class-level properties.
Instance blocks are ideal for common object initialization logic.
Constructors are ideal for handling object-specific setups.

By knowing this order, you can write cleaner, more efficient, and maintainable Java code.

Incredible New Features in JavaScript ES15 (2024)

Asitha Lakshan — Mon, 28 Oct 2024 17:06:29 +0000

The latest ECMAScript version, ES15, introduces some new features to give great developer experience for Javascript developers. These enhancements span across different areas, from updated Javascript syntax and data handling to advancements in security, performance, and tools geared for developer productivity.

1. Array Grouping

One of the most exciting (also one of my personal favorite) feature in ES15 is the Object.groupBy() method.
This way simplifies the way of grouping elements in an array, based on specific criteria. This makes data manipulation more efficient and less error-prone.

Example:

const cities = [
  { name: 'Melbourne', country: 'Australia' },  
  { name: 'Auckland', country: 'New Zealand' },
  { name: 'Sydney', country: 'Australia' },
  { name: 'Brisbane', country: 'Australia' },
  { name: 'Wellington', country: 'New Zealand' }
];

const groupedByCountry = Object.groupBy(cities, fruit => fruit.country);
console.log(groupedByCountry);

// Output:
// {
//   "Australia": [
//       { "name": "Melbourne", "country": "Australia" },
//       { "name": "Sydney", "country": "Australia" },
//       { "name": "Brisbane", "country": "Australia" }
//   ],
//   "New Zealand": [
//       { "name": "Auckland", "country": "New Zealand" },
//       { "name": "Wellington", "country": "New Zealand" }
//   ]
// }

By using this feature, we can reduce the need for custom functions or third-party libraries that we traditionally use for array grouping.

Also with this feature, we can make our code more understandable and maintainable by expressing our intent directly

2. Pipeline Operator (|>)

Sometimes we need to use multiple functions as a chaining process. In that kind of scenario, we can use the pipeline operator (|>) to simplify the chaining process.

Example:

const double = (x) => x * 2;
const increment = (x) => x + 1;
const square = (x) => x * x;

const result = 5 |> double |> increment |> square;

// Output: 121

The traditional way of doing above is this

const double = (x) => x * 2;
const increment = (x) => x + 1;
const square = (x) => x * x;

const result = square(increment(double(5)));
console.log(result);

// Output: 121

By using the pipeline operator we can use a more functional programming style. From that, we can make our code more readable by removing the complexity of deeply nested function calls.

3. Method Chaining Operator (?.())

ES15 expands optional chaining by introducing the new Method Chaining Operator. This Method Chaining Operator adds safety to method invocation in deeply nested objects.

Example:

const data = {
  user: {
    getName: () => 'Tim'
  }
};

console.log(data.user?.getName?.());  // Output: 'Alice'
console.log(data.user?.getAge?.());  // Output: undefined

The method chaining operator (?.()) allows you to safely invoke methods on potentially null or undefined objects. This reduces the risk of runtime errors caused by calling methods.

4. Set Methods Enhancements

ES15 introduces several enhancements to the Set object, including new methods like union, intersection, difference, and symmetricDifference. These methods simplify common set operations.

const setA = new Set([1, 2, 3]);
const setB = new Set([3, 4, 5]);

const unionSet = setA.union(setB);
const differenceSet = setA.difference(setB);
const intersectionSet = setA.intersection(setB);
const symmetricDifferenceSet = setA.symmetricDifference(setB);

console.log(unionSet); // Output: {1, 2, 3, 4, 5}
console.log(differenceSet); // Output: {1, 2}
console.log(intersectionSet); // Output: {3}
console.log(symmetricDifferenceSet); // Output: {1, 2, 4, 5}

union
The union() method of Set instances takes a set and returns a new set containing elements that are in either or both of this set and the given set.
difference
The difference() method of Set instances takes a set and returns a new set containing elements in this set but not in the given set.
intersection
The intersection() method of Set instances takes a set and returns a new set containing elements in both this set and the given set.
symmetricDifference
The symmetricDifference() method of Set instances takes a set and returns a new set containing elements that are in either this set or the given set, but not in both.

5. Enhanced JSON Modules

In previous ECMAScript versions, developers relied on bundlers or loaders to import JSON files. ES15 now supports dynamic import and schema validation, making it easier to work with structured data and ensuring that imported data conforms to the expected format.

You can now import JSON data directly, just like importing JavaScript modules.

Example:

// config.json
{
  "apiUrl": "https://api.example.com",
  "timeout": 5000,
  "features": {
    "enableFeatureX": true
  }
}

import config from './config.json' assert { type: 'json' };

console.log(config.apiUrl); // Outputs: https://api.example.com
console.log(config.timeout); // Outputs: 5000
console.log(config.features.enableFeatureX); // Outputs: true

However, this change might break code that relies on older, non-standard ways of importing JSON, or if certain build tools are configured with older behaviors.

Naming Conventions in Programming

Asitha Lakshan — Fri, 11 Oct 2024 15:03:46 +0000

As developers, there are many rules and best practices that we use in programming. One of the most important ones is the Naming conventions.

As programmers, we use names in lots of things, such as variables, functions, classes, methods, interfaces, types, filenames, and so on. There are several principles of naming conventions for a design system are listed below.

Clarity and obviousness

Names should be evident and unambiguous.

// bad
var value = 'James';

// bad
var val = 'James';

// good
var firstName = 'James';

Consistency and organization

The same name should be used for the same object, and there should be consistency in how each component name is created.

Uniqueness

Do not use repeating names to avoid conflicts.

Prefixes and Suffixes

We can use prefixes or suffixes for elements of different types.
Example: We can use “btn” for buttons, “lbl” for labels, etc.

Use Case Types in Programming

Lets think we need to create a variable in our code. The name of the variable is more than just one word. It has to be a meaningful readable name.
Also, we cannot use spaces in the naming in programming. Therefore we cannot use variable names like those below.

first name = 'James'
last name = 'William'
user Id = 'af6b3dff-c023-40b1-a32f-163b6071f360'

That is where Naming Conventions come from

There are sets of standards that are generally accepted by the developers for Naming conventions. Developers are using different case types to name different entities in code. These are the most popular case types among developers.

Camel Case
Snake Case
Kebab Case
Pascal Case

Camel Case

camelCase is a naming convention where the first word is always lowercase and every other word starts with a capital letter.

Examples:

firstName = 'James'
lastName = 'William'
userId = 'af6b3dff-c023-40b1-a32f-163b6071f360'

Commonly used in: Java, JavaScript, and TypeScript for creating variable, function, and method names

Snake Case

snake_case is a naming convention where each word is in lowercase, and separated by underscores.

Examples:

first_name = 'James'
last_name = 'William'
user_id = 'af6b3dff-c023-40b1-a32f-163b6071f360'
CONSTATNT_VALUE = 'value'

Commonly used in: Python, Ruby, C/C++ standard libraries, WordPress, database tables, and column names.

Kebab Case

kebab-case is a naming convention where each word is in lowercase, and separated by dashes.

Examples:

first-name = 'James'
last-name = 'William'
user-id = 'af6b3dff-c023-40b1-a32f-163b6071f360'

Commonly used in: COBOL, Lisp, Perl 6, CSS class names, HTML ids, URLs.

Pascal Case
PascalCase is a naming convention where the first letter in every word is a capital letter and the rest is in lowercase.

Examples:

FirstName = 'James'
LastName = 'William'
UserId = 'af6b3dff-c023-40b1-a32f-163b6071f360'

**Commonly used in: **Pascal, Modula, .NET, Java classes and enums, JavaScript classes, typescript types and interfaces.

Public Your localhost URLs with Pinggy

Asitha Lakshan — Fri, 11 Oct 2024 14:52:11 +0000

Pinggy is a secure tunneling service to localhost that allows you to share your website or app easily with the public. It Creates HTTP, TCP, or TLS tunnels to your Mac / PC even if it is sitting behind firewalls and NATs.

You do not need to configure a cloud or server to host your websites or do not need to install any apps or packages into your local PC.

Also, Pinggy provides a powerful TUI and a Web Debugger for monitoring and debugging incoming requests in real-time.

Share your localhost URL

Run your application on localhost
Find the localhost port where your application is running
Goto pinggy.io and enter the Your local port

Copy the command generated by the pinggy.io and run it on your localhost to start the tunnel ssh -p 443 -R0:localhost:3000 -L4300:localhost:4300 qr@a.pinggy.io
After running the command you can see the public URL and the QR code for the tunnel.