DEV Community: Prince

Web3 and Blockchain Projects

Prince — Sun, 25 May 2025 12:31:00 +0000

Exploring SmartFolio: Your Dynamic Web Diary

Prince — Mon, 01 Jul 2024 02:47:04 +0000

Introduction:
Introduce SmartFolio briefly. Mention its purpose as a dynamic web diary that simplifies sharing thoughts, ideas, and creations online.

www.elavarasan.me
Source Code

Features of SmartFolio:

Real-time Updates: Discuss how SmartFolio syncs changes seamlessly to Notion pages.
Easy Navigation: Highlight its clear outline for effortless content navigation.
Customizable Themes: Explain the ability to switch between different themes.
Language Support: Mention support for multiple languages.
Engagement Tools: Include native-style comments and Telegram bot integration.
SEO and Optimization: Talk about built-in SEO and Open Graph optimization.
Newsletter and Contact Form Integration: Discuss the ability to keep audience engaged and connected.

Getting Started:

Prerequisites: Mention the requirement of having pnpm installed.
Installation Guide:
- Clone the repository: https://github.com/follow-prince/SmartFolio.git
- Navigate to the project directory: cd smartfolio
- Install dependencies: pnpm install

Development and Deployment:

Development:
- Start the development server: ./dev.sh
Building and Deployment:
- Build the project: pnpm build
- Serve the built project: pnpm start

Contributing:
Encourage readers to contribute to SmartFolio, linking to the contributing guidelines.

Reference and License:

Mention Nobelium, if relevant.
License: Note that SmartFolio is licensed under the MIT License.

Acknowledgments:
Thank contributors and supporters who have contributed to SmartFolio.

Conclusion:
Summarize the benefits and uniqueness of SmartFolio. Encourage readers to explore and utilize it for their web diary needs.

PR!NC€ - Workfolio

a software developer, Proficient in JavaScript, oops concepts and ReactJs, he excel in front-end, app, and web development.

elavarasan.me

3D Portfolio - Prince

Prince — Fri, 22 Mar 2024 07:14:41 +0000

Check out this Pen I made!

Object-oriented programming(OOPS)

Prince — Sat, 16 Sep 2023 14:21:15 +0000

Object-oriented programming(OOPS)

Object-oriented programming (OOP) is a programming paradigm based on the concept of "objects", which can contain data and code: data in the form of fields (often known as attributes or properties), and code, in the form of procedures (often known as methods).

4 pillars of OOPS are:

Abstraction
Encapsulation
Inheritance
Polymorphism

Let’s take a look at them:

Abstraction

Abstraction is a process of hiding the implementation details and showing only functionality to the user.

Real world examples:

TV remote: To start the TV, you have to press the power button, you don’t have to know about the internal circuit operations like how infrared waves are passing.
Car gears: We know what happens when we change the gear. But we don’t know how changing gear works under the hood, that information is irrelevant to us, so it is abstracted.

In java, Abstraction can be achieved in two ways:

Abstract classes
Interfaces

Encapsulation

Encapsulation is a process of Binding data and methods within a class . Think of it like showing the essential details of a class by using the access control modifiers (public, private, protected ). So, we can say that Encapsulation leads to the desired level of Abstraction.

Example:
Java Bean, where all data members are made private and you define certain public methods to the outside world to access them.

Inheritance

Using inheritance means defining a parent-child relationship between classes, by doing so, you can reuse the code that is already defined in the parent class. Code reusability is the biggest advantage of Inheritance.

Java does not allow multiple inheritance through classes but it allows it through interfaces.

Polymorphism

Poly means many and Morph means forms. Polymorphism is the process in which an object or function takes different forms. There are 2 types of Polymorphism :

Compile Time Polymorphism (Method Overloading)
Run Time Polymorphism (Method Overriding)

In Method overloading, two or more methods in one class have the same method name but different arguments. It is called as Compile time polymorphism because it is decided at compile time which overloaded method will be called.

Overriding means when we have two methods with same name and same parameters in parent and child class. Through overriding, child class can provide specific implementation for the method which is already defined in the parent class.

Abstract Class

A class that is declared using "abstract" keyword is known as abstract class. It can have abstract methods (methods without body) as well as concrete methods (methods with body).

Some points to remember:

An abstract class cannot be instantiated, which means you are not allowed to create an object of the abstract class. This also means, an abstract class has no use unless it is extended by some other class
If there is any abstract method in a class then that class must be declared abstract
The first non-abstract class which is extending from an abstract class will have to give implementation of the abstract methods defined in abstract class

Example:


abstract class MyAbstractClass {
    //abstract method
    abstract void print();
    //concrete method
    public void display() {
        System.out.println("In display method");
    }
}

public class AbstractDemo extends MyAbstractClass {
    @Override
    void print() {
        System.out.println("In print method");
    }
    public static void main(String[] args) {
        AbstractDemo obj = new AbstractDemo();
        obj.print();
        obj.display();
    }
}

Output:

 In print method
 In display method

Does Abstract class have constructor?

Yes, abstract classes have constructor. Either you can provide it or the default one will be provided by Java. Now, you must be wondering if you cannot create an object of abstract class then what is the need of a constructor.
One thing you must know is that the constructors are used when you are creating an object of a class, to initialize the data members of that class and your abstract class can have data members.

Now, when your class extends abstract class then the same abstract class will become super class for your extending class and remember when you have constructor of your class then first line of your constructor is always a call to super class constructor and this is the time when your abstract class constructor will get called.

Example 1:

abstract class MyAbstractClass {

    public MyAbstractClass() {
        System.out.println("inside MyAbstractClass constructor");
    }

}

public class AbstractDemo extends MyAbstractClass {

    public AbstractDemo() {
        System.out.println("inside AbstractDemo constructor");
    }

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

}

Output:

inside MyAbstractClass constructor
inside AbstractDemo constructor

Example 2:


abstract class MyAbstractClass {

    public int a;
    public int b;

    public MyAbstractClass(int a, int b) {
        this.a = a;
        this.b = b;
    }

    public void print() {
        System.out.println("a = " + a);
        System.out.println("b = " + b);
    }

}

public class AbstractDemo extends MyAbstractClass {

    public AbstractDemo(int x, int y) {
        super(x, y);

    }
    public static void main(String[] args) {
        AbstractDemo obj = new AbstractDemo(5, 10);
        obj.print();
    }

}

Output:

a = 5
b = 10

Interface

An interface in Java is a blueprint of a class. It has static constants and abstract methods.
Interface specify what a class must do but not how to do
An interface is like defining a contract that is fulfilled by implementing classes
An interface is used to achieve full abstraction.
All methods in an interface are public and abstract by default and all variables declared in an interface are constants i.e. public, static and final
A class which implements an interface will have to provide implementation of all the methods that are defined in the interface
A class can implement more than one interface, this is how Java allows multiple inheritance.
Since Java 8, we can have default and static methods in an interface

Abstract class Vs Interface

The differences are:

Abstract class can have both abstract and concrete methods but interface can only have abstract methods (Java 8 onwards, it can have default and static methods as well)
Abstract class methods can have access modifiers other than public but interface methods are implicitly public and abstract
Abstract class can have final, non-final, static and non-static variables but interface variables are only static and final
A subclass can extend only one abstract class but it can implement multiple interfaces
An Abstract class can extend one other class and can implement multiple interfaces but an interface can only extend other interfaces

from Java 8 onwards, you can have static and default methods in an Interface so now what is the difference between abstract class and interface and the answer is – We can still extend only one class but can implement multiple interfaces.

What to choose – interface or abstract class

Consider these points while choosing between the two:

When you want to provide default implementation to some of the common methods that can be used directly by the sub-classes then you can use abstract class because it can have concrete methods also, this is not the case with Interface because the child classes that are implementing this interface will have to provide implementation for all the methods that are declared in the interface
If your contract keeps on changing then Interface will create problems because then you will have to provide implementation of those new methods in all the implementing classes, whereas with abstract class you can provide one default implementation to the new methods and only change those implementing classes that are actually going to use these new methods

Most of the times, interfaces are a good choice. It is also one of the best practices, when you code in terms of interfaces.

Why Java 8 has introduced default methods?

To extend the capability of an already existing interface, default methods are introduced in Java 8. Let’s understand this by one example:

Consider there are 100 classes that are implementing one interface. Now you want to define one new method inside your interface. In this case you will have to change all the implementation classes to fulfill the interface contract. So, Java introduced default methods, here you can provide default implementation of that new method inside your interface and as it is not mandatory to provide implementation of default methods by the implementing classes, all the 100 classes can use the default implementation or if they want they can provide their own implementation by overriding the default method.

Now consider one interesting scenario: You have two interfaces, Interface1 and Interface2 both having default method hello() and one class is implementing these 2 interfaces without giving implementation to this default method. You see the problem here? Yes, it is the famous Diamond Problem (Refer to Question 9 , if you’re not already familiar with this problem).

interface Interface1 {
    default void hello() {
        System.out.println("Hello from Interface1");
    }
}

interface Interface2 {
    default void hello() {
        System.out.println("Hello from Interface2");
    }
}

public class Child implements Interface1, Interface2 {

}

So, to avoid this error, it is mandatory to provide implementation for common default methods of interfaces


public class Child implements Interface1, Interface2 {
    @Override
    public void hello() {
        System.out.println("inside Child class hello method");
        Interface1.super.hello();
    }

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

Output:

Inside Child class hello method
Hello from Interface1

Why Java 8 has introduced static methods?

Consider an example where you want to define a utility class, what you usually do is you define a class which contains static methods and then you call these methods using class name. Now, Java 8 onwards you can do the same thing using an Interface by giving only static methods inside your interface. This way of using Interface for defining utility classes is better as it helps in performance also, because using a class is more expensive operation than using an interface.

Why Java does not allow multiple inheritance?

Multiple inheritance occurs when a class has more than one parent classes.
Why Java does not allow this : let us consider there are 2 parent classes having a method named hello() with same signature and one child class is extending these 2 classes, if you call this hello() method which is same in both parents, which parent class method will get executed – it results into an ambiguous situation, this is also called Diamond Problem .
You will get a compile time error if you try to extend more than one class.

class Parent1 {
    default void hello() {
        System.out.println("Hello from Parent1 class");
    }
}

class Parent2 {
    default void hello() {
        System.out.println("Hello from Parent2 class");
    }
}

public class Child extends Parent1, Parent2 {

}

Output:

Syntax error on token ",". expected.

Method Overloading and Overriding

There are 2 ways by which we can achieve polymorphic behavior

Method Overloading
Method Overriding

Method Overloading

Method overloading means two or more methods in a class having the same name but different parameters(arguments).
Methods may or may not have a different return type.
Method overloading reduces duplicate code and allows us to use the same method name for different purposes.
Method overloading is also called Compile time polymorphism because, at the time of compiling the code, the compiler decides which method is going to be called based on the method name, return type, and arguments.
Overloading can also happen in the case of inheritance. This is because the Child class already has one version of inherited methods from the parent class and can also write another overloaded version of that method.

Simply put, we can implement method overloading in two different ways:

implementing two or more methods that have the same name but take different numbers of arguments
implementing two or more methods that have the same name but take arguments of different types

Rules for Method Overloading

Two methods can be called overloaded if they follow rules:

Both have same method name
Both have different arguments

If both methods follow these two rules, then they may or may not:

Have different access modifiers
Have different return types
Throw different checked or unchecked exceptions

Example 1: Different Numbers of Arguments

The Multiplier class shows how to overload the multiply() method by simply defining two implementations that take different numbers of arguments:

public class Multiplier {
    public int multiply(int a, int b) {
        return a * b;
    }
    public int multiply(int a, int b, int c) {
        return a * b * c;
    }
}

Example 2: Arguments of Different Types
Similarly, we can overload the multiply() method by making it accept arguments of different types:

public class Multiplier {

    public int multiply(int a, int b) {
        return a * b;
    }

    public double multiply(double a, double b) {
        return a * b;
    }
}

it's legitimate to define the Multiplier class with both types of method overloading:

public class Multiplier {

    public int multiply(int a, int b) {
        return a * b;
    }

    public int multiply(int a, int b, int c) {
        return a * b * c;
    }

    public double multiply(double a, double b) {
        return a * b;
    }
}

however, that it's not possible to have two method implementations that differ only in their return types.

To understand why – let's consider the one example:

public int multiply(int a, int b) { 
    return a * b; 
}

public double multiply(int a, int b) { 
    return a * b; 
}

In this case, the code simply wouldn't compile because of the method call ambiguity – the compiler wouldn't know which implementation of multiply() to call.

Example 3: Type Promotion

One neat feature provided by method overloading is the so-called type promotion, a.k.a. widening primitive conversion.

In simple terms, one given type is implicitly promoted to another one when there's no matching between the types of the arguments passed to the overloaded method and a specific method implementation.

To understand more clearly how type promotion works, consider the implementations of the multiply() method:

public double multiply(int a, long b) {
    return a * b;
}

public int multiply(int a, int b, int c) {
    return a * b * c;
}

Now, calling the method with two int arguments will result in the second argument being promoted to long, as in this case there's not a matching implementation of the method with two int arguments.

Let's see a quick unit test to demonstrate type promotion:

@Test
public void whenCalledMultiplyAndNoMatching_thenTypePromotion() {
    assertThat(multiplier.multiply(10, 10)).isEqualTo(100.0);
}

Conversely, if we call the method with a matching implementation, type promotion just doesn't take place:

@Test
public void whenCalledMultiplyAndMatching_thenNoTypePromotion() {
    assertThat(multiplier.multiply(10, 10, 10)).isEqualTo(1000);
}

Here's a summary of the type promotion rules that apply for method overloading:

byte can be promoted to short, int, long, float, or double
short can be promoted to int, long, float, or double
char can be promoted to int, long, float, or double
int can be promoted to long, float, or double
long can be promoted to float or double
float can be promoted to double

Static Binding
The ability to associate a specific method call to the method's body is known as binding.
In the case of method overloading, the binding is performed statically at compile time, hence it's called static binding.
The compiler can effectively set the binding at compile time by simply checking the methods' signatures.

Method Overriding

Method overriding is defining a method in the child class with the same method name and same method signature which is already written in the parent class.
Return type of overridden method can be a subtype of the return type of parent class method. E.g. If the parent class method returns Vehicle then Subclass’s overridden method’s return type can be any subclass of Vehicle class, for example, Car can be a return type of overridden method in child class. (Assuming Vehicle as parent class and Car as a child class of Vehicle class).
It can’t have a lower access modifier. E.g. If the parent class method has a protected access modifier then the child class overridden method cannot have a private access modifier, but the public is allowed.
Use @override annotation for the overridden method, so if we don’t follow the overriding rules then the compiler will show the error.
Method overriding is called Dynamic Polymorphism because the method which is going to be called is decided at run time by the JVM.
Static methods can’t be overridden, only instance methods are overridden.

Rules for Method Overriding

The overriding method of child class must follow below rules:

It must have same method name as that of parent class method
It must have same arguments as that of parent class method
It must have either the same return type or covariant return type (child classes are covariant types to their parents)
It must not throw broader checked exceptions
It must not have a more restrictive access modifier (if parent method is public, then child method cannot be private/protected)

Example:

Let's see now how to use method overriding by creating a simple, inheritance-based ("is-a") relationship.

Lets say Vehicle is the base class:

public class Vehicle {

    public String accelerate(long mph) {
        return "The vehicle accelerates at : " + mph + " MPH.";
    }

    public String stop() {
        return "The vehicle has stopped.";
    }

    public String run() {
        return "The vehicle is running.";
    }
}

And a subclass:

public class Car extends Vehicle {

    @Override
    public String accelerate(long mph) {
        return "The car accelerates at : " + mph + " MPH.";
    }
}

In this hierarchy , we've simply overridden the accelerate() method in order to provide a more refined implementation for the subtype Car.

Here, it's clear to see that if an application uses instances of the Vehicle class, then it can work with instances of Car as well, as both implementations of the accelerate() method have the same signature and the same return type.

Let's unit tests to check the Vehicle and Car classes:

@Test
public void whenCalledAccelerate_thenOneAssertion() {
    assertThat(vehicle.accelerate(100))
      .isEqualTo("The vehicle accelerates at : 100 MPH.");
}

@Test
public void whenCalledRun_thenOneAssertion() {
    assertThat(vehicle.run())
      .isEqualTo("The vehicle is running.");
}

@Test
public void whenCalledStop_thenOneAssertion() {
    assertThat(vehicle.stop())
      .isEqualTo("The vehicle has stopped.");
}

@Test
public void whenCalledAccelerate_thenOneAssertion() {
    assertThat(car.accelerate(80))
      .isEqualTo("The car accelerates at : 80 MPH.");
}

@Test
public void whenCalledRun_thenOneAssertion() {
    assertThat(car.run())
      .isEqualTo("The vehicle is running.");
}

@Test
public void whenCalledStop_thenOneAssertion() {
    assertThat(car.stop())
      .isEqualTo("The vehicle has stopped.");
}

Now, let's see some unit tests that show how the run() and stop() methods, which aren't overridden, return equal values for both Car and Vehicle:

@Test
public void givenVehicleCarInstances_whenCalledRun_thenEqual() {
    assertThat(vehicle.run()).isEqualTo(car.run());
}

@Test
public void givenVehicleCarInstances_whenCalledStop_thenEqual() {
   assertThat(vehicle.stop()).isEqualTo(car.stop());
}

In our case, we have access to the source code for both classes, so we can clearly see that calling the accelerate() method on a base Vehicle instance and calling accelerate() on a Car instance will return different values for the same argument.

Therefore, the test demonstrates that the overridden method is invoked for an instance of Car:

@Test
public void whenCalledAccelerateWithSameArgument_thenNotEqual() {
    assertThat(vehicle.accelerate(100))
      .isNotEqualTo(car.accelerate(100));
}

Type Substitutability
It's valid to make an overridden method to accept arguments of different types and return a different type as well, but with full adherence to these rules:

If a method in the base class takes argument(s) of a given type, the overridden method should take the same type or a supertype (a.k.a. contravariant method arguments)
If a method in the base class returns void, the overridden method should return void
If a method in the base class returns a primitive, the overridden method should return the same primitive
If a method in the base class returns a certain type, the overridden method should return the same type or a subtype (a.k.a. covariant return type)
If a method in the base class throws an exception, the overridden method must throw the same exception or a subtype of the base class exception

Dynamic Binding

Considering that method overriding can be only implemented with inheritance, where there is a hierarchy of a base type
and subtype(s), the compiler can't determine at compile time what method to call, as both the base class and the
subclasses define the same methods.

As a consequence, the compiler needs to check the type of object to know what method should be invoked.

As this checking happens at runtime, method overriding is a typical example of dynamic binding.

Association

Association can be one way or both ways. When you see this kind of UML diagram, it means ClassA knows about ClassB, but
the reverse is not true.

The following diagram indicates a two-way association because both classes know each other.

Consider an example. In a college, a student can learn from multiple teachers, and a teacher can teach multiple
students. There is no ownership in this kind of relationship. So, when you represent them with classes and objects in
programming, you can say that both kinds of objects can be created and deleted independently.

Aggregation

Aggregation is a stronger type of association. The aggregation between a professor and department can be represented as
follows.

Let’s go deeper. Suppose that Professor X submits his resignation letter to his existing organization to join a new
organization. Although both Professor X and his former institution can survive without each other, Professor X needs to
associate himself with a department in an institution. In this situation, you’d say that the department is the owner of
this relationship and the department has professors.

Similarly, you can say that a human body has hands, a car has seats, a bike has tires, and so forth.

Note

In general, you say that a department has a professor. This is why an association relationship is also known as “has-a” relationship. (You can note down the key difference with inheritance here. Inheritance is associated with the “is-a” relationship.

Composition

Composition is a stronger form of aggregation, and this time you have a filled diamond in place.

A department in a college cannot exist without the college. The college only creates or closes its departments. (You can
argue that if there is no department at all, a college cannot exist, but you do not need to complicate things by
considering this type of corner case.) In other words, the lifetime of a department entirely depends on its college.

This is also known as a death relationship because if you destroy the college, all of its departments are destroyed
automatically. Similarly, you can say the hands (or legs, etc.)of a human being cannot exist without the body.

Association vs. Aggregation vs. Composition

Association	Aggregation	Composition
Association relationship is represented using an arrow.	Aggregation relationship is represented by a straight line with an empty diamond at one end.	The composition relationship is represented by a straight line with a black diamond at one end.
In UML, it can exist between two or more classes.	It is a part of the association relationship.	It is a part of the aggregation relationship.
It incorporates one-to-one, one-to-many, many-to-one, and many-to-many association between the classes.	It exhibits a kind of weak relationship.	It exhibits a strong type of relationship.
It can associate one more objects together.	In an aggregation relationship, the associated objects exist independently within the scope of the system.	In a composition relationship, the associated objects cannot exist independently within the scope of the system.
In this, objects are linked together.	In this, the linked objects are independent of each other.	Here the linked objects are dependent on each other.
It may or may not affect the other associated element if one element is deleted.	Deleting one element in the aggregation relationship does not affect other associated elements.	It affects the other element if one of its associated element is deleted.
Example: A tutor can associate with multiple students, or one student can associate with multiple teachers.	Example: A car needs a wheel for its proper functioning, but it may not require the same wheel. It may function with another wheel as well.	Example: If a file is placed in a folder and that is folder is deleted. The file residing inside that folder will also get deleted at the time of folder deletion.

Java 8

Prince — Sat, 16 Sep 2023 14:15:57 +0000

Java 8

New features

Lambda Expressions − a new language feature allowing treating actions as objects •Method References − enable defining Lambda Expressions by referring to methods directly using their names
Optional − This class is to provide a type-level solution for representing optional values instead of using null references.
Functional Interface – an interface with maximum one abstract method, implementation can be provided using a Lambda Expression
Default methods − give us the ability to add full implementations in interfaces besides abstract methods
Nashorn, JavaScript Engine − Java-based engine for executing and evaluating JavaScript code
Stream API − a special iterator class that allows processing collections of objects in a functional manner
Date and Time API − an improved, immutable JodaTime-inspired Date API

Lambda Expressions

A lambda expression is an unnamed block of code (or an unnamed function) with a list of formal parameters and a body.
Sometimes a lambda expression is simply called a lambda. The body of a lambda expression can be a block statement or an
expression. An arrow (->) is used to separate the list of parameters and the body.

Examples of lambda expressions

Takes an int parameter and returns the parameter value incremented by 1

(int x) -> x + 1

Takes two int parameters and returns their sum

(int x, int y) -> x + y

Takes two int parameters and returns the maximum of the two

(int x, int y) -> { int max = x > y ? x : y;
return max;
}

Takes no parameters and returns void

() -> { }

Takes no parameters and returns a string "OK"

() -> "OK"

Takes a String parameter and prints it on the standard output

(String msg) -> { System.out.println(msg); }

Takes a parameter and prints it on the standard output

msg -> System.out.println(msg)

Takes a String parameter and returns its length

(String str) -> str.length()

@FunctionalInterface
interface StringToIntMapper {
    int map(String str);
}

    StringToIntMapper mapper = (String str) -> str.length();

    String name = "Kristy";
    int mappedValue = mapper.map(name);
System.out.println("name="+name+", mapped value="+mappedValue);

Output:

name=Kristy, mapped value=6

The following snippet of code uses an anonymous class to achieve the same result as the lambda expression used in the
previous example:

StringToIntMapper mapper=new StringToIntMapper(){
@Override
public int map(String str){
        return str.length();
        }
        };

        String name="Kristy";
        int mappedValue=mapper.map(name);
        System.out.println("name="+name+", mapped value="+mappedValue);

Output:

name=Kristy, mapped value=6

Lambda Expression facilitates functional programming and simplifies the development a lot.
It provides a clear and concise way to represent one method interface using an expression. It is very useful in the collection library. It helps to iterate, filter, and extract data from the collection.
The Lambda expression is used to provide the implementation of an interface that has a functional interface. It saves a lot of code. In the case of the lambda expression, we don't need to define the method again for providing the implementation. Here, we just write the implementation code.
Java lambda expression is treated as a function, so the compiler does not create a .class file.
Lambda expressions have three parts: a list of parameters, and arrow, and a body: (Object o) -> System.out.println(o);
You can think of lambda expressions as anonymous methods (or functions) as they don't have a name.
A lambda expression can have zero (represented by empty parentheses), one or more parameters.
The type of the parameters can be declared explicitly, or it can be inferred from the context.
If there is a single parameter, the type is inferred, and is not mandatory to use parentheses.
If the lambda expression uses as a parameter name which is the same as a variable name of the enclosing context, a compile error is generated.
If the body has one statement, curly brackets are not required, and the value of the expression (if any) is returned.
If the body has more than one statement, curly brackets are required, and if the expression returns a value, it must return with a return statement.
If the lambda expression doesn't return a result, a return statement is optional.
The signature of the abstract method of a functional interface provides the signature of a lambda expression.
In order to use a lambda expression, you first need a functional interface.
However, lambda expressions don't contain the information about which functional interface are implementing.
The type of the expression is deduced from the context in which the lambda is used. This type is called a target type.
The contexts where the target type of a lambda expression can be inferred include an assignment, method or constructor arguments, and a cast expression.
Default methods of a functional interface cannot be accessed from within lambda expressions.

Why use Lambda Expression

To provide the implementation of the Java 8 Functional Interface.
Less coding.
Lambda Expressions enable you to encapsulate a single unit of behavior and pass it to other code. You can use lambda expressions if you want a certain action performed on each element of a collection, when a process is completed, or when a process encounters an error.

Lambda Expressions Syntax

Java Lambda Expression Syntax

(argument-list)->{body}

Java lambda expression consists of three components.

Argument-list: It can be empty or non-empty as well.
Arrow-token: It is used to link arguments-list and body of expression.
Body: It contains expressions and statements for the lambda expression.

A lambda expression consists of a list of parameters and a body separated by an arrow (->). The list of parameters is
declared the same way as the list of parameters for methods. The list of parameters is enclosed in parentheses, as is
done for methods. The body of a lambda expression is a block of code enclosed in braces. Like a method’s body, the body
of a lambda expression may declare local variables; use statements including break, continue, and return; throw
exceptions, etc. Unlike a method, a lambda expression does not have the following four parts:

• A lambda expression does not have a name. • A lambda expression does not have a return type. It is inferred by the
compiler from the context of its use and from its body. • A lambda expression does not have a throws clause. It is
inferred from the context of its use and its body. • A lambda expression cannot declare type parameters. That is, a
lambda expression cannot be generic.

Examples of Lambda Expressions and Equivalent Methods

Java Lambda Expression Syntax :

Generic Java Lambda Expression Syntax (argument-list) -> {body}
Java Lambda Expression with No Parameter: () -> { Systen.out.printIn("Lamda Expression"); };
Java Lambda Expression with Single Parameter (msg) -> system.om.printin(msg); }
Java Lambda Expression with Multiple Parameters: (int a,int b) -> (a+b);
Java Lambda Expression without return keyword: (a, b) -> (a + b);
Java Lambda Expression with Multiple Statements:

(x,r) -> {
        Systen.out.println("x: ":+x);
        Systen.out.printIn("Y :"+y);
        return(x+y);
        };

Stream

Java provides a new additional package in Java 8 called java.util.stream. This package consists of classes,
interfaces, and an enum to allows functional-style operations on the elements. You can use stream by importing
java.util.stream package in your programs.

Stream features

Stream does not store elements. It simply conveys elements from a source such as a data structure, an array, or an I/O channel, through a pipeline of computational operations.
Stream is functional in nature. Operations performed on a stream does not modify its source. For example, filtering a Stream obtained from a collection produces a new Stream without the filtered elements, rather than removing elements from the source collection.
Stream is lazy and evaluates code only when required.
The elements of a stream are only visited once during the life of a stream. Like an Iterator, a new stream must be generated to revisit the same elements of the source.

You can use Stream to filter, collect, print, and convert from one data structure to other etc.

Intermediate and Terminal operations

Intermediate vs Terminal operations

Intermediate operation is lazy while a terminal operation is not.
When you invoke an intermediate operation on a stream, the operation is not executed immediately. It is executed only when a terminal operation is invoked on that stream. In a way, an intermediate operation is memorized and is recalled as soon as a terminal operation is invoked.
You can chain multiple intermediate operations and none of them will do anything until you invoke a terminal operation. At that time, all of the intermediate operations that you invoked earlier will be invoked along with the terminal operation.
All intermediate operations return Stream (can be chained), while terminal operations don't.

Intermediate Operations

filter(Predicate)
map(Function)
flatMap(Function)
sorted(Comparator)
peek(Consumer)
distinct()
limit(long n)
skip(long n)

Terminal Operations

forEach
forEachOrdered
toArray
reduce
collect
min
max
count
anyMatch
allMatch
noneMatch
findFirst
findAny

Functional Interface

An Interface that contains exactly one abstract method is known as a functional interface.
It can have any number of default, static methods but can contain only one abstract method. It can also declare methods of the object class.
Functional Interface is also known as Single Abstract Method Interfaces or SAM Interfaces. It is a new feature in Java 8, which helps to achieve a functional programming approach.
A functional interface can extend another interface only when it does not have any abstract method.
The Java API has many one-method interfaces such as Runnable, Callable, Comparator, ActionListener, and others. They can be implemented and instantiated using anonymous class syntax.
A functional interface is an interface that has exactly one abstract method.
Since default methods have an implementation, they are not abstract so a functional interface can have any number of them.
If an interface declares an abstract method with the signature of one of the methods of java.lang.Object, it doesn't count toward the functional interface method count.
A functional interface is valid when it inherits a method that is equivalent but not identical to another.
An empty interface is not considered a functional interface.
A functional interface is valid even if the @FunctionalInterface annotation would be omitted.
Functional interfaces are the basis of lambda expressions

Custom Functional Interface

@FunctionalInterface
interface Sayable{
    void say(String msg);   // abstract method   
}

public class FunctionalInterfacesExample {

    public static void main(String[] args) {

        Sayable sayable = (msg) -> {
            System.out.println(msg);
        };
        sayable.say("Say something ..");
    }
}

Predefined Functional Interfaces

Java 8 provides predefined functional interfaces to deal with functional programming by using lambda and method
references.

@Setter
@Getter
public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
}

Predicate

We need a function for checking a condition. A Predicate is one such function accepting a single argument to evaluate to
a boolean result. It has a single method test that returns the boolean value.

Internal implementation of the Predicate interface: Predicate interface contains exactly one abstract method test(T t).
Note that it also contains a default, static methods.

@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

   static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

Example :

public class PredicateExample {
    public static void main(String[] args) {
        Predicate<Person> predicate = (person) -> person.getAge() > 28;
        boolean result = predicate.test(new Person("James", 29));
        System.out.println(result);
    }
}

Function

It represents a function that accepts one argument and returns a result.

The function interface contains exactly one abstract method apply(T t). Note that it also contains a default, static
methods.

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }


    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

Example :

import java.util.function.Function;

public class FunctionExample {

    public static void main(String[] args) {
        // convert centigrade to fahrenheit
        Function < Integer, Double > centigradeToFahrenheitInt = x -> new Double((x * 9 / 5) + 32);

        // String to an integer
        Function < String, Integer > stringToInt = x -> Integer.valueOf(x);
        System.out.println(" String to Int: " + stringToInt.apply("4"));


        Function < PersonEntity, PersonDTO > function = (entity) -> {
            return new PersonDTO(entity.getName(), entity.getAge());
        };
        PersonDTO personDTO = function.apply(new PersonEntity("James", 20));
        System.out.println(personDTO.getName());
        System.out.println(personDTO.getAge());
    }
}

class PersonEntity {
    private String name;
    private int age;

    public PersonEntity(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
}

class PersonDTO {
    private String name;
    private int age;

    public PersonDTO(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
}

Supplier

Represents a supplier of results.

Internal implementation of the Supplier interface. The supplier interface contains exactly one abstract method get(T t).
Hence we can apply lambda expression to it.

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

Example :

import java.util.function.Supplier;

public class SuppliersExample {

   public static void main(String[] args) {

       Supplier<Person> supplier = () -> {
           return new Person("John", 30);
       };

       Person p = supplier.get();
       System.out.println("Person Detail:\n" + p.getName() + ", " + p.getAge());
   }
}

Consumer

It represents an operation that accepts a single argument and returns no result. Internal implementation of the Consumer
interface. The consumer interface contains exactly one abstract method accept(T arg0). Hence we can apply lambda
expression to it.

@FunctionalInterface
public interface Consumer<T> {
    void accept(T arg0);

    default Consumer<T> andThen(Consumer<? super T> arg0) {
       Objects.requireNonNull(arg0);
       return (arg1) -> {
       this.accept(arg1);
       arg0.accept(arg1);
    };
  }
}

Example :

public class ConsumersExample {

    public static void main(String[] args) {
        List<Person> listOfPerson = new ArrayList<Person>();
        listOfPerson.add(new Person("abc", 27));
        listOfPerson.add(new Person("mno", 26));
        listOfPerson.add(new Person("pqr", 28));
        listOfPerson.add(new Person("xyz", 27));

        listOfPerson.forEach((person) -> {
            System.out.println(" Person name : " + person.getName());
            System.out.println(" Person age : " + person.getAge());
        });


        // Second example
        Consumer<Person> consumer = (person) -> {
           System.out.println(person.getName());
           System.out.println(person.getAge());
        };
        consumer.accept(new Person("John", 30));
    }
}

BiFunction

To define lambdas with two arguments, we have to use additional interfaces that contain "Bi" keyword in their names: BiFunction, ToDoubleBiFunction, ToIntBiFunction, and ToLongBiFunction.
BiFunction implementation that receives a key and an old value to calculate a new value for the salary and return it.

It represents a function that accepts two arguments and returns a result.
internal implementation of BiFunction interface. BiFunction interface contains exactly one abstract method apply(T arg0, U arg1). Hence we can apply lambda expression to it.

@FunctionalInterface
public interface BiFunction<T, U, R> {
 R apply(T arg0, U arg1);

 default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> arg0) {
  Objects.requireNonNull(arg0);
  return (arg1, arg2) -> {
   return arg0.apply(this.apply(arg1, arg2));
  };
 }
}

Example :

public class BiFunctionExample {

    public static void main(String[] args) {

       BiFunction<Person, Person, Integer> biFunction = (p1,p2) -> {
           return p1.getAge() + p2.getAge();
       };

        int totalAge = biFunction.apply(new Person("John", 10),
                new Person("James", 10));
        System.out.println(totalAge);

    }
}

BiConsumer

It represents an operation that accepts two input arguments and returns no result. Internal implementation of BiConsumer
interface. BiConsumer interface contains exactly one abstract method accept(T arg0, U arg1). Hence we can apply lambda
expression to it.

@FunctionalInterface
public interface BiConsumer<T, U> {
    void accept(T arg0, U arg1);

    default BiConsumer<T, U> andThen(BiConsumer<? super T, ? super U> arg0) {
        Objects.requireNonNull(arg0);
        return (arg1, arg2) -> {
             this.accept(arg1, arg2);
            arg0.accept(arg1, arg2);
        };
     }
}

Example :

public class BiConsumersExample {

    public static void main(String[] args) {

        BiConsumer<Person, Person> biConsumer = (p1, p2) -> {
             System.out.println(" print first persion");
             System.out.println(p1.getName());
             System.out.println(" print second persion");
             System.out.println(p2.getName());
       };

       biConsumer.accept(new Person("John", 10), new Person("James", 10));
    }
}

You can also define your own custom functional interface. Following is the list of a functional interface that is placed in java.util.function package.

Method References

Method reference is used to refer method of the functional interface. It is a compact and easy form of a lambda expression. Each time when you are using a lambda expression to just referring a method, you can replace your lambda expression with method reference.

Method References Types:

Reference to a static method : ContainingClass::staticMethodName
Reference to an instance method of a particular object : containingObject::instanceMethodName
Reference to an instance method of an arbitrary object of a particular type : ContainingType::methodName
Reference to a constructor: ClassName::new

For more information:

Java 8 Lambda Expressions

Java Basics

Prince — Sat, 16 Sep 2023 14:10:49 +0000

Java

Java 8 Features

Lambda Expressions : They enable you to treat functionality as a method argument, or code as data. Lambda expressions let you express instances of single-method interfaces (referred to as functional interfaces) more compactly.
Method references : Method references provide easy-to-read lambda expressions for methods that already have a name.
Pipelines and Streams New stream API to facilitate pipeline processing.
Functional interfaces : An Interface that contains only one abstract method is known as functional interface. It can have any number of default and static methods. It can also declare methods of object class.
Date and Time API: Date and Time API give us a new package java.time package.
Default Methods: Default methods enable new functionality to be added to the interfaces of libraries and ensure binary compatibility with code written for older versions of those interfaces.
Type Annotations: Before Java 8 Java annotations can be applied to type declarations. From this Java 8 release onwards, annotations can be applied to type use. Annotations can be applied wherever a type is used like in new instance creates, exception throws clause etc. This will help to enforce stronger type checks and using this feature we can come up with a type checking framework itself.
Nashorn JavaScript Engine: Using this we can develop standalone JavaScript applications in Java. Pre Java 8, we got JDK with a JavaScript engine based on Rhino. It is a developed from scratch. It will provide better compatibility with ECMA normalized JavaScript specification and better performance than Rhino.
Concurrent Accumulators: java.util.concurrent.atomic package is getting additional classes as part of Java 8 release. These will help to sum values from across multiple threads.
Parallel operations: Iterating over a collection can be done in parallel using the aggregate operations easily. Pre Java 8 Iterators are used to parse the elements of a collection one by on explicitly. Now that can be done in parallel internally with the use of streams and aggregate operations. We can create multiple substreams and those substreams can be processed internally in parallel and then the results be combined. For this to be effective, we need to have multiple cores and data volume.
PermGen Space Removed: The PermGen space is removed from Java 8 and instead we have MetaSpace introduced. One of the most dreaded error, "java.lang.OutOfMemoryError: PermGen error will no longer be seen from Java 8. Nice thing is that the MetaSpace default is unlimited and that the system memory itself becomes the memory.
TLS SNI : Server Name Indentification (SNI) is an extension of the TLS protocol used for identifying the certificate to serve based on the hostname specified by the client. This enables a server to have virtual host over HTTPS. The same IP address can be used for multiple hosts and their respective different security certificates.
Optional : Emphasis on best practices to handle null values properly.
Collection API improvements: Some new methods added in Collection API Iterator default method forEachRemaining(Consumer action),Collection default method removeIf(Predicate filter)
Concurrency API improvements: ConcurrentHashMap compute(), forEach(), forEachEntry(), forEachKey(), forEachValue(), merge(), reduce() and search() methods.

Why String is Immutable?

String is immutable for below reasons:

String Pool : String Pool is possible only because String is Immutable in Java. String pool is a special storage area in Java heap. If the string is already present in the pool, then instead of creating a new object, old object’s reference is returned. This way different String variables can refer to the same reference in the pool, thus saving a lot of heap space also. If String is not immutable then changing the string with one reference will lead to the wrong values to other string variables having the same reference.
Security : String parameters are used in network connections, database URL’s, username and passwords etc. Because String is immutable, these values can’t be changed. Otherwise any hacker could change the referenced values which will cause severe security issues in the application.
Multi-threading : Since String is immutable, it is safe for multithreading. A single String instance can be shared across different threads. This avoids the use of synchronization for thread safety. Strings are implicitly thread-safe.
Caching : The hashcode of string is frequently used in Java. Since string is immutable, the hashcode will remain the same, so it can be cached without worrying about the changes. This makes it a great candidate for using it as a Key in Map.
Class Loaders : Strings are used in Java ClassLoaders and since String is made immutable, it provides security that correct class is being loaded.

StringBuffer and StringBuilder

Both StringBuffer and StringBuilder classes are used for String manipulation. These are mutable objects. But StringBuffer provides thread-safety as all its methods are synchronized, this makes performance of StringBuffer slower as compared to StringBuilder.
StringBuffer class is present from Java 1.0, but due to its slower performance, StringBuilder class was introduced in Java 1.5
If you are in a single-threaded environment or don’t care about thread safety, you should use StringBuilder. Otherwise, use StringBuffer for thread-safe operations.
You should use String class if you require immutability, use StringBuffer if you require mutability + Thread safety and use StringBuilder if you require mutability and no thread safety.

equals and hashcode contract

The equals and hashcode contract says:

If two objects are equals according to equals() method, then their hashcode must be same but reverse is not true i.e. if two objects have same hashcode then they may/may not be equals.

Comparable and Comparator interfaces

Both Comparable and Comparator interfaces are used to sort the collection of objects. These interfaces should be implemented by your custom classes, if you want to use Arrays/Collections class sorting methods.
Comparable interface has compareTo(Obj) method, you can override this method in your class, and you can write your own logic to sort the collection.

General rule to sort a collection of objects is:

If ‘this’ object is less than passed object, return negative integer.
If ‘this’ object is greater than passed object, return positive integer.
If ‘this’ object is equal to the passed object, return zero.
Comparable Example :

Employee.java

public class Employee implements Comparable<Employee>{
    private int id;
    private String name;
    private int age;
    private long salary;

    public Employee(int id, String name, int age, long salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public int getId() { return id; }
    public String getName() { return name; }
    public int getAge() { return age; }
    public long getSalary() { return salary; }

    public void setId(int id) { this.id = id; }
    public void setName(String name) { this.name = name; }
    public void setAge(int age) { this.age = age; }
    public void setSalary(long salary) { this.salary = salary; }

    @Override
    public int compareTo(Employee obj) {
        return this.id - obj.id;
    }

    @Override
    public String toString() {
        return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", "
                + "salary=" + salary + "]" + "\n";
    }

}

ComparableDemo.java :


import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ComparableDemo {

    public static void main(String[] args) {
        List<Employee> empList = new ArrayList<>();

        empList.add(new Employee(4, "Dave", 25, 28000));
        empList.add(new Employee(20, "Mike", 20, 10000));
        empList.add(new Employee(9, "Abhi", 32, 5000));
        empList.add(new Employee(1, "Lisa", 40, 19000));

        Collections.sort(empList);
        System.out.println(empList);
    }

}

Output:

[Employee [id=1, name=Lisa, age=40, salary=19000]
, Employee [id=4, name=Dave, age=25, salary=28000]
, Employee [id=9, name=Abhi, age=32, salary=5000]
, Employee [id=20, name=Mike, age=20, salary=10000]
]

Here, we have sorted the Employee list based on ‘id’ attribute.

Comparator Example : Now, if we want to sort the employee list based on any other attribute, say name, we will have to change our compareTo() method implementation for this. So, Comparable allows only single sorting mechanism. But Comparator allows sorting based on multiple parameters. We can define another class which will implement Comparator interface and then we can override it’s compare(Obj, Obj) method. Suppose we want to sort the Employee list based on name and salary.

NameComparator.java :

import java.util.Comparator;
public class NameComparator implements Comparator<Employee> {

    @Override
    public int compare(Employee emp1, Employee emp2) {
        return emp1.getName().compareTo(emp2.getName());
    }
}

String class already implements Comparable interface and provides a lexicographic implementation for compareTo() method which compares 2 strings based on contents of characters or you can say in lexical order. Here, Java will determine whether passed String object is less than, equal to or greater than the current object.

ComparatorDemo.java :

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ComparatorDemo {
    public static void main(String[] args) {
        List<Employee> empList = new ArrayList<>();

        empList.add(new Employee(4, "Dave", 25, 28000));
        empList.add(new Employee(20, "Mike", 20, 10000));
        empList.add(new Employee(9, "Abhi", 32, 5000));
        empList.add(new Employee(1, "Lisa", 40, 19000));

        Collections.sort(empList, new NameComparator());
        System.out.println(empList);
    }
}

Output:

[Employee [id=9, name=Abhi, age=32, salary=5000]
, Employee [id=4, name=Dave, age=25, salary=28000]
, Employee [id=1, name=Lisa, age=40, salary=19000]
, Employee [id=20, name=Mike, age=20, salary=10000]
]

The output list is sorted based on employee’s names.

SalaryComparator.java :

import java.util.Comparator;
public class SalaryComparator implements Comparator<Employee> {
    @Override
    public int compare(Employee emp1, Employee emp2) {
        return (int) (emp1.getSalary() - emp2.getSalary());
    }
}

ComparatorDemo.java :

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ComparatorDemo {
    public static void main(String[] args) {
        List<Employee> empList = new ArrayList<>();

        empList.add(new Employee(4, "Dave", 25, 28000));
        empList.add(new Employee(20, "Mike", 20, 10000));
        empList.add(new Employee(9, "Abhi", 32, 5000));
        empList.add(new Employee(1, "Lisa", 40, 19000));

        Collections.sort(empList, new SalaryComparator());
        System.out.println(empList);
    }
}

Output:

[Employee [id=9, name=Abhi, age=32, salary=5000]
, Employee [id=20, name=Mike, age=20, salary=10000]
, Employee [id=1, name=Lisa, age=40, salary=19000]
, Employee [id=4, name=Dave, age=25, salary=28000]
]

Comparable and Comparator

Comparable interface can be used to provide single way of sorting whereas Comparator interface is used to provide multiple ways of sorting
Comparable interface is present in ‘java.lang’ package whereas Comparator interface is present in java.util package
For using Comparable, the class needs to implement Comparable interface whereas for using Comparator, there is no need to make changes in the class
Comparable provides compareTo() method to sort elements, whereas Comparator provides compare() method to sort elements
We can sort the list elements of Comparable type by using Collections.sort(listObj) method, whereas to sort the list elements of Comparator type, we have to provide a Comparator object like, Collections.sort(listObj, Comparator)

At times, when you are using any third-party classes or the classes where you are not the author of the class, then in that case Comparator is the only choice to sort those objects

static keyword

In Java, a static member is a member of a class that isn’t associated with an instance of a class. Instead, the member belongs to the class itself.

In Java, Static is applicable for the:

Variable
Method
Block
Nested class

Static Variable : if any variable is declared as static, then it is known as ‘static variable’. Only single copy of the variable gets created and all instances of the class share same static variable. The static variable gets memory only once in the class area at the time of class loading.
When to use static variable : static variables should be used to declare common property of all objects as only single copy is created and shared among all class objects, for example, the company name of employees etc.
Static Method : When a method is declared with static keyword then it is known as static method. These methods belong to the class rather than the object of the class. As a result, a static method can be directly accessed using class name without the need of creating an object.
One of the basic rules of working with static methods is that you can’t access a non-static method or field from a static method because the static method doesn’t have an instance of the class to use to reference instance methods or fields. Another restriction is, ‘this’ and ‘super’ cannot be used in static context.
For example: main() method is static, Java Runtime uses this method to start an application without creating an object.
Static Block : Static block gets executed exactly once when the class is first loaded, use static block to initialize the static variables.
Static nested classes :
Static nested classes are a type of inner class in java where the inner class is static. Static nested classes can access only the static members of the outer class. The advantage of using static nested classes is that it makes the code more readable and maintainable.
In the case of normal inner class, you cannot create inner class object without first creating the outer class object, but in the case of static inner class, there can be a static inner class object without the outer class object.

How to create object of static inner class:

    OuterClass.StaticNestedClass nestedClassObject = new OuterClass.StaticNestedClass();

Compile Time Error comes when we try to access non-static member inside static nested class:


class OuterClass {
    int a = 10;
    static int b = 20;
    private static int c = 30;

    static class InnerClass {
        void print() {
            System.out.println("Outer class variable a : " + a);
            System.out.println("Outer class variable b : " + b);
            System.out.println("Outer class variable c : " + c);
        }
    }
}

Compile Time Error

Non-static field 'a' cannot be referenced from a static context



class OuterClass {
    int a = 10;
    static int b = 20;
    private static int c = 30;

    static class InnerClass {
        void print() {
            //System.out.println("Outer class variable a : " + a);
            System.out.println("Outer class variable b : " + b);
            System.out.println("Outer class variable c : " + c);
        }
    }
}

public class StaticNestedTestClass {
    public static void main(String[] args) {
        OuterClass.InnerClass innerClassObject = new OuterClass.InnerClass();
        innerClassObject.print();
    }
}

Output:

Outer class variable b : 20
Outer class variable c : 30

If you have static members in your Static Inner class then there is no need to create the inner class object:


class OuterClass {
    static int x = 20;

    static class InnerClass {
        static int y = 30;

        static void display() {
            System.out.println("Outer x : " + x);
        }
    }
}

public class StaticNestedTestClass {
    public static void main(String[] args) {
        OuterClass.InnerClass.display();
        System.out.println(OuterClass.InnerClass.y);
    }   
}

Output:

Outer x : 20
30

Shallow Copy and Deep Copy

Shallow Copy : When we use the default implementation of clone() method, a shallow copy of object is returned, meaning if the object that we are trying to clone contains both primitive variables and non-primitive or reference type variable, then only the object’s reference is copied not the entire object itself.

Consider this with the example:
Employee object is having Company object as a reference, now when we perform cloning on Employee object, then for primitive type variables, cloning will be done i.e. new instances will be created and copied to the cloned object but for non-primitive i.e. Company object, only the object’s reference will be copied to the cloned object. It simply means Company object will be same in both original and cloned object, changing the value in one will change the value in other and vice-versa.
Now, if you want to clone the Company object also, so that your original and cloned Employee object will be independent of each other, then you have to perform Deep Copy.

Deep Copy : In Deep copy, the non-primitive types are also cloned to make the original and cloned object fully independent of each other.

Program 1:


class Company implements Cloneable {
    private String name;
    public Company(String name) {
        this.name = name;
    }
    public String getName() {   return name;    }
    public void setName(String name) {  this.name = name;   }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class Employee implements Cloneable {
    private String name;
    private int age;
    private Company company;

    public Employee(String name, int age, Company company) {
        this.name = name;
        this.age = age;
        this.company = company;
    }

    public String getName() {   return name;    }
    public int getAge() {   return age;     }
    public void setName(String name) {  this.name = name;   }
    public void setAge(int age) {   this.age = age;     }
    public Company getCompany() {   return company;     }
    public void setCompany(Company company) {   this.company = company;     }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Employee employee = (Employee) super.clone();
        employee.company = (Company) company.clone();
        return employee;
    }
    public static void main(String[] args) throws CloneNotSupportedException {
        Company c1 = new Company("Company_ABC");
        Employee e1 = new Employee("Mike", 10, c1);
        System.out.println("Employee 1, company name : " + e1.getCompany().getName());

        Employee e2 = (Employee) e1.clone();
        System.out.println("Employee 2, company name : " + e2.getCompany().getName());
        e2.getCompany().setName("XYZ");
        System.out.println("----------------------------");
        System.out.println("Employee 1, company name : " + e1.getCompany().getName());
        System.out.println("Employee 2, company name : " + e2.getCompany().getName());
    }
}

Output:

Employee 1, company name : Company_ABC
Employee 2, company name : Company_ABC
----------------------------
Employee 1, company name : Company_ABC
Employee 2, company name : XYZ

In above example, we have overridden the clone method in our employee class and we called the clone method on mutable company object.

We can also use Copy constructor to perform deep copy:

Program 2:


class Company {
    private String name;
    public Company(String name) {
        this.name = name;
    }
    public String getName() {   return name;    }
    public void setName(String name) {  this.name = name;   }

}

public class Employee {
    private String name;
    private int age;
    private Company company;

    public Employee(String name, int age, Company company) {
        this.name = name;
        this.age = age;
        this.company = company;
    }

    //Copy constructor
    public Employee(Employee emp) {
        this.name = emp.getName();
        this.age = emp.getAge();
        Company company = new Company(emp.getCompany().getName());
        this.company = company;
    }

    public String getName() {   return name;    }
    public int getAge() {   return age;     }
    public void setName(String name) {  this.name = name;   }
    public void setAge(int age) {   this.age = age;     }
    public Company getCompany() {   return company;     }
    public void setCompany(Company company) {   this.company = company;     }

    public static void main(String[] args) {
        Company c1 = new Company("Company_ABC");
        Employee e1 = new Employee("Mike", 10, c1);
        System.out.println("Employee 1, company name : " + e1.getCompany().getName());

        //Invoking copy constructor
        Employee e2 = new Employee(e1);
        System.out.println("Employee 2, company name : " + e2.getCompany().getName());
        e2.getCompany().setName("XYZ");
        System.out.println("----------------------------");
        System.out.println("Employee 1, company name : " + e1.getCompany().getName());
        System.out.println("Employee 2, company name : " + e2.getCompany().getName());
    }
}

Output:

Employee 1, company name : Company_ABC
Employee 2, company name : Company_ABC
----------------------------
Employee 1, company name : Company_ABC
Employee 2, company name : XYZ

There are 2 other methods by which you can perform deep copy:

By using Serialization, where you serialize the original object and returns the deserialized object as a clone
By using external library of Apache Commons Lang. Apache Common Lang comes with SerializationUtils.clone() method for performing deep copy on an object. It expects all classes in the hierarchy to implement Serializable interfaces else SerializableException is thrown by the system

Serialization and De-serialization

Serialization is a process of reading or writing an object. It is a process of saving an object’s state to a sequence of bytes, as well as a process of rebuilding those bytes back into a live object at some future time. An object is marked serializable by implementing the java.io.Serializable interface, which is only a marker interface -- it simply allows the serialization mechanism to verify that the class can be persisted, typically to a file.

Transient variables cannot be serialized. The fields marked transient in a serializable object will not be transmitted in the byte stream. An example would be a file handle, a database connection, a system thread etc. Such objects are only meaningful locally. So they should be marked as transient in a serializable class.

Serialization is a mechanism to convert the state of an object into a byte stream while De-serialization is the reverse process where the byte stream is used to recreate the actual object in memory. The byte stream created is platform independent that means objects serialized on one platform can be deserialized on another platform.
To make a Java Object serializable, the class must implement Serializable interface. Serializable is a Marker interface. Object

OutputStream and ObjectInputStream classes are used for Serialization and Deserialization in java.
We will serialize the below Employee class:


import java.io.Serializable;

public class Employee implements Serializable{
    private String name;
    private int age;
    private transient int salary;

    public Employee(String name, int age, int salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee [name=" + name + ", age=" + age + ", salary=" + salary + "]";
    }

}

SerializationDemo.java:


import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializationDemo {
    public static void main(String[] args) {
        Employee emp = new Employee("Mike", 15, 20000);
        String file = "byteStream.txt1";
        try {
            FileOutputStream fos = new FileOutputStream(file);
            ObjectOutputStream oos = new ObjectOutputStream(fos);           
            oos.writeObject(emp);

            fos.close();
            oos.close();            
            System.out.println("Employee object is serialized : " + emp);
        } catch (IOException e1) {
            System.out.println("IOException is caught");
        }   
        try {
            FileInputStream fis = new FileInputStream(file);
            ObjectInputStream ois = new ObjectInputStream(fis);
            Employee emp1 = (Employee) ois.readObject();

            fis.close();
            ois.close();
            System.out.println("Employee object is de-serialized : " + emp1);
        } catch (IOException e) {
            System.out.println("IOException is caught");
        } catch (ClassNotFoundException e) {
            System.out.println("ClassNotFoundException is caught"); 
        }
    }
}

Output:

Employee object is serialized : Employee [name=Mike, age=15, salary=20000]
Employee object is de-serialized : Employee [name=Mike, age=15, salary=0]

Here, while de-serializing the employee object, salary is 0, that is because we have made salary variable to be transient. static and transient variables do not take part in Serialization process. During de-serialization, transient variables will be initialized with their default values i.e. if objects, it will be null and if int, it will be 0 and static variables will be having the current value.
And if you look at the file present in current directory bytestream.txt, you can see how the object is serialized into this file,

See file bytestream.txt

Serialization scenarios with Inheritance

Case 1: If super class is Serializable then by default, its sub-classes are also Serializable


import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class Parent implements Serializable {
    int x;
    public Parent(int x) {
        this.x = x;
    }
}

class Child extends Parent {
    int y;
    public Child(int x, int y) {
        super(x);
        this.y = y;
    }
}

public class TestSerialization {
    public static void main(String[] args) {
        Child child = new Child(10,50);
        System.out.println("x : " + child.x);
        System.out.println("y : " + child.y);
        String file = "temp/child.ser";

        serializeObject(file, child);
        deserializeObject(file);            
    }

    private static void serializeObject(String file, Child child) {
        try {
            FileOutputStream fos = new FileOutputStream(file);
            ObjectOutputStream oos = new ObjectOutputStream(fos);           
            oos.writeObject(child);

            fos.close();
            oos.close();        
            System.out.println("The object has been serialized");
        } catch (IOException e) {
            e.printStackTrace();
        }   
    }

    private static void deserializeObject(String file) {
        try {
            FileInputStream fis = new FileInputStream(file);
            ObjectInputStream ois = new ObjectInputStream(fis);
            Child child1 = (Child) ois.readObject();

            fis.close();
            ois.close();
            System.out.println("The object has been deserialized");
            System.out.println("x : " + child1.x);
            System.out.println("y : " + child1.y);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace(); 
        }
    }
}

See file child.ser

Output:

x : 10
y : 50
The object has been serialized
The object has been deserialized
x : 10
y : 50

Case 2: When super class does not implement the Serializable Interface, then also we can serialize the subclass provided that it implements Serializable interface.

In this case, when we de-serialize the subclass object, then no-arg constructor of its parent class gets called. So, the serializable sub-class must have access to the default no-arg constructor of its parent class (general rule is that the Serializable sub-class must have access to the no-arg constructor of first non-Serializable super class).


import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class Parent {
    int x;
    public Parent(int x) {
        this.x = x;
    }
}

class Child extends Parent implements Serializable {
    int y;
    public Child(int x, int y) {
        super(x);
        this.y = y;
    }
}

public class TestSerialization {
    public static void main(String[] args) {
        Child child = new Child(20,40);
        System.out.println("x : " + child.x);
        System.out.println("y : " + child.y);
        String file = "child1.ser";

        serializeObject(file, child);
        deserializeObject(file);
    }

    private static void serializeObject(String file, Child child) {
        try {
            FileOutputStream fos = new FileOutputStream(file);
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(child);

            fos.close();
            oos.close();
            System.out.println("The object has been serialized");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void deserializeObject(String file) {
        try {
            FileInputStream fis = new FileInputStream(file);
            ObjectInputStream ois = new ObjectInputStream(fis);
            Child child1 = (Child) ois.readObject();

            fis.close();
            ois.close();
            System.out.println("The object has been deserialized");
            System.out.println("x : " + child1.x);
            System.out.println("y : " + child1.y);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

(Note: serializeObject() and deserializeObject() remains same as the Case 1 program)

Output:

x : 20
y : 40
The object has been serialized
java.io.InvalidClassException: Case2.Child; no valid constructor
    at java.base/java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(ObjectStreamClass.java:170)
    at java.base/java.io.ObjectStreamClass.checkDeserialize(ObjectStreamClass.java:917)
    at java.base/java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2203)
    at java.base/java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1712)
    at java.base/java.io.ObjectInputStream.readObject(ObjectInputStream.java:519)
    at java.base/java.io.ObjectInputStream.readObject(ObjectInputStream.java:477)
    at Case2.TestSerialization.deserializeObject(TestSerialization.java:54)
    at Case2.TestSerialization.main(TestSerialization.java:33)

When no-arg constructor is present in Super class:


import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class Parent {
    int x;
    public Parent(int x) {
        this.x = x;
        System.out.println("Parent class one-arg constructor");
    }
    public Parent() {
        x = 100;
        System.out.println("Parent class no-arg constructor");
    }
}

class Child extends Parent implements Serializable {
    int y;
    public Child(int x, int y) {
        super(x);
        this.y = y;
        System.out.println("Child class two-arg constructor");
    }
    public Child() {
        System.out.println("Child class no-arg constructor");
    }
}

public class TestSerialization {
    public static void main(String[] args) {
        Child child = new Child(20,40);
        System.out.println("x : " + child.x);
        System.out.println("y : " + child.y);
        String file = "child2.ser";

        serializeObject(file, child);
        deserializeObject(file);            
    }

    private static void serializeObject(String file, Child child) {
        try {
            FileOutputStream fos = new FileOutputStream(file);
            ObjectOutputStream oos = new ObjectOutputStream(fos);           
            oos.writeObject(child);

            fos.close();
            oos.close();        
            System.out.println("The object has been serialized");
        } catch (IOException e) {
            e.printStackTrace();
        }   
    }

    private static void deserializeObject(String file) {
        try {
            FileInputStream fis = new FileInputStream(file);
            ObjectInputStream ois = new ObjectInputStream(fis);
            Child child1 = (Child) ois.readObject();

            fis.close();
            ois.close();
            System.out.println("The object has been deserialized");
            System.out.println("x : " + child1.x);
            System.out.println("y : " + child1.y);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace(); 
        }
    }
}

(Note: serializeObject() and deserializeObject() remains same as the Case 1 program)

Output:

Parent class one-arg constructor
Child class two-arg constructor
x : 20
y : 40
The object has been serialized
Parent class no-arg constructor
The object has been deserialized
x : 100
y : 40

How to make a class Immutable?

As we know, String is an Immutable class in Java, i.e. once initialized its value never change. We can also make our own custom Immutable class, where the class object’s state will not change once it is initialized.

1 Benefits of Immutable class:

Thread-safe: With immutable classes, we don’t have to worry about the thread-safety in case of multi-threaded environment as these classes are inherently thread-safe
Cacheable: An immutable class is good for Caching because while we don’t have to worry about the value changes

2 How to create an Immutable class:

Declare the class as final so that it cannot be extended
Make all fields as private so that direct access to them is not allowed
Make all fields as final so that its value can be assigned only once
Don’t provide ‘setter’ methods for variables
When the class contains a mutable object reference,
1. While initializing the field in constructor, perform a deep copy
2. While returning the object from its getter method, make sure to return a copy rather than the actual object reference

Example:
We will make Employee class as immutable, but Employee class contains a reference of Address class

Address.java:


public class Address {

    private String city;
    private String state;

    public Address(String city, String state) {
        this.city = city;
        this.state = state;
    }

    public String getCity() { return city; }
    public String getState() { return state; }

    public void setCity(String city) { this.city = city; }
    public void setState(String state) { this.state = state; }

    @Override
    public String toString() {
        return "Address [city=" + city + ", state=" + state + "]";
    }

}

Employee.java:


public final class Employee {

    private final String name;
    private final int age;
    private final Address address;

    public Employee(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        Address cloneAddress = new Address(address.getCity(), address.getState());
        this.address = cloneAddress;
    }

    public String getName() { return name; }

    public int getAge() { return age; }

    public Address getAddress() {
        return new Address(address.getCity(), address.getState());
    }

    @Override
    public String toString() {
        return "Employee [name=" + name + ", age=" + age + ", address=" + address + "]";
    }

}

TestImmutable.java:

public class TestImmutable {
    public static void main(String[] args) {
        Address address = new Address("Chennai", "Tamil Nadu");
        Employee employee = new Employee("Mike", 15, address);

        System.out.println("Original Employee object : \n" + employee);

        address.setCity("Mumbai");
        address.setState("Maharashtra");

        System.out.println("Employee object after local variable address change :\n" + employee);

        Address empAddress = employee.getAddress();
        empAddress.setCity("Jaipur");
        empAddress.setState("Rajasthan");

        System.out.println("Employee object after employee address change:\n" + employee);
    }
}

Here, after creating Employee object, the first change is done in local address object and then we used the employee’s getter method to access the address object and tried to change the value in it.

Output:

Original Employee object : 
Employee [name=Mike, age=15, address=Address [city=Chennai, state=Tamil Nadu]]
Employee object after local variable address change :
Employee [name=Mike, age=15, address=Address [city=Chennai, state=Tamil Nadu]]
Employee object after employee address change:
Employee [name=Mike, age=15, address=Address [city=Chennai, state=Tamil Nadu]]

As, you can see that the value remained the same.
If we don’t follow the rule about mutable object reference present in the class, let’s see what will happen in that case.
Let’s change the Employee class constructor and getter method:

Employee.java:


public final class Employee {

    private final String name;
    private final int age;
    private final Address address;

    public Employee(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getName() { return name; }

    public int getAge() { return age; }

    public Address getAddress() {
        return address;
    }

    @Override
    public String toString() {
        return "Employee [name=" + name + ", age=" + age + ", address=" + address + "]";
    }

}

Now, if we run our TestImmutable.java class, below is the output:

Output:


Original Employee object :
Employee [name=Mike, age=15, address=Address [city=Chennai, state=Tamil Nadu]]
Employee object after local variable address change :
Employee [name=Mike, age=15, address=Address [city=Mumbai, state=Maharashtra]]
Employee object after employee address change:
Employee [name=Mike, age=15, address=Address [city=Jaipur, state=Rajasthan]]

Why we perform deep copy in constructor:

When you assign the actual address object in the constructor, then remember it is storing the reference of address object, so if you change the value in this address object, it will reflect in the employee object

Why we don’t return original reference from the getter:

When you return the original address object from the getter method then you can use the returned object reference to change the values in employee object

Class loaders in Java

ClassLoader is a java class which is used to load .class files in memory. When we compile a java class, JVM creates a bytecode which is platform independent. The bytecode is present in .class file. When we try to use a class, then classloader loads it into memory.

There are 3 types of built-in class loaders in java:

Bootstrap class loader : it loads JDK class files from jre/lib/rt.jar and other core classes. It is the parent of all class loaders, it is also called Primordial classloader.
Extensions class loader : it loads classes from JDK extensions directory, it delegates class loading request to its parent, Bootstrap and if the loading of class is unsuccessful, it loads classes from jre/lib/ext directory or any other directory pointed by java.ext.dirs system property.
System class loader : It loads application specific classes from the CLASSPATH. We can set classpath while invoking the program using -cp or classpath command line options. It is a child of Extension ClassLoader.

Java class loader is based on three principles:

Delegation principle: It forwards the request for class loading to its parent class loader. It only loads the class if the parent does not find or load the class.
Visibility principle: According to Visibility principle, the child ClassLoader can see all the classes loaded by parent ClassLoader. But the parent class loader cannot see classes loaded by the child class loader.
Uniqueness principle: According to this principle, a class loaded by Parent should not be loaded by Child ClassLoader again. It is achieved by delegation principle.

Suppose, you have created a class Employee.java and compiled this class and Emloyee.class file is created. Now, you want to use this class, the first request to load this class will come to System/Application ClassLoader, which will delegate the request to its parent, Extension ClassLoader which further delegates to Primordial or Bootstrap class loader
Now, Bootstrap ClassLoader will look for this class in rt.jar, since this class is not there, the request will come to Extension ClassLoader which looks in jre/lib/ext directory and tries to locate this class there, if this class is found there then Extension ClassLoader will load this class and Application ClassLoader will not load this class, this has been done to maintain the Uniqueness principle. But if the class is not loaded by Extension ClassLoader, then this Employee.class will be loaded by Application ClassLoader from the CLASSPATH.


public class Employee {

    public static void main(String[] args) {
        System.out.println(Employee.class.getClassLoader());
        System.out.println(System.class.getClassLoader());
    }

}

Output:

jdk.internal.loader.ClassLoaders$AppClassLoader@73d16e93
null

If you are thinking why null is printed when we tried to know which classloader is loading the java.lang.System class then take a look at the Javadoc :


    /**
     * Returns the class loader for the class.  Some implementations may use
     * null to represent the bootstrap class loader. This method will return
     * null in such implementations if this class was loaded by the bootstrap
     * class loader.
     *
     * <p>If this {@code Class} object
     * represents a primitive type or void, null is returned.
     *
     * @return  the class loader that loaded the class or interface
     *          represented by this {@code Class} object.
     * @throws  SecurityException
     *          if a security manager is present, and the caller's class loader
     *          is not {@code null} and is not the same as or an ancestor of the
     *          class loader for the class whose class loader is requested,
     *          and the caller does not have the
     *          {@link RuntimePermission}{@code ("getClassLoader")}
     * @see java.lang.ClassLoader
     * @see SecurityManager#checkPermission
     * @see java.lang.RuntimePermission
     */
    @CallerSensitive
    @ForceInline // to ensure Reflection.getCallerClass optimization
    public ClassLoader getClassLoader() {
        ClassLoader cl = getClassLoader0();
        if (cl == null)
            return null;
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            ClassLoader.checkClassLoaderPermission(cl, Reflection.getCallerClass());
        }
        return cl;
    }

We can also create our own custom class loader by extending the ClassLoader class.

Garbage Collector

The Garbage Collector has only two things to do:

Find garbage - unused objects. (An object is considered unused if none of the entities in the code currently executing contains references to it, or the chain of links that could connect the object with some application entity is broken);
Free memory from garbage.

There are two approaches to detecting garbage:

Reference counting ;
Tracing

Counting the Reference (reference counting). The essence of this approach is that each object has a counter. A counter stores information about how many references are pointing to an object. When the link is destroyed, the counter is decremented. If the counter value is zero, the object can be considered garbage. The main disadvantage of this approach is the difficulty of ensuring the accuracy of the meter. Also, with this approach, it is difficult to detect circular dependencies (when two objects point to each other, but no living object refers to them), which leads to memory leaks.

The main idea of the Tracing approach (tracing) is the assertion that only those objects that we can reach from the root points ( GC Root ) and those objects that are accessible from the living object can be considered alive. Everything else is rubbish.

There are 4 types of root points:

Local variables and method parameters;
Streams;
Static variables;
Links from JNI.

The simplest java application will have root points:

Local variables inside the main()method and main()method parameters ;
The thread that executes main();
Static variables of the class inside which the main() method is located .

Thus, if we represent all objects and links between them as a tree, then we will need to go from root nodes (points) along all edges. At the same time, the nodes that we can get to are not garbage, all the rest are garbage. With this approach, cyclical dependencies are easily identified. HotSpot VM takes exactly this approach.

There are two main methods for cleaning up memory from garbage:

Copying collectors
Mark-and-sweep

With the copying collectors approach, memory is divided into two parts "from-space" and "to-space", while the principle of operation is as follows:

Objects are created in "from-space";
When the "from-space" is full, the application is suspended;
The garbage collector starts. Live objects are found in "from-space" and copied to "to-space";
When all objects are copied, "from-space" is completely cleared;
"To-space" and "from-space" are swapped.

The main advantage of this approach is that objects densely clog up memory. Cons of the approach:

The application must be stopped for the time it takes to complete the garbage collection cycle;
In the worst case (when all objects are alive) "form-space" and "to-space" will have to be the same size.

The mark-and-sweep algorithm can be described as:

Objects are created in memory;
At the moment when the garbage collector needs to be started, the application is suspended;
The collector walks through the object tree, marking live objects;
The collector loops through the entire memory, finding all unmarked chunks of memory and storing them in the "free list";
When new objects start to be created they are created in memory available in the "free list"

Cons of this method:
The application does not run while garbage collection is in progress;
The stopping time directly depends on the size of the memory and the number of objects;
If you do not use "compacting" the memory will not be used efficiently.
The HotSpot VM garbage collectors use a combined Generational Garbage Collection approach that allows different algorithms to be used for different stages of garbage collection. This approach relies on the fact that:

most objects created quickly become garbage;
there are few links between objects that were created in the past and newly created objects.

How does the garbage collector work?

Garbage collection is the process of freeing space on the heap so that new objects can be added.

Objects are created through the operator new, thereby assigning a reference to the object. To finish working with an object, you just need to stop referring to it, for example, by assigning a reference to another object or value to a variable null; terminate the execution of the method so that its local variables expire naturally. Objects, links to which are not usually called garbage ( garbage ), which will be removed.

The Java virtual machine, using the garbage collection mechanism, ensures that any object that has references remains in memory - all objects that are unreachable from the executable code, due to the lack of references to them, are deleted, freeing the memory allocated for them. More precisely, an object is outside the scope of the garbage collection process if it is reachable through a chain of links starting at the GC Root , i.e. a link that directly exists in the executable code.

Memory is freed by the garbage collector at its own discretion. The program can successfully complete its work without exhausting the resources of free memory or not even approaching this limit, and therefore it will not need the "services" of the garbage collector.

Garbage is collected by the system automatically, without user or programmer intervention, but this does not mean that this process does not require attention at all. The need to create and delete a large number of objects has a significant impact on the performance of applications and, if program performance is an important factor, you should carefully consider decisions related to the creation of objects - this, in turn, will reduce the amount of garbage to be disposed of.

Types of garbage collectors

The Java HotSpot VM provides four different garbage collectors to choose from:

Serial is the easiest option for applications with low data volume and low latency requirements. At the moment, it is used relatively rarely, but on weak computers it can be selected by the virtual machine as the default collector. The use of Serial GC is enabled by option -XX:+UseSerialGC.
Parallel - inherits assembly approaches from the sequential collector, but adds parallelism to some operations, as well as the ability to automatically adjust to the required performance parameters. Parallel collector is enabled by option -XX:+UseParallelGC.
Concurrent Mark Sweep (CMS) - aims to reduce maximum latency by performing some of the garbage collection work in parallel with the main threads of the application. Suitable for dealing with relatively large amounts of data in memory. The use of CMS GC is enabled by option -XX:+UseConcMarkSweepGC.
Garbage-First (G1) - designed to replace CMS, especially in server applications running on multiprocessor servers and handling large amounts of data. G1 is enabled by Java option -XX:+UseG1GC.

Garbage Collection and types of Garbage Collectors

Garbage collection in java is the process of looking at heap memory, identifying which objects are in use and which are not and deleting the unused objects. An unused object or unreferenced object, is no longer referenced by any part of your program.

Garbage collector is a daemon thread that keeps running in the background, freeing up heap memory by destroying the unreachable objects.

There was an analysis done on several applications which showed that most objects are short lived, so this behavior was used to improve the performance of JVM. In this method, the heap space is divided into smaller parts or generations. These are, Young Generation , Old or Tenured Generation and Permanent Generation .

The Young Generation is where all new objects are allocated and aged. The young generation is further divided into 3 parts: Eden Space, Survivor space S0 and Survivor space S1. When the young generation fills up, this causes a minor garbage collection . Some surviving objects are aged and eventually move to the old generation. All minor garbage collections are "Stop the World" events. This means that all application threads are stopped until the operation completes. Minor garbage collections are always Stop the World events.

The Old Generation is used to store long surviving objects. Typically, a threshold is set for young generation object and when that age is met, the object gets moved to the old generation. Eventually the old generation needs to be collected. This event is called a major garbage collection . Major garbage collection are also Stop the World events. Often a major collection is much slower because it involves all live objects. So, for Responsive applications, major garbage collections should be minimized. Also note that the length of the Stop the World event for a major garbage collection is affected by the kind of garbage collector that is used for the old generation space.

The Permanent generation contains metadata required by the JVM to describe the classes and methods used in the application. The permanent generation is populated by the JVM at runtime based on classes in use by the application. In addition, Java SE library classes and methods may be stored here.

Classes may get collected (unloaded) if the JVM finds they are no longer needed and space may be needed for other classes.

Classes may get collected (unloaded) if the JVM finds they are no longer needed and space may be needed for other classes. The permanent generation is included in a full garbage collection. And Perm Gen was available till Java 7, it is removed from Java 8 onwards and JVM uses native memory for the representation of class metadata which is called MetaSpace.

There is a flag MaxMetaspaceSize, to limit the amount of memory used for class metadata. If we do not specify the value for this, the Metaspace re-sizes at runtime as per the demand of the running application.

How Garbage collection works:

When new objects are first created, they are stored in the eden space of Young Generation and at that time both Survivor spaces are empty. When the eden space is filled, then a minor garbage collection is triggered. All the unused or un-referenced objects are cleared from the eden space and the used objects are moved to first Survivor space S0.

At the next minor garbage collection, same process happens, un-referenced objects are cleared from the eden space but this time, the surviving objects are moved to Survivor space S1. In addition, the objects that were in S0 will also be matured and they also get moved to S1. Once all surviving objects are moved to S1, both eden and S0 are cleared.

At the next minor GC, the same process repeats. When surviving objects reached a certain threshold, they get promoted from Young generation to Old generation. These minor GC will continue to occur and objects will continue to be promoted to the Old generation.

Eventually, a major GC will be performed on the Old generation which cleans up and compacts the space.

Types of Garbage collector

Serial GC:
Serial GC is designed for smaller applications that have small heap sizes of up to a few hundred MBs. It only uses single virtual CPU for its garbage collection and the collection is done serially. It takes around couple of second for Full garbage collections.

It can be turned on by using -XX:+UseSerialGC

java -Xmx12m -Xms3m -Xmn1m -XX:PermSize=20m -XX:MaxPermSize=20m -XX:+UseSerialGC -jar C:\temp\test.jar

Parallel/Throughput GC:

Parallel garbage collector uses multiple threads to perform the garbage collection. By default, on a host with N CPUs, this collector uses N garbage collector threads for collection.

The number of collector threads can be controlled with the command line option: -XX:ParallelGCThreads=<N>

It is called Throughput collector as it uses multiple CPUs to speed up the application throughput. A drawback of this collector is that it pauses the application threads while performing minor or full GC, so it is best suited for applications where long pauses are acceptable. It is the default collector in JDK 8.

It can be turned on by using below 2 options:

-XX:+UseParallelGC

With this command line option, you get a multi-thread young generation collector with a single-threaded old generation collector. The option also does single-threaded compaction of old generation.

java -Xmx12m -Xms3m -Xmn1m -XX:PermSize=20m -XX:Max-PermSize=20m -XX:+UseParallelGC -jar C:\temp\test.jar

-XX:+UseParallelOldGC

With this option, the GC is both a multithreaded young generation collector and multithreaded old generation collector. It is also a multithreaded compacting collector.

Compacting describes the act of moving objects in a way that there are no holes between objects. After a garbage collection sweep, there may be holes left between live objects. Compacting moves objects so that there are no remaining holes. This compacting of memory makes it faster to allocate new chunks of memory to the heap.

java -Xmx12m -Xms3m -Xmn1m -XX:PermSize=20m -XX:MaxPermSize=20m -XX:+UseParallelOldGC -jar C:\temp\test.jar

Concurrent Mark Sweep (CMS) Collector:

The CMS collector, also called as the concurrent low pause collector, collects the tenured generation. It attempts to minimize the pauses due to garbage collection, by doing most of the garbage collection work concurrently with the application threads.

It can be turned on by passing -XX:+UseConcMarkSweepGC in the command line option.

If you want to set number of threads with this collector, pass -XX:ParallelCMSThreads=

java -Xmx12m -Xms3m -Xmn1m -XX:PermSize=20m -XX:Max-PermSize=20m -XX:+UseConcMarkSweepGC -XX:ParallelCMSThreads=2 -jar C:\temp\test.jar

G1 Garbage Collector:

The Garbage First or G1 collector is a parallel, concurrent and incrementally compacting low-pause garbage collector

G1 collector partitions the heap into a set of equal-sized heap regions. When G1 performs garbage collection then a concurrent global marking phase is performed to determine the liveliness of objects throughout the heap. After this mark phase is complete, G1 knows which regions are mostly empty. It collects unreachable objects from these regions first, which usually yields a large amount of free space, also called Sweeping. So G1 collects these regions (containing garbage) first, and hence the name Garbage-First.

It can be turned on by passing -XX:+UseG1GC in the command line options

java –Xmx25g –Xms5g -XX:+UseG1GC -jar C:\temp\test.jar

Java 8 has introduced one JVM parameter for reducing the unnecessary use of memory by creating too many instances of the same String. This optimizes the heap memory by removing duplicate String values to a global single char[] array. We can use the -XX:+UseStringDeduplication JVM argument to enable this optimization.

G1 is the default garbage collector in JDK 9.

Also Check: https://java2blog.com/garbage-collection-java/

final, finally and finalize()

Modifier final:

The class cannot have descendants;
The method cannot be overridden in inherited classes;
The field cannot change its value after initialization;
Local variables cannot be changed once a value has been assigned to them;
Method parameters cannot change their value inside a method.

The operator finally guarantees that a section of code defined in it will be executed regardless of what exceptions were raised and caught in the block try-catch.

The method finalize() is called before the garbage collector performs object disposal.

Example:

public class MainClass {

    public static void main(String args[]) {
        TestClass a = new TestClass();
        System.out.println("result of a.a() is " + a.a());
        a = null;
        System . gc (); // Forced to call the garbage collector 
        a = new TestClass();
        System.out.println("result of a.a() is " + a.a());
        System.out.println("!!! done");
    }

}

public class TestClass {

    public int a() {
        try {
            System.out.println("!!! a() called");
            throw new Exception("");
        } catch (Exception e) {
            System.out.println("!!! Exception in a()");
            return 2;
        } finally {
            System.out.println("!!! finally in a() ");
        }
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("!!! finalize() called");
        super.finalize();
    }
}

Execution result:

!!! a() called
!!! Exception in a()
!!! finally in a()
result of a.a() is 2
!!! a() called
!!! Exception in a()
!!! finally in a()
!!! finalize() called
result of a.a() is 2
!!! done

String, StringBuffer, StringBuilder

The class String is immutable ( the immutable ) - modify an object of this class can not, we can only replace it with a new instance.

The class is StringBuffer mutable - StringBuffer should be used when it is necessary to frequently modify the content.

The class StringBuilder was added in Java 5 and is identical to the class in every StringBuffer way, except that it is not synchronized and therefore its methods are much faster.

Reflection

Reflection is a mechanism for obtaining data about a program at runtime. In Java, Reflection is implemented using the Java Reflection API , which consists of the package classes java.langand java.lang.reflect.

Java Reflection API features:

Object class definition;
Getting information about class modifiers, fields, methods, constructors and superclasses;
Defining the interfaces implemented by the class;
Creating an instance of the class;
Getting and setting the values of the object's fields;
Calling object methods;
Creation of a new array.

Exceptions

Exceptions are divided into several classes, but they all have a common ancestor - a class Throwable whose descendants are classes Exception and Error.

Errors are more serious problems that, according to the Java specification, should not be handled in a native program, as they are related to JVM-level problems. For example, exceptions of this kind are thrown if the memory available to the virtual machine runs out.
Exceptions are the result of problems in the program that are, in principle, solvable, predictable, and the consequences of which can be eliminated within the program. For example, an integer was dividing by zero.

Checked and Unchecked Exception

In Java, all exceptions are of two types:

checked (checked / checked exceptions) must be handled by the block catch or described in the method header (for example throws IOException). The presence of such a handler / modifier in the method header is checked at compile time;
Examples: ArithmeticException, ClassCastException, ConcurrentModificationException, IllegalArgumentException, IllegalStateException, IndexOutOfBoundsException, NoSuchElementException, NullPointerException, UnsupportedOperationException.
unchecked (unchecked / unchecked exceptions) , which include errors Error(for example OutOfMemoryError), which are not recommended to be handled, and runtime exceptions presented by the class RuntimeExceptionand its descendants (for example NullPointerException), which may not be handled by the block catchand not described in the method header.
Class errors Error are the most serious problems at the JVM level. For example, exceptions of this kind are thrown if the memory available to the virtual machine runs out. It is not prohibited to handle such errors, but it is not recommended to do so.

Custom exception:

You must inherit from the base class of the required type of exception (for example, from Exception or RuntimeException).


class CustomException extends Exception {
    public CustomException() {
        super();
    }

    public CustomException(final String string) {
        super(string + " is invalid");
    }

    public CustomException(final Throwable cause) {
        super(cause);
    }
}

OutOfMemoryError

OutOfMemoryError thrown when the Java virtual machine cannot create (allocate) an object due to insufficient memory, and the garbage collector cannot reclaim enough memory.

The memory area occupied by a java process consists of several parts. The type OutOfMemoryErrordepends on which one is running out of space:

java.lang.OutOfMemoryError: Java heap space: There is not enough space in the heap, namely, in the area of memory in which objects created in the application programmatically are placed. Usually the problem lies in a memory leak. The size is set by the parameters -Xmsand -Xmx.
java.lang.OutOfMemoryError: PermGen space: (up to Java 8) This error occurs when there is not enough space in the Permanent area, the size of which is set by the -XX:PermSizeand parameters -XX:MaxPermSize.
java.lang.OutOfMemoryError: GC overhead limit exceeded: This error can occur both when the first and second areas are overflowed. It is connected with the fact that there is little memory left and the garbage collector is constantly working, trying to free up some space. This error can be disabled using the parameter -XX:-UseGCOverheadLimit.
java.lang.OutOfMemoryError: unable to create new native thread: Thrown out when it is not possible to create new streams.

Generics in Java

Java Generics provides a way to reuse the same code with different inputs. The difference is that the inputs to formal parameters are values, while the inputs to type parameters are types.

Advantages:

Generics provide compile-time type safety that allows programmers to catch invalid types at compile time.
When using Generics, there is no need of type-casting.
By using generics, programmers can implement generic algorithms that work on collections of different types, can be customized and are type safe and easier to read.

Benefits of Generics

1. Stronger type checks at compile time

A Java compiler applies strong type checking to generic code and issues errors if the code violates type safety. Fixing compile-time errors is easier than fixing runtime errors, which can be difficult to find.
Example: In this example, List holds only a String type of objects in generics. It doesn’t allow to store other objects

List<String> list = new ArrayList<String>(); 
list.add("abc");

2. Elimination of casts

Code snippet without generics requires casting:

List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0);

When re-written to use generics, the code does not require casting:

List<String> list = new ArrayList<String>();
list.add("hello");
String s = list.get(0);   // no cast

Collection Framework examples for Generics

For Example: ArrayList class declaration from java.util package.

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
   .......
}

For Example, HashSet class declaration from java.util package.

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{
 .....
}

For Example, HashMap class declaration from java.util package.

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
....
}

An Iterable interface from JDK 8 - java.lang package is an example for a Generic interface.

public interface Iterable<T> {

    Iterator<T> iterator();

    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

One more example for Generic interface is Comparable interface.

public interface Comparable<T> {
    public int compareTo(T o);
}

Type Parameter Naming Conventions

By convention, type parameter names are single, uppercase letters. The type parameters naming conventions are important to learn generics thoroughly.

The most commonly used type parameter names are:

E - Element (used extensively by the Java Collections Framework)
K - Key
N - Number
T - Type
V - Value
S, U, V etc. - 2nd, 3rd, 4th types

Multiple Type Parameters

A generic class can have multiple type parameters.
Example: The generic OrderedPair class, which implements the generic Pair interface:

public interface Pair<K, V> {
  public K getKey();
  public V getValue();
}

public class OrderedPair<K, V> implements Pair<K, V> {

  private K key;
  private V value;

  public OrderedPair(K key, V value) {
    this.key = key;
    this.value = value;
  }

  public K getKey() { return key; }
  public V getValue() { return value; }
}

create two instantiations of the OrderedPair class

Pair<String, Integer> p1 = new OrderedPair<String, Integer>("Even", 8);
Pair<String, String>  p2 = new OrderedPair<String, String>("hello", "world");

HashMap class is a good example of Multiple Type Parameters.

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
...
}
public interface Map<K,V> {
...
}

Immutable object

Immutable objects whose state (i.e. the object’s data) does not change once it is instantiated (i.e. it becomes a read-only object after instantiation). Immutable classes are ideal for representing numbers (e.g. java.lang.Integer, java.lang.Float, java.lang.BigDecimal etc are immutable objects), enumerated types, colors (e.g. java.awt.Color is an immutable object), short lived objects like events, messages etc.

Benefits of immutable objects

• Immutable classes can greatly simplify programming by freely allowing you to cache and share the references to the immutable objects without having to defensively copy them or without having to worry about their values becoming stale or corrupted.
• Immutable classes are inherently thread-safe and you do not have to synchronize access to them to be used in a multi-threaded environment. So there is no chance of negative performance consequences.
• Eliminates the possibility of data becoming inaccessible when used as keys in HashMaps or as elements in Sets. These types of errors are hard to debug and fix.

Immutable Class

Writing an immutable class is generally easy but there can be some tricky situations. Follow the following guidelines:

A class is declared final (i.e. final classes cannot be extended).

   public final class MyImmutable { ... }

All its fields are final (final fields cannot be mutated once assigned).

   private final int[] myArray; //do not declare as ->  private final int[] myArray = null;

Do not provide any methods that can change the state of the immutable object in any way – not just setXXX methods, but any methods which can change the state.
The this reference is not allowed to escape during construction from the immutable class and the immutable class should have exclusive access to fields that contain references to mutable objects like arrays, collections and mutable classes like Date etc by:
- Declaring the mutable references as private.
- Not returning or exposing the mutable references to the caller (this can be done by defensive copying)

Wrong way to write an immutable class

Wrong way to write a constructor:

public final class MyImmutable {
    private final int[] myArray;
    public MyImmutable(int[] anArray) { this.myArray = anArray; // wrong
    }
    public String toString() {
        StringBuffer sb = new StringBuffer("Numbers are: "); 
        for (int i = 0; i < myArray.length; i++) {
            sb.append(myArray[i] + " ");
        }
        return sb.toString(); }
}

The caller could change the array after calling the constructor.

 int[] array = {1,2};
MyImmutable myImmutableRef = new MyImmutable(array) ; 
System.out.println("Before constructing " + myImmutableRef); array[1] = 5; // change (i.e. mutate) the element 
System.out.println("After constructing " + myImmutableRef);

Out put:

 Before constructing Numbers are: 1 2
 After constructing Numbers are: 1 5

As you can see in the output that the MyImmutable object has been mutated. This is because the object reference gets copied

Wrong way to write an accessor. A caller could get the array reference and then change the contents:

public  int[] getArray() {
        return myArray;
}

Right way to write an immutable class

Right way is to copy the array before assigning in the constructor:

public final class MyImmutable {
    private final int[] myArray;
    public MyImmutable(int[] anArray) {
        this.myArray = anArray.clone(); // defensive copy
    }
    public String toString() {
        StringBuffer sb = new StringBuffer("Numbers are: "); for (int i = 0; i < myArray.length; i++) {
            sb.append(myArray[i] + " "); }
        return sb.toString(); }
}

The caller cannot change the array after calling the constructor.

int[] array = {1,2};
        MyImmutable myImmutableRef = new MyImmutable(array) ; 
        System.out.println("Before constructing " + myImmutableRef); 
        array[1] = 5; // change (i.e. mutate) the element 
 System.out.println("After constructing " + myImmutableRef);

Out put:

Before constructing Numbers are: 1 2
After constructing Numbers are: 1 2

As you can see in the output that the MyImmutable object has not been mutated.

Right way to write an accessor by cloning.

 public int[] getAray() {
        return (int[]) myArray.clone();
}

Pass by reference and Pass by value

Other languages use pass-by-reference or pass-by-pointer. But in Java no matter what type of argument you pass the corresponding parameter (primitive variable or object reference) will get a copy of that data, which is
exactly how pass-by-value (i.e. copy-by-value) works.

In Java, if a calling method passes a reference of an object as an argument to the called method then the passed- in reference gets copied first and then passed to the called method. Both the original reference that was passed-in and the copied reference will be pointing to the same object. So no matter which reference you use, you will be always modifying the same original object, which is how the pass-by-reference works as well.

If method call involves inter-process (e.g. between two JVMs) communication, then the reference of the calling method has a different address space to the called method sitting in a separate process (i.e. separate JVM). Hence inter-process communication involves calling method passing objects as arguments to called method
by-value in a serialized form, which can have negative affect performance due to marshaling and unmarshaling cost.

Shallow cloning and Deep cloning

The default behavior of an object’s clone() method automatically yields a shallow copy. So to achieve a deep copy the classes must be edited or adjusted.

Shallow copy: If a shallow copy is performed on object-1 then it is copied but its contained objects are not. The contained objects object-1 and object-2 are affected by changes to cloned Object-2. Java supports shallow cloning of objects by default when a class implements the java.lang.Cloneable interface.
Deep copy: If a deep copy is performed on object-1 then not only object-1 has been copied but the objects contained within it have been copied as well. Serialization can be used to achieve deep cloning. Deep cloning through serialization is faster to develop and easier to maintain but carries a performance overhead.

For example:
invoking clone() method on a collection like HashMap, List etc returns a shallow copy of HashMap, List, instances. This means if you clone a HashMap, the map instance is cloned but the keys and values themselves are not cloned. If you want a deep copy then a simple method is to serialize the HashMap to a ByteArrayOutputSream and then deserialize it. This creates a deep copy but does require that all keys and values in the HashMap are Serializable. Main advantage of this approach is that it will deep copy any arbitrary object graph. Alternatively you can provide a static factory method to deep copy.

Example: to deep copy a list of Car objects.

public static List deepCopy(List listCars) {
    List copiedList = new ArrayList(10);
    for (Object object : listCars) { 
        Car original = (Car)object;
        Car carCopied = new Car(); //instantiate a new Car object 
        carCopied.setColor((original.getColor())); 
        copiedList.add(carCopied);
    }
        return copiedList;
}

Instance variable and a Static variable

Static variables	Instance variables
Class variables are called static variables. There is only one occurrence of a class variable per JVM per class loader. When a class is loaded the class variables (aka static variables) are initialized.	Instance variables are non-static and there is one occurrence of an instance variable in each class instance (i.e. each object). Also known as a member variable or a field.
A static variable is used in the singleton pattern	Instance variables we can not use
A static variable is used with a final modifier to define constants.	Instance variables we can not use

Local variables vs Instance and static variables

Local variables	Instance and static variables
Local variables have a narrower scope than instance variables.	Instance variables have a narrower scope than static variables.
The lifetime of a local variable is determined by execution path and local variables are also known as stack variables because they live on the stack.	Instance and static variables are associated with objects and therefore live in the heap.
For a local variable, it is illegal for code to fail to assign it a value. It is the best practice to declare local variables only where required as opposed to declaring them upfront and cluttering up your code with some local variables that never get used.	Both the static and instance variables always have a value. If your code does not assign them a value then the run-time system will implicitly assign a default value (e.g. null/0/0.0/false).

Access modifiers

Modifier	Used with	Description
public	Outer classes, interfaces, constructors, Inner classes, methods and field variables	A class or interface may be accessed from outside the package. Constructors, inner classes, methods and field variables may be accessed wherever their class is accessed.
protected	Constructors, inner classes, methods, and field variables.	Accessed by other classes in the same package or any subclasses of the class in which they are referred (i.e. same package or different package).
private	Constructors, inner classes,methods and field variables,	Accessed only within the class in which they are declared
No modifier: (Package by default).	Outer classes, inner classes, interfaces, constructors, methods, and field variables	Accessed only from within the package in which they are declared.

Volatile keyword

The volatile keyword is only applicable to a variable and using a volatile keyword with class and method is illegal.
volatile keyword in Java guarantees that the value of the volatile variable will always be read from main memory and not from Thread's local cache.
In Java reads and writes are atomic for all variables declared using Java volatile keyword (including long and double variables).
Using the volatile keyword in Java on variables reduces the risk of memory consistency errors because any write to a volatile variable in Java establishes a happens-before relationship with subsequent reads of that same variable.
From Java 5 changes to a volatile variable are always visible to other threads. What's more, it also means that when a thread reads a volatile variable in Java, it sees not just the latest change to the volatile variable but also the side effects of the code that led up the change.
Reads and writes are atomic for reference variables are for most primitive variables (all types except long and double) even without the use of volatile keyword in Java.
Access to a volatile variable in Java never has a chance to block, since we are only doing a simple read or write, so unlike a synchronized block we will never hold on to any lock or wait for any lock.
Java volatile variable that is an object reference may be null.
Java volatile keyword doesn't mean atomic, its common misconception that after declaring volatile ++ will be atomic, to make the operation atomic you still need to ensure exclusive access using synchronized method or block in Java.
If a variable is not shared between multiple threads, you don't need to use volatile keyword with that variable.

synchronized vs volatile

The volatile keyword in Java is a field modifier while synchronized modifies code blocks and methods.
Synchronized obtains and releases the lock on monitor’s Java volatile keyword doesn't require that.
Threads in Java can be blocked for waiting for any monitor in case of synchronized, that is not the case with the volatile keyword in Java.
Synchronized method affects performance more than a volatile keyword in Java.
Since volatile keyword in Java only synchronizes the value of one variable between Thread memory and "main" memory while synchronized synchronizes the value of all variable between thread memory and "main" memory and locks and releases a monitor to boot. Due to this reason synchronized keyword in Java is likely to have more overhead than volatile.
You can not synchronize on the null object but your volatile variable in Java could be null.

For more information:

WorkFolio Portfolio

Prince — Sat, 26 Aug 2023 10:42:12 +0000

Creating a Real-Time Hand Tracking Application with MediaPipe and OpenCV

Prince — Thu, 17 Aug 2023 05:39:20 +0000

Welcome to an exciting journey into the world of computer vision! In this blog, we'll guide you through building a real-time hand tracking application using two powerful Python libraries: MediaPipe and OpenCV. By the end of this page, you'll be able to create an application that can detect and track hand landmarks in a video stream, paving the way for interactive experiences, gesture recognition, and more.

Prerequisites
Before we begin, ensure that you have both the mediapipe and opencv-python libraries installed. You can install them using the following command:

pip install mediapipe opencv-python

Step 1: Initializing the Environment
Let's start by importing the necessary libraries and initializing some variables:

import mediapipe as mp
import cv2
import time

# Initialize the video capture
cap = cv2.VideoCapture(0)

# Initialize the hand tracking model
mpHands = mp.solutions.hands
hands = mpHands.Hands()

# Initialize the drawing utility
mpDraw = mp.solutions.drawing_utils

# Initialize time variables
pTime = 0
cTime = 0

Step 2: The Tracking Loop
Next, we'll create an infinite loop to continuously process frames from the video capture and perform hand tracking:

while True:
    success, img = cap.read()

    imgRGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    result = hands.process(imgRGB)

    if result.multi_hand_landmarks:
        for handLms in result.multi_hand_landmarks:
            mpDraw.draw_landmarks(img, handLms, mpHands.HAND_CONNECTIONS)

    cTime = time.time()
    fps = 1 / (cTime - pTime)
    pTime = cTime

    cv2.putText(img, str(int(fps)), (10, 70), cv2.FONT_HERSHEY_PLAIN, 3, (255, 0, 255), 3)
    cv2.imshow("Hand Tracking", img)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

Step 3: Wrapping Up
Lastly, we need to release the video capture resources and close the OpenCV windows when we're done:

cap.release()
cv2.destroyAllWindows()

Conclusion
Congratulations! You've successfully built a real-time hand tracking application using MediaPipe and OpenCV. This application can detect and visualize hand landmarks while displaying the frames per second (FPS) on the video stream. Now you have a solid foundation to explore further and integrate hand tracking into various projects, from virtual reality interactions to creative gesture recognition applications.

🚀 Introducing My Latest Flutter Project Portfolio! 📱💻

Prince — Sun, 16 Jul 2023 08:51:37 +0000

🚀 Excited to share my latest project portfolio! 🎉

I'm thrilled to showcase my new project, which has been built entirely using Flutter. 📱💻

🔗 Check out the LiveProject : Live Preview

📁Check out the project here: ProjectRepositories

In this portfolio, I've poured my heart and soul into developing a range of innovative features and functionalities. From sleek UI designs to smooth animations, every aspect of this project has been meticulously crafted to deliver a top-notch user experience.

Flutter has been instrumental in enabling me to create a beautiful, responsive, and cross-platform application. The framework's flexibility and performance have truly elevated the development process.

Throughout the project, I utilized various Flutter packages and libraries to enhance the functionality and efficiency of the app. The end result is a polished and intuitive application that showcases the power of Flutter.

I'd like to express my gratitude to the amazing Flutter community for their continuous support and inspiration. It's been an incredible journey, and I can't wait to explore more possibilities with Flutter in the future.

Feel free to explore the project and provide your valuable feedback. I'm open to collaborations, feedback, and new opportunities, so don't hesitate to reach out!

🔗 Flutter App Development Setup Guide

🔧 Flutter 3.7.9 • channel stable

🛠 Tools: Dart 2.19.6 • DevTools 2.20.1

🌐 GitHub Pages

📌 Prerequisites:

1️⃣ Setup Flutter in the development environment

2️⃣ Install a code editor like Android Studio or Visual Studio Code

3️⃣ Setup Git in the development environment

4️⃣ Ensure compatibility with the flutter doctor command

5️⃣ Familiarity with Flutter app development

💡 How to Setup:

1️⃣ Download or clone the repository

2️⃣ Move the project to the desired directory

3️⃣ Open it with a code editor (e.g., Android Studio or Visual Studio Code)

4️⃣ Run flutter clean and pub get commands

5️⃣ Avoid updating or upgrading Gradle and other versions until the app is up and running with built versions

🚀 How to Run:

1️⃣ Download the web-build directory from the web-build branch

2️⃣ Move the build files to a server like localhost, GitHub Pages, or any other http/https web server

3️⃣ Set up and run the index.html file

🖼 Icons and Images:

Icons8

💎 Dependencies:

Flutter/Dart: Environment SDK: >=2.19.2 <3.0.0
Cupertino Icons: ^1.0.2
URL Launcher: ^6.1.9
Flutter Native Splash: ^2.2.17

💙 Contributing:

If you encounter any issues or have suggestions, feel free to submit a pull request or open an issue. Please make sure to follow the Contributing Guidelines before contributing.