JavaTechSeries

Use of this keyword in Java

2021-02-13T10:58:00.007+05:30

In this post, you will see in detail explained the use of this keyword. Do try all examples by yourself. Let's check out it below,

Use of this keyword

this keyword is used to refer current object. There are several uses of ' this '

• this keyword can be used to refer to the constructor: generally, constructors are called explicitly using this keyword to reinitialize the current object.

Syntax: this(parameter1, parameter2,.....);

• this keyword can be used to refer to a current instance variable: generally is used to differentiate between local variable and instance variable also between the current instance variable and another object instance variable.

Syntax: this.variable name

• this keyword can be used to refer current instance method

Syntax: this.method name

Example: use of this keyword for object reinitialization

use of this keyword for object reinitialization

public class Rectangle {

int length;

int breadth;

public Rectangle() {

this(34, 35);

}

public Rectangle(int length, int breadth) {

this.length = length;

this.breadth = breadth;

}

public int area() {

int ar = length * breadth;

return ar;

}

public static void main(String args[]) {

Rectangle rect = new Rectangle();

// this call will go to zero constructor

Rectangle rect1 = new Rectangle(23, 56); // this call will go to parameterized constructor

System.out.println("rect object length and breath is: " + rect.length + " " + rect.breadth);

System.out.println("rect1 bject length and breath is: " + rect1.length + " " + rect1.breadth);

int area1 = rect.area(); // calling instance method

System.out.println("Area of rect :" + area1);

int area2 = rect1.area(); // calling instance method

System.out.println("Area of rect1 :" + area2);

}

Output

rect object length and breath is: 34 35

rect1 bject length and breath is: 23 56

Area of rect :1190

Area of rect1 :1288

Parameter Passing :

The parameters can be passed by either

• Call by value

• Call by reference

Passing Parameters by Value:

While working under the calling process, arguments is to be passed. These should be in the same order as their respective parameters in the method specification. Passing Parameters by Value means calling a method with a parameter. Through this, the argument value is passed to the parameter. An example is shown above.

Passing objects:

In java, objects are implicitly passed by 'call by reference', but no need of & operator

Java instanceOf operator:

The Java instanceof operator is used to test whether the object is an instance specified type (class or subclass or interface).

The instanceof in java is also known as type comparison operator because it compares the instance with type. It returns either true or false. If we apply the instanceof operator with any variable that has null value, it returns false.

Example:

Following is the simple example of instance operator where it tests the current class.

public class Simple {

public static void main(String args[]) {

Simple s = new Simple();

System.out.println(s instanceof Simple);// true

}

Output

true

instanceof with reference variable :

An object of subclass type is also a type of parent class. For example, if Dog extends Animal then object of Dog can be referred by either Dog or Animal class.

Example:

class Animal {

}

public class Dog extends Animal { // Dog inherits Animal

public static void main(String args[]) {

Animal d = new Dog();

System.out.println(d instanceof Animal); // true}

}

Output

true

instanceof with a variable that have null value :

If we apply instanceof operator with a variable that have null value, it returns false.

Example:

public class Simple {

public static void main(String args[]) {

Simple s = null;

System.out.println(s instanceof Simple); // false

}

Output

false

Recommend Topics:

What is Classes, Constructors and Methods in Java explained in detailed.

2021-02-05T22:23:00.003+05:30

In this post, you will see detail about Classes, Constructors, and Methods in Java.

1. Class:

i) A class is the collection of data members and member functions.

ii) It is a blueprint from which objects can be constructed. It is just a logical construct.

iii) A class can contain fields and methods to describe the state and behavior of an object respectively.

iv) Methods are the members of a class that provide a service for an object or perform some business logic.

v) The current states of a class’s corresponding object are stored in the object’s instance variables.

vi) Methods define the operations that can be performed in java programming.

vii) Java is a case-sensitive language. That is Java fields and member function names are case sensitive.

A sample of a class is given below:

public class Rectangle {

int length;

int breadth;

public void area() {

// code

}

public void perimeter() {

// code

}

class Rectangle represents the states and behavior of Rectangle.

2. What is an Object in Java?

Object:

i) The object is known as an instance of the class.

ii) Objects actually have their own states and behavior. For example, Rectangle objects have their own length, breadth, area, and perimeter.

iii) Hence the length and breadth are known as instance variables and methods area and perimeter are known as instance methods.

iv) Classes are just a logical construct but Objects are actually loaded into memory. Objects are physically present.

In java, objects are created dynamically using a new keyword.

There are three steps when creating an object from a class:

Declaration: A variable declaration with a variable name with an object type.
Instantiation: The 'new' keyword is used to create the object.
Initialization: The 'new' keyword is followed by a call to a constructor. This call initializes the new object.

An example of creating an object is given below:

public class Rectangle {

int length;

int breadth;

public Rectangle() {

length = 34;

breadth = 35;

}

public Rectangle(int length, int breadth) {

this.length = length;

this.breadth = breadth;

}

public static void main(String args[]) {

Rectangle rect = new Rectangle(); // call will go to zero constructor

Rectangle rect1 = new Rectangle(23, 56); // call will go to parameterized constructor

System.out.println("rect object length and breath is: " + rect.length + " " + rect.breadth);

System.out.println("rect1 object length and breath is: " + rect1.length + " " + rect1.breadth);

}

In the above program, when a new statement is get executed, the call goes to the constructor and is returns the object by initializing it. Thus memory to the objects is dynamically allocated at the time of execution of byte code. By using multiple new statements, we can create multiple objects of the same class.

3. What is Constructor in Java?

Constructor:

i) Every class has a constructor.

ii) Constructors are required to create objects for a class.

iii) Constructors are used to initialize the instance variables of an object. It has the same name as a class name.

iv) Each time a new object is created, at least one constructor will be invoked.

v) If we do not explicitly write a constructor for a class the java compiler builds a default constructor for that class.

vi) A class can have more than one constructor.

vii) In java, constructors are implicitly invoked at the time of object creation using a new keyword. It constructs the values i.e. provides data for the object that is why it is known as a constructor.

An example of a constructor is given below:

public class Rectangle {

int length;

int breadth;

public Rectangle() {

// code for initialization

}

public Rectangle(int length) { // This constructor has one parameter, length

// code for initialization

}

2. 1 Properties of Constructor:

• Constructor name must be same as its class name

• Constructors used to initialize the data members

• Constructor must have no explicit return type as it implicitly returns an object

• Constructors can be declared private. In this case, we can not access this from outside of class.

• Constructors can be overloaded.

2.2 Types of java constructors There are two types of constructors:

• Non-parameterized Constructor also know as Zero constructor

• Parameterized Constructor

1. Zero constructors:

A constructor that has no parameter is known as a zero or non parameterized constructor.

Example :

In this example, we are creating the no-arg constructor in the Bike class. It will be invoked at the time of object creation.

public class Rectangle {

public Rectangle() {

System.out.println("Rectangle object initialization");

}

public static void main(String args[]) {

Rectangle rect = new Rectangle();

}

Output: Rectangle object initialization

2. Parameterized constructor

A constructor that has parameters is known as parameterized constructor. The parameterized constructor is used to provide different values to distinct objects.

Example :

In this example, we have created the constructor of the Student class that has two parameters. We can have any number of parameters in the constructor.

public class Rectangle {

int length;

int breadth;

public Rectangle(int length, int breadth) {

System.out.println("This is parameterized constructor");

}

public static void main(String args[]) {

Rectangle rect = new Rectangle(23, 56);

}

Note: When there is no constructor in the class. JVM provides a default constructor whose syntax is same as a zero constructors.

2.3 Constructor Overloading:

It is one kind of compile-time polymorphism where the same constructor name but different type signatures are there. Constructor overloading is used to initialize the objects in different ways. The call to the matching constructor is decided at compile time.

Example :

public class Rectangle {

int length;

int breadth;

public Rectangle() {

length = 34;

breadth = 35;

}

public Rectangle(int length, int breadth) {

this.length = length;

this.breadth = breadth;

}

public static void main(String args[]) {

Rectangle rect=new Rectangle() ; // call will go to zero constructor

Rectangle rect1=new Rectangle(23,56); // call will go to parameterized constructor

System.out.println("Zero Parameterized rect object length and breath is: "+rect.length+" "+rect.breadth);

System.out.println("Parameterized rect1 object length and breath is: "+rect1.length+" "+rect1.breadth);

}

Output:

Zero Parameterized rect object length and breath is: 34 35

Parameterized rect1 object length and breath is: 23 56

Note:

The problem of Instance Variable Hiding: If the local variable name and instance variable name is the same then by default local variable hides the instance variable in the local scope. Thus any assignment from local to an instance can not be done.

Solution: differentiate between both variables by referring to the current instance variable by using this keyword.

this.length=length;

this.breadth=breadth;

4. Method:

The method of a class contains the code which operates on data. It is the part where all logic is written. Methods can be static or not static. Non-static methods have their own copy for every object of the class. Static methods are class methods that have a single shared copy.

Syntax:

accessmodifer nonaccessmodifer returntype methodname(parameters)

{

// code of the method

}

Example:

public void demo()

{

System.out.println(“This is a demo method”);

}

Difference between constructor and method in java:

There are many differences between constructors and methods. They are given below

Java Constructor	Java Method
The constructor is used to initialize the state of an object.	The method is used to expose the behavior of an object.
The constructor must not have a return type. But it by default returns an object	Method must have return type or void.
Constructor is invoked implicitly, when a new statement is executed	Method is invoked explicitly
The java default constructor if you don't have any constructor.	Method is not provided by java in any case.
Constructor name must be same as the class name.	Method name may not be same as the class name.

5. Accessing Instance Variables and Methods:

Instance variables and methods are accessed via created objects. To access an instance variable the fully qualified path should be as follows:

• Create an object of the class

• using object, access the instance variables of that class

• using object, call the instance variables of that class

Example:

This example explains how to access instance variables and methods of a class:

public class Rectangle {

int length;

int breadth;

public Rectangle() {

length = 34;

breadth = 35;

}

public Rectangle(int length, int breadth) {

this.length = length;

this.breadth = breadth;

}

public int area() {

int ar = length * breadth;

return ar;

}

public static void main(String args[]) {

Rectangle rect = new Rectangle(); // this call will go to zero constructor

Rectangle rect1 = new Rectangle(23, 56); // this call will go to parameterized constructor

System.out.println("rect object length and breath is: " + rect.length + " " + rect.breadth);

System.out.println("rect1 bject length and breath is: " + rect1.length + " " + rect1.breadth);

int area1 = rect.area(); // calling instance method

System.out.println("Area of rect :" + area1);

int area2 = rect1.area(); // calling instance method

System.out.println("Area of rect1 :" + area2);

}

Output:

rect object length and breath is: 34 35

rect1 bject length and breath is: 23 56

Area of rect :1190

Area of rect1 :1288

This is all about Classes, Constructors, and Methods in Java, To want to learn more about core concepts you can prefer the below-recommended topics.

Recommend Topics:

Exception Handling in Java

2021-01-18T09:06:00.000+05:30

1. Introduction :

It is an unexpected unwanted event that disturbs the entire flow of the program.

RealTimeExample:

1) SleepingException

2) TirePuncharedException

If we are not handling exceptions, the program may terminate abnormally without releasing allocated resources. This is not a graceful termination. Being a good programming practice compulsory we should handle exceptions for graceful termination of the program.

Exception handling means it is not repairing an exception we are providing alternative ways to continue the program normally. For example, if our programming requirement is to read the data from the London file if at runtime the London file is not available, we have to provide a local file as part of exception handling. So that respect of the program will be continued normally

2. Exception and error:

An exception (or exceptional event) is a problem that arises during the execution of a program. When an Exception occurs the normal flow of the program is disrupted and the program/Application terminates abnormally, which is not recommended, therefore these exceptions are to be handled.

An exception can occur for many different reasons, below given are some scenarios where exception occurs.

• A user has entered invalid data.

• A file that needs to be opened cannot be found.

• A network connection has been lost in the middle of communications or the JVM has run out of memory. An error occurs at compile time. It is not more dangerous than the exception.

3. Exception class Hierarchy:

All exception classes are subtypes of the java.lang.Exception class. The exception class is a subclass of the Throwable class. Other than the exception class there is another subclass called Error which is derived from the Throwable class. Errors are not normally trapped from the Java programs. These conditions normally happen in case of severe failures, which are not handled by the java programs. Errors are generated to indicate errors generated by the runtime environment.

Example: JVM is out of Memory. Normally programs cannot recover from errors.

Note: The Error is a class in the Exception hierarchy.

It is not related to a compile-time error. The Exception class has a subclass: RuntimeException Class.

4. Types of Exceptions:

1. Checked exceptions:

A checked exception is an exception that occurs at the compile time, these are also called compile-time exceptions. These exceptions cannot simply be ignored at the time of compilation, the Programmer should take care of (handle) these exceptions. For example, if you use FileReader class in your program to read data from a file if the file specified in its constructor doesn't exist, then a FileNotFoundException occurs, and the compiler prompts the programmer to handle the exception.

Since the methods read() and close() of FileReader class throws IOException, you can observe that compiler notifies to handle IOException, along with FileNotFoundException.

2. Unchecked exceptions:

An Unchecked exception is an exception that occurs at the time of execution but not checked at compile-time, these are also called Runtime Exceptions. Runtime exceptions are ignored at the time of compilation. For example, if you have declared an array of size 5 in your program, and trying to call the 6th element of the array then an ArrayIndexOutOfBoundsExceptionexception occurs.

5. Inbuilt Methods:

Following is the list of important methods available in the Throwable class.

SN.	Method with Description
1.	public String getMessage() Returns a detailed message about the exception that has occurred. This message is initialized in the Throwable constructor.
2.	public Throwable getCause() Returns the cause of the exception as represented by a Throwable object.
3.	public String toString() Returns the name of the class concatenated with the result of getMessage()
4.	public void printStackTrace() Prints the result of toString() along with the stack trace to System.err, the error output stream.
5.	public StackTraceElement [] getStackTrace() Returns an array containing each element on the stack trace. The element at index 0 represents the top of the call stack, and the last element in the array represents the method at the bottom of the call stack.
6.	public Throwable fillInStackTrace() Fills the stack trace of this Throwable object with the current stack trace, adding to any previous information in the stack trace.

6. Exception handling mechanism:

There are several keywords that are used in exception handling. These keywords can be used to create blocks and clauses.

• try : block

• catch : block

• finally : block

• throw : clause / statement

• throws : clause / statement

6.1 Try block:

The code that you want to monitor for the exceptions writes that code into the try block. Code within a try/catch block is referred to as protected code, and the syntax for using try/catch looks like the following:

try {

//Protected code

} catch(ExceptionType e1) {

//Exception handling code

}

6.2 Catch block:

A try block is followed by a catch block which handles the exceptions. It contains the exception handling code.

Syntax:

catch(ExceptionType e1)

{

//Exception handling code

}

If an exception occurs in a try block, the exception object is created and that is thrown to the matching catch block. The catch block will handle the exception.

Here either we can print the exception object or can call the printStackTrace method and display the information of the exception that has occurred.

Exception object contains the following information: type of exception, class of exception.

But if we call method printStackTrace() from catch block then it will contain the following information: at which line it occurred, in which method it occurred, who is the caller of that method, from which line that method gets called, in which class it occurred, in which file it occurred, and so on.....

Example:

The following is an array that is declared with 2 elements. Then the code tries to access the 3rd element of the array which throws an exception.

public class ExcepTest {

public static void main(String args[]) {

try {

int a[] = new int[2];

System.out.println("Access element three :" + a[3]);

} catch (ArrayIndexOutOfBoundsException e) {

System.out.println("Exception thrown :" + e);

}

System.out.println("Code after catch block");

}

Output:

Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3

Code after catch block

try with Multiple catch Blocks:

A try block can be followed by multiple catch blocks. The syntax for multiple catch blocks looks like the following:

try {

// Protected code

} catch (ExceptionType1 e1) { // Child ExceptionType

// Handling code

} catch (ExceptionType2 e2) { // Child ExceptionType

// Handling code

} catch (ExceptionType3 e3) { // Parent Exception Type

// Handling code

}

The previous statements demonstrate three catch blocks, but you can have any number of them after a single try. If an exception occurs in the protected code, the exception is thrown to the first catch block in the list.

If the data type of the exception thrown matches ExceptionType1, it gets caught there.

If not, the exception passes down to the second catch statement. This continues until the exception either is caught or falls through all catches, in which case the current method stops execution and the exception is thrown down to the previous method on the call stack. If there is no matching catch, an exception will be handled by the default exception handler.

try {

file = new FileInputStream(fileName);

x = (byte) file.read();

} catch (FileNotFoundException f) {

f.printStackTrace();

return -1;

} catch (IOException i) {

i.printStackTrace();

return -1;

}

The following code will generate compile time error

try {

file = new FileInputStream(fileName);

x = (byte) file.read();

} catch (Exception e) {

e.printStackTrace();

return -1;

} catch (IOException i) // Not valid!

{

i.printStackTrace();

return -1;

} catch (FileNotFoundException f) // Not valid!

{

f.printStackTrace();

return -1;

}

Note: We can not write the catch taking superclass reference variable of exception hierarchy before that of the subclass.

Compiler Error will be: exception already caught. Thus While writing try with multiple catches, catch with subclass should be before catching with superclass.

6.3 throw clause :

When we want to explicitly throw an exception then we use the throw clause. We can throw an exception, either using a new instance or using an exception object by using the throw keyword.

throw new TypeOfException(parameters);

This method can explicitly throw an exception using the throw keyword.

6.4 throws clause: '

If a method is not able to handle a particular exception, the method must declare it using the throws keyword with its definition. It will throw that exception out of itself. Then the caller has the responsibility to handle that exception. The throws keyword appears at the end of a method's signature. A method can throw multiple exceptions using the throws clause.

Syntax:

throws Type1Exception,Type2Exception

Try to understand the difference between throws and throw keywords. The following method shows the use of both throw and throws

public class className

{

public void deposit(double amount) throws RemoteException

{

// Method implementation

if(remoteObject==null)

throw new RemoteException(“null remote object”);

}

//Remainder of class definition

}

A method can declare that it throws more than one exception, in which case the exceptions are declared in a list separated by commas. For example, the following method declares that it throws a RemoteException and an InsufficientFundsException:

Difference between throw and throws

throw	throws
To manually throw the exception	To throw the exception out of the method towards caller when the callee method is not able to handle that exception
Example: public void show() { throw new NullPointerException(); } public void show() { throw new NullPointerException(“pointing to null reference”); }	Example: public void show() throws IOException, NumberFormatException { // body of the method }
It is followed by an instance of the class	It is followed by name of the class
It is declared within the method body	It is declared with the method definition
It can throw only one exception at a time	It can declare multiple exception classes at a time
The exception that is thrown by throw can be handled within that method	The exception declared in throws can not be handled by that same method that's why it is propagated towards the caller.

6.5 The finally block :

The finally keyword is used to create a block of code that follows a try block or try-catch block. A finally block of code always executes, whether or not an exception has occurred. Using a finally block allows you to run any cleanup-type statements that you want to execute, no matter what happens in the protected code. For e.g. u can write the file closing or database closing code in the finally block if the file is opened in a try block or database connections are opened in the try block.

finally{

// important code, cleanuptype statements

}

A finally block which appears at the end of the catch blocks and has the following syntax:

try

{

// Protected code

}catch(ExceptionType1 e1)

{

// handling code

}catch(

ExceptionType2 e2)

{

// handling code

}catch(

ExceptionType3 e3)

{

// handling code

}finally

{

// cleanuptype statements

}

Note: The try block must have atleast one catch block or finally block

Example:

public class ExcepTest {

public static void main(String args[]) {

int a[] = new int[2];

try {

System.out.println("Access element three :" + a[3]);

} catch (ArrayIndexOutOfBoundsException e) {

System.out.println("Exception thrown :" + e);

} finally {

System.out.println("The finally statement is executed");

}

Output:

Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3

The finally statement is executed

Execution Sequence :

1. try{}finally{}: first, try block will get executed, then if an exception occurs then, finally will get executed and later exceptions will be caught by the default exception handler.

2. try{}catch{}finally{}: first try block will get executed, then if an exception occurs and if there is the matching catch, an exception will be handled in that catch, then finally will get executed.

7. User-Defined Exceptions:

You can create your own exceptions in Java. Keep the following points in mind when writing your own exception classes:

• All exceptions must be a child of Throwable.

• If you want to write a checked exception that is automatically enforced by the Handle or Declare Rule, you need to extend the Exception class.

• If you want to write a runtime exception, you need to extend the RuntimeException class. We can define our own Exception class as below:

class MyException extends Exception{ }

You just need to extend the Exception class to create your own Exception class. These are considered to be checked exceptions. The following InsufficientFundsException class is a user-defined exception that extends the Exception class, making it a checked exception. An exception class is like any other class, containing useful fields and methods.

To demonstrate using our user-defined exception, the following CheckingAccount class contains a withdraw() method that throws an InsufficientFundsException.

public class CheckingAccount {

private double balance;

private int number;

public double getBalance() {

return balance;

}

public void setBalance(double balance) {

this.balance = balance;

}

public int getNumber() {

return number;

}

public void setNumber(int number) {

this.number = number;

}

public CheckingAccount(int number) {

this.number = number;

}

public void deposit(double amount) {

balance += amount;

}

public void withdraw(double amount) throws InsufficientFundsException {

if (amount <= balance) {

balance -= amount;

} else {

double needs = amount - balance;

throw new InsufficientFundsException(needs);

}

class InsufficientFundsException extends Exception {

double needs;

InsufficientFundsException(double needs) {

this.needs = needs;

}

@Override

public String toString() {

return "InsufficientFundsException [needs=" + needs + "]";

}

import java.util.Scanner;

public class UserDefinedException {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

CheckingAccount ca = new CheckingAccount(4070856);

try {

ca.setBalance(50000);

System.out.println("The initial balance is: " + ca.getBalance());

System.out.println("Enter the amount to deposit: ");

double damount = sc.nextDouble();

ca.deposit(damount);

System.out.println("The balance is: " + ca.getBalance());

System.out.println("Enter the amount to withdraw: ");

double wamount = sc.nextDouble();

ca.withdraw(wamount);

} catch (InsufficientFundsException e) {

System.out.println("Balance is insufficient");

e.printStackTrace();

} catch (Exception e) {

e.printStackTrace();

}

System.out.println("The code after catch continued....");

}

Output :

The initial balance is: 50000.0

Enter the amount to deposit:

2000

The balance is: 52000.0

Enter the amount to withdraw:

53000

Balance is insufficient

InsufficientFundsException [needs=1000.0]

The code after catch continued....

at com.renuka.jan.blog.CheckingAccount.withdraw(CheckingAccount.java:37)

at com.renuka.jan.blog.UserDefinedException.main(UserDefinedException.java:17)

Thus InsufficientFundsException get generated when a user enters the amount to withdraw which is more than the available balance and it is get handled at the caller side

8. Chained Exceptions:

The chained exception feature allows you to associate another exception with an exception. This second exception describes the cause of the first exception. For example, imagine a situation in which a method throws an ArithmeticException because of an attempt to divide by zero.

However, the actual cause of the problem was that an I/O error occurred, which caused the divisor to be set improperly

9. Exception Propagation:

An exception is first thrown from the top of the stack and if it is not caught, it drops down the call stack to the previous method, If not caught there, the exception again drops down to the previous method, and so on until they are caught or until they reach the very bottom of the call stack.

This is called the exception propagation. It can be achieved via the throws clause.

Recommend Topics:

Core Java

Oops Features

String Handling

Servlet Questions and Answers for Beginner Level

2021-01-17T08:47:00.005+05:30

1. What is Servlet?

- Java Servlet is server-side technologies to extend the capability of web servers by providing support for dynamic response and data persistence.

2. What is the difference between web server and application server?

- A web server is a device or application program which handles HTTP request from the client browser and response to the client browser. - Application Servers handles request and responses and also provide additional features such as Enterprise JavaBeans support, JMS Messaging support, Transaction Management, etc.

3. Difference between CGI and Servlet?

Servlet	CGI
Servlets can link directly to the Web server.	CGI cannot directly link to the Web server.
Servlets can share data with each other.	CGI does not provide sharing property.
Servlets can perform session tracking and caching of previous computations.	CGI cannot perform session tracking and caching of previous computations.
In Servlets, the Java Virtual Machine stays up, and each request is handled by a lightweight Java thread.	In CGI, each request is handled by a heavyweight operating system process.
Servlets are portable.	CGI is not portable.
Servlets automatically parse and decode the HTML form data.	CGI cannot automatically parse and decode the HTML form data.
Servlets can read and set HTTP headers, handle cookies, tracking sessions	CGI cannot read and set HTTP headers, handle cookies, tracking sessions.
Servlets are inexpensive than CGI.	CGI is more expensive than Servlets.

4. Why servlet is mostly used?

- Servlets are mostly used because they are platform-independent Java classes and are compiled to platform-neutral byte code. Java byte code can be loaded dynamically into and run by java enabled webserver.

5. What is called a servlet container?

- A servlet container is a part of the Web server that provides network services depends on requests and responses are sent MIME-based requests and responses. It contains and manages servlets through their life cycle.

6. What is MIME Type?

- MIME is an abbreviation for "Multipurpose Internet Mail Extensions".The “ContentType” response header is known as MIME Type. MIME describes the type of data the file contains. -A MIME type nomenclature includes a type and subtype separated by a forward slash. For example, a popular one is text/html. Here text is called type and html is known as subtype. e.g response.setContentType("text/html");

7. What is a web application and what is it’s directory structure?

- Web Applications are modules that run on the server to provide both static and dynamic content to the client browser. Apache webserver supports PHP and we can create a web application using PHP. Java provides web application support through Servlets and JSPs that can run in a servlet container and provide dynamic content to the client browser. Java Web Applications are packaged as Web Archive (WAR) and it has a defined structure like the below image.

8. What are common tasks performed by Servlet Container?

Servlet containers are also known as web container, for example, Tomcat. Some of the important tasks of servlet container are:

• Communication Support: Servlet Container provides an easy way of communication between web clients (Browsers) and the servlets and JSPs. Because of the container, we don’t need to build a server socket to listen for any request from the web client, parse the request and generate a response. All these important and complex tasks are done by container and all we need to focus is on business logic for the applications.

• Lifecycle and Resource Management: Servlet Container takes care of managing the life cycle of a servlet. From the loading of servlets into memory, initializing servlets, invoking servlet methods, and to destroy them. The container also provides utility like JNDI for resource pooling and management.

• Multithreading Support: Container creates a new thread for every request to the servlet and provides them request and response objects to process. So servlets are not initialized for each request and save time and memory.

• JSP Support: JSPs doesn’t look like normal java classes but every JSP in the application is compiled by container and converted to Servlet and then container manages them like other servlets.

• Miscellaneous Task: Servlet container manages the resource pool, perform memory optimizations, execute garbage collector, provides security configurations, support for multiple applications, hot deployment and several other tasks behind the scene that makes a developer life easier.

9. Explain Life Cycle of Servlet?

- A servlet life cycle can be defined as the entire process from its creation till the destruction.

The following are the paths followed by a servlet.

• The servlet is initialized by calling the init () method.

• The servlet calls service() method to process a client's request.

• The servlet is terminated by calling the destroy() method.

10. When init() method of servlet gets called?

- The init method is designed to be called only once. It is called when the servlet is first created, and not called again for each user request. So, it is used for one-time initializations, just as with the init method of applets.

11. When service() method of servlet gets called?

- Each time the server receives a request for a servlet, the server spawns a new thread and calls service. The service() method checks the HTTP request type (GET, POST, PUT, DELETE, etc.) and calls doGet, doPost, doPut, doDelete, etc. methods as appropriate.

12. When doGet() method of servlet to be called?

- A GET request results from a normal request for a URL or from an HTML form that has no METHOD specified and it should be handled by doGet() method.

13. When doPost() method of the servlet to be called?

- A POST request results from an HTML form that specifically lists POST as the METHOD and it should be handled by doPost() method.

14. When destroy() method of servlet gets called?

- The destroy() method is called only once at the end of the life cycle of a servlet.

15. For what purpose init() method of a servlet is used?

- The init() method simply creates or loads some data that will be used throughout the life of the servlet.

16. For what purpose destroy() method of a servlet is used?

- This method gives your servlet a chance to close database connections, halt background threads, write cookie lists or hit counts to disk, and perform other such cleanup activities.

17. How to read form data in servlet?

- Servlets handles form data parsing automatically using the following methods depending on the situation:

• getParameter(): You call request.getParameter() method to get the value of a form parameter.

• getParameterValues(): Call this method if the parameter appears more than once and returns multiple values, for example checkbox.

• getParameterNames(): Call this method if you want a complete list of all parameters in the current request.

18. What is ServletConfig object?

- javax.servlet.ServletConfig is used to pass configuration information to Servlet. Every servlet has it’s own ServletConfig object and servlet container is responsible for instantiating this object. We can provide servlet init parameters in web.xml file or through use of WebInitParam annotation. We can use getServletConfig() method to get the ServletConfig object of the servlet.

19. What is ServletContext object?

- javax.servlet.ServletContext interface provides access to web application parameters to the servlet. The ServletContext is unique object and available to all the servlets in the web application. When we want some init parameters to be available to multiple or all of the servlets in the web application, we can use ServletContext object and define parameters in web.xml using element. We can get the ServletContext object via the getServletContext() method of ServletConfig. Servlet containers may also provide context objects that are unique to a group of servlets and which is tied to a specific portion of the URL path namespace of the host. ServletContext is enhanced in Servlet Specs 3 to introduce methods through which we can programmatically add Listeners and Filters and Servlet to the application. It also provides some utility methods such as getMimeType(), getResourceAsStream() etc.

20. What is difference between ServletConfig and ServletContext?

- Some of the differences between ServletConfig and ServletContext are:

• ServletConfig is a unique object per servlet whereas ServletContext is a unique object for complete application.

ServletConfig is used to provide init parameters to the servlet whereas ServletContext is used to provide application level init parameters that all other servlets can use.

• We can’t set attributes in ServletConfig object whereas we can set attributes in ServletContext that other servlets can use in their implementation.

21. What is Request Dispatcher?

- RequestDispatcher interface is used to forward the request to another resource that can be HTML, JSP or another servlet in same application. We can also use this to include the content of another resource to the response.

This interface is used for inter-servlet communication in the same context. There are two methods defined in this interface:

1. void forward(ServletRequest request, ServletResponse response) – forwards the request from a servlet to another resource (servlet, JSP file, or HTML file) on the server.

2. void include(ServletRequest request, ServletResponse response) – includes the content of a resource (servlet, JSP page, HTML file) in the response. We can get RequestDispatcher in a servlet using ServletContext getRequestDispatcher(String path) method. The path must begin with a / and is interpreted as relative to the current context root.

22. How can we create deadlock situation in servlet?

- We can create a deadlock in servlet by making a loop of method invocation, just call doPost() method from doGet() method and doGet() method to doPost() method to create deadlock situation in servlet.

23. What is the use of servlet wrapper classes?

- Servlet HTTP API provides two wrapper classes

– HttpServletRequestWrapper and HttpServletResponseWrapper.

These wrapper classes are provided to help developers with a custom implementation of a servlet request and response types. We can extend these classes and override only specific methods we need to implement for custom request and response objects. These classes are not used in normal servlet programming.

Advantages of OOP - Detailed Top 7 Advantages of OOP

2021-01-16T22:00:00.005+05:30

What is OOP??

- OOP (Object Oriented Programming) is a programming paradigm that is completely based on 'objects'. A general explanation of 'object' for better understanding - Mr. A is going to build a POT with the use of BLOCKS. So, Objects are nothing but POTS. We build an Object by assigning values to the properties when we need them.

BLOCK is nothing but the templates of the object. There we write how the object should appeal (means look like) and how the actions will take place. In Java, we call it a class.

Advantages of OOP

Moving to the advantages of OOP, we would like to say that there are many, as this is one of the core development approaches which is widely accepted. Let's what are the advantages of OOP offers to its users.

OOP makes java more reliable and scalable along with easy to write code for developing application.

1. Re-Usability

It means reusing some facilities rather than building it again and again. This can be achieved with the use of the class. We can use it 'n' number of times as per our need.

2. Data Redundancy:

This is a condition created at the place of the data storage (you can say Database) when the same piece of data is held in two separate places. So the data redundancy is one of the greatest advantages of OOP. If a user wants a similar functionality in multiple classes he/she can go ahead by writing a common class definition for similar functionalities and inherit them.

3. Code Maintenance:

This feature is more of a necessity for any programming language, it helps users from doing re-work in many ways. It is always easy and time-saving to maintain and modify the existing codes with the use of the data hiding and abstraction mechanism, we are filtering out limited data to exposure which means we are maintaining security and providing necessary data to view.

4. Design Benefits

If you are practicing on OOPs the design benet a user will get is in terms of designing and xing things easily and eliminating the risks (if any). Here the Object-Oriented Programs forces the...(continue in point 5)

5. Better productivity

with the above-mentioned facts of using the application definitely enhances its user's overall productivity. This leads to more work done, finish a better program, having more inbuilt features, and easier to read, write and maintain. An OOP programmer cans stitch new software objects to make completely new programs. A good number of libraries with useful functions in abundance make it possible.

6. Easy troubleshooting

let's witness some common issues or problems any developers face in their work.

Is this the problem in the widget le?

Is the problem is in the WhaleFlumper?

Will I have to trudge through that ‘sewage.c’ le?

Commenting on all these issues related to code.

So, many a time it happens that something has gone wrong which later becomes so brainstorming for the developers to look where the error is. Relax! Working with OOP language you will know where to look for. This is the advantage of using encapsulation in OOP; all the objects are self constrained.

With this modality behavior, the IT teams get a lot of work benefits as they are now capable to work on multiple projects simultaneously with an advantage that there is no possibility of code duplicity.

You behave in a different way if the place or surrounding gets change. A person will behave like a customer if he is in a market, the same person will behave like a student if he is in a school and as a son/daughter if put in a house. Here we can see that the same person showing different behavior every time the surroundings are changed. This means polymorphism is flexible and helps developers in a number of ways.

It's simplicity

Extensibility

7. Problems solving

Decomposing a complex problem into smaller chunks or discrete components is a good practice. OOP is specialized in this behavior, as it breaks down your software code into bite-sized – one object at a time. In doing this the broken components can be reused in solutions to different other problems (both less and more complex) or either they can be replaced by the future modules which relate to the same interface with implementation details.

A general – at a high level a car can be decomposed into wheels, engine, a chassis soon and each of those components can be further broken down into even smaller atomic components like screws and bolts. The engine’s design doesn’t need to know anything about the size of the tires in order to deliver a certain amount of power (as output) has little to do with each other.

13 Basic Java Programs for beginner

2021-01-10T21:43:00.002+05:30

In this post, you will learn different types of explained basic programs of JAVA for the Beginner level. Try all programs to clear the basic concept of the JAVA Program.

1. Program to compute Addition.

import java.util.Scanner;

public class Addition {

public static void main(String[] args) {

// TODO Auto-generated method stub

Scanner sc = new Scanner(System.in);

int number1, number2, addtion;

System.out.println("Please enter value of number1");

number1 = sc.nextInt(); // user input for number1

System.out.println("Please enter value of number2");

number2 = sc.nextInt(); // user input for number2

addtion = number1 + number2; // addition

System.out.println("The sum of "+number1 + " and " +number2 + " is " + addtion);

}

Output:

Please enter value of number1

100

Please enter value of number2

150

The sum of 100 and 150 is 250

2. . Program on Area of circle and Rectangle

import java.util.Scanner;

public class AreaCalc {

public static void main(String[] args) {

double radius, areac;

int length, breadth, arear;

Scanner sc = new Scanner(System.in);

System.out.println("-----CIRCLE-----");

System.out.println("Enter radius of circle : ");

radius = sc.nextDouble();

areac = 3.14 * radius * radius;

System.out.println("Area of Circle is : " + areac);

System.out.println("-----RECTANGLE-----");

System.out.println("Enter length and breadth of rectangle : ");

length = sc.nextInt();

breadth = sc.nextInt();

arear = length * breadth;

System.out.println("Area of Rectangle is : " + arear);

sc.close();

}

Output:

-----CIRCLE-----

Enter radius of circle :

Area of Circle is : 50.24

-----RECTANGLE-----

Enter length and breadth of rectangle :

3. Program on Mod,Div Operator to check the number of notes in ATM Transaction

import java.util.Scanner;

public class ATMNotes {

public static void main(String[] args) {

// TODO Auto-generated method stub

Scanner sc = new Scanner(System.in);

int amount;

int notes;

System.out.println("Enter amount : ");

amount = sc.nextInt();

if (amount % 100 != 0) {

System.out.println("Invalid amount entered");

} else {

if (amount >= 1000) {

notes = amount / 1000;

amount = amount % 1000;

System.out.println("notes of 1000 : " + notes);

}

if (amount >= 500) {

notes = amount / 500;

amount = amount % 500;

System.out.println("notes of 500 : " + notes);

}

if (amount >= 100) {

notes = amount / 100;

amount = amount % 100;

System.out.println("notes of 100 : " + notes);

}

Output1:

Enter amount :

250

Invalid amount entered

Output2:

Enter amount :

1600

notes of 1000 : 1

notes of 500 : 1

notes of 100 : 1

4. Program to perform an arithmetic operation using switch case

import java.util.Scanner;

public class ArithmeticSwitch {

public static void main(String[] args) {

// TODO Auto-generated method stub

Scanner sc = new Scanner(System.in);

int choice, a = 0, b = 0;

int add, sub, mult;

double div;

do {

System.out.println("1.Add\n2.Substract\n3.Multiply\n4.devide\n5.exit");

System.out.println("\nEnter yout choice");

choice = sc.nextInt();

System.out.println("enter value of a: ");

a = sc.nextInt();

System.out.println("enter value of b: ");

b = sc.nextInt();

switch (choice) {

case 1:

System.out.println("-----Addition-----");

add = a + b;

System.out.println("Addition is " + add);

break;

case 2:

System.out.println("-----Subtraction-----");

sub = a - b;

System.out.println("Subtraction is " + sub);

break;

case 3:

System.out.println("-----Multiplication-----");

mult = a * b;

System.out.println("Multiplication is " + mult);

break;

case 4:

System.out.println("-----Division-----");

div = (double) a / b;

System.out.println("division is " + div);

break;

case 5:

System.out.println("Thank you...");

System.exit(0);

break;

default:

System.out.println("U have entered wrong choice");

break;

}

} while (choice != 5);

sc.close();

}

Output:

1.Add

2.Substract

3.Multiply

4.devide

5.exit

Enter yout choice

enter value of a:

enter value of b:

-----Addition-----

Addition is 35

1.Add

2.Substract

3.Multiply

4.devide

5.exit

Enter yout choice

enter value of a:

enter value of b:

-----Subtraction-----

Subtraction is 25

1.Add

2.Substract

3.Multiply

4.devide

5.exit

Enter yout choice

enter value of a:

enter value of b:

-----Multiplication-----

Multiplication is 90

1.Add

2.Substract

3.Multiply

4.devide

5.exit

Enter yout choice

enter value of a:

200

enter value of b:

-----Division-----

division is 12.5

1.Add

2.Substract

3.Multiply

4.devide

5.exit

Enter yout choice

Thank you...

5. Program to validate date,month and year using switch case.

import java.util.Scanner;

public class DateValidationSwitch {

public static void main(String[] args) {

// TODO Auto-generated method stub

Scanner sc = new Scanner(System.in);

int dd, mm, yyyy;

int no_of_days = 0;

System.out.println("Enter date(dd): ");

dd = sc.nextInt();

System.out.println("Enter month(mm): ");

mm = sc.nextInt();

System.out.println("Enter year(yyyy): ");

yyyy = sc.nextInt();

switch (mm) {

case 1:

case 3:

case 5:

case 7:

case 8:

case 10:

case 12:

no_of_days = 31;

break;

case 4:

case 6:

case 9:

case 11:

no_of_days = 30;

break;

case 2:

if (yyyy % 4 == 0) {

no_of_days = 29;

System.out.println("This is leap year");

} else {

no_of_days = 28;

}

break;

default:

System.out.println("You have entered invalid month");

}// end switch

if (dd <= no_of_days) {

System.out.println("Given date is valid");

} else {

System.out.println("Given date is invalid");

}

sc.close();

}

Output:

Enter date(dd):

Enter month(mm):

Enter year(yyyy):

2016

This is leap year

Given date is valid

6. Program using increment , decrement and ternary operators

public class IncrementDecrement {

public static void main(String[] args)

{

int a=10,b=20,c,d,e,g,h,i;

System.out.println("values before increment "+a+" and "+b);

c = ++a; // pre increment

d = ++b;

System.out.println("values after increment "+c+" and "+d);

e= a>b ?++a:++b;

System.out.println("turnary operator value "+e);

g=e++; // post increment

System.out.println("value after increment "+g);

h=g--;

System.out.println("value after decrement "+h);

i=--h;

System.out.println("value after decrement "+i);

}

Output:

values before increment 10 and 20

values after increment 11 and 21

turnary operator value 22

value after increment 22

value after decrement 22

value after decrement 21

7. Program to calculate percentage of marks and display the grade.

import java.util.Scanner;

public class GradeCalc {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

double percentage, totalmarks;

int math, eng, phys;

System.out.println("enter your math score =");

math = sc.nextInt();

System.out.println("*************\nenter your eng score =");

eng = sc.nextInt();

System.out.println("*************\nenter your phys score =");

phys = sc.nextInt();

totalmarks = math + eng + phys;

percentage = (double) (totalmarks / 300.0) * 100;

System.out.println("your percentage : " + percentage);

if (percentage >= 70) {

System.out.println("Congrats... you got First class with Distinction");

} else if (percentage < 70 && percentage >= 60) {

System.out.println("Congrats... you got First class");

} else if (percentage < 60 && percentage >= 40) {

System.out.println("Congrats... you are passed");

} else {

System.out.println("Sorry... You are fail");

}

sc.close();

}

Output:

enter your math score =

*************

enter your eng score =

*************

enter your phys score =

your percentage : 75.0

Congrats... you got First class with Distinction

8. Program to determine Prime Number.

import java.util.Scanner;

public class PrimeNumber {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

int i, no;

System.out.println("enter the no");

no = sc.nextInt();

for (i = 2; i <= no; i++) {

if (no % i == 0)

break;

}

if (i == no) {

System.out.println("Given number is a prime no");

} else {

System.out.println("Given number is not a prime no");

}

sc.close();

}

Output:

enter the no

Given number is a prime no

9. Program on Fibonacci series

import java.util.Scanner;

public class FibonnacciSeries {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println("Enter the number for series : ");

int num = sc.nextInt();

int p = 0, q = 1, r = 0, i;

System.out.println("The fibonnacci series for number " + num + " is:");

for (i = 1; i < num; i++) {

System.out.print(p + " ");

r = p + q;

p = q;

q = r;

}

Output:

Enter the number for series :

The fibonnacci series for number 5 is:

0 1 1 2

10. Program on Reverse Number

import java.util.Scanner;

public class ReverseNumber {

public static void main(String args[]) {

int original, reverse = 0, number;

Scanner in = new Scanner(System.in);

System.out.println("Enter a number ");

number = in.nextInt();

original = number;

while (number != 0) {

reverse = reverse * 10;

reverse = reverse + number % 10;

number = number / 10;

}

System.out.println("Reverse number : " + reverse);

}

Output:

Enter a number

456

Reverse number : 654

11. Program to check number as Palindrome

/* A number is palindrome if the number and its reverse is same*/

import java.util.Scanner;

public class PalindromeNumber {

public static void main(String args[]) {

int original, reverse = 0, number;

Scanner in = new Scanner(System.in);

System.out.println("Enter a number to check if it is a palindrome");

number = in.nextInt();

original = number;

while (number != 0) {

reverse = reverse * 10;

reverse = reverse + number % 10;

number = number / 10;

}

System.out.println("Reverse number : " + reverse);

if (original == reverse) {

System.out.println("Numebr is palindrome");

}

Output:

Enter a number to check if it is a palindrome

121

Reverse number : 121

Numebr is palindrome

12. Program on Armstrong Number

/* Armstrong number is an integer such that the sum of the cubes of its digits is equal to the number itself.*/

import java.util.Scanner;

public class ArmstrongNumber {

public static void main(String arg[]) {

Scanner sc = new Scanner(System.in);

int no, rem = 0, x = 0;

System.out.println("enter the number to check for armstrong");

no = sc.nextInt();

int p = no;

while (no > 0) {

rem = no % 10;

x = x + (rem * rem * rem);

no = no / 10;

}

if (p == x) {

System.out.println("this is an armstrong");

} else {

System.out.println("This is not an armstrong number");

}

sc.close();

}

Output:

enter the number to check for armstrong

371

this is an armstrong

13. Programs on patterns:

public class Pattern1 {

public static void main(String[] args) {

for (int i = 1; i <= 5; i++) {

for (int j = 1; j <= 5; j++) {

System.out.print(i);

}

System.out.println("");

}

Output:

11111

22222

33333

44444

55555

2. Pattern Sample

12345
12345
12345
12345
12345

public class ForSeries1 {

public static void main(String[] args) {

for (int i = 1; i <= 5; i++) {

for (int j = 1; j <= 5; j++) {

System.out.print(j);

}

System.out.println(" ");

}

Output:

12345

333

4444

55555

public class Pattern2 {

public static void main(String args[]) {

for (int i = 1; i <= 5; i++) {

for (int j = 1; j <= i; j++) {

System.out.print(i);

}

System.out.println("");

}

Output:

333

4444

55555

* *

* * *

* * * *

* * * * *

* * * *

* * *

* *

public class Forseries3 {

public static void main(String[] args) {

int i, j, k;

{

for (i = 0; i < 5; i++) {

for (k = 5; k > i; k--) {

System.out.print(" ");

}

for (j = 0; j < i; j++) {

System.out.print("*");

System.out.print(" ");

}

System.out.println("");

}

for (i = 0; i < 5; i++) {

for (k = 0; k < i; k++) {

System.out.print(" ");

}

for (j = 5; j > i; j--) {

System.out.print("*");

System.out.print(" ");

}

System.out.println("");

}

Output:

* *

* * *

* * * *

* * * * *

* * * *

* * *

* *

1 2 1

1 2 3 2 1

1 2 3 4 3 2 1

1 2 3 4 5 4 3 2 1

1 2 3 4 5 6 5 4 3 2 1

public class Forloopdemo {

public static void main(String[] args) {

int i, j, k = 0;

for (i = 1; i <= 5; i++) {

for (int m = 5; m >= i; m--) {

System.out.print(" ");

}

for (j = 1; j <= i; j++) {

System.out.print(j);

System.out.print(" ");

}

for (k = j; k > 0; k--) {

System.out.print(k);

System.out.print(" ");

}

System.out.println();

}

Output:

1 2 1

1 2 3 2 1

1 2 3 4 3 2 1

1 2 3 4 5 4 3 2 1

1 2 3 4 5 6 5 4 3 2 1

public class For_demo {

public static void main(String[] args) {

int k = 5;

for (int i = 0; i < 5; i++) {

for (int m = 0; m < i; m++) {

System.out.print(" ");

}

for (int j = 0; j < 5; j++) {

if (i == j) {

System.out.print(k);

k--;

}

System.out.println("");

}

Output:

Above all the basic programs explained with all type of concept, by doing these programs you can know the basic concept of the JAVA programming. For more basic programs in Java Click Here.

More Topics:

Core Java

Oops Features

String Handling

103+ Java Interview Questions Answers for 2 to 7 Year Experienced Programmers

2021-01-10T10:45:00.004+05:30

130+ Java Interview Questions Answers for 2 to 7 Year Experienced Programmers

Time is changing and so is Java interviews. Gone are the days, when knowing the difference between String and StringBuffer can help you to go through the second round of interview, questions are becoming more advanced and interviewers are asking more deep questions.

When I started my career, questions like Vector vs Array and HashMap vs, Hashtable was the most popular ones and just memorizing them gives you a good chance to do well in interviews, but not anymore.

Nowadays, you will get questions from the areas where not many Java programmer looks e.g. NIO, patterns, sophisticated unit testing or those which are hard to master e.g. concurrency, algorithms, data structures and coding.

Since I like to explore interview questions, I have got this huge list of questions with me, which contains lots and lots of questions on different topics.

I have been preparing this MEGA list for quite some time and now It's ready to share with you guys. It contains interview questions not only from classic topics like threads, collections, equals and hashcode, sockets but also from NIO, array, string, Java 8, and much more.

It has questions for both entry-level Java programmers and senior developers with years of experience. No matter whether you are a Java developer of 1, 2, 3, 4, 5, 6, 8, 9, or even 10 years of experience, you will find something interesting on this list.

It contains questions that are super easy to answer, and also, a question that is tricky enough for even seasoned Java programmers.

If you need more questions then you can also check out this Java Interview Guide: 200+ Interview Questions with Answers

Given the list is long and we have questions from everywhere, it's imperative that answers must be short, concise, and crisp, no fluffing at all. So apart from this paragraph, you will only hear from me is the questions and answers, no more context, no more feedback, and no more evaluation. For that, I have already written blog posts, where you can find my views on a particular the question, e.g. why I like that question, what makes them challenging, and what kind of answer

you should expect from candidates. This list is a little bit different and I encourage you to share questions and answers in a similar way so that it should be easy to revise. I hope this list can be a great use for both interviewer and candidates, the interviewer can, of course, but a little variety on questions to bring novelty and surprise element, which is important for a good interview. While a candidate, can expand and test their knowledge about key areas of Java programming language and platform. In 2018 and in coming years the focus will be more on advanced concurrency concept, JVM internals, 32-bit vs 64-bit JVM, unit testing, and clean code. I am sure, once you read through this MEGA list of Java interview questions, you should be able to do well on both telephonic and face-to-face programming interviews.

Important Topics for Java Interviews Apart from quantity, as you can see with a huge number of questions, I have worked hard to maintain quality as well. I have not only shared questions from all important topics but also ensured to include so-called advanced topics which many programmers do not prefer to prepare or just left out because they have not worked on that. Java NIO and JVM internals questions are the best examples of that.

You can keep design patterns also on the same list but a growing number of an experienced programmer is now well aware of GOF design patterns and when to use them. I have also worked hard to keep this list up-to-date to include what interviewers are asking in 2018 and what will be their core focus on the coming years. To give you an idea, this list of Java interview questions includes the following topics:

1. Multithreading, concurrency, and thread basics
2. Date type conversion and fundamentals

3. Garbage Collection

4. Java Collections Framework

5. Array

6. String

7. GOF Design Patterns

8. SOLID design principles

9. Abstract class and interface

10. Java basics e.g. equals() and hashcode

11. Generics and Enum

12. Java IO and NIO

13. Common Networking protocols

14. Data structure and algorithm in Java

15. Regular expressions

16. JVM internals

17. Java Best Practices

18. JDBC
19. Date, Time, and Calendar
20. XML Processing in Java
21. JUnit
22. Programming

You guys are also lucky that nowadays there are some good books available to prepare for Java interviews, one of them which I particularly find useful and interesting to read is Java Programming Interview Exposed by Markham. It will take you to some of the most important topics for Java and JEE interviews, worth reading even if you are not preparing for Java interview.

Top 120 Java Interview Questions Answers So now the time has come to introduce you to this MEGA list of 120 Java questions collected from various interviews of the last 5 years. I am sure you have seen many of these questions personally in your interviews and many of you would have answered them correctly as well. Multithreading, Concurrency, and Thread basics Questions

1) Can we make the array volatile in Java?
This is one of the tricky Java multi-threading questions you will see in senior Java developer Interview. Yes, you can make an array volatile in Java but only the reference which is pointing to an array, not the whole array. What I mean, if one thread changes the reference variable to points to another array, that will provide a volatile guarantee, but if multiple threads are changing individual array elements they won't be having happens before guarantee provided by the volatile modifier.

2) Can volatile make a non-atomic operation to atomic?

This another good question I love to ask on volatile, mostly as a follow-up of the previous question. This question is also not easy to answer because volatility is not about atomicity, but there are cases where you can use a volatile variable to make the operation atomic. One example I have seen is having a long field in your class. If you know that a long field is accessed by more than one thread e.g. a counter, a price field, or anything, you better make it volatile. Why? because reading to a long variable is not atomic in Java and done in two steps, If one thread is writing or updating long value, it's possible for another thread to see the half value (fist 32-bit). While reading/writing a volatile long or double (64 bit) is atomic.

3) What are the practical uses of a volatile modifier?

One of the practical use of the volatile variable is to make reading double and long atomic. Both double and long are 64-bit wide and they are read in two parts, first 32-bit first time and next 32- bit second time, which is non-atomic but volatile double and long-read are atomic in Java. Another use of the volatile variable is to provide a memory barrier, just like it is used in Disrupter framework. Basically, the Java Memory model inserts a write barrier after you write to a volatile variable and a read barrier before you read it. This means, if you write to a volatile field then it's guaranteed that any thread accessing that variable will see the value you wrote and anything you did before doing that right into the thread is guaranteed to have happened and any updated data values will also be visible to all threads because the memory barrier flushed all other writes to the cache.

4) What guarantee volatile variable provides?

volatile variables provide the guarantee about ordering and visibility e.g. volatile assignment cannot be re-ordered with other statements but in the absence of any synchronization instruction compiler, JVM or JIT are free to reorder statements for better performance. volatile also provides the happens-before guarantee which ensures changes made in one thread are visible to others. In some cases volatile also provide atomicity e.g. reading 64-bit data types like long and double are not atomic but read of volatile double or long is atomic.

5) Which one would be easy to write?

synchronization code for 10 threads or 2 threads? In terms of writing code, both will be of the same complexity because synchronization code is independent of a number of threads. Choice of synchronization though depends upon a number of threads because the number of thread present more contention, so you go for advanced synchronization technique e.g. lock stripping, which requires more complex code and expertise.

6) How do you call wait() method? using if block or loop? Why?

wait() method should always be called in the loop because it's possible that until the thread gets CPU to start running again the condition might not hold, so it's always better to check the condition in loop before proceeding. Here is the standard idiom of using wait and notify method in Java:

// The standard idiom for using the wait method

synchronized (obj)

{ while (condition does not hold)

obj.wait(); // (Releases lock, and reacquires on wakeup)

... // Perform action appropriate to condition

}

7) What is false sharing in the context of multi-threading?

false sharing is one of the well-known performance issues on multi-core systems, where each process has its local cache. false sharing occurs when threads on different processor modify variables that reside on the same cache line as shown in the following image:

False sharing is very hard to detect because the thread may be accessing completely different global variables that happen to be relatively close together in memory. Like many concurrency issues, the primary way to avoid false sharing is a careful code review and aligning your data structure with the size of a cache line.

8) What is a busy spin? Why should you use it?

Busy spin is one of the techniques to wait for events without releasing the CPU. It's often done to avoid losing data in CPU cached which is lost if the thread is paused and resumed in some other core. So, if you are working on a low latency system where your order processing thread currently doesn't have any order, instead of sleeping or calling wait(), you can just loop and then again check the queue for new messages. It's only beneficial if you need to wait for a very small amount of time e.g. in microseconds or nanoseconds. LMAX Disrupter framework, a high-performance inter-thread messaging library has a BusySpinWaitStrategy which is based on this concept and uses a busy spin loop for EventProcessors waiting on the barrier.

9) How do you take thread dump in Java?

You can take a thread dump of Java application in Linux by using kill -3 PID, where PID is the process id of Java process. In Windows, you can press Ctrl + Break. This will instruct JVM to print thread dump in standard out or err and it could go to console or log file depending upon your application configuration. If you have used Tomcat then when

10) is Swing thread-safe?

No, Swing is not thread-safe. You cannot update Swing components e.g. JTable, JList, or JPanel from any thread, in fact, they must be updated from GUI or AWT thread. That's why swings provide invokeAndWait() and invokeLater() method to request GUI update from any other threads. This method put update request in AWT threads queue and can wait till update or return immediately for an asynchronous update. You can also check the detailed answer to learn more.

11) What is a thread-local variable in Java?

Thread-local variables are variables confined to a thread, it's like the thread's own copy which is not shared between multiple threads. Java provides a ThreadLocal class to support thread-local variables. It's one of the many ways to achieve thread-safety. Though be careful while using a thread-local variable in the managed environment e.g. with web servers where the worker threads outlive any application variable. Any thread-local variable which is not removed once its work is done can potentially cause a memory leak in the Java application.

12) Write wait-notify code for the producer-consumer problem?

Please see the answer for a code example. Just remember to call wait() and notify() method from the synchronized block and test waiting for condition on the loop instead of if block.

13) Write code for thread-safe Singleton in Java?

Please see the answer for a code example and step by step guide to creating thread-safe singleton class in Java. When we say thread-safe, which means Singleton should remain singleton even if initialization occurs in the case of multiple threads. Using Java enum as Singleton class is one of the easiest ways to create a thread-safe singleton in Java.

14) The difference between sleep and wait in Java?

Though both are used to pause the currently running thread, sleep() is actually meant for short pause because it doesn't release the lock, while wait() is meant for the conditional wait and that's why it releases lock which can then be acquired by another thread to change the condition on which it is waiting.

15) What is an immutable object?

How do you create an Immutable object in Java? (answer) Immutable objects are those whose state cannot be changed once created. Any modification will result in a new object e.g. String, Integer, and other wrapper class. Please see the answer for step by step guide to creating an Immutable class in Java.

16) Can we create an Immutable object, which contains a mutable object?

Yes, it's possible to create an Immutable object which may contain a mutable object, you just need to be a little bit careful not to share the reference of the mutable component, instead, you should return a copy of it if you have to. The most common example is an Object which contains the reference of java.util.Date object. Date types and Basic Java Interview Questions

17) What is the right data type to represent a price in Java?

BigDecimal if memory is not a concern and Performance is not critical, otherwise double with predefined precision.

18) How do you convert bytes to String? (answer)

you can convert bytes to the string using string constructor which accepts byte[], just make sure that right character encoding otherwise platform's default character encoding will be used which may or may not be the same.

19) How do you convert bytes to long in Java?

The byte takes 1 byte of memory and the long takes 8 bytes of memory. Assignment 1 byte value to 8 bytes is done implicitly by the JVM.

byte –> short –> int –> long –> float –> double

The left-side value can be assigned to any right-side value and is done implicitly. The reverse requires explicit casting.

20) Can we cast an int value into byte variable?

what will happen if the value of int is larger than byte? Yes, we can cast but int is 32 bit long in java while byte is 8 bit long in java so when you cast an int to byte higher 24 bits are lost and a byte can only hold a value from -128 to 128.

22) Which class contains clone method? Cloneable or Object?

java.lang.Cloneable is marker interface and doesn't contain any method clone method is defined in the object class. It is also knowing that clone() is a native method means it's implemented in C or C++ or any other native language.

23) Is ++ operator is thread-safe in Java?

No, it's not a thread-safe operator because it involves multiple instructions like reading a value, incriminating it and storing it back into memory which can be overlapped between multiple threads.

24) Difference between a = a + b and a += b ?

The += operator implicitly cast the result of addition into the type of the variable used to hold the result. When you add two integral variables e.g. variable of type byte, short, or int then they are first promoted to int and them addition happens. If the result of the addition is more than the maximum value of a then a + b will give a compile-time error but a += b will be ok as shown below

byte a = 127; byte b = 127; b = a + b; // error : cannot convert from int to byte b += a; // ok

25) Can I store a double value in a long variable without casting?

No, you cannot store a double value into a long variable without casting because the range of double is more than long and you need to typecast. It's not difficult to answer this question but many developers get it wrong due to confusion on which one is bigger between double and long in Java.

26) What will this return 3*0.1 == 0.3? true or false?

This is one of the really tricky questions. Out of 100, only 5 developers answered this question and only of them have explained the concept correctly. The short answer is false because some floating-point numbers can not be represented exactly.

27) Which one will take more memory, an int or Integer?

An Integer object will take more memory an Integer is the object and it stores metadata overhead about the object and int is primitive type so it takes less space.

28) Why is String Immutable in Java?

One of my favorite Java interview questions. The String is Immutable in java because java designer thought that string will be heavily used and making it immutable allow some optimization easy sharing the same String object between multiple clients. See the link for a more detailed answer. This is a great question for Java programmers with less experience as it gives them food for thought, to think about how things works in Java, what Jave designers might have thought when they created String class etc.

29) Can we use String in the switch case?

Yes from Java 7 onward we can use String in the switch case but it is just syntactic sugar. Internally string hash code is used for the switch. See the detailed answer for more explanation and discussion.

30) What is constructor chaining in Java?

When you call one constructor from another than it's known as constructor chaining in Java. This happens when you have multiple, overloaded constructors in the class.

JVM Internals and Garbage Collection Interview Questions In the year 2018, I have seen an increased focus on JVM internal and Garbage collection tuning, monitoring Java application, dealing with Java performance issues on various Java interviews. This actually becomes the prime topic for interviewing any experienced Java developer for a senior position e.g. technical lead, VP, or team lead. If you feel you are short of experience and knowledge in this area then you should read at least one book mentioned in my list of Java Performance books. My vote goes to Java Performance, The Definitive Guide by Scott.

31) What is the size of int in 64-bit JVM?

The size of an int variable is constant in Java, it's always 32-bit irrespective of platform. Which means the size of primitive int is the same in both 32-bit and 64-bit Java virtual machine.

32) The difference between Serial and Parallel Garbage Collector?

Even though both the serial and parallel collectors cause a stop-the-world pause during Garbage collection. The main difference between them is that a serial collector is a default copying collector that uses only one GC thread for garbage collection while a parallel collector uses multiple GC threads for garbage collection.

33) What is the size of an int variable in 32-bit and 64-bit JVM?

The size of int is the same in both 32-bit and 64-bit JVM, it's always 32 bits or 4 bytes.

34) A difference between WeakReference and SoftReference in Java?

Though both WeakReference and SoftReference helps garbage collector and memory efficiency, WeakReference becomes eligible for garbage collection as soon as the last strong reference is lost but SoftReference even though it can not prevent GC, can delay it until JVM absolutely need memory.

35) How does WeakHashMap works?

WeakHashMap works like a normal HashMap but uses WeakReference for keys, which means if the key object doesn't have any reference then both key/value mapping will become eligible for garbage collection.

36) What is -XX:+UseCompressedOops JVM option? Why use it?

When you go migrate your Java application from 32-bit to 64-bit JVM, the heap requirement suddenly increases, almost double, due to the increasing size of ordinary object pointer from 32 bit to 64 bit. This also adversely affects how much data you can keep in the CPU cache, which is much smaller than memory. Since the main motivation for moving to 64-bit JVM is to specify a large heap size, you can save some memory by using compressed OOP. By using - XX:+UseCompressedOops, JVM uses 32-bit OOP instead of 64-bit OOP.

37) How do you find if JVM is 32-bit or 64-bit from Java Program?

You can find that by checking some system properties like sun.arch.data.model or os. arch

38) What is the maximum heap size of 32-bit and 64-bit JVM?

Theoretically, the maximum heap memory you can assign to a 32-bit JVM is 2^32 which is 4GB but practically the limit is much smaller. It also varies between operating systems e.g. form 1.5GB in Windows to almost 3GB in Solaris. 64-bit JVM allows you to specify larger heap size, theoretically, 2^64 which is quite large but practically you can specify heap space up to 100GBs. There are even JVM e.g. Azul where heap space of 1000 gigs is also possible.

39) What is the difference between JRE, JDK, JVM, and JIT?

JRE stands for Java run-time and it's required to run Java application. JDK stands for Java development kit and provides tools to develop Java programs e.g. Java compiler. It also contains

JRE. The JVM stands for Java virtual machine and it's the process responsible for running Java application. The JIT stands for Just In Time compilation and helps to boost the performance of Java application by converting Java byte code into native code when the crossed certain threshold i.e. mainly hot code is converted into native code.

40) Explain Java Heap space and Garbage collection?

When a Java process is started using the java command, memory is allocated to it. Part of this memory is used to create heap space, which is used to allocate memory to objects whenever they are created in the program. Garbage collection is the process inside JVM which reclaims memory from dead objects for future allocation.

41) Can you guarantee the garbage collection process?

No, you cannot guarantee the garbage collection, though you can make a request using System.gc() or Runtime.gc() method.

42) How do you find memory usage from the Java program? How much percent of the heap is used?

You can use memory-related methods from java.lang.Runtime class to get the free memory, total memory, and maximum heap memory in Java. By using these methods, you can find out how many percents of the heap is used and how much heap space is remaining. Runtime.freeMemory() return amount of free memory in bytes, Runtime.totalMemory() returns total memory in bytes and Runtime.maxMemory() returns maximum memory in bytes.

43) What is the difference between stack and heap in Java?

Stack and heap are different memory areas in the JVM and they are used for different purposes. The stack is used to hold method frames and local variables while objects are always allocated memory from the heap. The stack is usually much smaller than heap memory and also didn't shared between multiple threads, but heap is shared among all threads in JVM.

Basic Java concepts Interview Questions

44) What's the difference between "a == b" and "a.equals(b)"?

The a = b does object reference matching if both a and b are an object and only return true if both are pointing to the same object in the heap space, on the other hand, a.equals(b) is used for logical mapping and its expected from an object to override this method to provide logically equality. For example, String class overrides this equals() method so that you can compare two Strings, which are the different object but contains same letters.

45) What is a.hashCode() used for? How is it related to a.equals(b)?

hashCode() method returns an int hash value corresponding to an object. It's used in hash-based collection classes e.g Hashtable, HashMap, LinkedHashMap and so on. It's very tightly related to equals() method. According to Java specification, two objects which are equal to each other using equals() method must have the same hash code.

46) Difference between final, finalize and finally?

The final is a modifier that you can apply to variables, methods, and classes. If you make a variable final it means its value cannot be changed once initialized. finalize is a method, which is called just before an object is a garbage collected, giving it last chance to resurrect itself, but the call to finalize is not guaranteed. finally is a keyword that is used in exception handling along with try and catch. the finally block is always executed irrespective of whether an exception is thrown from try block or not.

47) What is a compile-time constant in Java? What is the risk of using it?

public static final variables are also known as a compile-time constant, the public is optional there. They are replaced with actual values at compile time because compiler know their value up-front and also knows that it cannot be changed during run-time. One of the problem with this is that if you happened to use a public static final variable from some in-house or third party library and their value changed later than your client will still be using old value even after you deploy a new version of JARs. To avoid that, make sure you compile your program when you upgrade dependency JAR files. Java Collections Framework Interview Questions It also contains Data structure and algorithm Interview question in Java, questions on array, linked list, HashMap, ArrayList, Hashtable, Stack, Queue, PriorityQueue, LinkedHashMap and ConcurrentHashMap.

48) The difference between List, Set, Map, and Queue in Java?

The list is an ordered collection that allows duplicates. It also has an implementation that provides constant time index-based access, but that is not guaranteed by the List interface. Set is an unordered collection which

49) Difference between poll() and remove() method?

Both poll() and remove() take out the object from the Queue but if poll() fails then it returns null but if remove fails it throws Exception.

50) The difference between LinkedHashMap and PriorityQueue in Java?

PriorityQueue guarantees that the lowest or highest priority element always remains at the head of

the queue, but LinkedHashMap maintains the order in which elements are inserted. When you iterate over a PriorityQueue, the iterator doesn't guarantee any order but iterator of LinkedHashMap does guarantee the order in which elements are inserted.

51) Difference between ArrayList and LinkedList in Java?

The obvious difference between them is that ArrayList is backed by array data structure, supports random access and LinkedList is backed by linked list data structure and doesn't support random access. Accessing an element with the index is O(1) in ArrayList but its O(n) in LinkedList. See the answer for a more detailed discussion.

52) What are a couple of ways that you could sort a collection?

You can either use the Sorted collection like TreeSet or TreeMap or you can sort using the an ordered collection like a list and using Collections.sort() method.

53) How do you print Array in Java?

You can print an array by using the Arrays.toString() and Arrays.deepToString() method. Since array doesn't implement toString() by itself, just passing an array to System.out.println() will not print its contents but Arrays.toString() will print each element.

54) LinkedList in Java is doubly or singly linked list?

It's a doubly linked list, you can check the code in JDK. In Eclipse, you can use the shortcut, Ctrl + T to directly open this class in Editor.

55) Which kind of tree is used to implement TreeMap in Java?)

A Red Black tree is used to implement TreeMap in Java.

56) What is the difference between Hashtable and HashMap?

There are many differences between these two classes, some of them are following: a) Hashtable is a legacy class and present from JDK 1, HashMap was added later. b) Hashtable is synchronized and slower but HashMap is not synchronized and faster. c) Hashtable doesn't allow null keys but HashMap allows one null key. See the answer for more differences between HashMap and Hashtable in Java.

57) How HashSet works internally in Java?

HashSet is internally implemented using a HashMap. Since a Map needs key and value, a default value is used for all keys. Similar to HashMap, HashSet doesn't allow duplicate keys and only one null key, I mean you can only store one null object in HashSet.

58) Write code to remove elements from ArrayList while iterating?

The key here is to check whether the candidate uses ArrayList's remove() or Iterator's remove(). Here is the sample code which uses right way o remove elements from ArrayList while looping over and avoids ConcurrentModificationException.

59) Can I write my own container class and use it in the for-each loop?

Yes, you can write your own container class. You need to implement the Iterable interface if you want to loop over advanced for loop in Java, though. If you implement Collection then you by default get that property.

60) What is default size of ArrayList and HashMap in Java?

As of Java 7 now, default size of ArrayList is 10 and default capacity of HashMap is 16, it must be power of 2. Here is code snippet from ArrayList and HashMap class :

// from ArrayList.java JDK 1.7

private static final int DEFAULT_CAPACITY = 10; //from HashMap.java JDK 7

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

61) Is it possible for two unequal objects to have the same hashcode?

Yes, two unequal objects can have same hashcode that's why collision happens in a hashmap. the equal hashcode contract only says that two equal objects must have the same hashcode it doesn't say anything about the unequal object.

62) Can two equal objects have different hash code?

No, that's not possible according to hash code contract.

63) Can we use random numbers in the hashcode() method?

No, because hashcode of an object should be always same. See the answer to learning more about things to remember while overriding hashCode() method in Java.

64) What is the difference between Comparator and Comparable in Java?

The Comparable interface is used to define the natural order of object while Comparator is used to define custom order. Comparable can be always one, but we can have multiple comparators to define customized order for objects.

65) Why you need to override hashcode, when you override equals in Java?

Because equals have code contract mandates to override equals and hashcode together .since many container class like HashMap or HashSet depends on hashcode and equals contract.

Java Best Practices Interview question Contains best practices from different parts of Java programming e.g. Collections, String, IO, Multi-threading, Error and Exception handling, design patterns etc. This section is mostly for experienced Java developer, technical lead, AVP, team lead and coders who are responsible for products. If you want to create quality products you must know and follow the best practices.

66) What best practices you follow while writing multi-threaded code in Java?

Here are couple of best practices which I follow while writing concurrent code in Java: a) Always name your thread, this will help in debugging. b) minimize the scope of synchronization, instead of making whole method synchronized, only critical section should be synchronized. c) prefer volatile over synchronized if you can can. e) use higher level concurrency utilities instead of waitn() and notify for inter thread communication e.g. BlockingQueue, CountDownLatch and Semeaphore. e) Prefer concurrent collection over synchronized collection in Java. They provide better scalability.

67) Tell me few best practices you apply while using Collections in Java?

Here are couple of best practices I follow while using Collectionc classes from Java: a) Always use the right collection e.g. if you need non-synchronized list then use ArrayList and not Vector. b) Prefer concurrent collection over synchronized collection because they are more scalable. c) Always use interface to a represent and access a collection e.g. use List to store ArrayList, Map to store HashMap and so on. d) Use iterator to loop over collection. e) Always use generics with collection.

68) Can you tell us at least 5 best practices you use while using threads in Java?

This is similar to the previous question and you can use the answer given there. Particularly with thread, you should: a) name your thread b) keep your task and thread separate, use Runnable or Callable with thread pool executor. c) use thread pool d) use volatile to indicate compiler about ordering, visibility, and atomicity. e) avoid thread-local variable because incorrect use of ThreadLocal class in Java can create a memory leak. Look there are many best practices and I give extra points to the developer which bring something new, something even I don't know. I make sure to ask this question to Java developers of 8 to 10 years of experience just to gauge their hands-on experience and knowledge.

69) Name 5 IO best practices?

IO is very important for the performance of your Java application. Ideally, you should avoid IO in the critical path of your application. Here are a couple of Java IO best practices you can follow: a) Use buffered IO classes instead of reading individual bytes and char. b) Use classes from NIO and NIO2 c) Always close streams in finally block or use try-with-resource statements. d) use the memory-mapped file for faster IO. If a Java candidate doesn't know about IO and NIO, especially if he has at least 2 to 4 years of experience, he needs some reading.

70) Name 5 JDBC best practices you follow?

Another good Java best practice for experienced Java developers of 7 to 8 years of experience. Why it's important? because they are the ones which set the trend in the code and educate

junior developers. There are many best practices and you can name as per your comfort and convenience. Here are some of the more common ones: a) use batch statements for inserting and updating data. b) use PreparedStatement to avoid SQL exception and better performance. c) use database connection pool d) access resultset using column name instead of column indexes. e) Don't generate dynamic SQL by concatenating String with user input.

71) Name a couple of method overloading best practices in Java?

Here are some best practices you can follow while overloading a method in Java to avoid confusion with auto-boxing: a) Don't overload method where one accepts int and other accepts Integer. b) Don't overload method where the number of arguments is the same and only order of argument is different. c) Use varargs after overloaded methods have more than 5 arguments. Date, Time, and Calendar Interview questions in Java

72) Does SimpleDateFormat is safe to use in the multi-threaded program?

No, unfortunately, DateFormat and all its implementations including SimpleDateFormat is not thread-safe, hence should not be used in the multi-threaded program until external thread-safety measures are applied e.g. confining SimpleDateFormat object into a ThreadLocal variable. If you don't do that, you will get an incorrect result while parsing or formatting dates in Java. Though, for all practical date-time purposes, I highly recommend joda-time library.

73) How do you format a date in Java? e.g. in the ddMMyyyy format?

You can either use SimpleDateFormat class or joda-time library to format date in Java. DateFormat class allows you to format date on many popular formats. Please see the answer for code samples to format date into different formats e.g. dd-MM-yyyy or ddMMyyyy.

Java Interview questions from OOP and Design Patterns It contains Java Interview questions from SOLID design principles, OOP fundamentals e.g. class, object, interface, Inheritance, Polymorphism, Encapsulation, and Abstraction as well as more advanced concepts like Composition, Aggregation, and Association. It also contains questions from GOF design patterns.

74) What is the interface? Why you use it if you cannot write anything concrete on it?

The interface is used to define API. It tells about the contract your classes will follow. It also supports abstraction because a client can use interface method to leverage multiple implementations e.g. by using List interface you can take advantage of random access of ArrayList as well as flexible insertion and deletion of LinkedList. The interface doesn't allow you to write code to keep things abstract but from Java 8 you can declare static and default methods inside interface which are concrete.

75) The difference between abstract class and interface in Java?

There are multiple differences between abstract class and interface in Java, but the most important one is Java's restriction on allowing a class to extend just one class but allows it to implement multiple interfaces. An abstract class is good to define default behavior for a family of class, but the interface is good to define Type which is later used to leverage Polymorphism. Please check the answer for a more thorough discussion of this question.

76) Which design pattern have you used in your production code? apart from Singleton?

This is something you can answer from your experience. You can generally say about dependency injection, factory pattern, decorator pattern or observer pattern, whichever you have used. Though be prepared to answer follow-up question based upon the pattern you choose.

77) Can you explain Liskov Substitution principle?

This is one of the toughest questions I have asked in Java interviews. Out of 50 candidates, I have almost asked only 5 have managed to answer it. I am not posting an answer to this question as I like you to do some research, practice and spend some time to understand this confusing principle well.

78) What is Law of Demeter violation? Why it matters?

Believe it or not, Java is all about application programming and structuring code. If you have good knowledge of common coding best practices, patterns and what not to do than only you can write quality code. Law of Demeter suggests you "talk to friends and not stranger", hence used to reduce coupling between classes.

79) What is Adapter pattern? When to use it? Another frequently asked Java design pattern questions. It provides interface conversion. If your client is using some interface but you have something else, you can write an Adapter to bridge them together. This is good for Java software engineer having 2 to 3 years experience because the question is neither difficult nor tricky but requires knowledge of OOP design patterns.

80) What is an abstract class? How is it different from an interface? Why would you use it?

One more classic question from Programming Job interviews, it is as old as chuck Norris. An abstract class is a class which can have state, code and implementation, but an interface is a contract which is totally abstract. Since I have answered it many times, I am only giving you the gist here but you should read the article linked to answer to learn this useful concept in much more detail.

81) Which one is better constructor injection or setter dependency injection?

Each has their own advantage and disadvantage. Constructor injection guaranteed that class will be initialized with all its dependency, but setter injection provides flexibility to set an optional dependency. Setter injection is also more readable if you are using an XML file to describe dependency. Rule of thumb is to use constructor injection for mandatory dependency and use setter injection for optional dependency.

82) What is difference between dependency injection and factory design pattern?

Though both patterns help to take out object creation part from application logic, use of dependency injection results in cleaner code than factory pattern. By using dependency injection, your classes are nothing but POJO which only knows about dependency but doesn't care how they are acquired. In the case of factory pattern, the class also needs to know about factory to acquire dependency. hence, DI results in more testable classes than factory pattern. Please see the answer for a more detailed discussion on this topic.

83) Difference between Adapter and Decorator pattern?

Though the structure of Adapter and Decorator pattern is similar, the difference comes on the intent of each pattern. The adapter pattern is used to bridge the gap between two interfaces, but Decorator pattern is used to add new functionality into the class without the modifying existing code.

84) Difference between Adapter and Proxy Pattern?

Similar to the previous question, the difference between Adapter and Proxy patterns is in their intent. Since both Adapter and Proxy pattern encapsulate the class which actually does the job, hence result in the same structure, but Adapter pattern is used for interface conversion while The proxy pattern is used to add an extra level of indirection to support distribute, controlled or intelligent access.

85) What is Template method pattern?

Template pattern provides an outline of an algorithm and lets you configure or customize its steps. For examples, you can view a sorting algorithm as a template to sort object. It defines steps for sorting but let you configure how to compare them using Comparable or something similar in another language. The method which outlines the algorithms is also known as the template method.

86) When do you use the Visitor design pattern?

The visitor pattern is a solution of the problem where you need to add operations on a class hierarchy but without touching them. This pattern uses double dispatch to add another level of indirection.

87) When do you use Composite design pattern?

Composite design pattern arranges objects into tree structures to represent part-whole hierarchies. It allows clients treat individual objects and container of objects uniformly. Use Composite pattern when you want to represent part-whole hierarchies of objects.

88) The difference between Inheritance and Composition?

Though both allows code reuse, Composition is more flexible than Inheritance because it allows you to switch to another implementation at run-time. Code written using Composition is also easier to test than code involving inheritance hierarchies.

89) Describe overloading and overriding in Java?

Both overloading and overriding allow you to write two methods of different functionality but with the same name, but overloading is compile time activity while overriding is run-time activity. Though you can overload a method in the same class, but you can only override a method in child classes. Inheritance is necessary for overriding.

90) The difference between nested public static class and a top level class in Java?

You can have more than one nested public static class inside one class, but you can only have one top-level public class in a Java source file and its name must be same as the name of Java source file.

91) Difference between Composition, Aggregation and Association in OOP?

If two objects are related to each other, they are said to be associated with each other. Composition and Aggregation are two forms of association in object-oriented programming. The composition is stronger association than Aggregation. In Composition, one object is OWNER of another object while in Aggregation one object is just USER of another object. If an object A is composed of object B then B doesn't exist if A ceased to exists, but if object A is just an aggregation of object B then B can exists even if A ceased to exist.

92) Give me an example of design pattern which is based upon open closed principle?

This is one of the practical questions I ask experienced Java programmer. I expect them to know about OOP design principles as well as patterns. Open closed design principle asserts that your code should be open for extension but closed for modification. Which means if you want to add new functionality, you can add it easily using the new code but without touching already tried and tested code. There are several design patterns which are based upon open closed design principle e.g. Strategy pattern if you need a new strategy, just implement the interface and configure, no need to modify core logic. One working example is Collections.sort() method which is based on Strategy pattern and follows the openclosed principle, you don't modify sort() method to sort a new object, what you do is just implement Comparator in your own way.

93) Difference between Abstract factory and Prototype design pattern?

This is the practice question for you, If you are feeling bored just reading and itching to write something, why not write the answer to this question. I would love to see an example the, which should answer where you should use the Abstract factory pattern and where is the Prototype pattern is more suitable.

94) When do you use Flyweight pattern?

This is another popular question from the design pattern. Many Java developers with 4 to 6 years of experience know the definition but failed to give any concrete example. Since many of you might not have used this pattern, it's better to look examples from JDK. You are more likely have used them before and they are easy to remember as well. Now let's see the answer. Flyweight pattern allows you to share object to support large numbers without actually creating too many objects. In order to use Flyweight pattern, you need to make your object Immutable so that they can be safely shared. String pool and pool of Integer and Long object in JDK are good examples of Flyweight pattern. Miscellaneous Java Interview Questions It contains XML Processing in Java Interview question, JDBC Interview question, Regular expressions Interview questions, Java Error and Exception Interview Questions, Serialization,

95) The difference between nested static class and top level class?

One of the fundamental questions from Java basics. I ask this question only to junior Java developers of 1 to 2 years of experience as it's too easy for an experience Java programmers. The answer is simple, a public top level class must have the same name as the name of the source file, there is no such requirement for nested static class. A nested class is always inside a top level class and you need to use the name of the top-level class to refer nested static class e.g. HashMap.Entry is a nested static class, where HashMap is a top level class and Entry is nested static class.

96) Can you write a regular expression to check if String is a number? (solution)

If you are taking Java interviews then you should ask at least one question on the regular expression. This clearly differentiates an average programmer with a good programmer. Since one of the traits of a good developer is to know tools, regex is the best tool for searching something in the log file, preparing reports, etc. Anyway, the answer to this question is, a numeric The string can only contain digits i.e. 0 to 9 and + and - sign that too at the start of the String, by using this information you can write following regular expression to check if the given String is a number or not

97) The difference between checked and Unchecked Exception in Java?

checked exception is checked by the compiler at compile time. It's mandatory for a method to either handle the checked exception or declare them in their throws clause. These are the ones which are a sub class of Exception but doesn't descend from RuntimeException. The unchecked exception is the descendant of RuntimeException and not checked by the compiler at compile time. This question is now becoming less popular and you would only find this with interviews with small companies, both investment banks and startups are moved on from this question.

98) The difference between throw and throws in Java?

the throw is used to actually throw an instance of java.lang.Throwable class, which means you can throw both Error and Exception using throw keyword e.g.

throw new IllegalArgumentException("size must be multiple of 2") On the other hand, throws is used as part of method declaration and signals which kind of exceptions are thrown by this method so that its caller can handle them. It's mandatory to declare any unhandled checked exception in throws clause in Java. Like the previous question, this is another frequently asked Java interview question from errors and exception topic but too easy to answer.

99) The difference between Serializable and Externalizable in Java?

This is one of the frequently asked questions from Java Serialization. The interviewer has been asking this question since the day Serialization was introduced in Java, but yet only a few good candidate can answer this question with some confidence and practical knowledge. Serializable interface is used to make Java classes serializable so that they can be transferred over a network or their state can be saved on disk, but it leverages default serialization built-in JVM, which is expensive, fragile, and not secure. Externalizable allows you to fully control the Serialization process, specify a custom binary format, and add more security measures.

100) The difference between DOM and SAX parser in Java?

Another common Java question but from XML parsing topic. It's rather simple to answer and that's why many interviewers prefer to ask this question on the telephonic round. DOM parser loads the whole XML into memory to create a tree-based DOM model which helps it quickly locate nodes and make a change in the structure of XML while SAX parser is an event-based parser and doesn't load the whole XML into memory. Due to this reason, DOM is faster than SAX but require more memory and not suitable to parse large XML files.

101) Tell me 3 features introduced on JDK 1.7?

This is one of the good questions I ask to check whether the candidate is aware of the recent development in the Java technology space or not. Even though JDK 7 was not a big bang release like JDK 5 or JDK 8, it still has a lot of good features to count on e.g. try-with-resource statements, which free you from closing streams and resources when you are done with that, Java automatically closes that. Fork-Join pool to implement something like the Map-reduce the pattern in Java. Allowing String variable and literal into switch statements. Diamond operator for improved type inference, no need to declare generic type on the right-hand side of variable declaration anymore, results in more readable and succinct code. Another worth noting feature introduced was improved exception handling e.g. allowing you to catch multiple exceptions in the same catch block.

102) Tell me 5 features introduced in JDK 1.8?

This is the follow-up question of the previous one. Java 8 is path-breaking release in Java's history, here are the top 5 features from JDK 8 release Lambda expression, which allows you to pass an anonymous function as an object. Stream API, take advantage of multiple cores of modern CPU and allows you to write succinct code. Date and Time API, finally you have a solid and easy to use date and time library right into JDK Extension methods, now you can have static and default method into your interface Repeated annotation, allows you to apply the same annotation multiple times on a type

103) What is the difference between Maven and ANT in Java?

Another great question to check the all-round knowledge of Java developers. It's easy to answer questions from core Java but when you ask about setting things up, building Java artifacts, many Java software engineer struggles. Coming back to the answer of this question, Though both build tools and used to create Java application build, Maven is much more than that. It provides a standard structure for Java projects based upon the "convention over configuration" concept and automatically manages dependencies (JAR files on which your application is dependent) for Java application.

That's all guys, lots of Java Interview questions? isn't it? I am sure if you can answer this list of Java questions, you can easily crack any core Java or advanced Java interview. Though I have not included questions from Java EE or J2EE topics e.g. Servlet, JSP, JSF, JPA, JMS, EJB or any other Java EE technology or from major web frameworks like Spring MVC, Struts 2.0, Hibernate or both SOAP and RESTful web services, it's still useful for Java developers preparing for Java web developer position, because every Java interview starts with questions from fundamentals and JDK API.

If you think, I have missed any popular Java question here and you think it should be in this list then feel free to suggest me. My goal is to create the best list of Java Interview Questions with a latest and greatest questions from recent interviews.

HTML Tutorial for Beginner with Example

2020-10-06T21:23:00.006+05:30

In this article, we will see, Basic of HTML with examples.

Introduction:

HTML is HyperText Markup Language and is the language of the World Wide Web.

It is the standard text formatting language used for creating and displaying pages on the Web.

The definition of HTML is HyperText Markup Language.  HyperText is the method by which you move around on the web — by clicking on special the text called hyperlinks which bring you to the next page.

The fact that it is hyper just means it is not linear — i.e. you can go to any place on the Internet whenever you want by clicking on links — there is no set order to do things in.

 Markup means HTML tags mark it as a certain type of text. HTML completely relies on Tags.

Tags are labels you use to mark up the beginning and end of an element. There are two kinds of tags - opening tags: and closing tags:.

The only difference between an opening tag and a closing tag is the forward-slash "/". We label content by putting it between an opening tag and a closing tag.

HTML Versions:

Version	Year
HTML	1991
HTML 2.0	1995
HTML 3.2	1997
HTML 4.01	1999
XHTML	2000
HTML5	2014

HTML document structure:

<html>

<head>

Document header related tags

</head>

<body>

Document body related tags

</body>

</html

HTML Basic Tags:

1. The declaration helps the browser to display a web page correctly. It is not case-sensitive.

2. This shows document type is HTML.

3. This tag is used to write a comment

4. Every HTML document starts with tag and ends with

5. It contains such tags that provide information about the document.

6. : Contents which will display on the web page are included in the < body> tag.

HTML Basics:

1. Heading Tags :

In HTML Heading tags will allow giving Heading to Text. And it includes 6 types of Heading Tags.

They are as follows below with example:

1. <H1>

2. <H2>

3. <H3>

4. <H4>

5.<H5>

6. <H6>

Example

<!DOCTYPE html>

<html>

<head>

<title>Heading Tags</title>

</head>

<body>

<h1>JavaTechSeries heading 1</h1>

<h2>JavaTechSeries heading 2</h2>

<h3>JavaTechSeries heading 3</h3>

<h4>JavaTechSeries heading 4</h4>

<h5>JavaTechSeries heading 5</h5>

<h6>JavaTechSeries heading 6</h6>

</body>

</html>

Output:

JavaTechSeries heading 1

JavaTechSeries heading 2

JavaTechSeries heading 3

JavaTechSeries heading 4

JavaTechSeries heading 5

JavaTechSeries heading 6

2. Paragraph:

It offers you to write text in paragraph style. Each paragraph of the text should go in between an opening and a closing tag.

<!DOCTYPE html>

<html>

<head>

<title>Paragraph</title>

</head>

<body>

<p>Here is a first paragraph of text.</p>

<p>Here is a second paragraph of text.</p>

<p>Here is a third paragraph of text.</p>

</body>

</html>

Output:

Here is a first paragraph of text.

Here is a second paragraph of text.

Here is a third paragraph of text.

3. Line Break Tag:

Whenever we use the <br> element, anything following it starts from the next line. <br> is an empty tag which can be used without closing or we can use it as <br/>.

Example :

<!DOCTYPE html>

<html>

<head>

<title>Line Break Example</title>

</head>

<body>

<p>

Hello<br> You are reading this HTML basic Tag.<br> Thanks in

Advanced.

</p>

</body>

</html>

Output:

Hello
You are reading this HTML basic Tag.
Thanks in Advanced.

4. HTML Elements:

HTML document consist of elements. Elements contains content with <start tag> and </end tag>.

e.g <p><h1><div><br>

• <p> <h1> need to be closed. Sometimes this tag will produce result, but not all the times.

• Tags like <br>, <img> no need to close there are empty tags.

5. Attributes :

HTML elements can have attributes. Attributes provide additional information about an element. Attributes are always specified in the start tag. Attributes come in name/value pairs like: name="value".

5.1. lang attribute:

The document language can be declared in the tag. • The language is declared in the lang attribute. • Declaring a language is important for accessibility applications (screen readers) and search engines:

Example:

<!DOCTYPE html>

<head>

<title>Lang Attribute Example</title>

</head>

<body>

<h1>JavaTechSeries First Heading</h1>

<p>JavaTechSeries first paragraph.</p>

</body>

</html>

The first two letters define language and hyphen is used to use more letters.

Output:

JavaTechSeries First Heading

JavaTechSeries first paragraph.

5.2 title attribute:

This allows giving a title for the element. When you move the mouse over the element, the title will be displayed as a tooltip.

Example:

<!DOCTYPE html>

<html>

<head>

<title>The title Attribute Example</title>

</head>

<body>

<h3 title="Hello HTML!">Titled Heading Tag Example</h3>

</body>

</html>

Output:

Titled Heading Tag Example

5.3 href: This attribute is used with <a> tag to give link address.

Example :

<a href=”https://javatechseries.blogspot.com”> This is JavaTechSeries Link </a>

5.4 align Tag: It is used to set the alignment of the tag content.

Example:

<!DOCTYPE html>

<html>

<head>

<title>Align Example</title>

</head>

<body>

<p align="left">JavaTechSeries is left aligned</p>

<p align="center">JavaTechSeries is center aligned</p>

<p align="right">JavaTechSeries is right aligned</p>

</body>

</html>

Output:

JavaTechSeries is left aligned

JavaTechSeries is center aligned

JavaTechSeries is right aligned

5.5 style Attribute: The style attribute allows you to specify the adding Style Sheet (CSS) rules within the element.

Example:

<!DOCTYPE html>

<html>

<head>

<title>Style Attribute Example</title>

</head>

<body>

<p style="font-family:arial; color:red;">Welcome to Coder.....</p>

</body>

</html>

Output:

This is JavaTechSeries HTML Blog ...

Life Cycle of Servlet in Detail

2020-10-04T16:08:00.002+05:30

In this post, we will see the Servlet Life Cycle explained below in 5 steps.

1. Loading Servlet Class :

• A Servlet class is loaded when the first request for the servlet is received by the Web Container.

2. Servlet instance creation :

• After the Servlet class is loaded, Web Container creates the instance of it. Servlet instance is created only once in the life cycle.

3. Call to the init() method :

• init() method is called by the Web Container on servlet instance to initialize the servlet.

• Syntax: public void init(ServletConfig config) throws ServletException.

• The init method is designed to be called only once.

• It is called when the servlet is first created, and not called again for each user request.

4. Call to the service() method :

• The containers call the service() method each time the request for a servlet is received.

• The service() method will then call the doGet, doPost, doPut, doDelete, etc. methods as appropriate based on the type of the HTTP request.

• Syntax: public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException

• The service () method is called by the container and service method invokes doGet, doPost, doPut, doDelete, etc. methods as appropriate. So we override either doGet() or doPost() depending on what type of request we receive from the client.

5. Call to destroy() method:

• The Web Container calls the destroy() method before removing the servlet instance for cleanup activity.

• Syntax: public void destroy() { // Finalization code... }

• It is called only once at the end of the life cycle

• Then it is marked for garbage collection

HttpServlet Methods:

doGet method:

• It is used to serve the request of user.

• It will get called implicitly if no method is mentioned.

• The service method calles this method according to user requirement.

• Syntax: public void doGet(HttpServletRequest request, HttpServletResponse response)throws

ServletException, IOException { // Servlet code }

doPost method:

• It is also used to serve the request of the user.

• It has to be called explicitly whenever the user needs to pass secure content.

• The service method calls this method according to user requirements.

• Syntax: public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { // Servlet code }

doPut method:

• The doPut() method handles requests sent using the HTTP PUT method.

• The PUT method allows a client to store information on the server.

• For example, you can use it to post an image file to the server

• Syntax: public void doPut(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { // Servlet code }

doDelete method:

• It is called by the server (via the service method) to allow a servlet to handle a DELETE request.

• The DELETE operation allows a client to remove a document or Web page from the server.

Difference between GET and POST methods:

Feature	GET	POST
Sending of data	Client data is appended to URL and sent	Client data is sent separately
Storing in the browser history	As data is appended, the client data is stored in the browser history	As data is sent separately, the client data is not stored in the browser history
Bookmark	The URL with the client data can be bookmarked. Thereby, later without filling the HTML form, the same data can be sent to the server	Not possible to bookmark
Limitation of data sent	Limited to 2048 characters (browser dependent)	Unlimited data
Hacking easiness	Easy to hack the data as data is stored in the browser history	Difficult to hack
Type of data sent	Only ASCII data can be sent	Any type of data can be sent including binary data
Data secrecy	Data is not as secret as other people can see the data in the browser history	Data is secret as not stored in history
When to be used	Prefer when data sent is not secret. Do not use for passwords etc.	Prefer for critical and sensitive data like passwords etc.
Cache	Can be caught	Cannot be caught
Default	If not mentioned, GET is assumed as default	Should be mentioned explicitly
Performance	Relatively faster as data is appended to URL	A separate message the body is to be created

Recommended Topics:

Web Server and Working of CGI

Introduction to Servlet

Introduction to Servlet for Beginner

2020-10-04T14:32:00.004+05:30

In this post, you will get to know the Architecture of Servlet in detail with example.

Servlets are modules that run inside request/response-oriented servers, such as Java-enabled web servers.

Functionally they operate in a very similar way to CGI(Common Gateway Interface) scripts, however, being Java-based they are more platform-independent.

Servlet Technology is used to create web applications.

Web applications are helper applications that reside at the web server and build dynamic web pages.

A dynamic page could be anything like a page that randomly chooses pictures to display or even a page that displays the current time.

Working of Servlet:

After receiving any request from the client first web container checks whether the instance for the requested servlet exists or not.

If the servlet instance exists then the container pass that request to the instance.

If the instance does not exist container loads the servlet file and creates the instance of the requested servlet.

After receiving any request from the client first web container checks whether the instance for the requested servlet exists or not.

If the servlet instance exists then the container pass that request to the instance.

If the instance does not exist container loads the servlet file and creates the instance of the requested servlet.

Difference between CGI and Servlets:

CGI	Servlet
Platform Dependent	Platform independent
Every request is processed by own heavy process	Every request is processed by a thread which is lightweight
More vulnerable to attacks than servlets	Less vulnerable to attacks as it in java language
Not much stronger as Servlets	Stronger than CGI because of Strong memory management and exception handling
CGI does not provide sharing property.	Servlets can share data among each other.
CGI cannot read and set HTTP headers, handle cookies, tracking sessions	Servlets can read and set HTTP headers, handle cookies, tracking sessions.

Applications of Servlet:

• Processing data POSTed over HTTPS using an HTML form, including purchase order or credit card data: A servlet like this could be part of an order-entry and processing system, working with product and inventory databases, and an online payment system.

• Allowing collaboration between people: A servlet can handle multiple requests concurrently; they can synchronize requests to support systems such as on-line conferencing.

• Forwarding requests: Servlets can forward requests to other servers and servlets. This allows them to be used to balance load among several servers that mirror the same content. It also allows them to be used to partition a single logical service over several servers, according to task type or organizational boundaries.

Advantages of using Servlet:

• Servlet technology was introduced to overcome the shortcomings of CGI technology.

• It provides better performance than CGI in terms of processing time, memory utilization because servlets use benefits of multithreading and for each request, a new thread is created, that is faster than loading creating new Objects for each request with CGI.

• Servlets are platform-independent, the web application developed with Servlet can be run on any standard web container such as Tomcat, JBoss, Glassfish servers and on operating systems such as Windows, Linux, Unix, Solaris, Mac, etc.

• Servlets are robust because the container takes care of the life cycle of the servlet and we don’t need to worry about memory leaks, security, garbage collection, etc.

• Servlets are maintainable.

Servlet Architecture:

All servlets implement Servlet interface, either directly or, more commonly, by extending a class HttpServlet. HTTPServlet indirectly implements the Servlet interface.

The Servlet interface provides the following methods that manage the servlet and its communications with clients. init, service, getServletConfig, getServletInfo, destroy

When a servlet accepts a service call from a client, it receives two objects, ServletRequest and ServletResponse.

The ServletRequest class encapsulates the communication from the client to the server, while the ServletResponse class encapsulates the communication from the servlet back to the client.

The ServletRequest interface allows the servlet access to information such as the names of the parameters passed in by the client, the protocol (scheme) being used by the client, and the names of the remote host that made the request and the server that received it.

It also provides the servlet with access to the input stream, ServletInputStream, through which the servlet gets data from clients that are using application protocols such as the HTTP POST and PUT methods.

Subclasses of ServletRequest allow the servlet to retrieve more protocol-specific data. For example, HttpServletRequest contains methods for accessing HTTP-specific header information.

The ServletResponse interface gives the servlet methods for replying to the client. It allows the servlet to set the content length and mime type of the reply, and provides an output stream, ServletOutputStream, and a Writer through which the servlet can send the reply data.

Subclasses of ServletResponse give the servlet more protocol-specific capabilities.

For example, HttpServletResponse contains methods that allow the servlet to manipulate HTTP-specific header information.

HTTP servlets have some additional objects that provide session-tracking capabilities.

The servlet writer can use these APIs to maintain state between the servlet and the client that persists across multiple connections during some time period.

Recommended Topics:

1. Web Server and Working of CGI

2. Life Cycle of Servlet

Servlet Tutorial for Beginner

2020-10-03T21:51:00.007+05:30

In this Post, we will first understand the web request and response processing through server.

The web contains billions client and server which connected through the network. Web clients make requests to the web servers.

The web server receives the request, finds the resources, and returns the response to the client. When a server answers a request, it usually sends some type of content to the client.

The client uses a web browser to send a request to the server.

The server often sends a response to the browser with a set of instructions written in HTML(HyperText Markup Language).

All browsers know how to display an HTML page to the client.

Web Server, Application Server, and Web Client:

Web Server: Web Server is a software that can process the client's request and send the response back to the client.

For example, Apache is one of the most widely used web server. Web Server runs on some physical machine and listens to client requests on a specific port.

Application Server:

Most of the application servers have Web Server as integral part of them, that means App Server can do whatever Web Server is capable of. Additionally App Server have components and features to support Application level services such as Connection Pooling, Object Pooling, Transaction Support, Messaging services etc. e.g. WebLogic.

Web Client:

A web client is a software that helps in communicating with the server. Some of the most widely used web clients are Firefox, Google Chrome, Safari etc.

When we request something from server (through URL), web client takes care of creating a request and sending it to server and then parsing the server response and present it to the user.

HTTP:

• HTTP stands for hypertext tranfer protocol.

• It is used to send files (text, graphics, images, sounds, video and other multimedia files) on the web.

• It's a stateless, application-layer protocol for communicating between distributed systems.

• The current version of the protocol is HTTP/1.1.

• The default port number for HTTP is 80.

HTTP Methods and Descriptions :

Method Name	Method Description
OPTIONS	Request for communication options that are available on the request/response.
GET	Request to retrieve information from server using a given URL.
HEAD	Identical to GET except that it does not return a message body , only the headers and status line.
POST	Request for server to accept the entity enclosed in the body of HTTP method.
DELETE	Request for the Server to delete the resource.
CONNECT	Reserved to use with a proxy that can switch to being a tunnel.
PUT	This is same as POST, but POST is used to create, PUT can be used to create as well as update. It replaces all current representations of the target resource with the uploaded content.

Web Application:

A web application is an application accessible from the web. A web application is composed of web components like Servlet, JSP, Filter etc. and other components such as HTML.

The web components typically execute in Web Server and respond to HTTP request.

Common Gateway Interface:

CGI(Common Gateway Interface) which is used before the Servlet. It is used to create web application.

Working of CGI:

• User clicks a link that has URL to a dynamic page instead of a static page.

• The URL decides which CGI program to execute.

• Web servers run the CGI program in seperate OS shell. The shell includes OS environment and the process to execute code of the CGI program.

• The CGI response is sent back to the web server, which wraps the response in an HTTP response and send it back to the web browser.

Working of CGI(Common Gateway Interface)

Drawbacks of CGI:

• High response time because CGI programs execute in their own OS shell.

• CGI is not scalable.

• CGI programs are not always secure or object-oriented.

• It is Platform dependent.

Recommended Topics:

1. Introduction to Servlet

2. Life Cycle of Servlet

JSP Implicit object with Examples

2020-09-26T23:31:00.005+05:30

In this article, we will see JSP Implicit object with Examples,

There are total 9 Implicit Objects in JSP, they are below as follows,

1. Out Object

2. request Object

3. response Object

4. config Object

5. application Object

6. session Object

7. pageContext Object

8. page Object

9. exception Object

Let's see one by one implicit Object in detail with Examples ...

1. out Object:

JSP out implicit object is instance of javax.servlet.jsp.JspWriter implementation and it’s used to output content to be sent in client response. This is one of the most used JSP implicit objects and that's why we have JSP Expression to easily invoke out.print() method. In the case of Servlet we need to write:

Syntax:

PrintWriter out=response.getWriter();

But in JSP, you do not need to write this code. Because in JSP for print any result on the browser we use expression tag and this tag is auto-converted to out.print() statement and insert the out.print() into _jspService() of the servlet class by the container.

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>Insert title here</title>

</head>

<body>

out.print("Welcome");

</body>

</html>

Eclipse Code:

2. request Object

JSP request implicit object is instance of javax.servlet.http.HttpServletRequest implementation and it’s one of the arguments of the JSP service method. We can use request object to get the request parameters, cookies, request attributes, session, header information, and other details about the client request.

Example of JSP request implicit Object

JSP File 1. Input.jsp

Here we will create Output.jsp to request other JSP file to print the action form.

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>Insert title here</title>

</head>

<body>

</form>

</body>

</html>

Eclipse Code:

Output:

This is Input.jsp file output which will ask to enter input then after clicking "go" button, it will request Output.jsp file to get the output.

JSP File 2: Output.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>Insert title here</title>

</head>

<body>

String name=request.getParameter("uname");

out.print("welcome "+name);

</body>

</html>

Eclipse Code:

Output.jsp

Output:

3. response Object

JSP response implicit object is instance of javax.servlet.http.HttpServletResponse implementation and comes as an argument of the service method. We can response object to set content type, character encoding, header information in response, adding cookies to response and redirecting the request to other resource.

Example of response implicit object:

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>Insert title here</title>

</head>

<body>

response.sendRedirect("https://javatechseries.blogspot.com");

</body>

</html>

Eclipse Code:

Output:

4. config Object

JSP config implicit object is instance of javax.servlet.ServletConfig implementation and used to get the JSP init params configured in deployment descriptor. config object is an implicit object of type ServletConfig and it is created by the container, whenever servlet object is created. This object can be used to get initialization parameter for a particular JSP page. config object is created by the web container for every jsp page. It means if a web application has three jsp pages then three config object are created. In jsp, it is not mandatory to configure in web.xml. If we configure a jsp in web.xml then the logical name and init parameter given in web.xml file are stored into config object by the container. config object is accessible, only if the request is given to the jsp by using its url pattern, but not with name of the jsp. config object is accessible, only if the request is given to the jsp by using its url pattern, but not with name of the jsp

Example of config implicit object:

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>Insert title here</title>

</head>

<body>

String name=config.getInitParameter("name");

out.print("Programming name is = "+name);

</body>

</html>

Eclipse Code:

Web.xml :

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns="http://java.sun.com/xml/ns/javaee"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"

version="3.0">

<display-name>BasicPrograms</display-name>

<welcome-file-list>

<welcome-file>index.html</welcome-file>

<welcome-file>index.htm</welcome-file>

<welcome-file>index.jsp</welcome-file>

<welcome-file>default.html</welcome-file>

<welcome-file>default.htm</welcome-file>

<welcome-file>default.jsp</welcome-file>

</welcome-file-list>

<servlet-name>Home</servlet-name>

<jsp-file>/configObject.jsp</jsp-file>

<init-param>

<param-name>name</param-name>

<param-value>JavaTechSeries</param-value>

</init-param>

</servlet>

<servlet-mapping>

<servlet-name>Home</servlet-name>

<url-pattern>/configObject.jsp</url-pattern>

</servlet-mapping>

</web-app>

Here we are mentioning servlet mapping in web.xml to get called from jsp file.

Output:

5. application Object:

JSP application implicit object is instance of javax.servlet.ServletContext implementation and it’s used to get the context information and attributes in JSP. We can use it to get the RequestDispatcher object in JSP to forward the request to another resource or to include the response from another resource in the JSP.

Example of Application implicit object:

Context.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>Insert title here</title>

</head>

<body>

</body>

</html>

Eclipse Code:

Application.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>Insert title here</title>

</head>

<body>

String info=application.getInitParameter("info");

out.print("Program info = "+info); %>

</body>

</html>

Output:

Web.xml:

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns="http://java.sun.com/xml/ns/javaee"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"

version="3.0">

<display-name>BasicPrograms</display-name>

<welcome-file-list>

<welcome-file>index.html</welcome-file>

<welcome-file>index.htm</welcome-file>

<welcome-file>index.jsp</welcome-file>

<welcome-file>default.html</welcome-file>

<welcome-file>default.htm</welcome-file>

<welcome-file>default.jsp</welcome-file>

</welcome-file-list>

<servlet-mapping>

<servlet-name>One</servlet-name>

<url-pattern>/Application.jsp</url-pattern>

</servlet-mapping>

<context-param>

<param-name>info</param-name>

<param-value>Example of application object</param-value>

</context-param>

</web-app>

6. session object:

JSP session implicit object is instance of javax.servlet.http.HttpSession implementation. Whenever we request a JSP page, container automatically creates a session for the JSP in the service method. Since session management is a heavy process, so if we don’t want session to be created for JSP, we can use page directive to not create the session for JSP using <%@ page session="false" %>. This is very helpful when our login page or the index page is a JSP page and we don’t need any user session there

Example of Session implicit object:

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>Insert title here</title>

</head>

<body>

</form>

</body>

</html>

Eclipse Code:

Output:

Session1.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>Insert title here</title>

</head>

<body>

String name = request.getParameter("uname");

out.print("Welcome " + name);

session.setAttribute("user", name);

<a href="session2.jsp">second jsp page</a>

</body>

</html>

Eclipse Code:

Output:

Session2.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>Insert title here</title>

</head>

<body>

String name = (String) session.getAttribute("user");

out.print("Hello " + name);

</body>

</html>

7. pageContext Object:

JSP pageContext implicit object is instance of javax.servlet.jsp.PageContext abstract class implementation. We can use pageContext to get and set attributes with different scopes and to forward request to other resources. pageContext object also hold reference to other implicit object.

The pageContext object can be used to set,get or remove attribute from one of the following scopes.

• page

• request

• session

• application

Example of pageContext implicit object

Input3.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>Insert title here</title>

</head>

<body>

String name="JavaTechSeries";

pageContext.setAttribute("user",name,PageContext.SESSION_SCOPE);

pageContext.setAttribute("user",name,PageContext.PAGE_SCOPE);

pageContext.setAttribute("user",name,PageContext.REQUEST_SCOPE);

pageContext.setAttribute("user",name,PageContext.APPLICATION_SCOPE);

String sname=(String)pageContext.getAttribute("user",PageContext.SESSION_SCOPE);

String pname=(String)pageContext.getAttribute("user",PageContext.PAGE_SCOPE);

String rname=(String)pageContext.getAttribute("user",PageContext.REQUEST_SCOPE);

String aname=(String)pageContext.getAttribute("user",PageContext.APPLICATION_SCOPE);

<b>Value in Session scope  <%=sname%></b><br>

<b>Value in Request scope  <%=rname%></b><br>

<b>Value in Page scope  <%=pname%></b><br>

<b>Value in Application scope  <%=aname%></b><br>

</body>

</html>

Eclipse Code:

PageContext.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>Insert title here</title>

</head>

<body>

String sname=(String)pageContext.getAttribute("user",PageContext.SESSION_SCOPE);

String pname=(String)pageContext.getAttribute("user",PageContext.PAGE_SCOPE);

String rname=(String)pageContext.getAttribute("user",PageContext.REQUEST_SCOPE);

String aname=(String)pageContext.getAttribute("user",PageContext.APPLICATION_SCOPE);

<b>Value in Session scope  <%=sname%></b><br>

<b>Value in Request scope  <%=rname%></b><br>

<b>Value in Page scope  <%=pname%></b><br>

<b>Value in Application scope  <%=aname%></b><br>

</body>

</html>

Eclipse Code:

Output:

8. page Object:

JSP page implicit object is instance of java.lang.Object class and represents the current JSP page. page object provide reference to the generated servlet class. This object is very rarely used. When a jsp is translated to an internal Servlet, we can find the following statement in the service() method of servlet. Object page=this; For using this object it must be cast to Servlet type.

For Example:

<% (HttpServlet)page.log("message"); %>

Since, it is of type Object it is less used because you can use this object directly in jsp.

For example:

<% this.log("message"); %>

9. exception Object:

JSP exception implicit object is instance of java.lang.Throwable class and used to provide exception details in JSP error pages. We can’t use this object in normal JSP pages and it’s available only in

JSP error pages.

Example: This program is to show use of the <%=exception> object. In this 3 files are created. One file is used to take input from the user for the calculation which is “calculation.jsp”. And another file is used to perform the operation which is “Operation.jsp”. Third file is Exception file which is “exception.jsp”. For this 2 changes are required in jsp page directive.

• In every file at page directive isErrorPage=”true”.

• And set errorPage=”esception.jsp”.

Input.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>Insert title here</title>

</head>

<body>

Input First Integer:<input type="text" name="firstnum" />

Input Second Integer:<input type="text" name="secondnum" />

</form>

</body>

</html>

Operation.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<%@ page errorPage="exception.jsp" %>

<html>

<head>

<title>Insert title here</title>

</head>

<body>

String num1=request.getParameter("firstnum");

String num2=request.getParameter("secondnum");

int v1= Integer.parseInt(num1);

int v2= Integer.parseInt(num2);

int res= v1/v2;

out.print("Output is: "+ res);

</body>

</html>

exception.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<%@ page isErrorPage="true" %> <html>

<head>

<title>Insert title here</title>

</head>

<body>

Got this Exception: <%= exception %>

<b>Please enter correct value</b>

</body>

</html>

Recommended Topics

1. Introduction to JSP

2. Life Cycle of JSP

4. Introduction to JSP Scriplet

Introduction to JSP Scriplet with Example

2020-09-24T22:35:00.001+05:30

This post explains about JSP Scriplet stay tuned for a detailed explanation of it.

JSP Scriplet is nothing Java Source Code only which will be written within <% and %> tags. So, JSP Scriplet is used to write the Java Source Code to implement business logic.

This JSP Scriplet tags are declared inside of _jspService() method. The reason JSP Scriplet declared inside of this method is that every time while generating Servlet from JSP a new object is created for each new request from the client-side.

There are 3 types of tags in JSP,

1. Declaration Tag

2. Expression Tag

3. Scriplet Tag

Each JSP Scriptet tag has their on definition to insert the code in JSP application.

Declaration Tag is used to declare variables and methods.

Expression Tag is used to display the Output of the JSP application.

Scriplet Tag is used to include Java Source Code, this is mostly used for form action pages implementation.

How to Use Scriplet tag in JSP?

JSP scriplet tag is used within <% %> tag. This will allow us to include the entire Java Source Code.

Syntax:

<% Java Source Code %>

     <%  
        out.println("Content");   
     %>

Explanation:

Scriplet tag starts with <% tag and ends with %> tag.
Normally to Print Java output, we write System.out.println() but in the case of JSP we only have to write out.println() and System class automatically provided by the JSP container.
In JSP there are 9 Implicit Objects are there out is one of them.

Different between Declaration and Scriplet Tag

Declaration Tag	Scriplet Tag
1. Declaration Tag uses <%! %> symbol to declared inside of it.	1. Scriplet tag uses <% %> Symbol to write within it.
2. In this we can declare variables as well as methods	2. In this only variables can be declared not the methods.
3. This tag is placed outside of the _jspService() method.	3. This tag is placed inside of the _jspService() method.
4. It creates only one object for multiple requests.	4. It creates multiple objects for multiple requests.

Example


<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
<%out.print("Hello, Scriplet Tag JSP code");%>
</body>
</html>

Output

   Hello, Scriplet Tag JSP code

Eclipse Code:

Output:

Recommended Topics..

1. Introduction to JSP

2. Life Cycle of JSP

Life Cycle of JSP for beginner

2020-09-12T19:41:00.002+05:30

Introduction:

JSP is a server-side technology that does all the processing at the server. It is used for creating dynamic web applications, using Java as a programming language.

JSP page is saved with .jsp extension to know the servlet that this is the JSP page to process the JSP accordingly.

In my previous post, I have explained in detail about JSP. If you have not seen that post, do check out. Introduction to JSP tutorial

JSP Lifecycle Phases:

1. JSP Page Translation:

A java servlet file is generated from the JSP source file. This is the first step in its tedious multiple phase life cycle. In the translation phase, the container validates the syntactic correctness of the JSP pages and tag files. The container interprets the standard directives and actions, and the custom actions referencing tag libraries used in the page.

2. JSP Page Compilation:

The generated java servlet file is compiled into a java servlet class.

Note: The translation of a JSP source page into its implementation class can happen at any time between the initial deployment of the JSP page into the JSP container and the receipt and processing of a client request for the target JSP page.

3. ClassLoading: The java servlet class that was compiled from the JSP source is loaded into the container.

4. Execution phase:

In the execution phase, the container manages one or more instances of this class in response to requests and other events. The interface JspPage contains jspInit() and jspDestroy(). The JSP specification has provided a special interface HttpJspPage for JSP pages serving HTTP requests and this interface contains _jspService().

5. Initialization:

jspInit() method is called immediately after the instance was created. It is called only once during JSP life cycle.

6. _jspService() execution:

This method is called for every request of this JSP during its life cycle. This is where it serves the purpose of creation. Oops! it has to pass through all the above steps to reach this phase. It passes the request and the response objects. _jspService() cannot be overridden.

7. jspDestroy() execution:

JSP This method is called when this JSP is destroyed. With this call, the servlet serves its purpose and submits itself to heaven (garbage collection). This is the end of jsp life cycle. jspInit(), _jspService() and jspDestroy() is called the life cycle methods of the JSP

Advantages of JSP over Servlet:

1. We can generate HTML response from servlets also but the process is cumbersome and error-prone, when it comes to writing a complex HTML response, writing in a servlet will be a nightmare. JSP helps in this situation and provides us the flexibility to write a normal HTML page and include our java code only where it’s required.

2. JSP provides additional features such as tag libraries, expression language, custom tags that helps in faster development of user views.

3. JSP pages are easy to deploy, we just need to replace the modified page in the server and the container takes care of the deployment. For servlets, we need to recompile and deploy the whole project again.

The Servlet and JSPs complement each other. We should use Servlet as a server-side controller and to communicate with model classes whereas JSPs should be used for the presentation layer.

I hope you enjoyed this post, related to the JSP topic do read other post of JSPs.

Read Topics:

Introduction to JSP Tutorial

Learn JSP Tutorial with examples- JAVA SERVER PAGES

2020-09-12T13:23:00.011+05:30

Introduction:

Java Server Pages - (JSP) is a Server-side technology to create dynamic web pages. The JSP is more like HTML only with a bit mix of java code in it. This is used for implementing the Presentation Layer which is the GUI part of an Application.

JSP's are a lot used in web applications. As this is a bit mix of HTML and Java code, it is easy to understand the language.

JSP's provides additions features to such as JSP tags, Expression Language, and Custom tags. This makes the developer to create web pages quickly.

JSP's Versions:

Sr.No.	JSP Version	Java Platform	Released Year
1	1.1	J2EE 1.2	Dec 12, 1999
2	1.2	J2EE 1.3	Sept 14, 2001
3	2.0	J2EE 1.4	Nov 11, 2003
4	2.1	Java EE 5	May 11, 2006
5.	2.2	Java EE 6	Dec 10, 2009
6.	2.3	Java EE 7	June 12, 2013
7.	3.0	Java EE 8	August 31, 2017

If you are a beginner to JSP then check out below recommended topics...

1. Life Cycle for JSP

JSP Comments:

Since JSP is built on top of HTML, we can write comments in JSP file like HTML comments as below shown:

These comments are sent to the client and we can look at it with the view-source option of browsers.

We can put comments in the JSP file as below:

This comment is suitable for developers to provide code-level comments because these are not sent in the client's response.

JSP Tags -

JSP tags are used to write Java Source code to implement business logic. Check out this post a more detailed explanation.

1. Scriptlet tag

2. Declaration tag

3. Expression tag

JSP directives -

JSP Directives are used to give special instruction to the container for translation of JSP to Servlet code, for a detailed explanation of JSP directives check out this article by clicking on it.

1. page directive

2. include directive

3. taglib directive

Action tags-

They are used for performing for action during the request processing phase of the JSP life cycle.

1. include Action tag

2. Include action tag with parameters

3. forward action tag

4. useBean, setProperty, and getProperty action tags

JSP's Implicit Object -

These Implicit objects are created by the JSP container while translating the JSP page to servlet. These objects are present inside service methods so that we can directly use them without a declaration.

1. out implicit object

2. request implicit object

3. response implicit object

4. session implicit object

5. application implicit object

6. exception implicit object

7. pageContext implicit object

8. page implicit object

9. config implicit object

Expression Language (EL) in JSP

By using Expression language we can easily access the data variables, bean components, and expression using Expression language. Recommended for JSP beginner to read this topic in detail.

Exception Handling-

We have explained the exception handling method used in JSP. Do check out this topic for a detail explanation.

JSP API Interface and Classes

All the core JSP interfaces and classes are defined in javax.servlet.jsp package. Expression Language API interfaces are classes and are part of javax.servlet.jsp.el package. JSP Tag Libraries interfaces and classes are defined in javax.servlet.jsp.tagext package.

1. JspPage Interface-

JspPage interface extends Servlet interface and declares jspInit() and jspDestroy() life cycle methods of the JSP pages.

2. HttpJspPage Interface:

HttpJspPage interface describes the interaction that a JSP Page Implementation Class must satisfy when using the HTTP protocol. This interface declares the service method of JSP page for HTTP protocol as public void_jspService(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException.

3. JspWriter abstract Class:

Similar to PrintWriter in servlets with the additional facility of buffering support. This is one of the implicit variables in a JSP page with the name “out”. This class extends java.io.Writer and container provide their own implementation for this abstract class and use it while translating the JSP page to Servlet. We can get its object using PageContext.getOut() method. Apache Tomacat concrete class for JspWriter is org.apche.jasper.runtime.JspWriterImpl. 4. JspContext abstract Class: JspContext serves as the base class for the PageContext class and abstracts all information that is not specific to servlets. The JspContext provides a mechanism to obtain the JspWriter for output, a mechanism to work with attributes, and API to manage the various scoped namespaces.

4. JspContext abstract Class:

JspContext serves as the base class for the PageContext class and abstracts all information that is not specific to servlets. The JspContext provides a mechanism to obtain the JspWriter for output, a mechanism to work with attributes and API to manage the various scoped namespaces. JSP

5. PageContext abstract Class:

PageContext extends JspContext to provide useful context information when JSP is used for web applications. A PageContext instance provides access to all the namespaces associated with a JSP page, provides access to several page attributes, as well as a layer above the implementation details. Implicit objects are added to the pageContext automatically.

6. JspFactory abstract Class:

The JspFactory is an abstract class that defines a number of factory methods available to a JSP page at runtime for the purposes of creating instances of various interfaces and classes used to support the JSP implementation.

7. JspEngineInfo abstract Class:

The JspEngineInfo is an abstract class that provides information on the current JSP engine.

8. ErrorData final Class: Contains information about an error, for error pages.

9. JspException Class:

A generic exception is known to the JSP container, similar to ServletException.If JSP pages throw JspException then errorpage mechanism is used to present error information to the user.

10. JspTagException Class:

The exception to be used by a Tag Handler to indicate some unrecoverable error.

11. SkipPageException Class:

The exception to indicate the calling page must cease evaluation. Thrown by a simple tag handler to indicate that the remainder of the page must not be evaluated. This exception should not be thrown manually in a JSP page

Recommended Topics:

1. Life cycle of JSP(Java Server Pages)

String Handling in Java explained with example.

2020-09-04T00:48:00.006+05:30

In this post, we will see a detailed explanation of String Handling in Java with an example.

Introduction

String in Java is an important concept while writing java programs and learning Java. You must know what is String in Java, How is it useful.

String, which is widely used in Java Programming, is a sequence of characters. The Java Platform provides the String class to create and manipulate the Strings.

For Example "welcome" is a string containing a sequence of characters which is 'w','e','l','c','o','m','e'. And String are represents as double-quotes.

For example,

String name="John";

String Objects are Immutable:

String objects are fixed. Every time we create a string, a new object is created. Working on an immutable string is efficient than that of a mutable String.

Mutable classes: StringBuffer and StringBuilder

String in Java is a final and immutable class means we can not change or alter the object. It cannot be inherited once it is created.

Creating Strings:

There are two ways to create String,

1. String Object:

Create String Object Using new keyword

As with any other object, you can create String Objects by using the new keyword and a constructor.

For Example,

String strObj = new String("Hello World");

2. String Literals:

Create a String object using double quotes

String strName1="Beautiful";

String strName2="Beautiful";

Whenever it encounters a string literal in your code, the compiler creates a String object with its value in the constant pool.

Whenever there are two string literals with the same value assigned to it. The compiler will assign that two two string objects to the same string value.

for instance in the above string literal example,

If the (strName1)object already exist in the memory it does not create a new Object rather it assigns the same old object to the new instance, that means even though we have two string instances above(strName1 and strName2) compiler only created on string object (having the value “Beautiful”) and assigned the same to both the instances. For example, there are 20 string instances that have the same value, it means that in-memory there is only one object having the value and all the 20 string instances would be pointing to the same object.

else If you want to have two different objects with the same string..for that we need to use the new keyword to create two different objects as explained above.

Java String Example:

Eclipse IDE Code:

Java String Methods:

Here is the list of the explained methods available in the Java String class.

Methods	DESCRIPTION
String concat(String str)	It concatenates that is Joins the two string together, join the str at the end.
int length()	It returns the size of the specified String
boolean equals(Object obj)	It compares the value of the two string, if matches it returns true else false.
boolean contains(CharSequence cs)	It checks whether the string contains the specified sequence of char values. If yes then it returns true else false. It throws NullPointerException of ‘s’ is null.
char charAt(int index)	It returns the character at the specified index. Specified index value should be between 0 to length() -1 both inclusive. It throws IndexOutOfBoundsException if index<0\|\|>= length of String.
int indexOf(int ch)	Returns the index of first occurrence of the specified character ch in the string.
int indexOf(int ch, int fromIndex)	Same as indexOf method however it starts searching in the string from the specified fromIndex.
int lastIndexOf(int ch)	It returns the last occurrence of the character ch in the string.
int lastIndex(int ch, int fromIndex)	Same as lastIndexOf(int ch) method, it starts search from fromIndex.
int indexOf(String str)	This method returns the index of first occurrence of specified substring str.
int lastIndex(String str)	Returns the index of last occurrence of string str.
boolean startWith(String prefix)	It tests whether the string is having specified prefix, if yes then it returns true else false.
boolean endsWith(String suffix)	Checks whether the string ends with the specified suffix.
String substring(int beginIndex)	It returns the substring of the string. The substring starts with the character at the specified index.
String substring(int beginIndex, int endIndex)	Returns the substring. The substring starts with character at beginIndex and ends with the character at endIndex.
byte[] getBytes()	This method is similar to the above method it just uses the default charset encoding for converting the string into sequence of bytes.
byte[] getBytes(String charSetName)	It converts the String into sequence of bytes using the specified charset encoding and returns the array of resulted bytes.
static String valueOf()	This method returns a string representation of passed arguments such as int, long, float, double, char and char array
int hashCode()	It returns the hash code of the string.
String replace(char newchatr, char oldchar)	It returns the new updated string after changing all the occurrences of oldChar with the newChar.
String replaceFirst(String regex, String replacement)	It replaces the first occurrence of substring that fits the given regular expression “regex” with the specified replacement string.
String replaceAll(String regex, String replacement)	It replaces all the occurrences of substrings that fits the regular expression regex with the replacement string.
String[] split(String regex, init limit)	It splits the string and returns the array of substrings that matches the given regular expression. limit is a result threshold here.
String[] split(String regex)	Same as split(String regex, int limit) method however it does not have any threshold limit.
String toLowerCase(Locale locale)	It converts the string to lower case string using the rules defined by given locale.
public static String format()	This method returns a formatted java String
String trim()	Returns the substring after omitting leading and trailing white spaces from the original string.
String toUpperCase(Locale locale)	Converts the string to upper case string using the rules defined by specified locale.
String toUpperCase()	Equivalent to toUpperCase(Locale.getDefault()).
public String intern()	This method searches the specified string in the memory pool and if it is found then it returns the reference of it, else it allocates the memory space to the specified string and assign the reference to it.
public Boolean isEmpty()	This method returns true if the given string has 0 length. If the length of the specified Java String is non-zero then it returns false.
public static String join()	This method joins the given strings using the specified delimiter and returns the concatenated Java String
boolean matches(String index)	It checks whether the String is matching with the specified regular expression regex.
int codePointAt(int index)	It is similar to the charAt method however it returns the Unicode code point value of specified index rather than the character itself.
boolean contentEquals(StringBuffer sb)	It compares the string to the specified string buffer.
boolean regionMatches(int sroffset, String dest, int destoffset, int len)	It compares the substring of input to the substring of specified string
boolean regionMatches(boolean ignoreCase, int sroffset, String dest, int destoffset, int len	Another variation of regionMatches method with the extra boolean argument to specify whether the comparison is case sensitive or case insensitive.
boolean equalsIgnoreCase(String str)	It works same as equals method but it doesn’t consider the case while comparing strings. It does a case insensitive comparison.
int compareTo(String str)	This method compares the two strings based on the Unicode value of each character in the strings.
int compareToIgnoreCase(String str)	Same as CompareTo method however it ignores the case during comparison.
boolean startsWith(String prefix, int offset)	It checks whether the substring (starting from the specified offset index) is having the specified prefix or not.
static String copyValueOf(char[] data)	It returns a string that contains the characters of the specified character array.
static String copyValueOf(char[] data, int offset, int count)	Same as above method with two extra arguments – initial offset of subarray and length of subarray.
void getChars(int srcBegin, int srcEnd, char[] dest, int destBegin)	It copies the characters of src array to the dest array. Only the specified range is being copied(srcBegin to srcEnd) to the dest subarray(starting fromdestBegin).
char[] toCharArray()	Converts the string to a character array.

That's all about a detailed explanation of String Handling in Java, We discussed all string methods and the introduction of String in java in an easily understandable concept. I hope you enjoyed this post!!

Recommended String Programs:

Check entered String is Magic or not

Detailed Explanation of Inheritance in Java with example - JavaTechSeries

2020-09-01T23:43:00.003+05:30

Introduction -

Inheritance in java is the most important concept and pillar of OOPs(Object Oriented Programmings).

The process of acquiring properties i.e data members and functionalities i.e methods of one class to another class is known as Inheritance in Java.

The main advantage of Inheritance is to provide code reusability. There are two class will be used in Inheritance below as follows

1. Child class - The class that extends the feature of another class is known as Child class, subclass, and derived class.

2. Parent class - The class that data members and methods are used (extended) by another class is known as a parent class, superclass, and Base class.

Inheritance represents the IS-A relationship, also known as the parent-child relationship.

The extends keyword is used to get all features of the parent class. Here child class will use the extends keyword to extends from the parent class.

A real-Life example could be: son and father, that is all properties of a father are inherited by his son.

Note: Parent class reference can be used to hold child class object but by using that reference we are not allowed to call child class-specific methods.

Let's understand by example.

Syntax:

class Child-class name extends Parent-Class name

{

}

With Example:

Dog is the child class and Animal is the parent class. Now the relationship between these two classes is Dog IS-A Animal. That means Dog is a type of Animal but Animal is not a type of Dog.

class Animal

{

public void eat()

{

System.out.println("I can eat: Parent class");

}

class Dog extends

{

public void bark()

{

System.out.println("I can bark: Child class");

}

public class DemoCheck

{

public static void main(String args[])

{

Dog dogObj=new Dog();

dogObj.eat();

dogObj.bark();

}

Output:

I can eat: Parent class

I can bark: Child class

Eclipse Code:

In this example, we have a base class as Animal and a Subclass as Dog. As Dog is extends the eat functionalities of Animal class. So Dog class no need to explicitly write eat method. Dog class can acquire the eat method features by extending the class Animal using extends keyword.

Types of Inheritance in Java:

To Learn Inheritance in detail, you can refer to Types of Inheritance of Java.

1). Single Inheritance

This type of inheritance is referred to when a class extends only and another class. Class B extends Class A.

Single Inheritance

2). Multilevel Inheritance

This is the type of Inheritance is referred to relationship between the child and parent class.

Multilevel Inheritance

3). Hierarchical Inheritance

This type of inheritance explains the relationship between the child and parent class. Where one class extends more than one class.

Hierarchical Inheritance

4). Multiple Inheritance

This type of inheritance explains the relationship between one class with a two-parent class. That means Class c will extends from class A and Class B.

Multiple Inheritance

5). Hybrid inheritance: Combination of more than one types of inheritance in a single program. For example, class A & B extends class C and another class D extends class A then this is a hybrid inheritance example because it is a combination of single and hierarchical inheritance.

NOTE: Java does not support Multiple Inheritance as if parents have a method with the same name and same type signatures then it creates ambiguity when the subclass tries to access that method as it gets confused about which method to call.

That is all about a detailed explanation of Inheritance in Java and its types. Also, you can check out the recommended topics.

Recommended Topics

1. Core Java Tutorial

2. OOPs Concepts in detail

3. Java Programming

Java OOPs concepts with example

2020-08-31T08:27:00.010+05:30

Java OOPs concepts with an example.

To learn Java the basic requirement or you can say the pillar of java is to learn or to know about Java OOPs Concepts. This is Java Core basic, here you will see the OOps concepts with easy explanation and with an example.

Here first comes to mind what is an OOPs concept in java??

OOPs means Object Oriented Programming language used in modern programming like java. And it is the Programming concept in java that explains the Abstraction, Encapsulation, Inheritance, and polymorphism.

OOPs allows users to create the objects that they want to use and then create those methods to handle those objects.

Java is known as a truly object-oriented language. It is fully object-oriented, but still, primitive types are used as primitive for simplicity though in java we have Wrapper classes to use primitive types as objects.

The basic concept of OOPs is to create objects, re-use them throughout the program, and manipulate these objects to get results.

OOPs Concepts:

1. Abstraction

Hiding the implementation and showing the function definition to the user is known as Abstraction. An abstraction is an act of representing essential features without including background details. It is a technique of creating a new data type that is suited for a specific application. For example, while driving a car, you do not have to be concerned with its internal working. Here you just need to concern about parts like steering wheel, Gears, accelerator, etc.

2. Encapsulation

The concept of binding the data along with its related and corresponding method is known as Encapsulation. Encapsulation is an OOP technique of wrapping the data and code. In this OOPS concept, the variables of a class are always hidden from other classes. It can only be accessed using the methods of their current class. For example - in school, a student cannot exist without a class.

3. Inheritance

Inheritance is an OOPS the concept in which one object acquires the properties and behaviors of the parent object. It is also known as IS-A Relationship. It is creating a parent-child relationship between two classes. It offers a robust and natural mechanism for organizing and structure of any software.

4. Polymorphism

Defining multiple methods with the same name is known as Polymorphism. Polymorphism refers to the ability of a variable, object, or function to take on multiple forms. For example, in English, the verb run has a different meaning if you use it with a laptop, a foot race, and a business. Here, we understand the meaning of run based on the other words used along with it. The same also applied to Polymorphism.

Two types of Polymorphism:

1). Static Polymorphism

2). Dynamic Polymorphism

5. Association

Association is a relationship between two objects. It defines the diversity between objects. In this OOP concept, all object have their separate lifecycle, and there is no owner. For example, many students can associate with one teacher while one student can also associate with multiple teachers.

6. Aggregation

In this technique, all objects have their separate lifecycle. However, there is ownership such that child objects can’t belong to another parent object. For example, consider the class/object department and teacher. Here, a single teacher can’t belong to multiple departments, but even if we delete the department, the teacher object will never be destroyed.

7. Composition

A composition is a specialized form of Aggregation. It is also called a "death" relationship. Child objects do not have their lifecycle so when the parent object deletes all child objects will also delete automatically. For that, let’s take an example of House and rooms. Any house can have several rooms. One room can’t become part of two different houses. So, if you delete the house room will also be deleted.

Advantages of OOPs

1. OOP offers code reusability, method overloading, and method overriding concept which reduces and makes the code readable and easy to understand.

2. OOP offers easy to understand and a clear modular structure for programs.

3. Objects created for Object-Oriented Programs can be reused in other programs. Thus it saves significant development costs.

4. Large programs are difficult to write, but if the development and designing team follow the OOPS concept then they can better design with minimum flaws.

5. It also enhances program modularity because every object exists independently.

That is all OOPs concept with advantages.

Recommended article:

1. Core Java in detail

2.Inheritance with Program explanation

3.Abstraction concept with Program explanation

4.Encapsulation concept in detail with Program explanation

5.Polymorphism concept with Program explanation

Spring Framework Tutorial

2020-08-29T20:50:00.001+05:30

Introduction -

Spring framework is the most popular Java EE(Java Enterprise Edition) frameworks.

Spring is an open-source development framework for Enterprise Java.

The core features of the Spring Framework can be used in developing any Java EE platform. Spring framework targets to make Java EE development easier to use and promotes good programming practice by enabling a POJO- based programming model.

The Spring Framework was written by Rod Johnson in October 2002, Since then Spring has become an alternative technology as used in most Software Companies.

You can read more about the Spring Framework.

If you are preparing an interview question in spring, then you may visit this Spring Interview Questions and Answers.

Features –

· Lightweight

Spring is lightweight when it comes to size and transparency because of its POJO implementation. The basic version of the Spring Framework is 2MB.

· Inversion of Control

Loose coupling is achieved in Spring, with the Inversion of Control or Dependency Injection. The basic concept of the Dependency Injection or Inversion of Control is that, no need to create objects means someone else will create the objects for you and you just have to use that object, there comes IoC and DI in the picture.

Means the Spring IOC and DI will be responsible for creating objects.

· Aspect Oriented Programming (AOP)

Spring AOP enables Aspect-Oriented Programming in spring application.

AOP is a promising technology for separating crosscutting concerns, something usually hard to do in object-oriented programming. The application’s modularity is increased in that way and its maintenance becomes significantly easier.

Means: AOP does not mix non-business logic with actual Business logic in your Classes. To read more about Aspect Oriented Programming.

· Spring MVC Framework

Spring comes with MVC(i.e Model And View) which is used for creating web applications, built on core Spring functionality. Spring MVC Framework has ready components that can be used to develop flexible and loosely coupled web applications.

· Container

Spring container and manages the life cycle and configuration of the application objects.

· Transaction Management:

Spring provides a consistent transaction management interface that can scale down to a local transaction and scale up to global transactions (JTA). It is a unit of work in which either all operation/work must execute or none of them.

· JDBC Exception Handling

Spring provides a convenient API to translate technology-specific exception which is thrown by JDBC, HIbernate, or JDO into consistent, unchecked exceptions, which simplifies the error handling strategy.

Spring Framework Architecture -

Spring is a well-organized architecture consisting of seven modules. Modules in the Spring framework are:

· Spring Web

One of the key components of Spring is the AOP framework. AOP is used in Spring. TO provide declarative enterprise services, especially as a replacement for EJB declarative services the most important such service is declarative transaction management, which builds on Spring's transaction abstraction.

To allow users to implement customs aspects, complementing their use of OOP with AOP

· Spring ORM

The ORM package is related to the database access. It provides integration layers for popular object-relational mapping APIs, including JDO, Hibernate and iBatis.

· Spring Web

The Spring Web module is part of Spring?s web application development stack, which includes Spring MVC.

· Spring DAO

The DAO (Data Access Object) support in Spring is primarily for standardizing the data access work using technologies like JDBC, Hibernate or JDO.

· Spring Context

This package builds on the beans package to add support for message sources and for the observer design pattern, and the ability for application objects to obtain resources using a consistent API.

· Spring Web MVC

This is the Module that provides the MVC implementations for the web applications.

· Spring Core

The core package is the most important component of the Spring Framework.

This component provides Dependency Injection features. The BeanFactory provides a factory pattern that separates the dependencies like initialization, creation, and access of the object from your actual program logic.

Useful topics:

21 Spring Interview Questions and Answers

Check entered String is magic string or not

2020-08-28T20:33:00.004+05:30

Write a Program in Java to enter a string and check whether it is magic string or not?

In this post, we will see whether the entered string is a magic string or not.

The Scanner class used to get user input, and it is found in the java.util package.

To use the Scanner class, create as an object of the class and use any of the available methods found in the Scanner class documentation.

Example: Check entered String is a magic string or not

    import java.util.Scanner;
    public class UserInputString {
        public static void main(String args[]) {
              Scanner in = new Scanner(System.in);
             System.out.print("EnterString: ");
             String name= in.nextLine();
             String str = "magic";
             str.trim();
          if (name.equals(str)){
                 System.out.println("Entered String is magic string");
            }
          else {
                   System.out.println("Entered String is not magic string");
                }
             in.close();
         }
    }Output:

Enter the String: Kerla
Entered String is magic string

Eclipse Code:

Useful Programs:

Java Program to Multiply Two Number

Java Program to Check Even or Odd number

Java Program to check whether input character is vowel or consonant

Java Program to Check Even or Odd number

How to Install MySQL on Windows 10 step by step tutorial

2020-08-21T01:16:00.022+05:30

How to install MySQL on Windows 10.

In this post, we will learn how to How to Install Mysql on Windows 10. The same procedure can be used for installing MySQL on Windows 8/ Windows 7. But first, let’s see What is MySQL.

MySQL is a very popular, Open Source Database. Officially pronounced as “my Ess Que Ell” (not my sequel).

Handles very large database; very fast performance. Why are using MySQL? Free(much cheaper than Oracle!) Each student can install MySQL locally. Easy to use Shell for creating tables, etc.

Easy to use with JDBC. While installing MySQL, it will prompt you to create a root password. At this stage please select a safe and secure password.

Make sure you remember the password, to use it later. MySQL Tutorial for beginners and professionals with examples on CRUD, insert statement, select statement, Update Statement, Delete Statement, use database, keys, joins etc.

Let’s Start….

Step1:

Type Download MySQL in your browser.

Step2:

Select the Operating System whichever you are using then You will see go to Download Page button like shown in the below image.

Now you will see two windows installer here,

First windows Installer which containing 24.5MB megabytes. This will require an internet connection to install MySQL.

Second Windows Installer which containing 427.6MB. This will not require an internet connection to install this installer.

Step3:

After selecting any of Windows Installer you will be redirected to Downloads page as shown below in the image, then click on No thanks, just start my download.

Step4:

Then downloading will start, then double click on the MySQL installer.

Windows Installer will Prepare to install MySQL.

Step5:

After finding all packages below shown image window will appear saying Choosing a Setup Type. You need to select which setup you want to install MySQL.

Default selected will be Developer Default option, Accordingly will see the description of each Setup. I am choosing the default option here.

Step6:

If you didn't get the license agreement page, don't need to worry, you can go ahead continue installing the next step.

I got this Path Conflicts because earlier I have already installed, You can choose your default path.

Path Conflicts

Step7:

You will get Pop up saying one or more product requirements have not been satisfied. You need not to worry about it, click yes and go ahead.

Check Requirements:

Step8:

You will see All MySQL products which need to download on clicking on Execute button. It will start downloading each product, You can see Downloaded in Status as shown in the below image.

Installation and click on Execute:

Step9:

After the successful installation of each Product, You will see the Product Configuration window.

Product Configuration:

Step10:

It will check the Availability of MySQL. The default selected will be Standalone MySQL Server/Classic MySQL Replication. And you want Cluster kind of DB then choose that. I am continuing with default selected i.e first as shown in the below image.

Click on Next then: High Availability:

Step11:

Next will be Server Configuration type, In Config Type you can select Machine type, which is Developement Machine, Server Machine, and Dedicated Machine. Each will be varying some memory usage. Port is showing default Port:3306. You don't need to change, as there is no good reason to change the port. I chose default selected option. Development Computer You can go with the same as this is less memory usage and can do practice, Then click next.

Click on Next: Type and Networking:

Step12:

Authentication Method says default selected Use Strong Password Encryption for Authentication which is Recommended. Then click on the Next button to set the password for root account.

Step12:

Here it will ask to enter the Root account password, I have entered root as password and then click on check. Then click on the Next button for installer windows service.

Step13:

Now You will see Windows Service here, I will leave the default selected, Windows Service Name MySQL80 is coming from the MySQL version, currently, we are using 8.0.21 that's why it is showing MYSQL80. There is custom User selection also that is for an existing user account which is for advanced scenarios.

Step14:

Now you will see the configuration steps here, Click on Execute Button, it will execute all the steps. As shown in the below image you see steps have been completed.

Writing Configuration file

Updating Windows Firewall rules

Adjusting Windows Service

Starting the Service: When you will start the MySQL client, you will be directly able to connect to MySQL server.

Uploading the Start Menu link

Then click on finish.

Step15:

Now you will see MySQL Server 8.0.21 configuration is completed as shown in the below image.

Step16:

After the Product configuration MySQL Server 8.0.21 complete and MySQL Router 8.0.21, Samples and Examples configuration need to be complete as shown in step15. It will show that both the configuration is complete or not for MySQL Router and Sample, Examples.

After that MySQL Router Configuration will also get installed click on finish.

Step17:

After Router configuration completed, sample and Examples will also complete then enter the password of the root account, I have entered here root as password and then click on the check button, after Checked successfully then click on the next.

After clicking on the check button you will see the Connection succeeded. Then click on the Next button.

Step18:

Again the Configuration steps will get finished for the Samples and Example of Product Configuration and then click on Finish.

Step19:

And then You can see the Installation has been completed successfully as shown in the below image.

It says Start MySQL Workbench after Setup and Start MySQL Shell after Setup.

So when you click on Finish button, you will be able to see MySQL Workbench and MySQL Shell also.

Step20:

Now you will be able to see the MySQL Shell and also the MySQL Workbench.

You can go to the Start windows menus and search Workbench you will be able to see and you can also see the MySQL Command-line Client and can do the practice.

This is MySQL Command-Line, which will ask the password at start, you entered the password which you set then click enter.

Now After entering password you are ready to use the MySQL and create database and perform all insert, update and delete queries.

New Posts related to MySQL DB queries are coming soon...😀

Java Program to Multiply Two Number

2020-08-12T16:00:00.015+05:30

Here you will get two types of Java Program i.e one program will be to read two integers and multiply them and output of the multiplication. You surely get these types of programs in the assignment while learning the Java language. By practice, this type of Java Program example can understand the language also. And the second An example is to take any two numbers that can be an integer or floating display the output of it.

Let’s start the example one:

Example 1: Program to read two integers and print the Multiplication of them:

This program will ask the user to enter two integer numbers and display the multiplication of that two number, to take user input we are using Scanner class of java, to know more about Scanner class and example of reading an integer from the system input.

import java.util.Scanner;

public class MultiplicationOfTwoNum{

    public static void main(String[] args) {

        /* This reads the input provided by user
         * using keyboard
         */
        Scanner scan = new Scanner(System.in);
        System.out.print("Enter first number: ");

        // This method reads the number provided using keyboard
        int num1 = scan.nextInt();
        
        System.out.print("Enter second number: ");
        int num2 = scan.nextInt();

        // Closing Scanner after the use
        scan.close();
        
        // Calculating product of two numbers
        int product = num1*num2;
        
        // Displaying the multiplication result
        System.out.println("Output: "+product);
    }
}

Output:

Enter first number: 12
Enter second number: 5
Output: 60

Find here Eclipse Code:

Here 2nd Example: Read two integer or floating-point numbers and display the multiplication

In the above program, we can only integers. What if we want to calculate the multiplication of two float numbers? This program allows you to enter float numbers and calculates the product.

Here we are using data type double for numbers so that you can enter integer as well as floating-point numbers.

import java.util.Scanner;

public class FloatingNumMultiplication{

    public static void main(String[] args) {

        /* This reads the input provided by user
         * using keyboard
         */
        Scanner scan = new Scanner(System.in);
        System.out.print("Enter first number: ");

        // This method reads the number provided using keyboard
        double num1 = scan.nextDouble();
        
        System.out.print("Enter second number: ");
        double num2 = scan.nextDouble();

        // Closing Scanner after the use
        scan.close();
        
        // Calculating product of two numbers
        double product = num1*num2;
        
        // Displaying the multiplication result
        System.out.println("Output: "+product);
    }
}

Output:

Enter first number: 3.5
Enter second number: 1.5
Output: 5.25

JavaTechSeries

Use of this keyword in Java

Use of this keyword

Parameter Passing :

Passing Parameters by Value:

Passing objects:

Java instanceOf operator:

instanceof with reference variable :

instanceof with a variable that have null value :

What is Classes, Constructors and Methods in Java explained in detailed.

Recommend Topics:

Exception Handling in Java

1. Introduction :

2. Exception and error:

3. Exception class Hierarchy:

4. Types of Exceptions:

5. Inbuilt Methods:

6. Exception handling mechanism:

6.1 Try block:

6.2 Catch block:

6.3 throw clause :

6.4 throws clause: '

7. User-Defined Exceptions:

8. Chained Exceptions:

9. Exception Propagation:

Recommend Topics:

Servlet Questions and Answers for Beginner Level

1. What is Servlet?

2. What is the difference between web server and application server?

3. Difference between CGI and Servlet?

4. Why servlet is mostly used?

5. What is called a servlet container?

6. What is MIME Type?

7. What is a web application and what is it’s directory structure?

8. What are common tasks performed by Servlet Container?

9. Explain Life Cycle of Servlet?

10. When init() method of servlet gets called?

11. When service() method of servlet gets called?

12. When doGet() method of servlet to be called?

13. When doPost() method of the servlet to be called?

14. When destroy() method of servlet gets called?

15. For what purpose init() method of a servlet is used?

16. For what purpose destroy() method of a servlet is used?

18. What is ServletConfig object?

19. What is ServletContext object?

20. What is difference between ServletConfig and ServletContext?

21. What is Request Dispatcher?

22. How can we create deadlock situation in servlet?

23. What is the use of servlet wrapper classes?

Recommended Topics-

Advantages of OOP - Detailed Top 7 Advantages of OOP

What is OOP??

Advantages of OOP

1. Re-Usability

2. Data Redundancy:

3. Code Maintenance:

4. Design Benefits

5. Better productivity

6. Easy troubleshooting

7. Problems solving

Recommended TOPICS-

13 Basic Java Programs for beginner

103+ Java Interview Questions Answers for 2 to 7 Year Experienced Programmers

HTML Tutorial for Beginner with Example

JavaTechSeries First Heading

Life Cycle of Servlet in Detail

Introduction to Servlet for Beginner

Servlet Tutorial for Beginner

JSP Implicit object with Examples

Introduction to JSP Scriplet with Example

Life Cycle of JSP for beginner

Learn JSP Tutorial with examples- JAVA SERVER PAGES

Introduction:

JSP's Versions:

JSP Comments:

JSP Tags -

JSP directives -

Action tags-

JSP's Implicit Object -

Expression Language (EL) in JSP