Learn Java with Free Lessons & Tips

When a JavaServer Pages (JSP) file is accessed for the first time, it is translated or compiled into a servlet by the JSP container. This process involves several steps:

1. Translation:

   • The JSP container translates the JSP file into a servlet class. This translation is typically done the first time the JSP page is accessed or when changes are made to the JSP file.
   • The translation process involves converting the JSP elements, including Java code embedded in <% %> tags and custom tags, into equivalent Java code.

2. Compilation:

   • The translated Java code is then compiled into bytecode by the Java compiler. This results in the creation of a Java servlet class.

3. Class Loading:

   • The compiled servlet class is loaded by the classloader of the servlet container.

4. Instantiation:

   • An instance of the servlet class is created. This instance will handle subsequent requests for the corresponding JSP page.

5. Execution:

   • The servlet instance processes incoming HTTP requests and generates dynamic content as specified in the original JSP file.

The entire process can be visualized as follows:

The ObjectInputStream and ObjectOutputStream classes in Java are part of the Java Input/Output (I/O) system and are used for reading and writing objects, respectively. These classes are primarily designed for object serialization, which is the process of converting an object's state into a byte stream and reconstructing the object from that byte stream. Serialization is essential for scenarios like storing objects in files, sending objects over a network, or saving object states between different program executions.

1. ObjectOutputStream:

   • Purpose: This class is used to serialize objects. It takes an object and writes its state to a stream in a platform-independent and standardized format.
   • Methods: The key method is writeObject(Object obj), which writes the specified object to the underlying stream.
   import java.io.Serializable;
   
   public class MyClass implements Serializable {
   // Class members and methods
   }
   
   

• ObjectInputStream:

  • Purpose: This class is used to deserialize objects. It reads a byte stream and reconstructs the original object, restoring its state.
  • Methods: The primary method is readObject(), which reads the next object from the input stream and returns it as a generic Object. The caller must cast the returned object to its appropriate type.
  ObjectInputStream ois = new ObjectInputStream(new FileInputStream("data.ser"));
  MyClass obj = (MyClass) ois.readObject();
  ois.close();
  
  

It's important to note that for an object to be serializable, its class must implement the Serializable interface. This interface acts as a marker, indicating that the class can be serialized. If a class does not implement Serializable, an exception (NotSerializableException) will be thrown at runtime.

Here's a simple example of a serializable class:

These classes are powerful tools for handling object persistence and communication in Java, allowing objects to be easily saved, transmitted, and reconstructed.

In Java, memory allocation for objects is managed by the Java Virtual Machine (JVM) through a process known as dynamic memory allocation or garbage collection.

Java objects are stored in the heap memory, which is a region of the computer's memory that is managed by the JVM.

The heap is divided into different segments, such as the Young Generation, Old Generation (Tenured), and Perm (or Metaspace).

Newly created objects are initially allocated in the Young Generation and will eventually travel to Old Generation after survival through multiple GC.

The do-while loop is a type of loop in programming that is similar to the while loop, but with one key difference: the do-while loop guarantees that the block of code inside the loop is executed at least once, regardless of whether the loop condition is true or false.

Here is a sample do while loop:

do {
// code to be executed
} while (condition);

The flow of a do-while loop is as follows:

1. Execution of Code Block:
   • The code block inside the do statement is executed.
2. Evaluation of Condition:
   • After the code block is executed, the loop condition is evaluated.
3. Loop Continuation or Termination:
   • If the condition is true, the loop will execute the code block again.
   • If the condition is false, the loop terminates, and the program continues with the next statement after the do-while loop.

This loop will print the numbers 6.

The loop will execute at least once even if the initial value of i is greater than 5. The loop condition is checked after the first execution of the code block.

Inorder to create custom runtime exception->

create a class and extend it with RuntimeException class and create a constructor with string argument which accepts message and using super keyword send the message to parent class.

Code->

class MyRuntimeException extends RuntimeException{

public MyRuntimeException(String ms){

super(msg);

}

Inorder to create custom compiletime exception->

create a class and extend it with Exception class and create a constructor with string argument which accepts message and using super keyword send the message to parent class.

Code->

class CustomException extends Exception{

public CustomException(String ms){

super(msg);

}

Using throw keyword you can throw this exception where ever you want in yout code.