Stories by Pratik T on Medium

Understanding SOLID Principles: A Detailed Explanation with Examples

Pratik T — Wed, 30 Apr 2025 04:33:14 GMT

SOLID is an acronym for five fundamental principles of ObjectOriented Programming (OOP) and design. These principles help developers create maintainable, scalable, and flexible software. Introduced by Robert C. Martin (Uncle Bob), these principles are now standard guidelines for writing clean and efficient code.

1. Single Responsibility Principle (SRP)

Definition:A class should have only one reason to change, meaning it should handle only one responsibility.

Explanation:If a class has multiple jobs, changes in one part can affect unrelated functionality. Separating responsibilities improves maintainability and testability.

❌ Violation:

In an online store, if a OrderService class is responsible for placing orders, processing payments, and sending confirmation emails, it’s doing too much.

class OrderService {
    void placeOrder() { /* order logic */ }
    void processPayment() { /* payment logic */ }
    void sendConfirmationEmail() { /* email logic */ }
}

✅ Solution:Split responsibilities

class OrderService { void placeOrder() { } }
class PaymentService { void processPayment() { } }
class EmailService { void sendEmail() { } }

🎯 Each service now has one job, making them easier to maintain and test.

2. 🔓 Open/Closed Principle (OCP)

✅ Definition:Software entities should be open for extension but closed for modification.

📝 Explanation:You should be able to add new behavior without changing existing code. Use inheritance or interfaces.

❌ Violation:

class PaymentProcessor {
    double pay(String gateway, double amount) {
        if (gateway.equals("Stripe")) return amount * 0.98;
        else if (gateway.equals("PayPal")) return amount * 0.95;
        return amount;
    }
}

Adding a new discount type requires modifying this class.

✅ Solution:

interface PaymentGateway {
    double processPayment(double amount);
}

class StripeGateway implements PaymentGateway {
    public double processPayment(double amount) { return amount * 0.98; }
}

class PayPalGateway implements PaymentGateway {
    public double processPayment(double amount) { return amount * 0.95; }
}

Now, you can add new discount types without modifying existing classes.

3. 🧬 Liskov Substitution Principle (LSP)

✅ Definition:Subclasses should be substitutable for their parent classes without breaking functionality.

📝 Explanation:You should be able to use a subclass anywhere a parent class is expected, and it should behave properly.

Example: Document Generation System

In a reporting tool, you generate multiple formats: PDF, Word, Excel. All documents should follow a common interface.

❌ Violation:

class Document {
    void print() { System.out.println("Printing..."); }
}

class SecurePDF extends Document {
    @Override
    void print() {
        throw new UnsupportedOperationException("Secure PDFs can't be printed");
    }
}

✅ Solution:

class Document { /* common functionality */ }

class PrintableDocument extends Document {
    void print() { System.out.println("Printing..."); }
}

class SecurePDF extends Document {
    // No print() method here
}

🎯 Substituting subclasses won’t break behavior expected by the system.

4. 🧩 Interface Segregation Principle (ISP)

✅ Definition:Clients should not be forced to depend on methods they do not use.

📝 Explanation:Use smaller, more specific interfaces instead of one large interface.

Example: Banking Software — Different User Roles

A BankUser interface shouldn't force all users (e.g., tellers, customers, auditors) to implement all actions.

❌ Violation:

interface BankUser {
    void withdrawCash();
    void approveLoan();
    void viewAuditLogs();
}

A teller might not approve loans, and an auditor doesn’t need to withdraw cash.

✅ Solution:

interface CashHandler {
    void withdrawCash();
}

interface LoanManager {
    void approveLoan();
}

interface Auditor {
    void viewAuditLogs();
}

🎯 Each role implements only what it needs.

5. 🔌 Dependency Inversion Principle (DIP)

✅ Definition:

Highlevel modules should not depend on lowlevel modules. Both should depend on abstractions.

📝 Explanation:Use interfaces or abstract classes to reduce tight coupling.

Example: Notification System in Enterprise Applications

An app needs to send notifications via SMS, email, or push notifications.

❌ Violation:

class NotificationService {
    EmailSender sender = new EmailSender();
    void notifyUser() { sender.sendEmail(); }
}

✅ Solution:

interface Notifier {
    void notifyUser(String message);
}

class EmailSender implements Notifier {
    public void notifyUser(String message) { /* send email */ }
}

class SMSender implements Notifier {
    public void notifyUser(String message) { /* send SMS */ }
}

class NotificationService {
    private Notifier notifier;
    public NotificationService(Notifier notifier) {
        this.notifier = notifier;
    }

    void send(String message) {
        notifier.notifyUser(message);
    }
}

🎯 This design allows switching between notification types easily and is easier to test with mocks.

🏁 Conclusion

SOLID principles help create better software architecture.

Here’s a quick recap:

✅ SRP: One class = one responsibility

✅ OCP: Extend behavior without changing existing code

✅ LSP: Subtypes must be replaceable without errors

✅ ISP: Avoid forcing classes to use methods they don’t need

✅ DIP: Depend on abstractions, not concrete classes

➡️ Applying these principles makes code easier to understand, reuse, test, and maintain.

Exception Handling in REST API

Pratik T — Sat, 01 Mar 2025 07:37:07 GMT

Exception handling is a critical aspect of building robust and userfriendly REST APIs. When something goes wrong in your application — be it a validation error, a database issue, or an unexpected server error — it’s essential to handle these exceptions gracefully and provide meaningful feedback to the client. In this article, we’ll explore how to handle exceptions in REST APIs using Spring Boot, along with best practices and examples.

Why is Exception Handling Important?

1. Improved User Experience: Clients receive clear and meaningful error messages instead of cryptic stack traces.

2. Debugging and Maintenance: Proper exception handling makes it easier to identify and fix issues.

3. Consistency: Standardized error responses ensure consistency across your API.

Key Concepts in REST API Exception Handling

1. HTTP Status Codes

HTTP status codes are used to indicate the result of a client’s request. Some common status codes include:

2xx (Success): 200 OK, 201 Created

4xx (Client Errors): 400 Bad Request, 404 Not Found

5xx (Server Errors): 500 Internal Server Error

2. Error Response Structure

A well structured error response typically includes:

Status Code: The HTTP status code.

Message: A human readable error message.

Details: Additional information about the error (optional).

Timestamp: When the error occurred (optional).

Example:

{
  "status": 404,
  "message": "Resource not found",
  "details": "The requested resource with ID 123 does not exist.",
  "timestamp": "2023-10-25T12:34:56Z"
}

Exception Handling in Spring Boot

Spring Boot provides several mechanisms to handle exceptions in REST APIs. Let’s explore them step by step.

1. Custom Exception Class

Create a custom exception class to represent specific errors in your application.

public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException(String message) {
        super(message);
    }
}

2. Global Exception Handler

Use the @ControllerAdvice and @ExceptionHandler annotations to create a global exception handler. This ensures that all exceptions are handled consistently across your application.

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity handleResourceNotFoundException(ResourceNotFoundException ex) {
        ErrorResponse errorResponse = new ErrorResponse(
            404,
            ex.getMessage(),
            "The requested resource was not found.",
            LocalDateTime.now()
        );
        return new ResponseEntity<>(errorResponse, HttpStatus.NOT_FOUND);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity handleGenericException(Exception ex) {
        ErrorResponse errorResponse = new ErrorResponse(
            500,
            "An unexpected error occurred.",
            ex.getMessage(),
            LocalDateTime.now()
        );
        return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

3. Error Response Class

Create a class to represent the error response structure.

public class ErrorResponse {
    private int status;
    private String message;
    private String details;
    private LocalDateTime timestamp;

    // Constructor, Getters, and Setters
}

4. Throwing Exceptions in Service Layer

Throw custom exceptions in your service layer when specific conditions are met.

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public User getUserById(Long id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new ResourceNotFoundException("User not found with ID: " + id));
    }
}

5. Example: REST Controller

Use the service layer in your controller and let the global exception handler manage exceptions.

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public ResponseEntity getUserById(@PathVariable Long id) {
        User user = userService.getUserById(id);
        return new ResponseEntity<>(user, HttpStatus.OK);
    }
}

Best Practices for Exception Handling

1. Use Specific Exceptions: Create custom exceptions for specific error scenarios (e.g., ResourceNotFoundException, ValidationException).

2. Return Meaningful Error Messages: Provide clear and actionable error messages to the client.

3. Log Exceptions: Log exceptions for debugging and monitoring purposes.

4. Use HTTP Status Codes Correctly: Follow REST conventions for status codes (e.g., 404 for missing resources, 400 for bad requests).

5. Avoid Exposing Sensitive Information: Do not include stack traces or internal details in production error responses.

Example: Complete Workflow

Step 1: Client Sends a Request

GET /users/123

Step 2: Service Layer Throws an Exception

public User getUserById(Long id) {
    return userRepository.findById(id)
        .orElseThrow(() -> new ResourceNotFoundException("User not found with ID: " + id));
}

Step 3: Global Exception Handler Catches the Exception

@ExceptionHandler(ResourceNotFoundException.class)
public ResponseEntity handleResourceNotFoundException(ResourceNotFoundException ex) {
    ErrorResponse errorResponse = new ErrorResponse(
        404,
        ex.getMessage(),
        "The requested resource was not found.",
        LocalDateTime.now()
    );
    return new ResponseEntity<>(errorResponse, HttpStatus.NOT_FOUND);
}

Step 4: Client Receives the Error Response

{
  "status": 404,
  "message": "User not found with ID: 123",
  "details": "The requested resource was not found.",
  "timestamp": "2023-10-25T12:34:56Z"
}

Conclusion

Exception handling is a crucial part of building reliable and userfriendly REST APIs. By using custom exceptions, global exception handlers, and structured error responses, you can ensure that your API provides meaningful feedback to clients and simplifies debugging for developers.

In this article, we covered:

The importance of exception handling.

How to implement exception handling in Spring Boot.

Best practices for designing error responses.

With these techniques, you can build REST APIs that are robust, maintainable, and easy to use. Happy coding!

If you found this article helpful, feel free to share it with your network. Let me know your thoughts in the comments below!

Spring vs. Spring Boot: Understanding the Key Differences with Examples

Pratik T — Sat, 01 Mar 2025 05:45:56 GMT

If you’re a Java developer, chances are you’ve heard of Spring Framework and Spring Boot. Both are part of the Spring ecosystem, but they serve different purposes and cater to different needs. While Spring Framework is the foundation for building Java applications, Spring Boot is a game-changer that simplifies the development process. In this article, well dive deep into the differences between Spring and Spring Boot, explore their use cases, and provide practical examples to help you understand when and why to use each.

What is Spring Framework?

Spring Framework is a comprehensive, modular framework for building enterprise-level Java applications. It provides infrastructure support for dependency injection, transaction management, web applications, data access, messaging, and more. However, with great power comes great responsibility — Spring Framework requires developers to configure many components manually, which can be time-consuming.

Key Features of Spring Framework
— Dependency Injection (DI): Promotes loose coupling and easier testing.
— Aspect-Oriented Programming (AOP): Enables modularization of cross-cutting concerns.
— Data Access: Simplifies database access with JDBC, ORM, and transaction management.
— Web Framework: Supports MVC architecture for building web applications.

Example of Spring Framework
Heres an example of a manually configured Spring MVC application:

@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "com.example")
public class AppConfig implements WebMvcConfigurer {
    // Define beans and configurations manually
}

// Main class to deploy on an external server
public class Main {
    public static void main(String[] args) {
        // Deploy as WAR to Tomcat
    }
}

In this example, you need to manually configure the DispatcherServlet, view resolvers, and other beans. Additionally, you must deploy the application to an external server like Apache Tomcat.

What is Spring Boot?

Spring Boot is an extension of the Spring Framework designed to simplify the development of Spring-based applications. It provides defaults and auto-configuration to reduce boilerplate code and setup time. Spring Boot is particularly useful for creating stand-alone, production-grade applications with minimal effort.

Key Features of Spring Boot
— Auto-Configuration: Automatically configures beans based on dependencies.
— Embedded Server: Comes with Tomcat, Jetty, or Undertow by default.
— Starter Dependencies: Simplifies dependency management.
— Spring Boot Actuator: Provides built-in monitoring and management tools.

Example of Spring Boot
Heres an example of a Spring Boot application:

@SpringBootApplication
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }
}

@RestController
public class MyController {
    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, Spring Boot!";
    }
}

In this example, Spring Boot automatically configures the embedded server, data source, and other components. You can run the application as a standalone JAR file without needing an external server.

Key Differences Between Spring and Spring Boot

Lets break down the differences between Spring Framework and Spring Boot in detail:

1. Configuration
— Spring Framework: Requires explicit configuration for most components (e.g., XML or Java-based configuration).
— Spring Boot: Uses auto-configuration to reduce manual setup.

Example:
— In Spring Framework, you manually configure a DataSource:

- In Spring Boot, you simply add the configuration in

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
 spring.datasource.username=root
 spring.datasource.password=password
 spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

2. Dependency Management
— Spring Framework: Developers need to manually manage dependencies and resolve version conflicts.
— Spring Boot: Provides starter dependencies to simplify dependency management.

Example:
— In Spring Framework, you add dependencies manually:


    org.springframework
    spring-webmvc
    5.3.20

In Spring Boot, you use starter dependencies:


    org.springframework.boot
    spring-boot-starter-web

3. Embedded Server
— Spring Framework: Does not include an embedded server. You need to deploy the application to an external server like Tomcat.
— Spring Boot: Comes with an embedded server (Tomcat, Jetty, or Undertow) by default.

4. Development Speed
— Spring Framework: Requires more time for setup and configuration.
— Spring Boot: Speeds up development with defaults and auto-configuration.

5. Use Cases
— Spring Framework: Suitable for large, complex applications where fine-grained control over configuration is required.
— Spring Boot: Ideal for microservices, REST APIs, and rapid prototyping.

When to Use Spring Framework vs. Spring Boot?

- Use Spring Framework when:
— You need full control over configuration.
— You’re building large, complex applications with custom requirements.

Use Spring Boot when:
— You want to quickly develop stand-alone, production-ready applications.
— Youre building microservices or REST APIs.
— You want to reduce boilerplate code and configuration.

Thus,

Conclusion

Both Spring Framework and Spring Boot are powerful tools in the Java ecosystem, but they cater to different needs. Spring Framework provides the foundation and flexibility for building complex applications, while Spring Boot simplifies and accelerates the development process. By understanding their differences and use cases, you can choose the right tool for your project and build robust, scalable applications with ease.

Whether you’re building an enterprise-level application with Spring Framework or a microservice with Spring Boot, the Spring ecosystem has you covered. Happy coding! 🚀

If you found this article helpful, feel free to share it with your network. Let me know your thoughts in the comments below!

How to Use Thymeleaf with Spring Boot

Pratik T — Sat, 22 Feb 2025 11:05:27 GMT

Thymeleaf is a modern server-side Java template engine that is widely used with Spring Boot for rendering HTML views. It integrates seamlessly with Spring MVC and provides a natural way to create dynamic web pages. In this tutorial, we’ll walk through the steps to set up a Spring Boot project with Thymeleaf, create a simple web application, and explore some of Thymeleaf’s key features.

Step 1: Set Up a Spring Boot Project

To get started, create a Spring Boot project using Spring Initializr:

1. Go to https://start.spring.io/.

2. Add the following dependencies:

- Spring Web (for building web applications).

- Thymeleaf (for templating).

3. Generate the project and download the ZIP file.

4. Extract the ZIP file and open it in your favorite IDE (e.g., IntelliJ IDEA, Eclipse).

Step 2: Project Structure

Your project structure should look like this:

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           └── demo
│   │               ├── DemoApplication.java
│   │               ├── controller
│   │               │   └── HomeController.java
│   │               └── model
│   │                   └── User.java
│   └── resources
│       ├── static
│       ├── templates
│       │   └── home.html
│       └── application.properties
└── test
    └── java

Step 3: Add Thymeleaf Dependency

If you didn’t use Spring Initializr, add the Thymeleaf dependency to your `pom.xml`:


    org.springframework.boot
    spring-boot-starter-thymeleaf

Step 4: Create a Model Class

Create a simple `User` class to represent data:

package com.example.demo.model;

public class User {
    private String name;
    private String email;

    // Constructors, Getters, and Setters
    public User() {}

    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

Step 5: Create a Controller

Create a `HomeController` class to handle requests and pass data to the view:

package com.example.demo.controller;

import com.example.demo.model.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HomeController {

    @GetMapping("/")
    public String home(Model model) {
        // Add data to the model
        model.addAttribute("message", "Hello, Thymeleaf!");

        // Create a User object
        User user = new User("John Doe", "john.doe@example.com");
        model.addAttribute("user", user);

        // Return the Thymeleaf template name (home.html)
        return "home";
    }
}

Step 6: Create a Thymeleaf Template

Create a `home.html` file in the `src/main/resources/templates` directory:

Home Page

Default Message

User Information

Name: Default Name

Email: Default Email

Thymeleaf Features

Item

Step 7: Run the Application

1. Open `DemoApplication.java` (the main class) and run it.

2. Open your browser and go to `http://localhost:8080/`.

3. You should see the following output:

Hello, Thymeleaf!
User Information
Name: John Doe
Email: john.doe@example.com
Thymeleaf Features
• Item 1
• Item 2
• Item 3
• Item 4
• Item 5

Step 8: Explanation of Thymeleaf Features

1. Thymeleaf Attributes:

- `th:text`: Replaces the text content of an HTML element.

- `th:each`: Iterates over a collection (e.g., list, array).

- `th:if`: Conditionally displays an element.

2. Expression Utility Objects:

- `${numbers.sequence(1, 5)}`: Generates a sequence of numbers.

- `${dates.format(date, ‘dd/MM/yyyy’)}`: Formats a date.

3. Model Data:

- Data passed from the controller (`model.addAttribute`) can be accessed in the template using `${attributeName}`.

Step 9: Add Static Resources

1. Add a CSS file in `src/main/resources/static/css/styles.css`:

body {
    font-family: Arial, sans-serif;
    background-color: #f0f0f0;
}
h1 {
    color: #333;
}

2. Link the CSS file in `home.html`:

Step 10: Add Form Handling

1. Update the `HomeController` to handle form submissions:

@GetMapping("/form")
public String showForm(Model model) {
    model.addAttribute("user", new User());
    return "form";
}

@PostMapping("/submit")
public String submitForm(@ModelAttribute User user, Model model) {
    model.addAttribute("user", user);
    return "result";
}

2. Create a `form.html` template:




    
    User Form


    User Form

    
        Name:
        


        Email:

3. Create a `result.html` template to display the submitted data:

Result

Submitted User Information

Name:

Email:

Back to Form

Step 11: Test the Application

1. Run the application and navigate to `http://localhost:8080/form`.

2. Fill out the form and submit it.

3. You should see the submitted data displayed on the `result.html` page.

Advanced Features and Best Practices

1. Thymeleaf Layouts and Fragments

One of the most powerful features of Thymeleaf is its support for layouts and fragments. This allows you to create reusable templates and avoid duplicating code.

Step 1: Create a Layout Template

Create a `layout.html` file in the `templates` folder. This will serve as the base template for your application.




    
    My Application
    


    
        My Application

        
            Home
            Form
        

    


    
        
        

    


    
        © 2023 My Application

Step 2: Define Fragments

Fragments are reusable pieces of HTML that can be included in other templates. For example, create a `fragments.html` file:




    
        Welcome to My Application

    


    
        © 2023 My Application

Step 3: Use Layouts and Fragments

Now, update your `home.html` to use the layout and fragments:


      th:replace="~{layout :: layout}">

    Home Page


    


    
        Home Page Content

        This is the home page of my application.

2. Conditional Rendering with `th:if` and `th:unless`

Thymeleaf provides `th:if` and `th:unless` for conditional rendering. This is useful for displaying content based on certain conditions.

Example: Conditional Rendering


    Welcome, !



    Please log in.

3. Iteration with `th:each`

Thymeleaf’s `th:each` attribute allows you to iterate over collections (e.g., lists, arrays).

Example: Displaying a List of Users

@GetMapping("/users")
public String showUsers(Model model) {
    List users = Arrays.asList(
        new User("Alice", "alice@example.com"),
        new User("Bob", "bob@example.com")
    );
    model.addAttribute("users", users);
    return "users";
}

In the `users.html` template:

4. Form Validation and Error Handling

Thymeleaf integrates seamlessly with Spring’s validation framework to display validation errors.

Step 1: Add Validation Annotations

Update the `User` class with validation annotations:

import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.Email;

public class User {
    @NotEmpty(message = "Name is required")
    private String name;

    @Email(message = "Invalid email")
    private String email;

    // Getters and Setters
}

Step 2: Handle Validation in the Controller

@PostMapping("/submit")
public String submitForm(@Valid @ModelAttribute User user, BindingResult result, Model model) {
    if (result.hasErrors()) {
        return "form"; // Return to the form if there are errors
    }
    model.addAttribute("user", user);
    return "result";
}

Step 3: Display Validation Errors

Update the `form.html` template to show validation errors:


    Name:
    
    


    Email:

5. Internationalization (i18n)

Thymeleaf supports internationalization, allowing you to create multilingual applications.

Step 1: Add Message Files

Create `messages.properties` and `messages_fr.properties` in the `src/main/resources` folder.

messages.properties:

welcome.message=Welcome to My Application

messages_fr.properties:

welcome.message=Bienvenue sur Mon Application

Step 2: Use Messages in Templates

Welcome

Step 3: Configure Locale Resolver

Add a `LocaleResolver` bean in your configuration:

@Bean
public LocaleResolver localeResolver() {
    SessionLocaleResolver resolver = new SessionLocaleResolver();
    resolver.setDefaultLocale(Locale.US);
    return resolver;
}

6. Best Practices

1. Use Fragments for Reusable Components: Avoid duplicating code by creating reusable fragments.

2. Keep Templates Clean: Use `th:replace` and `th:insert` to modularize your templates.

3. Leverage Internationalization: Use message files for text to support multiple languages.

4. Validate Inputs: Always validate user inputs and display meaningful error messages.

5. Use CSS and JavaScript: Organize static resources in the `static` folder and link them in your templates.

Conclusion

Thymeleaf is a powerful and flexible template engine that integrates seamlessly with Spring Boot. It simplifies the process of creating dynamic web pages and reduces the amount of boilerplate code required.

How Spring JPA Works and Writing Custom Queries

Pratik T — Sat, 25 Jan 2025 05:53:09 GMT

Spring JPA is an essential tool in the Spring ecosystem that simplifies database interactions, enabling developers to focus on building features rather than managing boilerplate code. This article will explain how Spring JPA works, how to write custom queries using it, and when to use different approaches.

Understanding How Spring JPA Works

Spring JPA (Java Persistence API) is a module of Spring Data that abstracts the complexities of database interactions by offering a simple, unified approach to data persistence. It leverages JPA as the standard API and Hibernate as the default implementation for Object-Relational Mapping (ORM).

Core Components of Spring JPA

Entity Classes: Entity classes map to database tables. These are simple Java classes annotated with @Entity and optionally with @Table. Each field in the class corresponds to a column in the table, marked with annotations like @Id, @Column, and @GeneratedValue.
Repositories: Spring JPA introduces repository interfaces, such as JpaRepository, CrudRepository, and PagingAndSortingRepository. These interfaces provide methods like save(), findById(), deleteById(), and more for basic CRUD operations.
Hibernate ORM: Hibernate, as the default JPA implementation, manages the actual interaction between Java objects and database records. It converts Java objects into SQL statements and vice versa.
Query Mechanisms: Spring JPA allows you to write queries in three primary ways:

Query methods (derived queries based on method names).
JPQL (Java Persistence Query Language).
Native SQL (raw SQL queries).

Transaction Management: Spring manages transactions using the @Transactional annotation, ensuring data integrity across multiple operations.

Creating a Basic Spring JPA Application

Let’s walk through a simple example to understand how Spring JPA works in practice.

1. Define an Entity Class

import jakarta.persistence.*;
@Entity
@Table(name = "students")
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(name = "name", nullable = false)
    private String name;
    @Column(name = "email", unique = true, nullable = false)
    private String email;
    // Getters and Setters
}

This class maps to a students table in the database.

2. Define a Repository Interface

import org.springframework.data.jpa.repository.JpaRepository;

public interface StudentRepository extends JpaRepository {
    // Custom queries can be added here
}

The StudentRepository interface provides CRUD operations for the Student entity.

3. Implement a Service Layer

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
@Service
public class StudentService {
    @Autowired
    private StudentRepository studentRepository;
    public List getAllStudents() {
        return studentRepository.findAll();
    }
    public Student saveStudent(Student student) {
        return studentRepository.save(student);
    }
}

The service layer acts as a bridge between the controller and the repository.

4. Expose an API via a Controller

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
@RestController
@RequestMapping("/students")
public class StudentController {
    @Autowired
    private StudentService studentService;
    @GetMapping
    public List getAllStudents() {
        return studentService.getAllStudents();
    }
    @PostMapping
    public Student createStudent(@RequestBody Student student) {
        return studentService.saveStudent(student);
    }
}

The controller handles HTTP requests and delegates them to the service layer.

Writing Custom Queries in Spring JPA

Spring JPA provides multiple ways to write custom queries depending on the complexity of the requirements. Let’s explore these methods in detail.

1. Query Methods (Derived Queries)

Spring JPA can automatically generate SQL queries based on method names in repository interfaces. These are known as query methods.

Example:

import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;

public interface StudentRepository extends JpaRepository {
    // Find students by name
    List findByName(String name);
    // Find students by name and email
    List findByNameAndEmail(String name, String email);
    // Find students whose name contains a keyword
    List findByNameContaining(String keyword);
    // Find all students and sort by name
    List findAllByOrderByNameAsc();
}

Generated SQL Examples:

findByName(String name) generates:

SELECT * FROM students WHERE name = :name

findByNameAndEmail(String name, String email) generates:

SELECT * FROM students WHERE name = :name AND email = :email

2. JPQL (Java Persistence Query Language)

JPQL is an object-oriented query language that operates on entity objects and their fields, not directly on database tables.

Example:

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import java.util.List;

public interface StudentRepository extends JpaRepository {
    // JPQL query to find students by name
    @Query("SELECT s FROM Student s WHERE s.name = :name")
    List findStudentsByName(@Param("name") String name);

    // JPQL query to find students with emails containing a keyword
    @Query("SELECT s FROM Student s WHERE s.email LIKE %:keyword%")
    List findStudentsByEmailKeyword(@Param("keyword") String keyword);
}

Example Query Output:

findStudentsByName("John") generates:

SELECT * FROM students WHERE name = 'John'

3. Native SQL Queries

When you need to use database-specific SQL or optimize performance, native SQL queries can be used with @Query.

Example:

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import java.util.List;

public interface StudentRepository extends JpaRepository {
    // Native SQL query to find students by email
    @Query(value = "SELECT * FROM students WHERE email = :email", nativeQuery = true)
    Student findStudentByEmail(@Param("email") String email);

    // Native SQL query to fetch students with pagination
    @Query(value = "SELECT * FROM students ORDER BY name LIMIT :limit OFFSET :offset", nativeQuery = true)
    List fetchStudentsWithPagination(@Param("limit") int limit, @Param("offset") int offset);
}

Dynamic Queries Using Specifications

For more complex queries involving dynamic filters, you can use the JpaSpecificationExecutor interface.

Example:

Extend JpaSpecificationExecutor:

public interface StudentRepository extends JpaRepository, JpaSpecificationExecutor {
}

Write Specifications:

import org.springframework.data.jpa.domain.Specification;

public class StudentSpecifications {
    public static Specification hasName(String name) {
        return (root, query, criteriaBuilder) ->
                criteriaBuilder.equal(root.get("name"), name);
    }
    public static Specification emailContains(String keyword) {
        return (root, query, criteriaBuilder) ->
                criteriaBuilder.like(root.get("email"), "%" + keyword + "%");
    }
}

Use in Service:

import org.springframework.data.jpa.domain.Specification;
import java.util.List;

List students = studentRepository.findAll(Specification
    .where(StudentSpecifications.hasName("John"))
    .and(StudentSpecifications.emailContains("gmail")));

When to Use Each Approach

Query Methods: Use for simple and standard queries.
JPQL: Use when you need flexibility or operate on entities.
Native SQL: Use for database-specific optimizations or raw SQL.
Specifications: Use for complex filtering with dynamic conditions.

Spring JPA simplifies data access while giving you the flexibility to write custom queries as needed. Understanding these approaches will empower you to handle any database interaction with ease.

Method Overloading in Java: A Comprehensive Guide

Pratik T — Thu, 14 Nov 2024 06:16:18 GMT

In Java, method overloading allows developers to define multiple methods with the same name but different parameters. This flexibility makes code more readable and adaptive, as different variations of a method can handle different argument types or quantities. However, understanding how Java picks which method to call is essential for writing bug-free code.

In this article, we’ll dive deep into Java’s method selection process and the rules it follows to resolve overloaded methods. We’ll cover exact matches, type promotion, varargs, boxing, and the infamous ambiguity errors that can arise in method overloading.

The Basics of Method Overloading

Method overloading in Java occurs when multiple methods in a class share the same name but differ in parameter type or count. Here’s a simple example:

class Calculator {
    void add(int a, int b) {
        System.out.println("add(int, int) called: " + (a + b));
    }

    void add(double a, double b) {
        System.out.println("add(double, double) called: " + (a + b));
    }
}

When calling add() with int or double arguments, Java determines which method to use based on the arguments passed. The compiler automatically selects the appropriate method.

Method Resolution Rules

Java follows a specific set of rules when choosing which overloaded method to call, and understanding these can help you avoid some common pitfalls.

1. Exact Match — The Most Specific Method Wins

When there’s an exact match between the argument types and a method’s parameters, Java uses this method directly.

class Example {
    void print(int a) {
        System.out.println("print(int) called");
    }
    void print(double a) {
        System.out.println("print(double) called");
    }

    public static void main(String[] args) {
        Example ex = new Example();
        ex.print(10);    // Calls print(int)
        ex.print(10.5);  // Calls print(double)
    }
}

Output:

print(int) called
print(double) called

When print() is called with an int, Java matches it directly to print(int), and similarly for double. This is the simplest case of method resolution.

2. Type Promotion (Widening)

When there’s no exact match, Java tries to promote the type to the next wider type in its type hierarchy, following this order:
— byte → short → int → long → float → double
— char → int

class Example {
    void display(long a) {
        System.out.println("display(long) called");
    }
    void display(double a) {
        System.out.println("display(double) called");
    }

    public static void main(String[] args) {
        Example ex = new Example();
        ex.display(10);       // Promotes int to long and calls display(long)
        ex.display(10.5f);    // Promotes float to double and calls display(double)
    }
}

Output:

display(long) called
display(double) called

Since no int or float method exists, int promotes to long, and float promotes to double.

3. Varargs — The Fallback Option

If there’s no exact or promotable match, Java uses a varargs method (variable-length argument list). Varargs are treated as a “catch-all” when no better match exists.

class Example {
    void print(int... numbers) {
        System.out.println("print(int...) called with " + numbers.length + " arguments");
    }

    public static void main(String[] args) {
        Example ex = new Example();
        ex.print(10);          // Calls print(int...) with 1 argument
        ex.print(10, 20);      // Calls print(int...) with 2 arguments
    }
}

Output:

print(int…) called with 1 arguments
print(int…) called with 2 arguments

Java calls print(int…) when there’s no match for (int) or (int, int). Varargs should ideally be used sparingly as they’re the least specific option.

4. Ambiguity and Compile-Time Errors

When overloaded methods are ambiguous, Java can’t decide which one to use, leading to a compile-time error. Ambiguity usually occurs when multiple methods match the provided arguments, but none is more specific.

class Example {
    void print(int a, long b) {
        System.out.println("print(int, long) called");
    }
    void print(long a, int b) {
        System.out.println("print(long, int) called");
    }

    public static void main(String[] args) {
        Example ex = new Example();
        ex.print(10, 20);  // Compile-time error: reference to print is ambiguous
    }
}

Error:

error: reference to print is ambiguous

Since 10, 20 can match both print(int, long) and print(long, int), the compiler doesn’t know which to choose and throws an error.

5. Boxing and Widening Together

Java supports autoboxing (automatically converting primitives to their wrapper classes) and can combine widening with autoboxing when necessary, though this can add complexity.

class Example {
    void print(Integer a) {
        System.out.println("print(Integer) called");
    }
    void print(long a) {
        System.out.println("print(long) called");
    }

    public static void main(String[] args) {
        Example ex = new Example();
        ex.print(10);   // Calls print(long) since widening (int → long) is preferred over autoboxing
    }
}

Output:

print(long) called

Java prioritizes widening over boxing, so int is widened to long instead of being boxed to Integer.

Summary of Method Resolution Rules

To summarize Java’s priority when selecting an overloaded method:
1. Exact match — Java directly chooses a method that matches the argument types.
2. Type promotion — Java promotes the argument type to the next suitable primitive type.
3. Autoboxing — Java boxes the primitive type into its wrapper class.
4. Varargs — As the last option, Java uses varargs if all else fails.

Final Thoughts

Mastering method overloading is essential for writing flexible, efficient Java code. Remembering the priority of method resolution rules can help you avoid compile-time errors and unexpected behavior in your overloaded methods. Try experimenting with these scenarios in your own code to deepen your understanding.

Happy Coding!

Guide to Servlet in Java

Pratik T — Wed, 16 Oct 2024 08:37:01 GMT

What are Servlets?

- Servlets are Java-based web technologies that enable the creation of dynamic web applications. They run on the server side and handle the logic required to respond to requests from clients, usually web browsers.

- Servlets are used to develop web applications that can be accessed through a browser. Sun Microsystems originally developed Servlets (now managed by Oracle).

A Servlet is a Java class that extends the capabilities of servers that host web applications. It responds to incoming requests (usually HTTP requests from web browsers or clients) and generates a response, often in HTML format, to send back to the client.

What is a Web Application?

- A web application is software hosted on a server that users can access using a browser over the internet or an intranet.

- In web applications, the server hosts all application logic, and the clients interact with it using a browser interface. This approach allows centralized data handling, making it easier to manage and update.

Components in Web Applications

1. Client-side components: These are developed using technologies like HTML, XHTML, JSP (Java Server Pages), JavaScript, CSS, etc. They define how the content is presented to the user in the browser.

2. Server-side components: These are developed using technologies like Servlets, JSP, Filters, and more. Server-side components handle the business logic, data processing, and other backend operations of the web application.

How Web Requests Work

- When you enter a URL in a browser, the browser sends a request to the DNS server to resolve the domain name to an IP address.

- Once the IP address is found, the request is forwarded to the appropriate server hosting the web application.

- The server processes the request and sends back a response to the client (browser), which is then displayed to the user.

- Servers determine the client’s IP address from the HTTP request to track user sessions or send customized responses.

Versions of Servlets

The evolution of the Servlets API has happened over different versions of Java EE:

1. Servlets 2.2 — Released with J2EE 1.2

2. Servlets 2.3 — Released with J2EE 1.3

3. Servlets 2.4 — Released with J2EE 1.4

4. Servlets 2.5 — Released with JEE 5

5. Servlets 3.0 — Released with JEE 6

6. Servlets 3.1 — Released with JEE 7

Each version of the Servlets API brings new features, improvements, and updates to enhance web application development.

Types of Applications

1. Standalone Applications: These are traditional software applications that run on a single computer. Examples include MS Word, music players, etc. The main drawback is that they require installation on each machine, and data sharing is not possible.

2. Client-Server Applications: These applications have two components: the server-side application and the client-side application installed on multiple machines. Examples include chat applications like Yahoo Messenger. Although data sharing is possible, client software must be maintained on each machine.

3. Web Applications: These applications solve the problems of client-server applications. They run on a central server, and users access them using a web browser. Examples include Gmail, Google Maps, etc. Web applications can be implemented using technologies like Servlets, JSP, and more. Maintenance is easier since updates only need to be done on the server.

4. Distributed Applications: These applications are designed to work across multiple servers or locations, allowing businesses to share information with partners in real time.

5. Enterprise Applications: These are large-scale software systems designed to support an organization’s core business processes. They are usually integrated with other software systems to ensure seamless business operations.

Static vs. Dynamic Web Applications

- Static Web Applications: These have a fixed view, and the content remains the same for all users. Static web pages are developed using HTML and do not involve data processing or interaction.

- Dynamic Web Applications: These allow users to interact with the server and send data that is processed to produce dynamic responses. Servlets are often used to create these applications.

General Technical Terms Explained

1. Web Server: Software that handles HTTP requests from clients and sends back HTTP responses. Examples include Apache Server, IIS (Internet Information Services).

2. Web Client: Software (typically a web browser) that makes HTTP requests to a web server and receives responses.

3. Web Container: Also known as a Servlet container, this is the component within the web server that manages the lifecycle of Servlets and JSPs. It handles low-level tasks like request handling, security, resource management, and more.

4. HTTP (Hypertext Transfer Protocol): Protocol used for communication between the client and the server.

5. TCP/IP: Network protocol stack used for data communication. IP is responsible for addressing, while TCP manages the data transmission.

6. DNS (Domain Name Server): Translates domain names into IP addresses to locate servers on the internet.

Setting up Apache Tomcat

Prerequisites

1. Java Development Kit (JDK): Ensure you have JDK installed on your machine (version 8 or later).

2. Apache Tomcat: Download the latest version of Apache Tomcat from the [official website](https://tomcat.apache.org/).

Step 1: Install Apache Tomcat

1. Download Tomcat:

- Choose the appropriate distribution (usually the `.zip` or `.tar.gz` file).

2. Extract the Archive:

- Unzip or untar the downloaded file to a directory of your choice (e.g., `C:\apache-tomcat-9.0.xx` or `/usr/local/tomcat`).

3. Set Environment Variables (optional but recommended):

- JAVA_HOME: Point this to your JDK installation.

- CATALINA_HOME: Point this to your Tomcat installation directory.

For example, on Linux:

export JAVA_HOME=/path/to/jdk
export CATALINA_HOME=/path/to/tomcat

Step 2: Start Tomcat

1. Navigate to the `bin` directory of your Tomcat installation:

cd $CATALINA_HOME/bin

2. Start Tomcat:

- On Windows:

catalina.bat start

- On Linux/Unix:

./catalina.sh start

3. Open a web browser and go to `http://localhost:8080`. You should see the Tomcat welcome page.

Step 3: Create a Servlet

1. Create a Dynamic Web Project:

- Use an IDE like Eclipse or IntelliJ IDEA to create a new Dynamic Web Project.

2. Add Servlet:

- Create a new Java class that extends `HttpServlet` and override the `doGet` or `doPost` methods. Example:

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html");
        response.getWriter().println("Hello, World!
");
    }
}

Configure web.xml (if not using annotations):

If you’re not using servlet annotations, define your servlet in WEB-INF/web.xml:


    HelloServlet
    com.example.HelloServlet


    HelloServlet
    /hello

Step 4: Deploy the Servlet

1. Compile the Project: Make sure your project compiles without errors.

2. Create a WAR file: If using an IDE, it typically has an option to export the project as a WAR file.

3. Deploy the WAR:

- Place the WAR file in the `webapps` directory of your Tomcat installation.

4. Restart Tomcat:

- After placing the WAR file, restart Tomcat for the changes to take effect.

Step 5: Access the Servlet

1. Open a web browser and go to:

http://localhost:8080/your_project_name/hello

Replace `your_project_name` with the name of your WAR file (without the `.war` extension).

Troubleshooting Tips

- Check the `logs` directory in your Tomcat installation for any error messages.

- Ensure the servlet is correctly mapped and that there are no typos in your URL.

Java Servlets, classes and interfaces

Classes in Servlets

1. Servlet Class:

- The core of a servlet is a class that extends HttpServlet. This class provides methods to handle HTTP requests and responses.

- Commonly overridden methods include:

- doGet(HttpServletRequest request, HttpServletResponse response): Handles GET requests.

- doPost(HttpServletRequest request, HttpServletResponse response): Handles POST requests.

- Example:

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
public class MyServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, 
                         HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("Hello, World!
");
    }
}

2. Utility Classes:

- Often, utility classes are created to handle common tasks, such as database access, data processing, or configuration management.

Interfaces in Servlets

1. Servlet Interface:

- The Servlet interface defines the methods that must be implemented by any servlet class. It includes methods like init(), service(), and destroy().

- While developers typically extend HttpServlet, knowing the Servlet interface is important for understanding servlet lifecycle and behavior.

2. Other Interfaces:

- ServletConfig: This interface provides configuration information to the servlet. It allows access to initialization parameters and the servlet context.

- ServletContext: This interface provides information about the web application context. It allows servlets to interact with their environment, such as retrieving resources or attributes.

- HttpServletRequest and HttpServletResponse: These interfaces represent the request and response objects, respectively, enabling servlets to handle incoming requests and send responses back to clients.

Step-by-Step Guide to Developing and Running a Servlets 2.x-Based Web Application

1. Requirement Analysis

The application you’re building is a simple login page. When a user submits the form, the information will be processed by a servlet, which will display user details and some additional data.

2. Create a Dynamic Web Project in Eclipse

1. Open Eclipse.

2. Go to the menu and select File > New > Dynamic Web Project.

3. Provide the Project Name as lms1.

4. For the first-time setup:

- Click on the New Runtime button.

- Select Apache Tomcat 10.1 as the server and click on the Next button.

- Browse to the Tomcat Home Directory (e.g., E:\Tomcat 10.1) and click on Finish.

5. Click Finish again to create the project.

3. Project Directory Structure

Once the project is created, the default directory structure will look like this:

lms1

WebContent
login.html
src
com.lmsindia.servlets (package)
LoginServlet.java
WEB-INF
web.xml

4. Create the Login Page (login.html)

In the WebContent folder of your project, create a new HTML file named login.html. Here’s the code for the file:


  
    Login Page
  
  
    lms Test

    

    
      







                  UserName:

This HTML form sends a POST request to the servlet when the user submits the form.

5. Create the Servlet Class (LoginServlet.java)

1. In the src folder, create a package named com.lmsindia.servlets.

2. Inside this package, create a Java class named lmsServlet.java. Use the following code:

package com.lmsindia.Servlets;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class lmsServlet extends HttpServlet {
   String phone;
   String email;
   String state;
   String country;
   public void init(ServletConfig sc) throws ServletException {
      System.out.println("lmsServlet - init()");
      // Config parameters
      phone = sc.getInitParameter("Phone");
      email = sc.getInitParameter("Email");
      // Context parameters
      ServletContext ctx = sc.getServletContext();
      state = ctx.getInitParameter("State");
      country = ctx.getInitParameter("country");
   }
   protected void service(HttpServletRequest req, HttpServletResponse res)
         throws IOException, ServletException {
      System.out.println("lmsServlet - service()");
      
      // Request parameter
      String un = req.getParameter("uname");
      
      // Display parameters
      res.setContentType("text/html");
      PrintWriter out = res.getWriter();
      out.println("Username: " + un + "
");
      out.println("Phone: " + phone + "
");
      out.println("Email: " + email + "
");
      out.println("State: " + state + "
");
      out.println("Country: " + country + "
");
   }
   public void destroy() {
      System.out.println("lmsServlet - destroy()");
   }
}

This servlet retrieves and displays request parameters (username) as well as initialization and context parameters.

6. Update the Deployment Descriptor (web.xml)

In the WEB-INF folder, open the web.xml file and update it as follows:



  
    login.html
  

    State
    UTTAR PRADESH
  
  
    country
    INDIA
  
  
    test
    com.lmsindia.Servlets.lmsServlet
    
      Email
      som@lmsindia.org
    
    
      Phone
      33333
    
    1
  
  
    test
    /test.lms

This file defines the servlet configuration, context parameters, and servlet mappings. It maps requests to /test.lms to the lmsServlet.

7. Deploy and Run the Project on Tomcat

1. Right-click on your project (lms1) in Eclipse.

2. Select Run As > Run on Server.

3. Choose Apache Tomcat 6.0 as the server and click Finish.

This step will deploy your web application to Tomcat and start the server.

8. Access the Web Application

- Open a web browser.

- Enter the URL: http://localhost:9999/lms1/login.html

- You should see the login form. Enter a username and submit the form to see the output from the servlet.

Summary of Required Files

1. Login.html: The HTML page that collects user input.

2. web.xml: The deployment descriptor that configures the servlet and mappings.

3. lmsServlet.java: The servlet class that handles the HTTP request and response.

Creating a Simple Servlet using annotaions:

Step 1: Create the Servlet Class

Here is a basic example of a servlet that generates a simple “Hello, World!” response.

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet("/hello") // URL pattern
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        // Set response content type
        response.setContentType("text/html");
        // Write output to the client
        response.getWriter().println("Hello, World!
");
    }
}

Explanation:

- @WebServlet(“/hello”): This annotation maps the servlet to the URL pattern /hello.

- doGet() Method: Handles HTTP GET requests. When a client sends a request to the URL /hello, this method is executed.

- response.setContentType(“text/html”): Sets the response’s content type to HTML.

- response.getWriter().println(): Sends an HTML response back to the client.

Step 3: Deploy the Servlet

To deploy the servlet, you need to package it into a WAR (Web Application Archive) file or directly place it in the webapps directory of Tomcat.

1. Folder Structure for manual deployment:

webapps/
    └── your_app_name/
        ├── WEB-INF/
        │   ├── web.xml
        │   └── classes/
        │       └── HelloServlet.class

2. Configuration in web.xml:

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
         http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         version="3.0">
         
    
        HelloServlet
        HelloServlet
    
    
        HelloServlet
        /hello

This web.xml file configures your servlet with the name HelloServlet and maps it to the URL /hello.

Step 4: Access the Servlet

- Start the Apache Tomcat server.

- Open your web browser and visit http://localhost:8080/your_app_name/hello.

You should see the response: Hello, World!

Servlet Instance Creation

1. Default Behavior:

- By default, a servlet instance is created when the first client request is received.

- Only one instance of the servlet is created, and it handles all client requests using multiple threads.

2. Eager Initialization:

- If you want a servlet instance to be created when the server or container starts (before any request is received), you can configure it using the following options:

In web.xml:


    ...
    X

Using Annotations:

@WebServlet(urlPatterns = {"/example"}, loadOnStartup = X)

- X is an integer value that determines the order of initialization. Lower values are given higher priority.

Parameters in Servlets

Parameters are key-value pairs used to pass information to a servlet. There are three types of parameters:

1. ServletRequest Parameters:

- These parameters are sent from the client to the server as part of the HTTP request.

- Useful for handling data entered by users in web forms.

Example of retrieving request parameters:

String firstName = req.getParameter("fname");
String lastName = req.getParameter("lname");

2. ServletConfig Parameters:

- These parameters are specific to a particular servlet and are defined in the web.xml file or using annotations.

- They are useful for data that is common to all users of a specific servlet.

In web.xml:


    HelloServlet
    com.lmsindia.servlets.HelloServlet
    
        email
        hellosom@lmsindia.org

Accessing ServletConfig parameters:

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

3. ServletContext Parameters:

- These parameters are shared across all servlets in the web application.

- They are useful for data that needs to be accessed by multiple servlets.

Defining context parameters in web.xml:


    website
    www.lmsindia.org

Accessing ServletContext parameters:

String website = context.getInitParameter("website");

Explanation of the Code



   
      
      Insert title here
   
   
      THIS IS INDEX HTML

      
         Enter Name

         
         

         
      

      
         Enter Phone

Web.xml

lms2

   index.html


   website
   www.lmsindia.org


   helloSevlet
   com.lmsindia.servlet.HelloServlet
   
      email
      hellosom@lmsindia.org
   


   helloservlet
   /hello.lms


   haiservlet
   com.lmsindia.servlet.HaiServlet
   
      email
      haisom@lmsindia.org
   


   haiservlet
   /hai.lms
undefined

Example Servlets

1. HelloServlet.java:

package com.lmsindia.servlet;
import java.io.IOException;
import java.io.Writer;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class HelloServlet extends HttpServlet {
    ServletConfig cfg = null;
    @Override
    public void init(ServletConfig config) throws ServletException {
        this.cfg = config; // Corrected to use 'config' instead of 'cfg'
        System.out.println("init() method of HelloServlet");
    }
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse res)
            throws ServletException, IOException {
        System.out.println("service() method of HelloServlet");
        String fname = req.getParameter("fname");
        String phone = req.getParameter("phone");
        Writer out = res.getWriter();
        res.setContentType("text/html");
        out.write("Response from HelloServlet
");
        out.write("
Request Parameters");
        out.write("
Fname: " + fname);
        out.write("
Phone: " + phone);
        out.write("
Servlet Config Parameters");
        String eml = cfg.getInitParameter("email");
        out.write("
" + cfg);
        out.write("
Email: " + eml);
        out.write("
Servlet Context Parameters");
        ServletContext ctx = cfg.getServletContext();
        String web = ctx.getInitParameter("website");
        out.write("
" + ctx);
        out.write("
Web: " + web);
    }
}

This servlet handles requests and reads parameters from the HTTP request, ServletConfig, and ServletContext.

- It retrieves data like fname and phone from the request, email from ServletConfig, and website from ServletContext.

2. HaiServlet.java:

package com.lmsindia.servlet;
import java.io.IOException;
import java.io.Writer;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class HaiServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse res)
            throws ServletException, IOException {
        System.out.println("service() method of HelloServlet");
        String fname = req.getParameter("fname");
        String phone = req.getParameter("phone");
        Writer out = res.getWriter();
        res.setContentType("text/html");
        out.write("Response from HelloServlet
");
        out.write("
Request Parameters");
        out.write("
Fname: " + fname);
        out.write("
Phone: " + phone);
        out.write("
Servlet Config Parameters");
        ServletConfig cfg = getServletConfig();
        String eml = cfg.getInitParameter("email");
        out.write("
" + cfg);
        out.write("
Email: " + eml);
        out.write("
Servlet Context Parameters");
        ServletContext ctx = cfg.getServletContext();
        String web = ctx.getInitParameter("website");
        out.write("
" + ctx);
        out.write("
Web: " + web);
    }
}

- Similar to HelloServlet, but handles different parameters and requests.

Key Points

- init() method:

- It initializes the servlet instance when it is created, either upon the first request or during server startup (if specified).

- If you override the init() method without calling super.init(config), the ServletConfig will not be initialized.

- Servlet Lifecycle:

- init(): Called once when the servlet is created.

- service(): Called for every request to handle the logic.

- destroy(): Called before the servlet instance is destroyed.

Servlet Lifecycle Overview

The servlet lifecycle includes three main phases:

1. Initialization (Container Startup)

2. Request Processing

3. Destruction (Container Shutdown)

1. Initialization Phase (Container Startup)

When the server starts, the following steps occur:

1. Reading the web.xml: The container reads the deployment descriptor (web.xml) and stores its data in memory using a parser. If any error occurs in web.xml, the container stops the initialization process and cannot handle requests.

2. Servlet Context Creation:

- The container creates a ServletContext object, initializing it with context parameters defined in the web.xml.

- The context object is shared among all servlets in the web application.

3. Thread Pool Creation: The container creates a thread pool to handle incoming requests efficiently.

4. Listener Initialization:

- All the listeners defined in web.xml are initialized. This involves loading the listener classes, creating instances, and performing any setup tasks specified.

5. Filter Initialization:

- All filters specified in the web.xml are initialized. This means the filter classes are loaded, instances are created, and initialization tasks are performed.

6. Servlet Initialization (load-on-startup):

- The container checks for servlets configured with the load-on-startup parameter.

- The HelloServlet has load-on-startup set to a positive value, so it will be initialized when the server starts.

- For HelloServlet, the container performs the following steps:

1. Loads the servlet class into memory.

2. Creates an instance of the servlet using the default constructor.

3. Creates a ServletConfig object with the servlet’s initialization parameters (city parameter).

4. Associates the ServletConfig object with the ServletContext object.

5. Calls the init() method of the servlet with the ServletConfig object, completing the initialization process.

- The HaiServlet does not have a load-on-startup parameter, so it will be initialized later when the first request is made.

2. Request Processing Phase

Case 1: First Request to HelloServlet

1. URL Pattern Matching: The container matches the incoming URL (/hello.lms) with the servlet mapping.

2. Thread Allocation: Since HelloServlet is already initialized, the container picks a thread from the thread pool.

3. Request and Response Creation:

- A ServletRequest object is created and populated with data from the client.

- A ServletResponse object is created to hold the response data.

4. Service Method Invocation:

- The service() method of the servlet is called with the ServletRequest and ServletResponse objects.

- The servlet processes the request and generates the response.

5. Response Delivery: The response is sent back to the client, and the request and response objects are destroyed.

6. Thread Return: The thread is returned to the thread pool for reuse.

Case 2: Second Request to HelloServlet

- The process is the same as Case 1 since HelloServlet is already initialized.

Case 3: First Request to HaiServlet

1. URL Pattern Matching: The container matches the URL (/hai.lms) with the servlet mapping.

2. Servlet Initialization: Since HaiServlet is not yet initialized, the container initializes it by:

- Loading the servlet class into memory.

- Creating an instance of the servlet.

- Creating a ServletConfig object with the initialization parameters.

- Associating the ServletConfig object with the ServletContext object.

- Calling the init() method of the servlet.

3. Thread Allocation: After initialization, a thread from the pool is assigned to handle the request.

4. Request and Response Creation: The ServletRequest and ServletResponse objects are created.

5. Service Method Invocation: The service() method of HaiServlet is invoked.

6. Response Delivery: The response is delivered to the client, and the request and response objects are destroyed.

7. Thread Return: The thread is returned to the thread pool.

Case 4: Second Request to HaiServlet

- The process is the same as the second request to HelloServlet since HaiServlet is now already initialized.

3. Destruction Phase (Container Shutdown)

When the server shuts down, the following steps occur:

1. Thread Pool Destruction: The container destroys the thread pool, stopping all threads.

2. Servlet Destruction:

- The container destroys each servlet by calling the destroy() method of each servlet instance.

- This ensures that the resources held by the servlet are properly released.

3. Filter Destruction: Each filter is destroyed by invoking its destroy() method.

4. Listener Destruction: All listeners are destroyed in this phase, releasing any resources they hold.

5. Session Object Cleanup: Any active session objects are destroyed.

Summary of the Lifecycle

1. Container Startup:

- Reads web.xml, initializes context, listeners, filters, and servlets with load-on-startup.

2. Request Processing:

- Servlets handle client requests, with the service method being executed for each request.

3. Container Shutdown:

Proper cleanup of resources, threads, servlets, filters, listeners, and session objects.

RequestDispatcher Interface Overview

- RequestDispatcher is an interface available in the javax.servlet package.

- It is used to forward a request from one resource (like a servlet, JSP, or HTML page) to another resource on the server or to include the content of one resource in another.

- This interface provides two key methods:

- forward(ServletRequest req, ServletResponse res): Forwards a request from one resource to another.

- include(ServletRequest req, ServletResponse res): Includes the content of a resource in the response.

forward() Method

- The forward() method is used to forward the request from:

- Servlet to HTML

- Servlet to JSP

- Servlet to another Servlet

- JSP to HTML

- JSP to another JSP

- JSP to a Servlet

- Only one forward() can be executed per request. If you try to invoke another forward after the response is committed, you will get a java.lang.IllegalStateException.

- It prevents response modification or writing content to the response stream after the forward operation.

Example Usage

RequestDispatcher rd = null;
rd = req.getRequestDispatcher("test.html");
rd.forward(req, res);

include() Method

- The include() method is used to include the response of one servlet or JSP in another servlet or JSP.

- Unlike forward(), you can have multiple include() statements within a servlet or JSP.

- The response stream remains open after the inclusion, so additional content can still be written.

Files Required for Servlet Example

Required Files for Program Example Using forward() Method

1. Index.html




    
    
    Document


    THIS IS INDEX HTML

    Test

2. web.xml


    
        index.html
    
    
        helloservlet
        com.lmsindia.servlet.HelloServlet
    
    
        helloservlet
        /test.lms

3. TestServlet.java

package com.lmsindia.servlet;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.Writer;
public class HelloServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse res)
            throws ServletException, IOException {
        Writer out = res.getWriter();
        out.write("Hi, Welcome to lms
");
    }
}

Required Files for Servlet Example Using include() Method

1. Index.html




    Insert title here


    GO TO HOME

2. Additional HTML files (Header.html, Footer.html, Menu.html, Home.html, etc.)

Each of these files contains simple HTML structure with content to be included, like:



    Header Content

3. ShowHomeServlet.java

package com.lmsindia.servlet;
import java.io.IOException;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class ShowHomeServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse res)
            throws ServletException, IOException {
        RequestDispatcher rd1 = req.getRequestDispatcher("header.html");
        rd1.include(req, res);
        
        RequestDispatcher rd2 = req.getRequestDispatcher("menu.html");
        rd2.include(req, res);
        
        RequestDispatcher rd3 = req.getRequestDispatcher("home.html");
        rd3.include(req, res);
        
        RequestDispatcher rd4 = req.getRequestDispatcher("footer.html");
        rd4.include(req, res);
    }
}

Key Differences between forward() and include() Methods

- forward():

- Transfers control to another resource without returning to the original.

- Only one forward() is allowed per request.

- Response is not modifiable after forward() is executed.

- include():

- Includes the content of another resource within the response.

- Allows multiple include() statements.

- Response stream remains open for additional modifications.

Servlet Thread Models

Servlets in Java can be implemented using two main thread models:

1. Single Thread Model

2. Multi-Thread Model (default and preferred approach)

1. Single Thread Model

- The SingleThreadModel interface is a deprecated way to ensure that only one thread executes the servlet’s service() method at a time.

- Implementing this model means that the servlet container creates a new servlet instance for each request or uses a pool of instances to handle requests, which can lead to significant overhead and inefficiency.

- The SingleThreadModel interface has been deprecated in J2EE 1.4 due to performance concerns and better alternatives available through proper synchronization.

2. Multi-Thread Model (default)

- By default, servlets follow the multi-threaded model, where a single instance of the servlet handles all the requests.

- Each request is handled by a different thread, which allows multiple clients to access the servlet simultaneously.

- The servlet container manages threading, which is more efficient and provides better performance for handling concurrent requests.

Example: Single Thread Model Servlet

Required Files for Servlet 2.X Example

The example below demonstrates the use of the Single Thread Model with a servlet named TestServlet. The setup includes an HTML form, the servlet code, and the web configuration file.

1. Index.html

This HTML form allows the user to input a name and submit it to the servlet.



   
      
      Enter Name
   
   
      
         Enter Name

2. TestServlet.java

This servlet implements the SingleThreadModel interface to demonstrate how it handles requests in a synchronized manner.

package com.lmsindia.servlet;
import java.io.IOException;
import java.io.Writer;
import javax.servlet.ServletException;
import javax.servlet.SingleThreadModel;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class TestServlet extends HttpServlet implements SingleThreadModel {
    public TestServlet() {
        System.out.println("**TestServlet Def Cons: " + this);
    }
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse res) 
            throws ServletException, IOException {
        String uname = req.getParameter("uname");
        Writer out = res.getWriter();
        out.flush();
        Thread currentThread = Thread.currentThread();
        for (int i = 0; i < 10; i++) {
            System.out.println(currentThread.getName() + "\t" + uname + "\t" + this);
            out.write("
" + currentThread.getName() + "\t" + uname + "\t" + this);
            try {
                Thread.sleep(1000); // Simulates a delay in processing
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            out.write("Hi " + uname + "
Response from Server
");
        }
    }
}

Explanation:

- This servlet uses the SingleThreadModel, meaning each request will be handled in a synchronized way, ensuring no two threads are executing the service method at the same time.

- The Thread.sleep(1000) statement adds a delay of 1 second to simulate a time-consuming operation.

- The servlet prints out the current thread name, the user input, and the servlet instance details to the response stream.

3. web.xml

The web.xml configuration file registers the servlet and maps it to a URL pattern.


         xmlns="http://java.sun.com/xml/ns/javaee" 
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/webapp_3_0.xsd" 
         id="WebApp_ID" 
         version="3.0">
   lms13
   
      index.html
   
   
      TestServlet
      com.lmsindia.servlet.TestServlet
   
   
      TestServlet
      /test.lms

Key Points on Servlet Thread Models

- Multi-threaded model (default): Offers better performance and scalability by allowing a single instance of the servlet to handle multiple requests concurrently using multiple threads.

- SingleThreadModel (deprecated): Intended to simplify thread safety by serializing request handling but is not recommended due to performance drawbacks and higher resource consumption.

Creating a Servlet Class in Eclipse

1. Right-click on the src folder in the Eclipse project.

2. Select New -> Servlet.

3. Provide the following details:

- Package name: Specify the package where the servlet will reside.

- Class name: Enter the name of the servlet class.

4. Change the superclass if needed, then click Next.

5. Provide the name of the servlet and the URL mapping.

6. Optionally, add any required init-parameters.

7. Click Finish to create the servlet.

This process sets up the servlet with default method signatures and configurations, making it ready for development.

Understanding HttpServletRequest and HttpServletResponse

HttpServletRequest and HttpServletResponse are interfaces provided by the Java Servlet API that represent the HTTP request and response in a servlet-based application. They are used to handle client-server communication using the HTTP protocol.

HttpServletRequest

- Represents an HTTP request sent by the client to the server.

- It contains information about the request, such as parameters, headers, cookies, and other data sent by the client.

Structure of an HTTP Request

1. Headers: Information about the request, such as the content type, user agent, cookies, and more.

2. Body: The main data of the request, used mainly in POST requests.

How Data is Transmitted

- When using the GET method, parameters are sent as a query string in the URL:

http://localhost:9999/lms1/login.lms?username=som&password=lmsindia

- URL: http://localhost:9999/lms1/login.lms

- Context Path: /lms1

- Protocol: http

- Host: localhost

- Port: 9999

- Query String: username=som&password=lmsindia

- The data is visible in the URL.

- When using the POST method, parameters are placed in the request body:

- Data is not visible in the URL, making it more secure.

- Allows sending a larger amount of data compared to the GET method.

HttpServletResponse

- Represents the response sent by the server back to the client.

- It contains:

- Response Headers: Information about the response (e.g., content type, status code).

- Response Body: The actual content sent to the client (e.g., HTML, JSON).

Files Required for Program

1. Index.html

This HTML file contains a form that sends data using the POST method.

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

   
      
      Request & Response Example
   
   
      
         Request & Response Example

      
      
         Enter Username

         
         Enter Password

2. TestServlet.java

The servlet code that processes the request and sends the response.

package com.lmsindia.servlet;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Enumeration;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class TestServlet extends HttpServlet {
   @Override
   protected void service(HttpServletRequest req, HttpServletResponse res)
   throws ServletException, IOException {
      // 1. Request parameters
      String un = req.getParameter("uname");
      String pw = req.getParameter("password");
      // 2. Display request parameters
      PrintWriter out = res.getWriter();
      out.println("Username: " + un);
      out.println("
Password: " + pw);
      out.println("
Request Headers");
      // 3. Request Headers
      Enumeration e = req.getHeaderNames();
      while (e.hasMoreElements()) {
         String hn = e.nextElement();
         String hv = req.getHeader(hn);
         out.println("
" + hn + ": " + hv);
      }
      // 4. Locale information
      out.println("
Locale: " + req.getLocale());
      // 5. Other information
      out.println("
Method: " + req.getMethod());
      out.println("
RequestURI: " + req.getRequestURI());
      out.println("
RequestURL: " + req.getRequestURL());
      out.println("
Protocol: " + req.getProtocol());
      out.println("
ContentLength: " + req.getContentLength());
      out.println("
ContentType: " + req.getContentType());
      out.println("
RemoteAddr: " + req.getRemoteAddr());
      out.println("
RemotePort: " + req.getRemotePort());
      out.println("
RemoteHost: " + req.getRemoteHost());
      out.println("
ServerPort: " + req.getServerPort());
      out.println("
ServerName: " + req.getServerName());
      out.println("
QueryString: " + req.getQueryString());
      out.println("
ServletPath: " + req.getServletPath());
      out.println("
ContextPath: " + req.getContextPath());
   }
}

3. web.xml

Configuration file that registers the servlet and maps it to a specific URL pattern.


         xmlns="http://java.sun.com/xml/ns/javaee" 
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
         http://java.sun.com/xml/ns/javaee/webapp_3_0.xsd" 
         id="WebApp_ID" 
         version="3.0">
   lms14
   
      index.html
   
   
      TestServlet
      com.lmsindia.servlet.TestServlet
   
   
      TestServlet
      /test.lms

Key Points

- GET Method:

- Data is sent as part of the URL.

- Limited data transmission capability.

- Less secure since data is visible in the URL.

- POST Method:

- Data is sent in the request body.

- Supports unlimited data transmission.

- More secure since data is not visible in the URL.

Working with Command Prompt

1. Set up the development directory structure.

2. Create and edit the required files.

3. Set the classpath for servlet-api.jar to compile the servlet class.

- Example:

Set CLASSPATH=%CLASSPATH%;E:\Tomcat 6.0\lib\Servlet-api.jar;

4. Compile the servlet class and place the files in the required directory.

5. Deploy the application to the webapps directory of Tomcat.

6. Start the Tomcat server and test the application using a web browser with the following URL:

http://localhost:9999/lmsapp

Request Handling with HTTP

Servlets interact with the HTTP protocol through the following key methods and objects:

1. HttpServletRequest:
— Represents the client’s request and contains information such as request parameters, HTTP headers, and request methods.
— Provides methods to access request data:
— getParameter(String name): Retrieves a request parameter.
— getHeader(String name): Retrieves an HTTP header.
— getMethod(): Returns the HTTP method (e.g., GET, POST).
— getInputStream(): Retrieves the request body as an input stream.

2. HttpServletResponse:
— Represents the response that will be sent to the client and provides methods to set response headers, status codes, and the response body.
— Provides methods to construct the response:
— setContentType(String type): Sets the MIME type of the response.
— setHeader(String name, String value): Sets a response header.
— getWriter(): Returns a PrintWriter to write character data to the response body.
— getOutputStream(): Returns an OutputStream to write binary data to the response body.

3. Handling Different HTTP Methods

Servlets can handle different HTTP methods by overriding specific methods:

- doGet(HttpServletRequest req, HttpServletResponse resp):
— Handles HTTP GET requests, typically used to retrieve data from the server.
— Example:

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
throws ServletException, IOException {
    String name = req.getParameter("name");
    resp.setContentType("text/plain");
    resp.getWriter().write("Hello, " + name);
}

doPost(HttpServletRequest req, HttpServletResponse resp):
— Handles HTTP POST requests, typically used to submit data to the server.
— Example:

@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) 
throws ServletException, IOException {
    String data = req.getParameter("data");
    // Process the data
    resp.setContentType("text/plain");
    resp.getWriter().write("Data received");
}

- doPut(HttpServletRequest req, HttpServletResponse resp):
— Handles HTTP PUT requests, which are often used to update resources.

- doDelete(HttpServletRequest req, HttpServletResponse resp):
— Handles HTTP DELETE requests, which are used to delete resources.

4. Example of a Simple Servlet

Here’s an example of a basic servlet that handles a GET request:

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.IOException;
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
   throws ServletException, IOException {
        resp.setContentType("text/html");
        resp.setCharacterEncoding("UTF-8");
        resp.getWriter().write("Hello, World!
");
    }
}

5. Request and Response Flow

1. Client Request:
— A client (browser) sends an HTTP request to the server.

2. Servlet Invocation:
— The servlet container receives the request, maps it to the appropriate servlet based on the URL pattern, and calls the service() method of the servlet.

3. Processing Request:
— The servlet processes the request using the HttpServletRequest object and generates a response using the HttpServletResponse object.

4. Sending Response:
— The servlet writes the response content to the HttpServletResponse object.

5. Client Response:
— The server sends the HTTP response back to the client.

In summary, servlets work with the HTTP protocol by managing the lifecycle of servlets, handling requests and responses through HttpServletRequest and HttpServletResponse objects, and processing different HTTP methods to generate appropriate responses for the client.

7. What is the Role of the ServletConfig and ServletContext Interfaces?

In the servlet API, two important interfaces — ServletConfig and ServletContext — provide access to configuration information for servlets and the overall web application. Both are used to share data across the servlet and application scope, but they serve different purposes.

1. ServletConfig Interface

ServletConfig is used to configure a specific servlet. It provides information that is specific to that servlet, such as initialization parameters defined in the web.xml file or through annotations. Each servlet in a web application has its own ServletConfig object, which is created by the servlet container when the servlet is initialized.

Key Methods of ServletConfig:
— getInitParameter(String name): Retrieves the value of a specific initialization parameter for the servlet.
— getInitParameterNames(): Returns an Enumeration of all initialization parameter names.
— getServletContext(): Provides access to the ServletContext object, allowing the servlet to access shared resources.
— getServletName(): Returns the name of the servlet as defined in the web.xml or by annotation.

Example Usage of ServletConfig:

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
@WebServlet("/configExample")
public class ConfigExampleServlet extends HttpServlet {
    private String adminEmail;
    @Override
    public void init(ServletConfig config) throws ServletException {
        super.init(config);
        // Retrieve initialization parameter from web.xml
        adminEmail = config.getInitParameter("adminEmail");
    }
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse
                         response)
            throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("");
        out.println("Servlet Config Example
");
        out.println("Admin Email: " + adminEmail + "
");
        out.println("");
    }
}

When to Use ServletConfig:
— Use ServletConfig when you need to pass configuration parameters that are specific to a particular servlet (e.g., a database connection string, a file path, or an email address).

2. ServletContext Interface

ServletContext is used to share information across the entire web application. It represents the web application’s environment and can be used to access shared resources such as files, attributes, and initialization parameters that are global to the application. Unlike ServletConfig, there is only one ServletContext object per web application, and it is shared by all servlets in that application.

Key Methods of ServletContext:
— getInitParameter(String name): Retrieves the value of an initialization parameter that is global to the entire web application.
— getInitParameterNames(): Returns an Enumeration of all global initialization parameter names.
— getAttribute(String name): Retrieves an attribute that has been set in the servlet context.
— setAttribute(String name, Object object): Sets an attribute that can be shared across servlets.
— getResourceAsStream(String path): Retrieves a resource as an input stream (e.g., a file from the WEB-INF directory).
— getRealPath(String path): Converts a virtual path to a real path on the server’s filesystem.
— log(String message): Logs a message to the server’s log file.

Example Usage of ServletContext:

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
@WebServlet("/contextExample")
public class ContextExampleServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse 
                         response)
            throws ServletException, IOException {
        ServletContext context = getServletContext();
        
        // Get a global initialization parameter
        String supportEmail = context.getInitParameter("supportEmail");
        
        // Set an attribute that can be shared across servlets
        context.setAttribute("appName", "My Web Application");
        
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("");
        out.println("Servlet Context Example
");
        out.println("Support Email: " + supportEmail + "
");
        out.println("Application Name: " + context.getAttribute("appName") 
                    + "
");
        out.println("");
    }
}

When to Use ServletContext:
— Use ServletContext when you need to share data or configuration parameters across the entire web application.
— It is also used when you need to interact with resources at the application level (e.g., reading a file from WEB-INF or logging messages).

Differences Between ServletConfig and ServletContext:
— Scope:
— ServletConfig is specific to a single servlet.
— ServletContext is shared by all servlets in the web application.
— Initialization Parameters:
— ServletConfig provides initialization parameters specific to a servlet.
— ServletContext provides initialization parameters that are global to the entire application.
— Attributes:
— ServletConfig does not manage attributes.
— ServletContext allows you to set and get attributes that are shared across servlets.

Conclusion
— ServletConfig is used for servlet-specific configuration, while ServletContext is used for application-wide configuration and shared resources.
— They both provide a way to access initialization parameters, but at different scopes: servlet-specific vs. application-wide.

Introduction to JSP (Java Server Pages)

Java Server Pages (JSP) is a technology that enables the creation of dynamic web content using a combination of HTML and Java code. JSP is commonly used for developing web applications that generate dynamic content, allowing you to embed Java code directly within HTML pages.

Key Features of JSP

1. Combination of HTML and Java Code: JSP allows the mixing of HTML tags with Java code to create web pages with dynamic content.

2. JSP Processing: The web container processes the JSP file by converting it into a Servlet, which is then compiled and executed to generate the HTML response.

3. File Extension: JSP files have the .jsp extension.

4. Predefined Objects: JSP provides several built-in objects that can be accessed without any explicit creation. Some of these objects include:

- request: Represents the HttpServletRequest object.

- session: Represents the HttpSession object for session tracking.

- out: Represents the PrintWriter object for sending data to the response.

- application: Represents the ServletContext object.

JSP Scripting Elements

JSP uses scripting elements to allow Java code to be embedded within the HTML. Here are the primary types of scripting elements:

1. Scriptlet: Allows you to write Java code that is valid inside a method.

<%
   // Java code here
   int sum = 5 + 3;
%>

- The code inside <% %> will be executed as part of the Servlet’s service method.

2. Expression: Outputs the result of an expression to the response.

<%= sum %>

- The <%= %> syntax evaluates the expression and converts it to a string that is directly inserted into the HTML.

3. Directive: Used to define page-level settings such as importing classes, content type, etc.

<%@ page import="java.util.Date" %>

- Directives are used to import classes or set page properties.

Example JSP File (Index.jsp)

Below is an example of a simple JSP file that demonstrates the use of scriptlets, expressions, and directives.

<%@ page import="java.util.Date" %>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1" %>


   
      
      JSP Example
   
   
      THIS IS INDEX JSP

      <%
         for (int i = 0; i < 5; i++) {
            System.out.println(i); // prints to server console
            out.write("
" + i); // writes to the web page
         }
      %>
      
Current Time: 
      <%
         Date dt = new Date();
         out.write("
" + dt);
         String str = "lms";
      %>
      

      <%= dt %>
      

      <%= str %>

Working with Multiple JSP Pages

Sometimes, JSP pages interact with each other, passing data between them. Here’s an example using two JSP files: Index.jsp and Show.jsp.

Index.jsp

The Index.jsp file sets some attributes in the application context, which will be shared across multiple JSP pages.

<%@ page import="java.util.ArrayList" %>
<%@ page import="java.util.List" %>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1" %>


   
      
      JSP Example
   
   
      THIS IS INDEX JSP

      <%
         String str = "lms";
         application.setAttribute("MSG", str);
         List emails = new ArrayList<>();
         emails.add("som@lms.com");
         emails.add("Rahul@lms.com");
         emails.add("Neha@lms.com");
         application.setAttribute("EMAILS", emails);
      %>
      Show Data

Show.jsp

The Show.jsp file retrieves the attributes set by Index.jsp and displays them on the page.

<%@ page import="java.util.List" %>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1" %>


   
      
      Show Data
   
   
      THIS IS SHOW JSP

      Message: <%= application.getAttribute("MSG") %>

      <%
         List emails = (List)application 
                                               .getAttribute("EMAILS");
         for (String email : emails) {
      %>
         
<%= email %>
      <%
         }
      %>

Key Concepts in JSP

- Scripting elements allow embedding Java code in HTML.

- Directives are used to import classes or set properties for the JSP page.

- Predefined objects like request, response, session, and application are automatically available in JSP.

Advantages of JSP

1. Separation of Content and Logic: Easier to maintain than traditional Servlets because the presentation logic (HTML) is separated from the business logic (Java code).

2. Predefined Objects: JSP provides implicit objects to handle common tasks like session management and output generation.

3. Easy to Use: JSP code is easier to write and understand as compared to Servlets.

Conclusion

JSP provides a convenient way to create dynamic web pages by combining HTML with Java code. It simplifies web application development by separating the presentation layer from the business logic, making it a popular choice for building Java-based web applications.

Session Management in Web Applications

Session management is crucial in web applications because HTTP and web servers are stateless by nature. This means they treat each request as a new one without knowing if it comes from the same user or a different one. Session management helps to maintain user information across multiple requests.

Key Concepts of Session Management

1. Stateless Nature of HTTP: The HTTP protocol does not keep track of client interactions. Each request sent to the server is processed independently without any memory of previous requests.

2. Need for Sessions: In many applications like shopping carts, user authentication, or personalized content, it’s necessary to track the user’s activity, such as which items they have added to the cart or which pages they have visited.

3. Session: A session is a series of related requests and responses between a client and a server. Sessions store user-specific information so that it can be shared across multiple requests.

How Sessions Work

To maintain a session, the server uses a session ID to recognize the client. This session ID is generated when a session is created and is stored either in cookies or URL parameters. The server uses this ID to track the session.

To use sessions in a web application, the following two steps are performed:

1. Identifying the Client: Check if the client has an existing session or needs a new one.

2. Managing the Conversational State: Store and retrieve user-specific data throughout the session.

Using HttpSession in JSP/Servlet

- You can use the HttpServletRequest object to create or access the HttpSession object in JSP/Servlet.

- Methods to access the session object:

HttpSession sess = request.getSession();
HttpSession sess = request.getSession(boolean);

Example of Session Management Techniques

Session Management Techniques:

1. HttpSession (Most common way to store session data)

2. Cookies (Stores session ID in the client-side browser)

3. URL Rewriting (Carries session ID within the URL)

4. Hidden Fields (Uses hidden HTML fields to pass data between requests)

Example Program for Session Management in a Shopping Cart

Here’s a breakdown of a JSP/Servlet-based program for handling session management in a shopping cart application:

Directory:

/ShoppingCartApp
├── /src
│   ├── /com
│   │   └── /lmsindia
│   │       └── /servlets
│   │           ├── AddToCartServlet.java
│   │           ├── ShowCartServlet.java
│   │           ├── RemoveFromCartServlet.java
│   │           └── SearchBooksServlet.java
│   ├── /META-INF
│   │   └── context.xml
│   └── /WEB-INF
│       ├── web.xml
│       └── classes
│           └── (compiled .class files)
├── /WebContent
│   ├── /jsp
│   │   ├── index.jsp
│   │   ├── showbooks.jsp
│   │   ├── showcart.jsp
│   │   └── placeorder.jsp
│   ├── /css
│   │   └── styles.css (optional CSS files for styling)
│   ├── /images
│   │   └── (any image files used in the project)
│   └── /scripts
│       └── scripts.js (optional JavaScript files for client-side logic)
└── /lib
    └── (external libraries or JAR files required for the project)

1. Index.jsp

This file serves as the entry point for the shopping cart application. It displays a form where users can select a category of books and search for them.

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


   
      
      lms Bookstore
   
   
      
         lms Bookstore

         Book Search

         
            





               Select Category

Explanation: This JSP page displays a simple dropdown form where users can select a category of books. Upon submission, the form directs the request to the searchbooks.lms servlet to handle the search logic.

2. Showcart.jsp

This file is responsible for displaying the items currently in the user’s shopping cart.

<%@page import="java.util.*"%>
<%@ page language="java" contentType="text/html; charset=ISO8859-1" pageEncoding="ISO-8859-1"%>


   
      
      lms BookStore - Shopping Cart
   
   
      
         lms BookStore

         Your Shopping Cart

      
      <% 
         Object object = request.getAttribute("MSG");
         if(object != null) {
      %>
      

      
         <%= object %>
      
      <%
         } else {
            object = request.getAttribute("CART");
            ArrayList blist = (ArrayList) object;
            for(String bnm : blist) {
      %>
      
         
         <%= bnm %> 
      

      <%
            }
         }
      %>
      

      PLACE ORDER
      
ADD TO CART

Explanation: This page displays the list of items in the shopping cart. If the cart is empty or if there’s an error message, it displays the corresponding message. It also provides links to place the order or add more items to the cart.

3. Showbooks.jsp

Displays the list of available books based on the category selection.

<%@page import="java.util.*"%>
<%@ page language="java" contentType="text/html;charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>


   
      
      lms Bookstore - Available Books
   
   
      
         lms Bookstore

         Book List

         ${ADDED}
      
      

      <% Object obj = request.getAttribute("MSG");
         if (obj != null) { 
      %>
      

      
         <%= obj %>
         
GO TO SEARCH PAGE
      
      <%
         } else {
            obj = session.getAttribute("BOOKS");
            ArrayList blist = (ArrayList) obj;
            for (String bnm : blist) {
      %>
      
         
         <%= bnm %> 
         
      

      <%
            }
         }
      %>

Explanation: This page lists the books based on the selected category. It provides an option to add each book to the shopping cart.

4. Placeorder.jsp

This JSP page confirms the order placement and then invalidates the session.

<%@page import="java.util.*"%>
<%@ page language="java" contentType="text/html;charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>


   
      
      Order Confirmation
   
   
      
         Bookstore

         Your Order has been placed successfully

         <%
            session.invalidate();
         %>
         

         GO TO SEARCH PAGE

Explanation: Once the order is placed, the session is invalidated to clear the user’s cart, and a success message is displayed.

5. Web.xml

Deployment descriptor that configures the servlet mappings and application settings.


   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"
   id="WebApp_ID" version="3.0">
   Shopping Cart
   
      index.jsp
   
   
      SearchBooks
      com.lmsindia.servlets.SearchBooksServlet
   
   
      SearchBooks
      /searchbooks.lms
   
   
      AddToCartServlet
      com.lmsindia.servlets.AddToCartServlet
   
   
      AddToCartServlet
      /addtocart.lms
   
   
      ShowCartServlet
      com.lmsindia.servlets.ShowCartServlet
   
   
      ShowCartServlet
      /showcart.lms
   
   
      RemoveFromCartServlet
      com.lmsindia.servlets.RemoveFromCartServlet
   
   
      RemoveFromCartServlet
      /removeformcart.lms

Explanation: This file maps specific URLs to their corresponding servlets and defines the application’s welcome file, which is the page users see first when they access the application.

Summary of Session Management

- HttpSession is the most common method for managing sessions.

- Cookies and URL Rewriting can be used to maintain session IDs.

- Hidden Fields can be used in forms to pass data between requests.

Session management is vital for building user-specific experiences in web applications like e-commerce sites, where tracking the user’s state and data is necessary for personalized interactions.

Exploring HttpSession in Detail

HttpSession is an interface that allows server-side session tracking in Java-based web applications. It helps maintain user data across multiple requests. Here’s a quick overview of its primary methods and uses:

1. Creating a Session:

- HttpSession getSession() — Retrieves the current session or creates a new session if none exists.

- HttpSession getSession(boolean create) — Retrieves the current session, and if create is true, it creates a new session if none exists.

2. Storing and Retrieving Data from the Session:

- void setAttribute(String name, Object value) — Stores data in the session as an attribute.

- Object getAttribute(String name) — Retrieves the value of an attribute stored in the session.

- void removeAttribute(String name) — Removes an attribute from the session.

- Enumeration getAttributeNames() — Returns an enumeration of attribute names stored in the session.

3. Session Management:

- public String getId() — Returns the unique session ID.

- public boolean isNew() — Checks if the session is newly created.

- public void invalidate() — Destroys the session immediately.

- public void setMaxInactiveInterval(int seconds) — Sets the maximum inactive interval for a session before it expires.

- public long getLastAccessedTime() — Returns the last time the session was accessed.

- public long getCreationTime() — Returns the time the session was created.

Now, let’s take a look at the program files using HttpSession.

1. Index.jsp

This JSP page demonstrates the usage of the session to display the session ID and check if the session is new.

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


   
      
      Session Test
   
   
      
         
Session ID: <%= session.getId() %>
         
Is New Session: <%= session.isNew() %>
         
TEST

Explanation:

- This page retrieves and displays the session ID and checks if the session is new using the methods session.getId() and session.isNew().

- The link redirects to the TestServlet when clicked.

2. Web.xml

This configuration file sets up the servlet mapping and session timeout settings.


         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" 
         id="WebApp_ID" version="3.0">
   lms_20
   
      index.jsp
   
   
      TestServlet
      com.lmsindia.servlet.TestServlet
   
   
      TestServlet
      /test.lms
   
   
      30

Explanation:

- The servlet mapping binds the TestServlet to the URL pattern /test.lms.

- The section sets the session timeout to 30 minutes. This means that if the session remains inactive for 30 minutes, it will be automatically invalidated.

3. TestServlet.java

This servlet demonstrates the creation of a session and the use of its properties.

package com.lmsindia.servlet;
import java.io.IOException;
import java.io.Writer;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
public class TestServlet extends HttpServlet {
   @Override
   protected void service(HttpServletRequest req, HttpServletResponse res) 
         throws ServletException, IOException {
      HttpSession session = req.getSession(); // Retrieves or creates a new session
      Writer out = res.getWriter();
      out.write("
ID: " + session.getId());
      out.write("
isNew: " + session.isNew());
      // Checking if the session is new or already exists
   }
}

Explanation:

- req.getSession() creates a new session if none exists or retrieves the current session.

- session.getId() displays the unique session identifier.

- session.isNew() checks if the session is newly created (returns true) or if it’s a pre-existing session.

Session Management Methods

To manage session expiration, you can use these methods:

1. Explicitly Destroying a Session:

session.invalidate();

This method destroys the session immediately.

2. Setting Session Timeout Interval:

session.setMaxInactiveInterval(int intervalInSeconds);

This sets the timeout interval, after which the session will expire if it remains inactive.

3. Session Timeout in Web.xml:

This setting in web.xml defines the timeout interval in minutes for all sessions in the web application.

Summary

This example illustrates the basics of session management using HttpSession in a Java web application:

- Session Tracking: Create, track, and manage user sessions.

- Session Attributes: Store and retrieve user-specific data in session attributes.

- Session Invalidation: Destroy sessions explicitly or automatically using timeouts.

This approach helps maintain state across multiple client requests in stateless HTTP connections, making it fundamental for web applications requiring user-specific interactions.

Servlet Scopes

Servlets provide three main scopes for managing data: Request Scope, Session Scope, and Context (or Application) Scope. Each scope defines the visibility and lifespan of the data stored within it.

1. Request Scope

- Definition: Data stored in the HttpServletRequest object.

- Accessibility: Accessible only for the duration of a single request. Once the request is completed (e.g., after a response is sent to the client), the data is no longer available.

- Use Case: Ideal for temporary data that is only needed while processing a specific request, such as form input.

Methods:

- void setAttribute(String name, Object value): Stores an attribute in the request.

- void removeAttribute(String name): Removes an attribute from the request.

- Object getAttribute(String name): Retrieves an attribute from the request.

- Enumeration getAttributeNames(): Gets the names of all attributes.

2. Session Scope

- Definition: Data stored in the HttpSession object.

- Accessibility: Accessible across multiple requests made by the same user during a session. A session typically lasts until the user logs out or the session times out.

- Use Case: Suitable for user-specific data that should persist across requests, such as user preferences or login status.

Methods:

- Similar to request scope but using the session object instead.

3. Context (or Application) Scope

- Definition: Data stored in the ServletContext object.

- Accessibility: Accessible by all users across multiple requests. The data persists as long as the application is running, making it suitable for shared resources or configuration settings.

- Use Case: Best for global data that needs to be accessed by multiple users, like application-wide settings or shared data.

Methods:

- Same as above but using the context object.

Summary

- Request Scope: Temporary data for a single request.

- Session Scope: User-specific data across multiple requests within a session.

- Context/Application Scope: Shared data available to all users and requests during the application’s lifecycle.

These scopes help manage data effectively in web applications, ensuring that data is available where and when it’s needed while also managing memory efficiently.

Exploring Cookies

Cookies are small pieces of data stored on the client-side, which help in maintaining session state between HTTP requests. They are used to store user-specific information like session IDs, preferences, or tracking data. Here are the key points:

1. Creating a Cookie:

- A cookie is created on the server with a name and value:

Cookie ck = new Cookie("email", "som@lms.com");

- Cookies store information in key-value pairs, and both the name and value are strings.

2. Adding a Cookie to the Response:

- Once a cookie is created, it is added to the HTTP response to send it to the client:

response.addCookie(ck);

3. Accessing Cookies from a Request:

- Cookies that were stored on the client machine are sent back to the server with each HTTP request:

Cookie[] cookies = request.getCookies();
for (Cookie c : cookies) {
    String cookieName = c.getName();
    String cookieValue = c.getValue();
    System.out.println(cookieName + ": " + cookieValue);
}

4. Removing Cookies:

- To remove a cookie from the client’s browser, set its maximum age to 0 and add it to the response:

Cookie c = new Cookie("cookieName", "");
c.setMaxAge(0);
response.addCookie(c);

Understanding JSESSIONID Cookie

The container manages sessions by using a special cookie named JSESSIONID. The process involves:

- Creating a cookie with the session ID when a session is created.

- Adding that cookie to the response to the client.

- Retrieving this cookie with subsequent requests to track the session.

Web Container’s Role in Session Management:

- The server generates a special cookie: JSESSIONID.

- It adds the JSESSIONID cookie to the response.

- It uses JSESSIONID to map the session ID to the corresponding session object.

Example Program Files

Let’s review the example files involved in demonstrating how to work with cookies in a Java web application.

1. Index.html

This file contains a form to add and remove cookies.



   
      
      Cookie Example
   
   
      Cookie Example

      
         

         
      

      

      
         Enter Book Name

2. AddServlet.java

This servlet handles adding a new cookie.

package com.lmsindia.servlet;
import java.io.IOException;
import java.io.Writer;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
public class AddServlet extends HttpServlet {
   protected void service(HttpServletRequest req, HttpServletResponse res) 
                                   throws ServletException, IOException {
      Writer out = res.getWriter();
      String bnm = req.getParameter("bname");
      Cookie c1 = new Cookie(bnm, null);
      res.addCookie(c1);
      out.write("" + bnm + " added
");
      Cookie cs[] = req.getCookies();
      if (cs == null) {
         out.write("You are a new client
");
         HttpSession sess = req.getSession();
      } else {
         boolean found = false;
         for (Cookie c : cs) {
            String nm = c.getName();
            String val = c.getValue();
            out.write("" + nm + ": " + val + "
");
            if (nm.equals("JSESSIONID")) found = true;
         }
         if (found) {
            out.write("You are an existing client
");
         }
      }
      RequestDispatcher rd = req.getRequestDispatcher("index.html");
      rd.include(req, res);
   }
}

3. RemoveServlet.java

This servlet handles removing a cookie.

package com.lmsindia.servlet;
import java.io.IOException;
import java.io.Writer;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
public class RemoveServlet extends HttpServlet {
   protected void service(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
      String bnm = req.getParameter("bname");
      Writer out = res.getWriter();
      Cookie[] cs = req.getCookies();
      if (cs == null) {
         out.write("You are a new client
");
         HttpSession sess = req.getSession();
      } else {
         boolean found = false;
         for (Cookie c : cs) {
            String nm = c.getName();
            if (nm.equals(bnm)) {
               c.setMaxAge(0);
               res.addCookie(c);
               out.write("Cookie " + bnm + " removed
");
            } else {
               out.write("" + nm + ": " + c.getValue() + "
");
            }
         }
      }
      RequestDispatcher rd = req.getRequestDispatcher("index.html");
      rd.include(req, res);
   }
}

4. Web.xml

The web descriptor file with servlet mappings.


         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"
         id="WebApp_ID" version="3.0">
   lms22
   
      index.html
   
   
      AddServlet
      com.lmsindia.servlet.AddServlet
   
   
      AddServlet
      /add.lms
   
   
      RemoveServlet
      com.lmsindia.servlet.RemoveServlet
   
   
      RemoveServlet
      /remove.lms

When dealing with web applications, maintaining a session state between the client and the server is crucial. Cookies are a common method to store session information, but they aren’t always reliable because users can disable them, or certain browsers might not support them. In such scenarios, alternatives like URL Rewriting and Hidden Fields are used to manage session tracking. Let’s explore these two techniques in detail.

1. URL Rewriting

URL Rewriting is a technique where the session information (usually the session ID) is appended to the URL of every link or form action in the web application. This way, the session ID is carried in the URL, ensuring that it is passed from the client to the server with each request, even if cookies are disabled.

How URL Rewriting Works

When a session is created, the server generates a unique session ID for each user. Instead of relying on cookies to carry this session ID, URL rewriting explicitly appends the session ID to every URL as a query parameter. For example:

- Original URL: http://example.com/page.jsp

- Rewritten URL: http://example.com/page.jsp;jsessionid=12345ABCDEF

The session ID (jsessionid=12345ABCDEF) is appended to the URL. The web server or servlet container recognizes the session ID in the URL and associates it with the correct session object.

URL Encoding in Java Servlets

To encode URLs with the session ID automatically, you can use the encodeURL() method provided by the HttpServletResponse class in Java servlets. This method checks whether the client supports cookies and, if not, adds the session ID to the URL.

Example code:

String encodedURL = response.encodeURL("page.jsp");

- If cookies are enabled, the encoded URL remains as page.jsp.

- If cookies are disabled, the URL will be rewritten to something like page.jsp;jsessionid=12345ABCDEF.

The encodeURL() method ensures that the session ID is included only when necessary.

Advantages of URL Rewriting

- Works even if cookies are disabled: Since the session ID is carried directly in the URL, it doesn’t rely on cookies.

- Simple to implement: Most servlet containers handle URL rewriting automatically when you use encodeURL().

Disadvantages of URL Rewriting

- URL visibility: The session ID is visible in the URL, which could be a security risk if the URL is shared.

- Manual intervention: If the web page has many links, each link must be rewritten with the session ID, which can be error-prone.

- Session expiration: Once the browser is closed, the session ID may be lost if not managed properly.

2. Hidden Fields

Hidden Fields are another way to manage session tracking by storing the session ID in a form’s hidden input field. Hidden fields allow data to be passed from the client to the server without displaying it to the user.

How Hidden Fields Work

The hidden field is added to the HTML form, and when the form is submitted, the session ID is sent to the server as part of the request. Here is an example of an HTML form with a hidden field:

In this example:

- The hidden field (”>) holds the session ID.

- When the form is submitted, the session ID is sent to the server along with the other form data.

The server can then use the session ID from the hidden field to retrieve the session object associated with the user.

Advantages of Hidden Fields

- Compatible with all browsers: Since hidden fields are part of the HTML form, they work with all browsers and are not affected by cookie settings.

- Easy to use with form submissions: Hidden fields integrate seamlessly with form-based interactions in web applications.

Disadvantages of Hidden Fields

- Limited to form submissions: Hidden fields only work when the data is sent via form submissions, making them unsuitable for links or navigation between pages.

- Manual updates required: You need to ensure that the hidden field is included in every form, which can be cumbersome for large applications.

- Security risks: Although hidden fields are not visible to the user, they can still be viewed or modified using browser developer tools, so they are not completely secure.

Comparison of URL Rewriting and Hidden Fields

When to Use URL Rewriting or Hidden Fields

- URL Rewriting:

- Use it when you need to track sessions across multiple pages using links.

- It is more flexible since it works with any type of HTTP request.

- Hidden Fields:

- Use it primarily for form-based interactions.

- It is ideal when you do not want the session ID to appear in the URL.

Combining Techniques for Session Management

For robust session management, it is common to use a combination of cookies, URL rewriting, and hidden fields. Here’s a strategy:

1. Default to Cookies: Use cookies as the primary method for session tracking since they are simple and widely supported.

2. Fallback to URL Rewriting: If cookies are disabled, use URL rewriting to carry the session ID in the URL.

3. Use Hidden Fields: For form submissions, use hidden fields to ensure the session ID is always included in the request.

By combining these techniques, you can ensure that your web application can maintain sessions effectively even if cookies are not supported or are disabled by the user.

Conclusion

URL Rewriting and Hidden Fields are essential alternatives for session tracking when cookies cannot be used. Both techniques have their own use cases and limitations, and understanding their advantages and disadvantages allows you to design more flexible and robust web applications.

Filters in Java Servlets

Filters are web components similar to servlets but designed to perform tasks before and after the core request processing by a servlet. They allow for pre-processing (before request handling) and post-processing (after response handling) of HTTP requests and responses.

Why Use Filters?

Instead of writing the same code for logging, security checks, or other common tasks in multiple servlets, you can use filters to centralize these tasks. This approach reduces code duplication and simplifies maintenance.

Common Tasks Using Filters

- Pre-processing tasks (before core request processing):

- Logging: Keeping track of incoming requests for debugging or auditing.

- Security checks: Implementing authentication and authorization checks to secure resources.

- Session validation: Ensuring that user sessions are valid before allowing access to certain parts of the application.

- Post-processing tasks (after core request processing):

- Data compression: Compressing the response to improve network efficiency.

- Data encoding/encryption: Securing sensitive data in the response.

- URL Rewriting: Modifying URLs in the response, if needed.

Developing Filters with Servlet 2.x

To create a filter using Servlet 2.x, you need to:

1. Create a Filter Class: Implement the javax.servlet.Filter interface.

2. Override Filter Methods: Implement three lifecycle methods:

- init(FilterConfig fc): Initializes the filter.

- doFilter(ServletRequest req, ServletResponse res, FilterChain chain): Handles the request and response.

- destroy(): Releases resources when the filter is destroyed.

3. Configure the Filter in web.xml: Register the filter in the web.xml deployment descriptor.

Example Configuration (web.xml):


    demoFilter
    com.lmsindia.servlet.DemoFilter
    
        city
        Noida
    


    demoFilter
    /test

Developing Filters with Servlet 3.0 Annotations

Servlet 3.0 introduced annotations, making it easier to configure filters directly in the Java code without modifying the web.xml file.

Steps to develop a filter using Servlet 3.0:

1. Create a Filter Class: Implement the javax.servlet.Filter interface.

2. Use Annotations: Configure the filter with the @WebFilter annotation.

Example Using Annotations:

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.IOException;
@WebFilter(filterName="demoFilter", urlPatterns={"/demo.lms"},
           initParams={@WebInitParam(name="city", value="Noida")})
public class DemoFilter implements Filter {
    @Override
    public void init(FilterConfig config) throws ServletException {
        System.out.println("**DemoFilter..Init()");
        String city = config.getInitParameter("city");
        System.out.println(city);
    }
    @Override
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
            throws IOException, ServletException {
        String name = req.getParameter("name");
        String email = req.getParameter("email");
        String ip = req.getRemoteAddr();
        System.out.println(name);
        System.out.println(email);
        System.out.println(ip);
        chain.doFilter(req, res);  // Continue with the next filter or servlet in the chain
        System.out.println("DemoFilter doFilter()-after");
    }
    @Override
    public void destroy() {
        System.out.println("destroy()");
    }
}

Lifecycle of a Filter

1. Initialization: During server startup, filters are initialized with the init() method.

- The container loads the filter class and creates an instance.

- It creates a FilterConfig object containing initialization parameters and a reference to the ServletContext.

- The init() method is called with the FilterConfig object.

2. Request Processing:

- The doFilter() method is invoked for each incoming request.

- It performs pre-processing tasks and then forwards the request to the next filter or the target servlet using chain.doFilter().

- Post-processing tasks are performed after the servlet processes the request.

3. Destruction: When the server shuts down, the filter’s destroy() method is called to release any resources.

Filter Configuration Options

Filters can be configured to apply to multiple servlets in different ways:

1. Mapping by URL pattern:


    filterC
    /add.lms

2. Mapping by servlet name:


    lmsSessionFilter
    removeServlet

3. Mapping to multiple URLs:


    filterC
    /add.lms
    /remove.lms

4. Mapping to URL patterns with wildcards:


    lmsSessionFilter
    *.lms

Example Files for the Filter Program

1. Index.html: HTML form for user input.

2. DemoServlet.java: Servlet handling the core request processing.

3. DemoFilter.java: Filter for pre-processing and post-processing tasks.

4. web.xml: Servlet configuration file (if not using annotations).

Conclusion

Filters are a powerful way to manage request processing in web applications, allowing developers to handle cross-cutting concerns like security, logging, and data manipulation in a centralized and efficient manner. They help reduce code duplication and make maintenance easier by keeping the logic separate from the core servlet processing.

Explanation of Listener Concepts in Servlet API

Listeners in the Servlet API are a powerful mechanism that allows developers to monitor and respond to specific events in a web application’s lifecycle. They can track various changes in the application, such as the creation or destruction of objects like ServletContext, HttpSession, or request attributes. Here’s a detailed explanation of listeners and their usage:

1. Core Tasks Monitored by Listeners

When a web application is running within a web container, the following tasks can be monitored using listeners:

1. ServletContext Events:

- Creating and destroying the ServletContext object.

- Adding, removing, or replacing attributes in the ServletContext.

2. HttpServletRequest Events:

- Creating and destroying the HttpServletRequest object.

- Adding, removing, or replacing attributes in the HttpServletRequest.

3. HttpSession Events:

- Creating and destroying the HttpSession object.

- Adding, removing, or replacing attributes in the HttpSession.

- Passivating (serializing) and activating (deserializing) the HttpSession.

2. List of Listener Interfaces in the Servlet API

The Servlet API provides several listener interfaces to handle these events. Each listener interface is paired with an event class that encapsulates the event information. Here are the commonly used listener interfaces:

3. Steps to Create a Listener in Servlet 2.x

1. Create a Listener Class: Write your own listener class by implementing the required listener interface.

2. Override the Listener Methods: Implement the methods defined in the listener interface.

Example:

public class MyListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        // Code to execute when the context is initialized
    }
    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        // Code to execute when the context is destroyed
    }
}

3. Register the Listener in web.xml:


    com.lms.MyListener

4. Steps to Create a Listener in Servlet 3.0

1. Create a Listener Class: Implement the listener interface.

2. Override the Listener Methods.

3. Use Annotations to Register: Register the listener using the @WebListener annotation, eliminating the need to modify web.xml.

Example:

@WebListener
public class MyListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        // Code to execute when the context is initialized
    }
    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        // Code to execute when the context is destroyed
    }
}

5. Container Tasks During Start-Up and Shutdown

At Start-Up:

1. The ServletContext object is created.

2. Context parameters are retrieved from web.xml and stored.

3. A ServletContextEvent is created.

4. The ServletContextListener is created, and the contextInitialized() method is called.

At Shutdown:

1. The contextDestroyed() method is invoked on the ServletContextListener.

2. The ServletContext object is destroyed.

Program Files Example Overview

1. index.html

This file is the front-end of the web application. It is an HTML file that contains a simple form with a text field for the user to enter their email address and a submit button.

Explanation:

- When the user fills in the email address and clicks on the “Submit” button, the form data is sent to the TestServlet using a POST request.

- The action=”test.lms” in the form specifies that the request should be handled by the servlet mapped to /test.lms.



   
      
      Insert title here
   
   
      lms

      Listener Example

      
         Enter Email:

2. TestServlet.java

This is the servlet that processes the form submission from index.html. It interacts with the HttpSession and ServletContext to add, replace, and remove attributes.

Explanation:

- The servlet uses the service() method to handle the HTTP request.

- It retrieves the email parameter from the form and stores it as an attribute in the ServletContext.

- The servlet then performs operations like replacing and removing the attribute from the ServletContext.

- It also invalidates the current session to trigger the session destruction event.

package com.lmsindia.Servlet;
import java.io.IOException;
import java.io.Writer;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
public class TestServlet extends HttpServlet {
   @Override
   protected void service(HttpServletRequest req, HttpServletResponse res)
   throws ServletException, IOException {
      System.out.println("TestServlet-> service()");
      System.out.println("Accessing Session object");
      HttpSession session = req.getSession();
      String eml = req.getParameter("email");
      ServletContext ctx = getServletContext();
      System.out.println("Storing attribute in Context");
      ctx.setAttribute("email", eml);
      System.out.println("Replacing attributes in Context");
      ctx.setAttribute("email", "som@lms.com");
      System.out.println("Removing attribute in Context");
      ctx.removeAttribute("email");
      System.out.println("Validating Session Objects");
      session.invalidate();
      Writer out = res.getWriter();
      out.write("Verify the server console
");
   }
}

3. MyContextListener.java

This listener class implements ServletContextListener and listens to the creation and destruction events of the ServletContext.

Explanation:

- contextInitialized() method: Executes when the ServletContext is initialized at the start-up of the web application.

- contextDestroyed() method: Executes when the ServletContext is destroyed during the shutdown of the web application.

package com.lmsindia.Servlet;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
public class MyContextListener implements ServletContextListener {
   public MyContextListener() {
      System.out.println("** MyContextListener() default constructor");
   }
   @Override
   public void contextDestroyed(ServletContextEvent event) {
      ServletContext ctx = event.getServletContext();
      System.out.println("ContextDestroyed: " + ctx);
   }
   @Override
   public void contextInitialized(ServletContextEvent event) {
      ServletContext ctx = event.getServletContext();
      System.out.println("ContextInitialized: " + ctx);
   }
}

4. MyContextAttributeListener.java

This listener handles changes in attributes within the ServletContext. It implements ServletContextAttributeListener.

Explanation:

- attributeAdded(), attributeRemoved(), and attributeReplaced() methods handle the events of adding, removing, and replacing attributes in the ServletContext.

package com.lmsindia.Servlet;
import javax.servlet.ServletContextAttributeEvent;
import javax.servlet.ServletContextAttributeListener;
public class MyContextAttributeListener implements ServletContextAttributeListener {
   public MyContextAttributeListener() {
      System.out.println("** MyContextAttributeListener() default constructor");
   }
   @Override
   public void attributeAdded(ServletContextAttributeEvent event) {
      String name = event.getName();
      String value = event.getValue().toString();
      System.out.println("Attribute Added: " + name + "\t" + value);
   }
   @Override
   public void attributeRemoved(ServletContextAttributeEvent event) {
      String name = event.getName();
      String value = event.getValue().toString();
      System.out.println("Attribute Removed: " + name + "\t" + value);
   }
   @Override
   public void attributeReplaced(ServletContextAttributeEvent event) {
      String name = event.getName();
      String value = event.getValue().toString();
      System.out.println("Attribute Replaced: " + name + "\t" + value);
   }
}

5. MySessionListener.java

This listener monitors session events. It implements HttpSessionListener.

Explanation:

- sessionCreated() method: Executes when a new session is created.

- sessionDestroyed() method: Executes when a session is destroyed.

package com.lmsindia.Servlet;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
public class MySessionListener implements HttpSessionListener {
   public MySessionListener() {
      System.out.println("** MySessionListener() default constructor");
   }
   @Override
   public void sessionCreated(HttpSessionEvent event) {
      System.out.println("Session Created");
   }
   @Override
   public void sessionDestroyed(HttpSessionEvent event) {
      System.out.println("Session Destroyed");
   }
}

6. MyRequestListener.java

This listener tracks the creation and destruction of HTTP requests. It implements ServletRequestListener.

Explanation:

- requestInitialized() method: Executes when a request is initialized.

- requestDestroyed() method: Executes when a request is destroyed.

package com.lmsindia.Servlet;
import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
public class MyRequestListener implements ServletRequestListener {
   public MyRequestListener() {
      System.out.println("MyRequestListener() default constructor");
   }
   @Override
   public void requestDestroyed(ServletRequestEvent event) {
      System.out.println("Request Destroyed");
   }
   @Override
   public void requestInitialized(ServletRequestEvent event) {
      System.out.println("Request Initialized");
   }
}

7. web.xml

This is the deployment descriptor file that configures the servlet and listener classes for the web application. It tells the web container which classes to use for handling specific events.

Explanation:

- It defines servlet mappings for TestServlet.

- It registers all the listeners (MyContextListener, MyContextAttributeListener, MyRequestListener, and MySessionListener).


   xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
   id="WebApp_ID" version="3.0">
   lms27
   
      index.html
   
   
      testServlet
      com.lmsindia.Servlet.TestServlet
   
   
      testServlet
      /test.lms
   
   
      com.lmsindia.Servlet.MyContextListener
   
   
      com.lmsindia.Servlet.MyContextAttributeListener
   
   
      com.lmsindia.Servlet.MyRequestListener
   
   
      com.lmsindia.Servlet.MySessionListener

Summary

- index.html: Displays the form for user input.

- TestServlet.java: Processes the form submission and interacts with context and session attributes.

- Listener classes (MyContextListener, MyContextAttributeListener, MySessionListener, MyRequestListener): Handle various lifecycle events of the web application’s components.

- web.xml: Configures the servlet and listeners to handle requests and lifecycle events.

These files work together to demonstrate how listeners can be used to track and respond to different events in a Java web application’s lifecycle.

Here are the key components of a sample Servlet listener implementation:

1. HTML Form (index.html): Contains a simple form for user interaction.

2. TestServlet.java: Implements the core logic to interact with session and context attributes.

3. Listener Classes:

- MyContextListener.java: Tracks ServletContext initialization and destruction.

- MyContextAttributeListener.java: Tracks attribute changes in the ServletContext.

- MySessionListener.java: Monitors session creation and destruction.

- MyRequestListener.java: Monitors request creation and destruction.

4. Web Configuration (web.xml): Registers servlets and listeners to the application.

This approach helps you efficiently manage the different states of your web application’s objects while keeping the code modular and maintainable.

Session Migration

What is Session Migration?

Session migration is the process of transferring a user’s session data from one server to another in a distributed or clustered server environment. This is common in large-scale enterprise applications where multiple servers (nodes) are used to handle numerous user requests efficiently.

Why Session Migration is Needed?

In a clustered environment, load balancers distribute user requests across multiple servers to handle the load efficiently. If a user starts a session on one server and then their next request is handled by a different server, the session data must be migrated to maintain continuity.

How Session Migration Works:

- Session Creation: The user’s first request is processed by a server (e.g., Server 1), where a session object is created.

- Session Migration: If the subsequent request from the same user is handled by a different server (e.g., Server 3), the session object must be transferred from Server 1 to Server 3.

- Events in Session Migration: Two key events occur during session migration:

- Session Passivation: The session is passivated (temporarily stored or serialized) on Server 1 before being transferred.

- Session Activation: The session is activated (restored or deserialized) on Server 3 when it is needed.

Handling Session Events with HttpSessionActivationListener

To handle session passivation and activation events, you can use the HttpSessionActivationListener interface with the following methods:

- void sessionWillPassivate(HttpSessionEvent event): This method is called by the web container when the session is about to be passivated on the original server (e.g., Server 1).

- void sessionDidActivate(HttpSessionEvent event): This method is called by the web container when the session is activated on the new server (e.g., Server 3).

Servlet API and Class Hierarchy

Overview of the Servlet API:

- javax.servlet.Servlet Interface: This is the root interface for all servlets. It defines the service() method, which is responsible for handling requests from the client.

- javax.servlet.GenericServlet Class: This is an abstract class that implements the Servlet interface. It provides default implementations for some methods and leaves the service() method abstract. It is used as a base class for servlets that are not tied to any specific protocol.

- javax.servlet.http.HttpServlet Class: This class extends GenericServlet and is designed for HTTP-based servlets. It provides methods for handling HTTP-specific request types like GET, POST, PUT, and others.

Servlet Class Hierarchy:

1. Servlet Interface

- Contains the method: void service(ServletRequest req, ServletResponse res)

2. GenericServlet Class

- Extends the Servlet interface and provides a skeletal implementation.

- The service() method remains abstract in this class.

3. HttpServlet Class

- Extends GenericServlet.

- It provides implementations for HTTP-specific methods like doGet(), doPost(), and others.

3. Servlet Method Overriding Cases

Case 1: Extending HttpServlet and Overriding the Generic service() Method

If you extend HttpServlet and override the generic service() method, then that overridden method will be called for every request, regardless of the HTTP method (GET, POST, etc.).

class HelloServlet extends HttpServlet {
    @Override
    public void service(ServletRequest req, ServletResponse res) {
        // This method will handle all incoming HTTP requests.
    }
}

Case 2: Extending HttpServlet and Overriding the HTTP service() Method

In this scenario, you extend HttpServlet and override the HTTP-specific service() method, which handles incoming requests at the HTTP level. This method internally determines the HTTP method (GET, POST, etc.) and calls the appropriate doXXX() method.

class HelloServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse res) {
        // This method will handle all HTTP requests and delegate to doGet(), doPost(), etc.
    }
}

Case 3: Extending GenericServlet and Overriding the service() Method

If you extend GenericServlet directly and override the service() method, you will handle all incoming requests generically, without any protocol-specific logic (like GET or POST).

class HelloServlet extends GenericServlet {
    @Override
    public void service(ServletRequest req, ServletResponse res) {
        // Handles all requests as a generic servlet, not HTTP-specific.
    }
}

Explanation:

- Extending GenericServlet means that your servlet is protocol-independent.

- Since you’re not tied to HTTP, you can’t use methods like doGet() or doPost().

Case 4: Extending HttpServlet and Overriding Both service() Methods

If you override both the generic service() method and the HTTP-specific service() method in HttpServlet, then both methods play different roles:

- The generic service() method will handle all incoming requests.

- The HTTP service() method will delegate to the appropriate doXXX() method based on the HTTP request type.

class HelloServlet extends HttpServlet {
    @Override
    public void service(ServletRequest req, ServletResponse res) {
        // Generic service method
    }
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse res) {
        // HTTP-specific service method
    }
}

Explanation:

- The container first calls the generic service() method, which might call the HTTP-specific service() method.

- The HTTP-specific method then delegates to doGet(), doPost(), etc., depending on the request type.

Case 5: Extending HttpServlet and Overriding the doGet() Method

When you extend HttpServlet and only override the doGet() method, the container automatically determines which HTTP method is being requested and calls the appropriate doXXX() method.

class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
        // Handle GET request
    }
}

Explanation:

- The container invokes the HTTP service() method of HttpServlet.

- The service() method checks the HTTP method of the request and calls doGet(), doPost(), or other doXXX() methods.

Key Points to Remember:

- Generic service() Method: If you override this method in your servlet, it will handle all incoming requests regardless of the HTTP method.

- HTTP service() Method: If you override this method, it can delegate to HTTP-specific methods like doGet() or doPost().

- doXXX() Methods: These methods (doGet(), doPost(), etc.) are specifically designed to handle HTTP requests based on the method type. Overriding these methods allows you to handle requests in a more structured and organized way.

HTTP Status Code 405 Error

- HTTP Status 405: This error indicates that the HTTP method (e.g., POST) is not supported by the requested URL. This happens when you try to handle a request with a method that your servlet does not support or has not overridden.

Understanding these cases helps you write more efficient and robust servlets, taking advantage of the servlet lifecycle and session management features to handle HTTP requests properly in your web applications.

Java Essentials: A Deep Dive into the java.lang Package

Pratik T — Fri, 11 Oct 2024 11:03:16 GMT

The java.lang package is one of the most fundamental packages in Java and is automatically imported into every Java program. It contains essential classes, interfaces, and methods that are commonly used in Java applications, making it the backbone of the Java language.

Key Characteristics of the java.lang Package

1. Default Package: The java.lang package is automatically available to all Java programs, so you don’t need to explicitly import it. This is why you can directly use classes like String, System, Math, and others without importing them.

2. Purpose: It provides a wide range of classes and interfaces that perform basic and essential operations, such as string manipulation, mathematical operations, system operations, and object manipulation.

3. Essential Classes: The classes in the java.lang package are fundamental to Java programming. These classes and interfaces provide critical functionalities that form the foundation for creating Java applications.

Example: Usage of java.lang Classes

Here’s a simple example demonstrating the use of some classes from the java.lang package:

package com.P1;
class LMS {
    public static void main(String arg[]) {
        Object o1 = new Object(); // java.lang.Object class object
        String s1 = new String(); // java.lang.String class object
    }
}

In the example above:

- We are creating an object of the Object class and the String class, both of which belong to the java.lang package.

- We do not need to import the java.lang.Object or java.lang.String classes, proving that the java.lang package is always available by default.

Important Classes, Interfaces, and Enums in java.lang

Here are some of the most commonly used classes, interfaces, and enums in the java.lang package:

1. java.lang.Object: The root class of the Java class hierarchy. Every class in Java directly or indirectly inherits from this class.

2. java.lang.String: Represents immutable sequences of characters. Widely used for string manipulations.

3. java.lang.StringBuffer: A thread-safe, mutable sequence of characters used for string manipulations.

4. java.lang.StringBuilder: A mutable sequence of characters, similar to StringBuffer but not synchronized, making it faster in single-threaded scenarios.

5. java.lang.System: Provides access to system resources, standard input/output, and other system-level properties.

6. java.lang.Runtime: Provides methods that interface with the Java runtime environment.

7. java.lang.Class: Used to obtain information about classes and objects at runtime.

8. java.lang.Throwable: The superclass of all errors and exceptions in Java.

9. java.lang.Exception: The base class for all checked exceptions.

10. java.lang.Error: Represents serious problems that a reasonable application should not try to catch.

11. java.lang.RuntimeException: Represents exceptions that can be thrown during the normal operation of the Java Virtual Machine (JVM).

12. java.lang.Math: Provides methods for performing basic numeric operations such as trigonometry, logarithms, square roots, and random number generation.

13. java.lang.Thread: Represents a thread of execution in a program.

14. java.lang.Runnable: An interface that should be implemented by any class whose instances are intended to be executed by a thread.

Wrapper Classes in java.lang

Java also provides wrapper classes for the eight primitive data types, and all these classes are part of the java.lang package. Wrapper classes allow you to treat primitive data types as objects.

1. java.lang.Byte: Wraps the primitive data type byte.

2. java.lang.Short: Wraps the primitive data type short.

3. java.lang.Integer: Wraps the primitive data type int.

4. java.lang.Long: Wraps the primitive data type long.

5. java.lang.Float: Wraps the primitive data type float.

6. java.lang.Double: Wraps the primitive data type double.

7. java.lang.Boolean: Wraps the primitive data type boolean.

8. java.lang.Character: Wraps the primitive data type char.

Why is java.lang a Default Package?

The java.lang package is included by default in every Java program because it contains the most fundamental classes and methods that are required for basic operations in Java. Without these classes, it would be difficult to perform even the simplest tasks in Java, such as:

- System Operations: Using the System class for input/output operations.

- String Manipulation: Using String, StringBuffer, and StringBuilder for handling text.

- Mathematical Calculations: Using the Math class for basic arithmetic operations.

- Object Methods: Using methods like toString(), equals(), and hashCode() from the Object class.

The availability of these classes by default ensures that Java developers have easy access to the essential tools needed to build applications without the hassle of manually importing basic classes.

java.lang.Object Class

Importance of java.lang.Object Class

- The java.lang.Object class is the root of the Java class hierarchy. Every class in Java implicitly inherits from the Object class unless it explicitly extends another class.

- This means that all classes in Java, directly or indirectly, are subclasses of Object.

Members of java.lang.Object Class

The java.lang.Object class contains several important methods that are frequently used in Java programming. Here is a detailed explanation of these methods:

1. public java.lang.Object()

- Type: Constructor

- Access Modifier: public

- Description: This is the default constructor of the Object class. It initializes a new instance of the class.

2. public final native java.lang.Class getClass()

- Type: Final Instance Method

- Access Modifier: public

- Description: Returns the Class object associated with the object’s runtime class. This method is used to get information about the object such as its class name, superclass, interfaces, and other details.

3. public native int hashCode()

- Type: Instance Method

- Access Modifier: public

- Description: Returns a unique hash code for the object. The hash code is used for efficient storage and retrieval of objects in data structures like hash tables.

4. public boolean equals(Object obj)

- Type: Instance Method

- Access Modifier: public

- Description: Compares the current object with the specified object for equality. By default, it checks if both objects refer to the same memory location.

5. protected native Object clone() throws CloneNotSupportedException

- Type: Instance Method

- Access Modifier: protected

- Description: Creates and returns a copy (or clone) of the object. The clone() method is used to perform shallow copying.

6. public String toString()

- Type: Instance Method

- Access Modifier: public

- Description: Returns a string representation of the object. The default implementation of toString() prints the class name and the hash code in hexadecimal form.

7. public final native void notify()

- Type: Instance Method

- Access Modifier: public

- Description: Wakes up a single thread that is waiting on the object’s monitor (typically used in thread synchronization).

8. public final native void notifyAll()

- Type: Instance Method

- Access Modifier: public

- Description: Wakes up all threads that are waiting on the object’s monitor.

9. public final native void wait(long timeout) throws InterruptedException

- Type: Instance Method

- Access Modifier: public

- Description: Causes the current thread to wait until another thread invokes the notify() or notifyAll() methods for this object, or a specified amount of time has passed.

10. public final void wait(long timeout, int nanos) throws InterruptedException

- Type: Instance Method

- Access Modifier: public

- Description: Similar to the previous method, but allows for greater precision with the inclusion of nanoseconds.

11. protected void finalize() throws Throwable

- Type: Instance Method

- Access Modifier: protected

- Description: This method is called by the garbage collector before an object is destroyed to perform any cleanup activities.

Example Program Demonstrating Object Class Methods

class LMS {
    public static void main(String arg[]) {
        A a1 = new A();
        System.out.println(a1.hashCode());
        System.out.println(a1.toString());
    }
}
class A {
}

Explanation:

- Since class A does not explicitly extend any other class, Object is its superclass by default.

- We create an object of class A using A a1 = new A(); and use it to call hashCode() and toString(), which are inherited from the Object class.

Exploring the getClass() Method

Example:

package com.P1;
interface I1 {}
interface I2 {}
interface I3 {}
class A implements I1, I2, I3 {}
class LMS {
    public static void main(String arg[]) {
        A a1 = new A();
        Class c1 = a1.getClass();
        System.out.println("----A.class file information----");
        System.out.println("Class Name :- " + c1.getName());
        System.out.println("Class Simple Name :- " + c1.getSimpleName());
        System.out.println("Package Name :- " + c1.getPackage().getName());
        System.out.println("Super Class Name :- " + c1.getSuperclass().getName());
        
        System.out.println("---A.class interface information----");
        Class[] interfaces = c1.getInterfaces();
        for (Class iface : interfaces) {
            System.out.println("Interface implemented by class A :- " + iface.getName());
        }
    }
}

Output:

----A.class file information----
Class Name :- com.P1.A
Class Simple Name :- A
Package Name :- com.P1
Super Class Name :- java.lang.Object
Super Class Package Name :- java.lang
---A.class interface information----
Interface implemented by class A :- com.P1.I1
Interface implemented by class A :- com.P1.I2
Interface implemented by class A :- com.P1.I3

Explanation:

This code demonstrates the use of the getClass() method to get detailed information about the A class, including its package, superclass, and interfaces.

Garbage collection in Java

Garbage collection in Java is an automatic memory management process that handles the cleanup of unused or unreferenced objects from the heap.

Key Concepts of Garbage Collection in Java

1. Dynamic Memory Allocation

- Java uses dynamic memory allocation, primarily in the heap area, where memory for objects is allocated when the new keyword is used.

- Unlike C/C++, where you have to manually deallocate memory using free() or delete, Java automates this cleanup process using garbage collection.

2. Garbage Collection Mechanism

- Purpose: Garbage collection is used to identify and dispose of objects that are no longer referenced, making their memory available for future allocation.

- The JVM automatically performs this task when it detects that memory resources are low or inefficiently utilized.

How JVM Identifies Unreferenced Objects

Here are two examples illustrating when an object becomes eligible for garbage collection:

Example 1

class LMS {
    public static void main(String arg[]) {
        A a1 = new A();
        A a2 = new A();
        a1 = null; // line - 7
    }
}
class A {
}

- In this example, two objects of class A are created.

- When a1 is set to null at line 7, the first object becomes eligible for garbage collection because it no longer has a reference.

Example 2

class A {
    static void m1() {
        A a1 = new A();
        A a2 = new A();
    }
    public static void main(String arg[]) {
        m1();
    }
}

- Here, the objects created inside the m1() method are local to that method.

- Once the m1() method execution completes, the local variables a1 and a2 go out of scope, and their objects in the heap become eligible for garbage collection.

When Does Garbage Collection Occur?

- The JVM triggers the garbage collection process when it detects that memory resources are low or when there’s a need to reclaim space for new object creation.

- Garbage collection is not guaranteed to run immediately upon request but is managed by the JVM based on memory availability and the CPU scheduler.

Important Garbage Collection Methods

1. System.gc()

- Syntax: public static void gc()

- This method suggests that the JVM should make an effort to start the garbage collection process.

- Internally, it calls Runtime.getRuntime().gc().

- Note: Calling System.gc() does not guarantee immediate garbage collection.

2. System.runFinalization()

- Syntax: public static void runFinalization()

- This method requests the JVM to run the finalization methods of objects that have been discarded but not yet finalized.

- Internally, it calls Runtime.getRuntime().runFinalization().

Steps Followed by JVM for Garbage Collection

1. Listing Unused Objects: The JVM first identifies objects that are no longer referenced.

2. gc() Method Invocation: If there is insufficient memory, the JVM calls the System.gc() method to start garbage collection.

3. Finalization: The JVM may also call runFinalization() to ensure that any necessary cleanup operations for discarded objects are completed.

Key Points to Remember

- Garbage collection is automatic in Java and does not require manual intervention like in languages such as C or C++.

- Although you can request garbage collection using System.gc(), the timing of the actual cleanup depends on the JVM’s memory management strategy.

- Understanding garbage collection is crucial for efficient memory management and to avoid memory leaks in Java applications.

Garbage collection ensures that Java applications run smoothly without running out of memory, helping developers focus on logic without worrying about memory cleanup.

Cloning

Please Refer this article

Cloning in Java is a technique to create a copy of an existing object. This process ensures that the new object is a separate instance with its own memory space, even though it may contain the same data as the original object. Java provides two main types of cloning: Shallow Cloning and Deep Cloning. Let’s explore both in detail with examples.

Shallow Cloning

Shallow Cloning creates a new object and copies the values of the instance variables from the original object to the new one. However, if the object contains references to other objects (nested objects), only the references are copied, not the actual objects. This means that the cloned object and the original object share references to the same memory locations for nested objects.

Example of Shallow Cloning

class A {
    int a;
    A(int a) {
        this.a = a;
    }
}
class B {
    int b;
    A a1;
    B(int b, A a1) {
        this.b = b;
        this.a1 = a1;
    }
}
class C implements Cloneable {
    int c;
    B b1;
    C(int c, B b1) {
        this.c = c;
        this.b1 = b1;
    }
    C getClone() throws CloneNotSupportedException {
        return (C) this.clone();
    }
}
public class LMS {
    public static void main(String arg[]) throws CloneNotSupportedException {
        A a1 = new A(101);
        B b1 = new B(202, a1);
        C c1 = new C(303, b1);
        C clone = c1.getClone();
        System.out.println("c1.b1.a1.hashCode: " + c1.b1.a1.hashCode());
        System.out.println("clone.b1.a1.hashCode: " + clone.b1.a1.hashCode());
    }
}

Output:

c1.b1.a1.hashCode: 123456
clone.b1.a1.hashCode: 123456

In this example, c1.b1.a1 and clone.b1.a1 have the same hash code, indicating that both objects share the same reference. This is a clear indication of shallow cloning.

Deep Cloning

Deep Cloning involves creating a copy of the object as well as all objects that are referenced by the original object. It creates an entirely new instance of the object, including any nested objects, ensuring that the clone and the original object do not share any references.

Example of Deep Cloning

class A {
    int a;
    A(int a) {
        this.a = a;
    }
}
class B {
    int b;
    A a1;
    B(int b, A a1) {
        this.b = b;
        this.a1 = a1;
    }
}
class C implements Cloneable {
    int c;
    B b1;
    C(int c, B b1) {
        this.c = c;
        this.b1 = b1;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        A clonedA = new A(this.b1.a1.a);
        B clonedB = new B(this.b1.b, clonedA);
        return new C(this.c, clonedB);
    }
    C getClone() throws CloneNotSupportedException {
        return (C) this.clone();
    }
}
public class LMS {
    public static void main(String arg[]) throws CloneNotSupportedException {
        A a1 = new A(101);
        B b1 = new B(202, a1);
        C c1 = new C(303, b1);
        C clone = c1.getClone();
        System.out.println("c1.b1.a1.hashCode: " + c1.b1.a1.hashCode());
        System.out.println("clone.b1.a1.hashCode: " + clone.b1.a1.hashCode());
    }
}

Output:

c1.b1.a1.hashCode: 123456
clone.b1.a1.hashCode: 789012

In this example, c1.b1.a1 and clone.b1.a1 have different hash codes, indicating that they are distinct objects. This demonstrates that deep cloning was successfully implemented.

Key Differences between Shallow and Deep Cloning

Conclusion

- Shallow Cloning is useful when you are only concerned with creating a copy of the top-level object.

- Deep Cloning is necessary when the nested objects should also be independently cloned to avoid unwanted reference sharing.

In Java, deep cloning typically requires manually overriding the clone() method, as the default implementation only provides shallow cloning.

java.lang.String

The java.lang.String class in Java is a powerful and fundamental part of the Java programming language, used to create and manipulate strings. Here’s a detailed breakdown of its characteristics and important methods:

Key Characteristics of java.lang.String Class

1. Not a Primitive Data Type:

- String is not a primitive data type but a class in the java.lang package.

- It is one of the most commonly used classes in Java for handling sequences of characters.

2. Immutable Nature:

- String objects are immutable, meaning that once a String object is created, its value cannot be changed.

- If you perform operations like concatenation or modification on a String, a new object is created instead of modifying the existing one.

3. Final Class:

- The String class is declared as final, which means it cannot be extended or subclassed.

4. String Constant Pool (SCP):

- Java uses a special memory area called the String Constant Pool (SCP) to store string literals.

- If two strings have the same value, they share the same object in the SCP, which helps save memory.

5. String Creation:

- Strings can be created in two ways:

1. Using String Literals:

String s1 = "Hello";

2. Using the new Operator:

String s2 = new String("Hello");

String Creation and SCP Behavior

String Object Creation in Java

In Java, when you create String objects, the JVM treats them differently based on whether you use the new keyword or string literals.

1. String Literal Creation:

When you create a String using a string literal (e.g., String s3 = “Hello”;), the JVM checks the String Constant Pool (SCP) to see if an object with that value already exists.

- If it exists: It reuses that existing object.

- If it does not exist: A new String object is created in the SCP.

2. Using the new Operator:

When you use the new keyword (e.g., String s1 = new String(“Hello”);), the following steps occur:

- The JVM checks the SCP for the string literal “Hello”.

- If it exists: The existing object in the SCP is not used; instead, a new String object is created on the heap.

- If it does not exist: A new object is created both in the SCP and on the heap.

Example Breakdown

Consider the following code snippet:

class A {
    public static void main(String arg[]) {
        String s1 = new String("Hello");
        String s2 = new String("Hello");
        String s3 = "Hello";
        
        System.out.println("s1 == s2 :- " + (s1 == s2));
        System.out.println("s1 == s3 :- " + (s1 == s3));
        System.out.println("s2 == s3 :- " + (s2 == s3));
    }
}

Analysis of the Code:

- String s1 = new String(“Hello”);:

- A new String object is created on the heap.

- The SCP is checked, and since “Hello” might not exist there yet, it’s also added to the SCP.

- s1 refers to the heap object.

- String s2 = new String(“Hello”);:

- Again, a new String object is created on the heap.

- The SCP is checked, but since “Hello” already exists there (created by s1), it does not create a new SCP object.

- s2 refers to a different heap object than s1.

- String s3 = “Hello”;:

- The SCP is checked for “Hello”, which now exists.

- s3 refers to the String object in the SCP, not a new object.

Comparison Results

Now, when you perform comparisons:

- s1 == s2:

- s1 and s2 reference different objects (both created in the heap).

- Output: false

- s1 == s3:

- s1 references the heap object, while s3 references the SCP object.

- Output: false

- s2 == s3:

- s2 also references a different heap object than the SCP object referenced by s3.

- Output: false

Why are strings immutable in Java?

Strings in Java are immutable for several reasons:

1. Security: Prevents sensitive data from being altered. For example, if a password string is passed to a method, it can’t be changed accidentally within that method.

2. Hashing and Caching: Ensures consistent hash codes, which is crucial for using strings as keys in hash maps. For example, if String key = “example”; is used as a key, it will always hash the same way.

3. Thread Safety: Multiple threads can access the same string without concern for it being modified, making it easier to write safe concurrent code.

4. Performance Optimization: Allows string interning. For example, String s1 = “Hello”; and String s2 = “Hello”; will refer to the same object in memory, saving space.

5. Simplified Code: Code is easier to reason about. If a method returns a string, you can trust it won’t change after being returned.

Example:

String s1 = "Hello";
String s2 = s1.toUpperCase(); // s1 remains "Hello", s2 becomes "HELLO"

In this example, s1 is unchanged, demonstrating immutability in action.

Important Methods in java.lang.String

1. hashCode():

- The hashCode() method in the String class is overridden to generate a hash code based on the string’s content.

- Two strings with the same content will have the same hash code.

Example:

String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1 == s2); // false
System.out.println(s1.hashCode()); // 96354
System.out.println(s2.hashCode()); // 96354

2. equals():

- The equals() method in the String class is overridden to compare the actual content of strings rather than their references.

Example:

String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1 == s2); // false
System.out.println(s1.equals(s2)); // true

3. compareTo():

- The compareTo() method compares two strings lexicographically based on their Unicode values.

- It returns:

- 0 if the strings are equal.

- A negative number if the first string is lexicographically less than the second.

- A positive number if the first string is lexicographically greater than the second.

Example:

String s1 = "ABC";
String s2 = "ABC";
String s3 = "ACC";
String s4 = "ABCLMS";
System.out.println(s1.compareTo(s2)); // 0
System.out.println(s1.compareTo(s3)); // -1
System.out.println(s1.compareTo(s4)); // -3
System.out.println(s3.compareTo(s4)); // 1

4. split():

- The split() method splits a string into an array of substrings based on a specified delimiter.

Example:

String s1 = "Hello Welcome to the LMS Tutorial";
String[] ar1 = s1.split(" ");
for (int i = 0; i < ar1.length; i++) {
    System.out.println("Index: " + i + " Value: " + ar1[i]);
}

Output:

Index: 0 Value: Hello
Index: 1 Value: Welcome
Index: 2 Value: to
Index: 3 Value: the
Index: 4 Value: LMS
Index: 5 Value: Tutorial

Immutability in Action

- When you concatenate strings, a new string is created:

String s1 = "Hello";
String s2 = "LMS";
String s3 = s1 + s2;
String s4 = "HelloLMS";
System.out.println(s3 == s4); // false

In this example, the comparison s3 == s4 evaluates to false because of how Java handles string creation and memory allocation.

1. String Creation:
— String s1 = “Hello”; creates a String literal in the String Constant Pool (SCP).
— String s2 = “LMS”; also creates another String literal in the SCP.
— String s3 = s1 + s2; creates a new String object in the heap, as it results from concatenation. Even though s3 will contain the value “HelloLMS”, it is a different object in memory.

2. String Literal:
— String s4 = “HelloLMS”; creates another String literal in the SCP.

Comparison:
— The expression s3 == s4 checks if both s3 and s4 reference the same object in memory.
— Since s3 is a new object created by concatenation and s4 is a literal in the SCP, they are two distinct objects.

System.out.println(s3.equals(s4)); // true

This will return true since both strings have the same content.

Using final makes the concatenated strings refer to the same object:

final String s1 = "Hello";
final String s2 = "LMS";
String s3 = s1 + s2;
String s4 = "HelloLMS";
System.out.println(s3 == s4); // true

In this example, the expression s3 == s4 evaluates to true due to the use of final keywords for s1 and s2. Here’s a detailed explanation:

1. Final Variables:
— The final keyword indicates that the variables s1 and s2 cannot be reassigned. This means their values are known at compile time.

2. String Concatenation:
— When you create String s3 = s1 + s2;, the Java compiler recognizes that both s1 and s2 are final. Therefore, it can optimize the concatenation at compile time.
— The compiler effectively replaces s1 + s2 with the literal ”HelloLMS” during the compilation process.

3. String Literal:
— String s4 = “HelloLMS”; creates a String literal in the String Constant Pool (SCP).

Memory Reference:
— Since both s3 (the result of the concatenation) and s4 (the literal) resolve to the same string literal ”HelloLMS” in the SCP, they reference the same memory object.

Comparison:
— The expression s3 == s4 checks if both references point to the same object.
— In this case, they do, so the result is true.

System.out.println(s3.equals(s4)); // true

StringBuffer

The StringBuffer class in Java, which is part of the java.lang package, is designed for mutable string manipulation. Here’s a breakdown of the key points regarding StringBuffer:

Key Characteristics of StringBuffer

1. Mutability: Unlike String objects, StringBuffer objects are mutable, meaning they can be modified after creation without creating a new object.

2. Memory Allocation: Objects of StringBuffer are stored in the heap area and do not use the string pool like String objects.

3. Final Class: StringBuffer is a final class, so it cannot be extended.

4. Thread-Safety: All methods in StringBuffer are synchronized, making it thread-safe, but this synchronization can lead to performance issues in a multi-threaded environment.

Creating StringBuffer Objects

- Default Constructor: When you create a StringBuffer using the default constructor, the initial capacity is set to 16.

StringBuffer s1 = new StringBuffer(); // Capacity is 16

- Custom Capacity: You can also specify a custom initial capacity.

StringBuffer s2 = new StringBuffer(20); // Capacity is 20

- With String Literal: If you create a StringBuffer with a string literal, the initial capacity is set to the length of the string plus 16.

StringBuffer s3 = new StringBuffer("LMS"); // Capacity is 19 (3 + 16)

Example of StringBuffer’s Mutable Behavior

Here’s a demonstration of how mutability works with the append() method:

class LMS {
    public static void main(String arg[]) {
        StringBuffer s1 = new StringBuffer("Hello");
        StringBuffer s2 = s1.append("LMS");
        System.out.println("s1 :- " + s1); // Output: HelloLMS
        System.out.println("s2 :- " + s2); // Output: HelloLMS
        System.out.println("s1 == s2 :- " + (s1 == s2)); // Output: true
    }
}

In this example, both s1 and s2 reference the same object. Since StringBuffer objects are mutable, the append() operation modifies the original object itself.

Capacity and Growth Mechanism

The capacity of a StringBuffer can increase as more characters are added. The formula to calculate the new capacity when the current capacity is exceeded is:

New Capacity = (Current Capacity + 1) *2

Example of Capacity Growth

class LMS {
    public static void main(String arg[]) {
        StringBuffer s1 = new StringBuffer();
        System.out.println("s1.capacity :- " + s1.capacity()); // 16
        System.out.println("s1.length :- " + s1.length()); // 0
        s1.append("1234567890111213");
        System.out.println("s1.capacity :- " + s1.capacity()); // 16
        System.out.println("s1.length :- " + s1.length()); // 16
        s1.append("14");
        System.out.println("s1.capacity :- " + s1.capacity()); // 34
        System.out.println("s1.length :- " + s1.length()); // 18
        s1.append("1516171819202122232425");
        System.out.println("s1.capacity :- " + s1.capacity()); // 70
        System.out.println("s1.length :- " + s1.length()); // 40
        s1.append("1234567890123456789012345678901");
        System.out.println("s1.capacity :- " + s1.capacity()); // 142
        System.out.println("s1.length :- " + s1.length()); // 71
    }
}

In this example, you can see how the capacity changes when the length of the StringBuffer exceeds its current capacity.

Important Methods of StringBuffer

1. length()

- Description: Returns the length of the string in the StringBuffer.

- Syntax: public synchronized int length();

2. capacity()

- Description: Returns the current capacity of the StringBuffer.

- Syntax: public synchronized int capacity();

3. append()

- Description: Appends the specified string to the existing StringBuffer and returns the same object.

- Syntax: public synchronized StringBuffer append(String str);

Performance Consideration

Although StringBuffer is thread-safe due to synchronization, this can cause performance issues in multi-threaded applications because only one thread can operate on a StringBuffer object at a time. To overcome this limitation, consider using StringBuilder, which is similar to StringBuffer but without synchronization, making it faster in single-threaded scenarios.

Use Cases

- Frequent String Modifications: Use StringBuffer when you need to perform frequent modifications to strings to avoid the overhead of creating multiple String objects.

- Thread Safety: If thread safety is required, StringBuffer is a better choice than StringBuilder.

Understanding when to use String, StringBuffer, or StringBuilder is crucial for writing efficient Java code, especially when dealing with string manipulation and concurrency.

StringBuilder class

The StringBuilder class in Java is a mutable sequence of characters, very similar to the StringBuffer class. It is part of the java.lang package and provides almost identical functionalities as StringBuffer but with a key difference in how it handles synchronization.

Key Characteristics of StringBuilder

1. Mutability: StringBuilder objects are mutable, meaning you can change the content of a StringBuilder object without creating a new object.

2. Thread-Unsafety: Unlike StringBuffer, StringBuilder is not synchronized, which means it is not thread-safe. This lack of synchronization makes StringBuilder faster than StringBuffer in single-threaded scenarios.

3. Memory Allocation: StringBuilder objects are stored in the heap area, similar to StringBuffer objects.

4. Final Class: StringBuilder is a final class, so it cannot be extended.

Creating StringBuilder Objects

- Default Constructor: When you create a StringBuilder using the default constructor, the initial capacity is set to 16.

StringBuilder s1 = new StringBuilder(); // Capacity is 16

- Custom Capacity: You can specify a custom initial capacity while creating a StringBuilder.

StringBuilder s2 = new StringBuilder(20); // Capacity is 20

- With String Literal: If you create a StringBuilder with a string literal, the initial capacity is set to the length of the string plus 16.

StringBuilder s3 = new StringBuilder("LMS"); // Capacity is 19 (3 + 16)

Example of StringBuilder’s Mutable Behavior

Here’s a demonstration of how mutability works with the append() method:

class LMS {
    public static void main(String arg[]) {
        StringBuilder s1 = new StringBuilder("Hello");
        StringBuilder s2 = s1.append("LMS");
        System.out.println("s1 :- " + s1); // Output: HelloLMS
        System.out.println("s2 :- " + s2); // Output: HelloLMS
        System.out.println("s1 == s2 :- " + (s1 == s2)); // Output: true
    }
}

In this example, both s1 and s2 reference the same object. Since StringBuilder objects are mutable, the append() operation modifies the original object itself, and s1 and s2 remain equal.

Capacity and Growth Mechanism

The capacity of a StringBuilder can grow dynamically when more characters are added. The formula used to calculate the new capacity when the current capacity is exceeded is:

New Capacity = (Current Capacity + 1)*2

Example of Capacity Growth

class LMS {
    public static void main(String arg[]) {
        StringBuilder s1 = new StringBuilder();
        System.out.println("s1.capacity :- " + s1.capacity()); // 16
        System.out.println("s1.length :- " + s1.length()); // 0
        s1.append("1234567890111213");
        System.out.println("s1.capacity :- " + s1.capacity()); // 16
        System.out.println("s1.length :- " + s1.length()); // 16
        s1.append("14");
        System.out.println("s1.capacity :- " + s1.capacity()); // 34
        System.out.println("s1.length :- " + s1.length()); // 18
        s1.append("1516171819202122232425");
        System.out.println("s1.capacity :- " + s1.capacity()); // 70
        System.out.println("s1.length :- " + s1.length()); // 40
        s1.append("1234567890123456789012345678901");
        System.out.println("s1.capacity :- " + s1.capacity()); // 142
        System.out.println("s1.length :- " + s1.length()); // 71
    }
}

In this example, you can see how the capacity of the StringBuilder changes as its length exceeds the current capacity, using the formula for dynamic growth.

Important Methods of StringBuilder

1. length()

- Description: Returns the length of the string contained in the StringBuilder.

- Syntax: public int length();

2. capacity()

- Description: Returns the current capacity of the StringBuilder.

- Syntax: public int capacity();

3. append()

- Description: Appends the specified string to the existing StringBuilder and returns the same object.

- Syntax: public StringBuilder append(String str);

StringBuilder vs. StringBuffer

- Synchronization: The primary difference between StringBuilder and StringBuffer is that StringBuilder methods are not synchronized, whereas StringBuffer methods are synchronized. This makes StringBuilder faster but not thread-safe.

- Use Case: Use StringBuilder when you do not require thread safety and want better performance. Use StringBuffer when working in a multi-threaded environment where synchronization is required.

Use Cases

- Frequent String Modifications: StringBuilder is ideal when you need to perform frequent string manipulations without the overhead of creating multiple String objects.

- Performance: It is preferred in single-threaded applications due to its better performance compared to StringBuffer.

java.lang.System class

The java.lang.System class is a crucial part of the Java programming language, providing methods and fields that interact with the system environment, manage input and output streams, perform system operations, and more. It is a part of the java.lang package and is automatically imported into all Java programs, making its methods and fields readily available for use.

Key Characteristics of the System Class

- Final Class: The System class is declared as final, which means it cannot be subclassed.

- Private Constructor: It has a private constructor, which means you cannot create an instance of the System class directly.

- Static Members: Most of the methods and fields of the System class are static, allowing them to be accessed directly through the class name without creating an object.

Example of System Class Usage

Here’s a basic example to illustrate the use of the System class:

class LMS {
    public static void main(String arg[]) {
        StringBuilder s1 = new StringBuilder("Hello");
        StringBuilder s2 = s1.append("LMS");
        System.out.println("s1 :- " + s1);
        System.out.println("s2 :- " + s2);
        System.out.println("s1 == s2 :- " + (s1 == s2));
    }
}

Important Members of the System Class

The System class includes several fields and methods that are frequently used in Java programming. Let’s go through some of the most important members:

1. public static final java.io.InputStream in

- Description: The in field represents the standard input stream, typically linked to the keyboard.

- Usage: This field is used to take input from the user via the console.

Example:

import java.util.Scanner;
class A {
    public static void main(String arg[]) {
        System.out.println("Enter Input: ");
        Scanner s1 = new Scanner(System.in);
        String input = s1.nextLine();
        System.out.println("Input is: " + input);
    }
}

2. public static void setIn(java.io.InputStream)

- Description: This method allows you to change the standard input stream to another source.

- Usage: It is used when you need to take input from a file or other source instead of the keyboard.

Example:

import java.io.FileInputStream;
class LMS {
    public static void main(String[] args) throws Exception {
        System.setIn(new FileInputStream("file.txt"));
        char c1 = (char) System.in.read();
        System.out.println(c1);
    }
}

3. public static final java.io.PrintStream out

- Description: The out field represents the standard output stream, usually linked to the console.

- Usage: It is used to print output to the console using methods like print() and println().

Example:

System.out.println("This text will appear on the console.");

How System.out.println works?

System.out.println() is a commonly used method in Java for printing output to the console. Here’s how it works, step by step:

Breakdown of System.out.println()

1. System Class:

- System is a final class in the java.lang package that provides various system-related utilities and resources, including standard input and output.

2. Out Field:

- out is a static field of type PrintStream within the System class. It represents the standard output stream (typically the console).

3. PrintStream Class:

- PrintStream is a class that provides methods for printing data to various output streams. It has several overloaded println() methods that accept different types of arguments (e.g., String, int, double, etc.).

4. println() Method:

- The println() method in PrintStream prints the argument passed to it, followed by a newline character. This means that after the output, the cursor moves to the next line.

- If no argument is provided (i.e., println() with no parameters), it simply moves to the next line.

How It Works Internally

1. Method Call:

- When you call System.out.println(someValue), the method is invoked on the PrintStream object referenced by System.out.

2. Type Handling:

- The println() method can take various data types:

- If you pass a String, it prints the string.

- If you pass a primitive type (like int, double, etc.), it converts the value to its string representation using String.valueOf().

- If you pass an object, it calls the object’s toString() method to get its string representation.

3. Output to Console:

- The formatted string is sent to the output stream that PrintStream is connected to, which is typically the console.

- After printing the string, a newline character (\n) is automatically appended.

4. public static void setOut(java.io.PrintStream)

- Description: This method changes the destination of the output stream.

- Usage: It is used to redirect output to a file or another destination instead of the console.

Example:

import java.io.*;
class LMS {
    public static void main(String[] args) throws Exception {
        FileOutputStream f = new FileOutputStream("file.txt");
        System.setOut(new PrintStream(f));
        System.out.println("This text will be redirected to file.txt.");
    }
}

5. public static final java.io.PrintStream err

- Description: The err field represents the standard error output stream, used to output error messages.

- Usage: It is often used to display error messages or debug information.

Example:

System.err.println("This is an error message.");

6. public static void setErr(java.io.PrintStream)

- Description: This method allows you to change the destination of the error output stream.

- Usage: It is used to redirect error messages to a file or another output stream.

Example:

import java.io.*;
class LMS {
    public static void main(String[] args) throws Exception {
        FileOutputStream f = new FileOutputStream("file.txt");
        System.setErr(new PrintStream(f));
        System.err.println("This error message will be written to file.txt.");
    }
}

7. public static void exit(int)

- Description: This method terminates the currently running Java Virtual Machine (JVM).

- Usage: It is often used to exit a program when a certain condition is met.

Example:

class A {
    public static void main(String arg[]) {
        System.out.println("Before Exit()");
        System.exit(0);
        System.out.println("This line will not be executed.");
    }
}

8. public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

- Description: This method copies data from one array to another.

- Usage: It is used for quickly copying array elements.

Example:

class A {
    public static void main(String arg[]) {
        String source[] = {"Welcome", "To", "LMS", "Tutorial", "This", "Is", "System", "Class"};
        String destination[] = new String[8];
        System.arraycopy(source, 1, destination, 1, 4);
        for (int i = 0; i < destination.length; i++) {
            System.out.println("Index: " + i + " Value: " + destination[i]);
        }
    }
}

Other Notable Methods

- currentTimeMillis(): Returns the current time in milliseconds since the epoch (January 1, 1970, 00:00:00 GMT).

- nanoTime(): Returns the current time in nanoseconds for measuring time intervals.

- gc(): Requests the Java Virtual Machine to perform garbage collection.

- getProperty(String key): Retrieves system properties.

- load(String filename): Loads a specified file as a dynamic library.

Conclusion

The java.lang.System class is a powerful utility class in Java that provides essential methods and fields for interacting with the system environment, handling input and output streams, and performing other system-level operations. Its static fields and methods enable developers to control system I/O, manage properties, and handle system resources efficiently.

java.lang.Runtime

1. java.lang.Runtime Class Overview
The Runtime class is a built-in class provided by Java in the java.lang package. It allows Java applications to interface with the runtime environment in which they are executing. This class is based on the Singleton Design Pattern, which ensures that only one instance of the class can exist in the program.

Singleton Design Pattern: This design pattern restricts the instantiation of a class to a single instance. It ensures that no matter how many times you try to create an object, the same instance is returned.

Private Constructor: The Runtime class has a private constructor to prevent the instantiation of objects outside the class. Instead, it provides a static method getRuntime() to return the same Runtime instance every time it is called.

Singleton Design Pattern Example
Let’s break down the example provided:

class LMS {
    public static void main(String arg[]) {
        A a1 = A.getA();
        A a2 = A.getA();
        A a3 = A.getA();
        System.out.println("a1 hashcode :- " + a1.hashCode());
        System.out.println("a2 hashcode :- " + a2.hashCode());
        System.out.println("a3 hashcode :- " + a3.hashCode());
        System.out.println("a1 == a2 :- " + (a1 == a2));
        System.out.println("a2 == a3 :- " + (a2 == a3));
        System.out.println("a1 == a3 :- " + (a1 == a3));
    }
}
class A {
    static A a1 = null;
    // Private constructor prevents instantiation outside this class
    private A() {}
    // Static block to create a single instance
    static {
        a1 = new A();
    }
    // Static method to return the same instance
    static A getA() {
        return a1;
    }
}

Explanation:
— The class A follows the Singleton Design Pattern. The constructor is private, so no new object can be created using new A().
— In the static block, a single instance of the class A is created and assigned to the static variable a1.
— The method getA() returns the same instance a1 every time it’s called.
— Since a1, a2, and a3 all point to the same object, their hashcodes are identical, and the comparison using == returns true.

Output:
a1 hashcode :- 1652149987
a2 hashcode :- 1652149987
a3 hashcode :- 1652149987
a1 == a2 :- true
a2 == a3 :- true
a1 == a3 :- true

2. Runtime.getRuntime() Method

The Runtime class is based on the Singleton pattern, and you can’t create its object using new. Instead, you call getRuntime() to get the single instance.

class LMS {
    public static void main(String arg[]) {
        Runtime r1 = Runtime.getRuntime();
        System.out.println("r1 hashcode :- " + r1.hashCode());
        Runtime r2 = Runtime.getRuntime();
        System.out.println("r2 hashcode :- " + r2.hashCode());
        System.out.println("r1 == r2 :- " + (r1 == r2));
    }
}

Explanation:
— Runtime.getRuntime() is used to get the Runtime object. Every time you call it, it returns the same object (due to Singleton pattern).
— r1 and r2 refer to the same object, so the comparison using == returns true.

Output:
r1 hashcode :- 123456789
r2 hashcode :- 123456789
r1 == r2 :- true

3. Key Methods in java.lang.Runtime

a. availableProcessors()
This method returns the number of available processors for the current Java Virtual Machine (JVM).

class LMS {
    public static void main(String arg[]) {
        System.out.println("Number of processors allocated to the current JVM: ");
        System.out.println(Runtime.getRuntime().availableProcessors());
    }
}

Explanation:
— Runtime.getRuntime().availableProcessors() returns the number of processors available to the JVM.

Example Output:
Number of processors allocated to the current JVM: 8

b. freeMemory()
This method returns the amount of free memory available in the JVM’s heap, measured in bytes.

class LMS {
    public static void main(String arg[]) {
        System.out.println("Free heap memory: " + Runtime.getRuntime().freeMemory() + " bytes");
    }
}

Explanation:
— Runtime.getRuntime().freeMemory() returns the amount of unused heap memory in the JVM, in bytes.

Example Output:

Free heap memory: 16548960 bytes

c. totalMemory()
This method returns the total memory allocated to the JVM’s heap in bytes.

class LMS {
    public static void main(String arg[]) {
        System.out.println("Total heap memory: " + Runtime.getRuntime().totalMemory() + " bytes");
    }
}

Explanation:
— Runtime.getRuntime().totalMemory() returns the total memory allocated to the heap.

Example Output:
Total heap memory: 25690112 bytes

d. maxMemory()
This method returns the maximum memory the JVM will attempt to use for the heap.

class LMS {
    public static void main(String arg[]) {
        System.out.println("Maximum heap memory limit: " + Runtime.getRuntime().maxMemory() + " bytes");
    }
}

Explanation:
— Runtime.getRuntime().maxMemory() returns the maximum amount of memory that the JVM can use.

Example Output:
Maximum heap memory limit: 536870912 bytes

e. exec(String command)
This method allows running system commands directly from Java.

class LMS {
    public static void main(String arg[]) throws Exception {
        Runtime.getRuntime().exec("notepad");
        Runtime.getRuntime().exec("calc");
    }
}

Explanation:
— Runtime.getRuntime().exec() can execute commands like opening Notepad or Calculator on Windows.

Conclusion

The java.lang package is an integral part of Java's core functionality. It provides the basic classes and interfaces that form the foundation of Java programming. Understanding the methods in the java.lang.Object class and other classes within this package is crucial for writing efficient and robust Java applications.

Collection Framework in Java revision

Pratik T — Tue, 08 Oct 2024 13:37:00 GMT

Overview of ArrayList

ArrayList is part of the java.util package and implements the List interface. Here are some important points:

1. Order Preservation: It stores elements in the order they are added.

2. Index-Based Access: Elements can be accessed using their index.

3. Type Flexibility: Different types of data can be stored.

4. Duplicates Allowed: It permits duplicate elements.

5. Iterators: Traversal can be done using Iterator and ListIterator.

6. Not Synchronized: Methods are not synchronized, affecting concurrency.

7. Random Access: Direct access to elements is allowed.

8. Cloning and Serialization: It supports cloning and serialization.

Basic Example

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
public class ArrayListExample {
    public static void main(String[] args) {
        ArrayList al1 = new ArrayList<>();
        al1.add(101);
        al1.add(102);
        al1.add("Hello");
        al1.add(true);
        System.out.println("al1: " + al1);
        // Accessing elements by index
        for (int i = 0; i < al1.size(); i++) {
            System.out.println("Index: " + i + " | Value: " + al1.get(i));
        }
        // Using Iterator
        Iterator iterator = al1.iterator();
        System.out.print("Using Iterator: ");
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
        System.out.println();
        // Using ListIterator
        ListIterator listIterator = al1.listIterator();
        System.out.print("In Forward Order: ");
        while (listIterator.hasNext()) {
            System.out.print(listIterator.next() + " ");
        }
        System.out.println();
    }
}

java.util.Collection Interface:

public interface java.util.Collection extends java.lang.Iterable {
    public abstract int size();
    public abstract boolean isEmpty();
    public abstract boolean contains(java.lang.Object);
    public abstract java.util.Iterator iterator();
    public abstract java.lang.Object[] toArray();
    public abstract  T[] toArray(T[]);
    public abstract boolean add(E);
    public abstract boolean remove(java.lang.Object);
    public abstract boolean containsAll(java.util.Collection);
    public abstract boolean addAll(java.util.Collection);
    public abstract boolean removeAll(java.util.Collection);
    public boolean removeIf(java.util.function.Predicate);
    public abstract boolean retainAll(java.util.Collection);
    public abstract void clear();
    public abstract boolean equals(java.lang.Object);
    public abstract int hashCode();
    public java.util.Spliterator spliterator();
    public java.util.stream.Stream stream();
    public java.util.stream.Stream parallelStream();
}

java.util.ArrayList:

public class java.util.ArrayList extends java.util.AbstractList
 implements java.util.List, java.util.RandomAccess, java.lang.Cloneable, 
 java.io.Serializable {
      transient java.lang.Object[] elementData;
      public java.util.ArrayList(int);
      public java.util.ArrayList();
      public java.util.ArrayList(java.util.Collection);
      public void trimToSize();
      public void ensureCapacity(int);
      public int size();
      public boolean isEmpty();
      public boolean contains(java.lang.Object);
      public int indexOf(java.lang.Object);
      public int lastIndexOf(java.lang.Object);
      public java.lang.Object clone();
      public java.lang.Object[] toArray();
      public  T[] toArray(T[]);
      E elementData(int);
      public E get(int);
      public E set(int, E);
      public boolean add(E);
      public void add(int, E);
      public E remove(int);
      public boolean remove(java.lang.Object);
      public void clear();
      public boolean addAll(java.util.Collection);
      public boolean addAll(int, java.util.Collection);
      protected void removeRange(int, int);
      public boolean removeAll(java.util.Collection);
      public boolean retainAll(java.util.Collection);
      public java.util.ListIterator listIterator(int);
      public java.util.ListIterator listIterator();
      public java.util.Iterator iterator();
      public java.util.List subList(int, int);
      static void subListRangeCheck(int, int, int);
      public void forEach(java.util.function.Consumer);
      public java.util.Spliterator spliterator();
      public boolean removeIf(java.util.function.Predicate);
      public void replaceAll(java.util.function.UnaryOperator);
      public void sort(java.util.Comparator);
      static int access$000(java.util.ArrayList);
      static {};
}

Constructors

1. Default Constructor

ArrayList al1 = new ArrayList<>(); // Default capacity is 10

2. Constructor with Initial Capacity

ArrayList al2 = new ArrayList<>(20); // Custom capacity

3. Constructor from Collection

ArrayList al3 = new ArrayList<>(al1); // Create from another collection

Important Methods

1. size()

System.out.println("Size of al1: " + al1.size());

2. add(E)

al1.add(200); // Adds to the end

3. add(int index, E)

al1.add(1, "Inserted Element"); // Inserts at index 1

4. addAll(Collection)

ArrayList al4 = new ArrayList<>();
al4.add("A");
al4.add("B");
al1.addAll(al4); // Adds all elements from al4

5. remove(int index)

al1.remove(0); // Removes element at index 0

6. remove(Object o)

al1.remove("Hello"); // Removes "Hello" from the list

7. removeAll(Collection)

ArrayList toRemove = new ArrayList<>();
toRemove.add(101);
al1.removeAll(toRemove); // Removes all occurrences of elements in toRemove

8. toArray()

Object[] array = al1.toArray(); // Converts to array

9. sort(Comparator)

ArrayList al5 = new ArrayList<>();
al5.add(3);
al5.add(1);
al5.add(2);
al5.sort(Comparator.naturalOrder()); // Sorts in natural order
System.out.println(al5); // Output: [1, 2, 3]

Custom Sorting with Comparator

import java.util.ArrayList;
import java.util.Comparator;
class Student {
    int id;
    String name;
    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student{" + "id=" + id + ", name='" + name + '\'' + '}';
    }
}
public class StudentSortExample {
    public static void main(String[] args) {
        ArrayList students = new ArrayList<>();
        students.add(new Student(2, "Alice"));
        students.add(new Student(1, "Bob"));
        students.add(new Student(3, "Charlie"));
        students.sort(Comparator.comparingInt(s -> s.id)); // Sort by id
        System.out.println(students);
    }
}

Summary

The ArrayList class in Java provides a flexible and dynamic way to store a collection of elements. It supports various methods for manipulating the list, making it a powerful tool for developers. Use the examples provided to understand how to work with ArrayList effectively!

LinkedList

- LinkedList is a class in the java.util package that implements the List interface. It stores elements in the form of nodes, where each node contains two parts:

- The data (the actual element).

- A reference (or link) to the next node in the list.

Key Points:

- Duplicate elements are allowed.

- Random access is not supported because LinkedList elements are stored in a chain, requiring sequential access.

- It can store elements of different types (just like ArrayList).

- It is not synchronized by default, meaning it’s not thread-safe without external synchronization.

- LinkedList implements java.io.Serializable (for serialization) and java.lang.Cloneable (for cloning).

java.util.LinkedList:

public class java.util.LinkedList extends 
  java.util.AbstractSequentialList implements java.util.List,
  java.util.Deque, java.lang.Cloneable, java.io.Serializable {
        transient int size;
        transient java.util.LinkedList$Node first;
        transient java.util.LinkedList$Node last;
        public java.util.LinkedList();
        public java.util.LinkedList(java.util.Collection);
        void linkLast(E);
        void linkBefore(E, java.util.LinkedList$Node);
        E unlink(java.util.LinkedList$Node);
        public E getFirst();
        public E getLast();
        public E removeFirst();
        public E removeLast();
        public void addFirst(E);
        public void addLast(E);
        public boolean contains(java.lang.Object);
        public int size();
        public boolean add(E);
        public boolean remove(java.lang.Object);
        public boolean addAll(java.util.Collection);
        public boolean addAll(int, java.util.Collection);
        public void clear();
        public E get(int);
        public E set(int, E);
        public void add(int, E);
        public E remove(int);
        java.util.LinkedList$Node node(int);
        public int indexOf(java.lang.Object);
        public int lastIndexOf(java.lang.Object);
        public E peek();
        public E element();
        public E poll();
        public E remove();
        public boolean offer(E);
        public boolean offerFirst(E);
        public boolean offerLast(E);
        public E peekFirst();
        public E peekLast();
        public E pollFirst();
        public E pollLast();
        public void push(E);
        public E pop();
        public boolean removeFirstOccurrence(java.lang.Object);
        public boolean removeLastOccurrence(java.lang.Object);
        public java.util.ListIterator listIterator(int);
        public java.util.Iterator descendingIterator();
        public java.lang.Object clone();
        public java.lang.Object[] toArray();
        public  T[] toArray(T[]);
        public java.util.Spliterator spliterator();
}

2. Basic LinkedList Operations

Example Code:

import java.util.LinkedList;
import java.util.Iterator;
import java.util.ListIterator;
public class JTC {
   public static void main(String[] args) {
      LinkedList l1 = new LinkedList();
      l1.add("10");
      l1.add("Hello");
      l1.add(12.34f);
      l1.add(13.678);
      l1.add(true);
      l1.add('A');
      l1.add(new JTC()); // Adding an object of the current class.
      l1.add(null); // Adding a null value.
      System.out.println("l1 :- " + l1);
      
      // Traversing using Iterator.
      Iterator iterator = l1.iterator();
      while (iterator.hasNext()) {
         System.out.print(iterator.next() + " ");
      }
      
      // Traversing in forward order using ListIterator.
      System.out.print("\nForward :- ");
      ListIterator iterator1 = l1.listIterator();
      while (iterator1.hasNext()) {
         System.out.print(iterator1.next() + " ");
      }
      
      // Traversing in reverse order using ListIterator.
      System.out.print("\nReverse :- ");
      while (iterator1.hasPrevious()) {
         System.out.print(iterator1.previous() + " ");
      }
   }
}

Output:

l1 :- [10, Hello, 12.34, 13.678, true, A, com.P1.JTC@36aa7bc2, null]
10 Hello 12.34 13.678 true A com.P1.JTC@36aa7bc2 null 
Forward :- 10 Hello 12.34 13.678 true A com.P1.JTC@36aa7bc2 null 
Reverse :- null com.P1.JTC@36aa7bc2 A true 13.678 12.34 Hello 10

3. Constructors of LinkedList

- Default Constructor:

LinkedList l1 = new LinkedList();

- Creates an empty LinkedList.

- Parameterized Constructor:

ArrayList al1 = new ArrayList();
al1.add(101);
al1.add("Hello");
LinkedList l2 = new LinkedList<>(al1);

- Creates a LinkedList l2 that copies all the elements from the ArrayList al1.

4. Important Methods of LinkedList

a. add(E e):

- Appends the specified element to the end of the list.

l1.add("Hello");

b. add(int index, E element):

- Inserts an element at a specified position, shifting subsequent elements.

l1.add(1, "New Element");

c. addAll(Collection c):

- Adds all elements from another collection to the LinkedList.

l1.addAll(al1);

d. get(int index):

- Returns the element at the specified index.

l1.get(0); // Returns the first element.

e. set(int index, E element):

- Updates the element at the specified index.

l1.set(2, "Updated Element");

f. descendingIterator():

- Returns an iterator to traverse the list in reverse order.

Iterator i1 = l1.descendingIterator();

5. Traversal Examples

Forward Traversal:

ListIterator iterator1 = l1.listIterator();
while (iterator1.hasNext()) {
System.out.print(iterator1.next() + " ");
}

Reverse Traversal:

while (iterator1.hasPrevious()) {
System.out.print(iterator1.previous() + " ");
}

6. Common Exceptions

- ConcurrentModificationException: If the LinkedList is modified while iterating over it, this exception is thrown.

Iterator i1 = l1.iterator();
while (i1.hasNext()) {
   l1.add(606); // Causes ConcurrentModificationException
}

- IndexOutOfBoundsException: Thrown if attempting to access an invalid index.

l1.get(100); // Throws IndexOutOfBoundsException

Conclusion:

- LinkedList is a versatile and commonly used data structure for storing elements in a non-contiguous memory space, linked via nodes.

- It supports adding, removing, and updating elements, and can be traversed using iterators.

However, random access is not efficient, and it’s prone to ConcurrentModificationException if modified during iteration without proper handling.

Here is a simplified explanation and breakdown of the Vector and Stack classes in Java, with code examples:

Vector Class (Legacy Class)

- Definition: The Vector class, found in the java.util package, is a part of the Java Collection Framework but was originally a part of Java before the framework was introduced. It is similar to ArrayList but with synchronized methods.

java.util.Vector:
public class java.util.Vector extends java.util.AbstractList implements 
java.util.List, java.util.RandomAccess, java.lang.Cloneable, 
java.io.Serializable {
    protected java.lang.Object[] elementData;
    protected int elementCount;
    protected int capacityIncrement;
    public java.util.Vector(int, int);
    public java.util.Vector(int);
    public java.util.Vector();
    public java.util.Vector(java.util.Collection);
    public synchronized void copyInto(java.lang.Object[]);
    public synchronized void trimToSize();
    public synchronized void ensureCapacity(int);
    public synchronized void setSize(int);
    public synchronized int capacity();
    public synchronized int size();
    public synchronized boolean isEmpty();
    public java.util.Enumeration elements();
    public boolean contains(java.lang.Object);
    public int indexOf(java.lang.Object);
    public synchronized int indexOf(java.lang.Object, int);
    public synchronized int lastIndexOf(java.lang.Object);
    public synchronized int lastIndexOf(java.lang.Object, int);
    public synchronized E elementAt(int);
    public synchronized E firstElement();
    public synchronized E lastElement();
    public synchronized void setElementAt(E, int);
    public synchronized void removeElementAt(int);
    public synchronized void insertElementAt(E, int);
    public synchronized void addElement(E);
    public synchronized boolean removeElement(java.lang.Object);
    public synchronized void removeAllElements();
    public synchronized java.lang.Object clone();
    public synchronized java.lang.Object[] toArray();
    public synchronized  T[] toArray(T[]);
    E elementData(int);
    public synchronized E get(int);
    public synchronized E set(int, E);
    public synchronized boolean add(E);
    public boolean remove(java.lang.Object);
    public void add(int, E);
    public synchronized E remove(int);
    public void clear();
    public synchronized boolean containsAll(java.util.Collection);
    public synchronized boolean addAll(java.util.Collection);
    public synchronized boolean removeAll(java.util.Collection);
    public synchronized boolean retainAll(java.util.Collection);
    public synchronized boolean addAll(int, java.util.Collection);
    public synchronized boolean equals(java.lang.Object);
    public synchronized int hashCode();
    public synchronized java.lang.String toString();
    public synchronized java.util.List subList(int, int);
    protected synchronized void removeRange(int, int);
    public synchronized java.util.ListIterator listIterator(int);
    public synchronized java.util.ListIterator listIterator();
    public synchronized java.util.Iterator iterator();
    public synchronized void forEach(java.util.function.Consumer);
    public synchronized boolean removeIf(java.util.function.Predicate);
    public synchronized void replaceAll(java.util.function.UnaryOperator);
    public synchronized void sort(java.util.Comparator);
    public java.util.Spliterator spliterator();
}

Key Features:

1. Index-Based Access: Like ArrayList, Vector allows random access to elements via index.

2. Synchronization: All methods in Vector are synchronized, making it thread-safe but with a performance cost due to synchronization overhead.

3. Traversal: You can traverse a Vector using Iterator, ListIterator, and Enumeration.

- Differences from ArrayList:

1. Synchronization: While ArrayList is not synchronized, Vector is.

2. Enumeration Support: Vector supports Enumeration, which is not supported by ArrayList.

- Example:

import java.util.Iterator;
import java.util.ListIterator;
import java.util.Enumeration;
import java.util.Vector;
public class VectorExample {
    public static void main(String[] args) {
        Vector vector = new Vector<>();
        vector.add(101);
        vector.add(102);
        vector.add(103);
        vector.add(104);
        vector.add(105);
        
        // Traversing using Iterator
        Iterator iterator = vector.iterator();
        System.out.print("Iterator: ");
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
        
        // Traversing using ListIterator (forward and reverse)
        ListIterator listIterator = vector.listIterator();
        System.out.print("\nListIterator (forward): ");
        while (listIterator.hasNext()) {
            System.out.print(listIterator.next() + " ");
        }
        
        System.out.print("\nListIterator (reverse): ");
        while (listIterator.hasPrevious()) {
            System.out.print(listIterator.previous() + " ");
        }
        
        // Traversing using Enumeration
        Enumeration enumeration = vector.elements();
        System.out.print("\nEnumeration: ");
        while (enumeration.hasMoreElements()) {
            System.out.print(enumeration.nextElement() + " ");
        }
    }
}

Output:

Iterator: 101 102 103 104 105
ListIterator (forward): 101 102 103 104 105
ListIterator (reverse): 105 104 103 102 101
Enumeration: 101 102 103 104 105

Stack Class (LIFO Structure)

- Definition: The Stack class extends the Vector class and represents a Last-In-First-Out (LIFO) stack. It inherits all Vector methods and adds several stack-specific methods.

- Key Features:

1. Push/Pop Operations: Items can be added using the push() method and removed using the pop() method, which follows LIFO order.

2. Peek: The peek() method returns the top element without removing it.

3. Empty Check: The empty() method checks if the stack is empty.

4. Search: The search() method returns the position of an element in the stack (distance from the top).

- Example 1: Basic Stack Operations:

import java.util.Stack;
public class StackExample {
    public static void main(String[] args) {
        Stack stack = new Stack<>();
        stack.push(101);
        stack.push("Hello");
        stack.push(true);
        stack.push('A');
        stack.push(12.34);
        stack.push(-89.78f);
        
        // Pop operation
        System.out.println("Popped: " + stack.pop());  // -89.78
        System.out.println("Popped: " + stack.pop());  // 12.34
        
        // Peek operation
        System.out.println("Top Element: " + stack.peek());  // A
        
        // Stack content
        System.out.println("Stack: " + stack);  // [101, Hello, true, A]
    }
}

Output:

Popped: -89.78
Popped: 12.34
Top Element: A
Stack: [101, Hello, true, A]

- Example 2: Searching in Stack:

import java.util.Stack;
public class StackSearchExample {
    public static void main(String[] args) {
        Stack stack = new Stack<>();
        stack.push(101);
        stack.push("Hello");
        stack.push(true);
        stack.push('A');
        
        // Search operation
        System.out.println("Position of 'Hello': " + stack.search("Hello"));  // 3
        System.out.println("Position of 101: " + stack.search(101));  // 4
        System.out.println("Position of 'NotFound': " + stack.search("NotFound"));  // -1
    }
}

- Output:

Position of 'Hello': 3
Position of 101: 4
Position of 'NotFound': -1

Key Methods in Stack:

1. push(E item): Adds an element to the top of the stack.

2. pop(): Removes and returns the top element of the stack.

3. peek(): Returns the top element without removing it.

4. empty(): Checks if the stack is empty.

5. search(Object o): Searches for an element and returns its 1-based position from the top of the stack, or -1 if not found.

Conclusion:

- Vector is a legacy class that behaves like an ArrayList but with thread safety via synchronization.

- Stack, which extends Vector, adds stack-specific methods (push, pop, peek) and follows the LIFO principle.

Set Interface in Java

The Set interface is part of the java.util package, representing a collection that does not allow duplicate elements. It is implemented by various classes like HashSet and LinkedHashSet and is extended by the SortedSet interface, which is further implemented by the TreeSet class.

HashSet Overview

- HashSet is a collection that does not allow duplicate elements.

- It is part of the Set family, meaning it follows the contract of a Set (i.e., no duplicates allowed).

- HashSet can store various types of elements, including objects of different classes like String, Integer, Boolean, etc.

Important Characteristics of HashSet

1. No Duplicates: A HashSet ensures that each element is unique, which means adding a duplicate element will not change the set.

2. Forward Traversal with Iterator: A HashSet can be traversed in forward order using an Iterator, but not using ListIterator or Enumeration, which are available for lists or vectors.

3. Index Representation: Internally, HashSet uses index representation to store elements, similar to ArrayList or Vector. This allows for random access to elements based on their position in the hash table.

4. Not Synchronized: The methods of HashSet are not synchronized, meaning they are not thread-safe by default. If you need thread safety, you need to manually synchronize it using Collections.synchronizedSet().

5. Unordered Elements: HashSet does not store elements in the order they are added. The internal structure, based on a HashMap, determines the ordering.

6. Cloneable and Serializable: A HashSet is cloneable (implements Cloneable interface) and can be serialized (implements Serializable interface), which means it can be copied or saved to a stream for later retrieval.

7. Internally Uses a Map: All Set type collections, including HashSet, internally use a map (specifically HashMap).

java.util.HashSet:

public class java.util.HashSet extends java.util.AbstractSet 
implements java.util.Set, java.lang.Cloneable, java.io.Serializable {
    static final long serialVersionUID;
    public java.util.HashSet();
    public java.util.HashSet(java.util.Collection);
    public java.util.HashSet(int, float);
    public java.util.HashSet(int);
    java.util.HashSet(int, float, boolean);
    public java.util.Iterator iterator();
    public int size();
    public boolean isEmpty();
    public boolean contains(java.lang.Object);
    public boolean add(E);
    public boolean remove(java.lang.Object);
    public void clear();
    public java.lang.Object clone();
    public java.util.Spliterator spliterator();
    static {};
}

Constructors of HashSet

Default Constructor:

public HashSet()

- This constructor creates an empty HashSet with an initial capacity of 16 and a default load factor of 0.75.

2. Collection Constructor:

public HashSet(Collection)

- This constructor creates a HashSet containing all the elements of a specified collection (e.g., an ArrayList). It is used when you want to initialize a set from another collection.

Example:

ArrayList list1 = new ArrayList();
list1.add(101);
list1.add(true);
list1.add("Hello");
HashSet set2 = new HashSet(list1);

- Here, set2 contains all the elements from list1.

3. Initial Capacity Constructor:

public HashSet(int initialCapacity)

- This constructor creates an empty HashSet with a specified initial capacity.

4. Capacity and Load Factor Constructor:

public HashSet(int initialCapacity, float loadFactor)

- Allows you to set both the initial capacity and the load factor, which is a threshold for when the HashSet needs to expand.

Capacity and Load Factor

- Initial Capacity: Refers to the number of buckets (or slots) the HashSet starts with.

- Load Factor: Defines how full the set can get before it resizes. A default load factor of 0.75 means the HashSet will expand when 75% of its capacity is filled.

Important Methods in HashSet

1. Iterator Method:

public Iterator iterator()

- Returns an Iterator for the elements in the set. This allows iteration over the set using a while loop and iterator.next().

2. Size Method:

public int size()

- Returns the number of elements in the HashSet.

3. isEmpty Method:

public boolean isEmpty()

- Returns true if the set contains no elements, otherwise false.

4. add Method:

public boolean add(E element)

- Adds an element to the HashSet. If the element is already present, it returns false.

5. remove Method:

public boolean remove(Object element)

- Removes the specified element from the set and returns true if the element was present, otherwise returns false.

Example Code Explanation

The provided examples showcase different methods and operations of HashSet:

import java.util.ArrayList;
import java.util.HashSet;
public class JTC {
   public static void main(String[] args) {
      // Creating HashSet by default constructor.
      HashSet set1 = new HashSet();
      System.out.println("size of set1 :- " + set1.size());
      System.out.println("set1 :- " + set1);
      ArrayList list1 = new ArrayList();
      list1.add(101);
      list1.add(true);
      list1.add(12.34);
      list1.add("Hello");
      list1.add('A');
      // Creating HashSet using HashSet(Collection) constructor.
      HashSet set2 = new HashSet < > (list1);
      System.out.println("set2 :- " + set2.size());
      System.out.println("set2 :- " + set2);
   }
}

Output

size of set1 :- 0
    set1 :- []
    set2 :- 5
    set2 :- [A, 12.34, Hello, 101, true]

- Creates an empty HashSet (set1).

- Creates an ArrayList (list1) and adds various types of elements to it.

- Initializes another HashSet (set2) with the contents of list1. Elements are stored in an unordered fashion.

2. Iterator Example:

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
public class JTC {
   public static void main(String[] args) {
      HashSet set = new HashSet();
      set.add(101);
      set.add("Hello");
      set.add('A');
      set.add(true);
      set.add(new JTC());
      set.add(null);
      set.add(12.34);
      Iterator iterator = set.iterator();
      while (iterator.hasNext()) {
         System.out.println(iterator.next());
      }
   }
}

Output:

null
A
12.34
Hello
101
com.P1.JTC@3d012ddd
true

Demonstrates the use of an Iterator to loop through and print each element in the HashSet.

3. Various HashSet Methods Example:

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
public class JTC {
   public static void main(String[] args) {
      HashSet set = new HashSet();
      System.out.println("Added :- " + set.add(101));
      System.out.println("Added :- " + set.add("Hello"));
      System.out.println("Added :- " + set.add('A'));
      System.out.println("Added :- " + set.add(true));
      System.out.println("Added :- " + set.add(101));
      System.out.println("Added :- " + set.add(new JTC()));
      System.out.println("Added :- " + set.add(null));
      System.out.println("Added :- " + set.add(12.34));
      System.out.println("Number of elements :- " + set.size());
      System.out.println("Empty Status :- " + set.isEmpty());
      System.out.println("Elements availability :- " + set.contains("Hello"));
      System.out.println("Elements availability :- " + set.contains("JTC"));
      System.out.println("set :- " + set);
      System.out.println("Removing Element :- " + set.remove(101));
      System.out.println("set :- " + set);
      System.out.println("Removing Element :- " + set.remove("JTC"));
   }
}

Output:

Added :- true
Added :- true
Added :- true
Added :- true
Added :- false
Added :- true
Added :- true
Added :- true
Number of elements :- 7
Empty Status :- false
Elements availability :- true
Elements availability :- false
set :- [null, A, 12.34, Hello, 101, com.P1.JTC@515f550a, true]
Removing Element :- true
set :- [null, A, 12.34, Hello, com.P1.JTC@515f550a, true]
Removing Element :- false

Demonstrates adding elements, checking the size, testing for emptiness, checking for element presence (contains), and removing elements.

- Highlights the behavior of not adding duplicate elements (e.g., 101 was added once, and the second attempt to add it fails).

Key Takeaways for Set Collections

- No Duplicates: Set collections do not allow duplicate elements.

- Not Synchronized: They are not thread-safe by default.

- Cannot Use List-Specific Traversal Methods: You cannot use ListIterator or Enumeration with a set.

- Eligible for Cloning and Serialization: Since they implement the Cloneable and Serializable interfaces.

LinkedHashSet Class

LinkedHashSet is part of the java.util package and extends HashSet. It implements several interfaces: Set, Cloneable, and Serializable. This class maintains a linked list of the entries in the set, preserving the order of insertion.

public class java.util.LinkedHashSet extends java.util.HashSet implements
 java.util.Set, java.lang.Cloneable, java.io.Serializable {
    public java.util.LinkedHashSet(int, float);
    public java.util.LinkedHashSet(int);
    public java.util.LinkedHashSet();
    public java.util.LinkedHashSet(java.util.Collection);
    public java.util.Spliterator spliterator();
}

Important Characteristics:

1. Order of Elements:

- Elements are stored in the order they are added. This is a key feature that differentiates LinkedHashSet from HashSet, which does not guarantee order.

2. Node Representation:

- LinkedHashSet uses a node-based structure to store elements. Each node contains data and references to the next and previous nodes, forming a doubly linked list.

3. No Random Access:

- Unlike an array or ArrayList, you cannot access elements randomly in a LinkedHashSet. You must traverse the set in sequential order.

4. Iterator Access:

- The only way to traverse a LinkedHashSet is through an Iterator. Other methods like ListIterator or Enumeration are not available.

5. Cloning and Serialization:

- Since it implements Cloneable and Serializable, you can clone a LinkedHashSet or serialize it for storage or transmission.

Constructors of LinkedHashSet:

1. Default Constructor:

- public LinkedHashSet(): Creates an empty LinkedHashSet with an initial capacity of 16 and a load factor of 0.75.

2. Collection Constructor:

- public LinkedHashSet(Collection c): Initializes the LinkedHashSet with elements from the specified collection. It removes any duplicates and maintains the insertion order.

3. Capacity Constructor:

- public LinkedHashSet(int initialCapacity): Creates an empty LinkedHashSet with a specified initial capacity and a default load factor of 0.75.

4. Capacity and Load Factor Constructor:

- public LinkedHashSet(int initialCapacity, float loadFactor): Constructs an empty LinkedHashSet with a specified initial capacity and load factor.

Example Code:

import java.util.ArrayList;
import java.util.LinkedHashSet;
public class JTC {
   public static void main(String[] args) {
      // Creating an empty LinkedHashSet using the default constructor
      LinkedHashSet hashSet1 = new LinkedHashSet<>();
      System.out.println("hashSet1: " + hashSet1);
      System.out.println("hashSet1 size: " + hashSet1.size());
      System.out.println("hashSet1 is empty: " + hashSet1.isEmpty());
      // Creating an ArrayList with various types
      ArrayList a1 = new ArrayList<>();
      a1.add("Hello");
      a1.add(101);
      a1.add(true);
      a1.add(101); // Duplicate
      a1.add(new JTC());
      a1.add('A');
      System.out.println("\nArrayList: " + a1);
      // Creating LinkedHashSet using the Collection constructor
      LinkedHashSet hashSet2 = new LinkedHashSet<>(a1);
      System.out.println("hashSet2: " + hashSet2);
      System.out.println("hashSet2 size: " + hashSet2.size());
      System.out.println("hashSet2 is empty: " + hashSet2.isEmpty());
   }
}

Output:

hasSet1 :- []
hashSet1 size :- 0
hashSet1 is empty :- true
Array List :- [Hello, 101, true, 101, com.P1.JTC@156643d4, A]
hashSet2 :- [Hello, 101, true, com.P1.JTC@156643d4, A]
hashSet2 size :- 5
hashSet2 is empty :- false

Output Explanation:

1. Initial Empty Set:

- The first LinkedHashSet is empty, confirming its creation. It shows size 0 and indicates that it is empty.

2. ArrayList Creation:

- An ArrayList is created with mixed data types, including a duplicate integer.

3. Creating LinkedHashSet from ArrayList:

- A second LinkedHashSet is created from the ArrayList. This set preserves the order of elements from the ArrayList but omits the duplicate entry.

4. Final Output:

- The results demonstrate the order preservation and the removal of duplicates in hashSet2.

Conclusion:

The LinkedHashSet is a versatile collection that combines the properties of a hash set (for fast lookups) and a linked list (for maintaining order). It is particularly useful when you need to maintain insertion order while avoiding duplicates.

SortedSet Interface

The SortedSet interface extends Set and arranges the elements in natural order (or a custom order if provided). It is implemented by the TreeSet class.

java.util.SortedSet:

public interface java.util.SortedSet extends java.util.Set {
    public abstract java.util.Comparator comparator();
    public abstract java.util.SortedSet subSet(E, E);
    public abstract java.util.SortedSet headSet(E);
    public abstract java.util.SortedSet tailSet(E);
    public abstract E first();
    public abstract E last();
    public java.util.Spliterator spliterator();
}

TreeSet Class

TreeSet is an implementation of SortedSet, meaning it stores elements in sorted order (either natural or via a comparator). It uses a Red-Black tree under the hood, making all operations (add, remove, search) log-time efficient.

1. TreeSet Overview:

- TreeSet is part of the java.util package and extends the AbstractSet class.

- It implements interfaces like NavigableSet, Cloneable, and Serializable.

- The TreeSet class does not directly implement Set, but because it implements NavigableSet (which extends SortedSet, and SortedSet extends Set), it behaves like a Set collection (like HashSet and LinkedHashSet).

public class java.util.TreeSet extends java.util.AbstractSet implements
 java.util.NavigableSet, java.lang.Cloneable, java.io.Serializable {
      java.util.TreeSet(java.util.NavigableMap);
      public java.util.TreeSet();
      public java.util.TreeSet(java.util.Comparator);
      public java.util.TreeSet(java.util.Collection);
      public java.util.TreeSet(java.util.SortedSet);
      public java.util.Iterator iterator();
      public java.util.Iterator descendingIterator();
      public java.util.NavigableSet descendingSet();
      public int size();
      public boolean isEmpty();
      public boolean contains(java.lang.Object);
      public boolean add(E);
      public boolean remove(java.lang.Object);
      public void clear();
      public boolean addAll(java.util.Collection);
      public java.util.NavigableSet subSet(E, boolean, E, boolean);
      public java.util.NavigableSet headSet(E, boolean);
      public java.util.NavigableSet tailSet(E, boolean);
      public java.util.SortedSet subSet(E, E);
      public java.util.SortedSet headSet(E);
      public java.util.SortedSet tailSet(E);
      public java.util.Comparator comparator();
      public E first();
      public E last();
      public E lower(E);
      public E floor(E);
      public E ceiling(E);
      public E higher(E);
      public E pollFirst();
      public E pollLast();
      public java.lang.Object clone();
      public java.util.Spliterator spliterator();
      static {};
}

2. Characteristics of TreeSet:

No duplicate elements: Similar to other Set types, TreeSet does not allow duplicate elements.
TreeSet doesn’t store different types of data, unlike other Set-type collections such as HashSet and LinkedHashSet.
Natural sorting: By default, it sorts elements in their natural order (like numerical or lexicographical order).
No null values: You cannot store null values in a TreeSet.
Non-synchronized: TreeSet is not thread-safe. You need to synchronize it externally for multithreaded environments.
Backed by TreeMap: TreeSet uses TreeMap internally to store data.

3. Constructors and Key Methods:

- Constructors:

- TreeSet(): Creates an empty set that sorts elements by natural order.

- TreeSet(Comparator): Accepts a custom comparator to define custom sorting logic.

- TreeSet(Collection): Creates a set from another collection.

- Key Methods:

- add(): Adds an element.

- remove(): Removes an element.

- subSet(), headSet(), tailSet(): Methods to get a portion of the set.

- pollFirst(), pollLast(): Retrieves and removes the first or last element.

4. Natural Sorting and Comparable Interface:

Natural Sorting:

Natural sorting refers to the automatic arrangement of elements in ascending order based on their natural order, which is defined by the Comparable interface in Java. When a class implements this interface, it can specify how its objects should be compared.

Comparable Interface

- The Comparable interface requires the implementation of the compareTo() method.

- Method Signature:

public int compareTo(T o);

Behavior of compareTo()

- Returns 0 if both objects are equal.

- Returns a positive integer if the current object is greater.

- Returns a negative integer if the current object is smaller.

Example: Natural Sorting with Integer and String

Here’s an example demonstrating the natural sorting of integers and strings:

import java.util.TreeSet;
public class NaturalSortingExample {
    public static void main(String[] args) {
        // Using TreeSet for natural sorting of Integers
        TreeSet integerSet = new TreeSet<>();
        integerSet.add(5);
        integerSet.add(1);
        integerSet.add(3);
        integerSet.add(4);
        integerSet.add(2);
        System.out.println("Sorted Integers: " + integerSet);
        // Using TreeSet for natural sorting of Strings
        TreeSet stringSet = new TreeSet<>();
        stringSet.add("Banana");
        stringSet.add("Apple");
        stringSet.add("Mango");
        stringSet.add("Orange");
        System.out.println("Sorted Strings: " + stringSet);
    }
}

Output:

Sorted Integers: [1, 2, 3, 4, 5]
Sorted Strings: [Apple, Banana, Mango, Orange]

In this example:

- The integers are sorted in ascending order.

- Strings are sorted based on their natural alphabetical order.

In Descending Order

import java.util.*;

public class NaturalSortingExample {
    public static void main(String[] args) {
        // Using TreeSet for descending sorting of Integers with a named comparator class
        TreeSet integerSet = new TreeSet<>(new DescendingIntegerComparator());

        // Adding elements to the set
        integerSet.add(5);
        integerSet.add(1);
        integerSet.add(3);
        integerSet.add(4);
        integerSet.add(2);
        System.out.println("Sorted Integers (Descending): " + integerSet);

        // Using TreeSet for descending sorting of Strings with a named comparator class
        TreeSet stringSet = new TreeSet<>(new DescendingStringComparator());

        // Adding elements to the set
        stringSet.add("Banana");
        stringSet.add("Apple");
        stringSet.add("Mango");
        stringSet.add("Orange");
        System.out.println("Sorted Strings (Descending): " + stringSet);
    }
}

// Named comparator class for Integers (Descending Order)
class DescendingIntegerComparator implements Comparator {
    @Override
    public int compare(Integer a, Integer b) {
        return b - a;  // Sort in descending order
    }
}

// Named comparator class for Strings (Descending Order)
class DescendingStringComparator implements Comparator {
    @Override
    public int compare(String a, String b) {
        return b.compareTo(a);  // Sort in descending order
    }
}

Using Java 8

import java.util.*;

public class NaturalSortingExample {
    public static void main(String[] args) {
        // Using TreeSet for descending sorting of Integers with a custom Comparator
        TreeSet integerSet = new TreeSet<>((a, b) -> b - a);  // Custom comparator for descending order
        integerSet.add(5);
        integerSet.add(1);
        integerSet.add(3);
        integerSet.add(4);
        integerSet.add(2);
        System.out.println("Sorted Integers (Descending): " + integerSet);
        
        // Using TreeSet for descending sorting of Strings with a custom Comparator
        TreeSet stringSet = new TreeSet<>((a, b) -> b.compareTo(a));  // Custom comparator for descending order
        stringSet.add("Banana");
        stringSet.add("Apple");
        stringSet.add("Mango");
        stringSet.add("Orange");
        System.out.println("Sorted Strings (Descending): " + stringSet);
    }
}

5. Custom Sorting Using Comparator

When you need to sort objects that don’t have a natural order, or if you want to sort them in a different way, you can use the Comparator interface.

Comparator Interface

- The Comparator interface provides the compare() method to define custom comparison logic.

- Method Signature:

public int compare(T o1, T o2);

Example: Custom Sorting with Student Class

Let’s create a Student class and sort Student objects by different fields using custom comparators.

import java.util.*;
class Student {
    String name;
    int marks;
    public Student(String name, int marks) {
        this.name = name;
        this.marks = marks;
    }
    @Override
    public String toString() {
        return name + ": " + marks;
    }
}
class SortByName implements Comparator {
    @Override
    public int compare(Student s1, Student s2) {
        return s1.name.compareTo(s2.name); // Sort by name
    }
}

class SortByMarks implements Comparator {
    @Override
    public int compare(Student s1, Student s2) {
        return s1.marks - s2.marks; // Sort by marks 
    }
}
public class CustomSortingExample {
    public static void main(String[] args) {
        List students = new ArrayList<>();
        students.add(new Student("Alice", 85));
        students.add(new Student("Bob", 72));
        students.add(new Student("Charlie", 90));
        students.add(new Student("David", 85));
        // Sort by name
        Collections.sort(students, new SortByName());
        System.out.println("Sorted by Name: " + students);
        // Sort by marks
        Collections.sort(students, new SortByMarks());
        System.out.println("Sorted by Marks: " + students);
    }
}

Output:

Sorted by Name: [Alice: 85, Bob: 72, Charlie: 90, David: 85]
Sorted by Marks: [Bob: 72, Alice: 85, David: 85, Charlie: 90]

In this example:

- We define a Student class with name and marks attributes.

- Two custom comparators (SortByName and SortByMarks) are created to sort Student objects by name and marks, respectively.

- We use Collections.sort() to sort the list with these comparators.

Using lambda function :

import java.util.*;

class Student {
    String name;
    int marks;

    public Student(String name, int marks) {
        this.name = name;
        this.marks = marks;
    }

    @Override
    public String toString() {
        return name + ": " + marks;
    }
}

public class CustomSortingExample {
    public static void main(String[] args) {
        List students = new ArrayList<>();
        students.add(new Student("Alice", 85));
        students.add(new Student("Bob", 72));
        students.add(new Student("Charlie", 90));
        students.add(new Student("David", 85));

        // Sort by name using lambda
        students.sort(Comparator.comparing(s -> s.name));
        System.out.println("Sorted by Name: " + students);

        // Sort by marks using lambda
        students.sort(Comparator.comparingInt(s -> s.marks));
        System.out.println("Sorted by Marks: " + students);
    }
}

6. Difference between Comparable and Comparator:

- Comparable:

- Defines the natural order of objects within the class itself by implementing the Comparable interface and overriding the compareTo() method.

- Single sorting sequence (only one way to compare).

- Comparator:

- Defines custom order by implementing the Comparator interface and overriding the compare() method.

- Allows multiple sorting sequences (you can sort by different attributes by passing different comparators).

Example:

- Using Comparable, the natural sorting for integers is by value (1, 2, 3, etc.).

-Using Comparator, you could sort Student objects by either marks, name, or city based on custom logic.

Queue Interface in Java

The `Queue` interface is a part of the `java.util` package and extends the `Collection` interface. A `Queue` represents a data structure that follows the First-In-First-Out (FIFO) principle, where elements are added at the end and removed from the front. The `Queue` interface provides methods for adding, removing, and inspecting elements, as well as managing capacity and order.

java.util.Queue:

public interface java.util.Queue extends java.util.Collection {
 public abstract boolean add(E);
 public abstract boolean offer(E);
 public abstract E remove();
 public abstract E poll();
 public abstract E element();
 public abstract E peek();
}

Key Points of Queue Interface

1. FIFO Principle: Elements are processed in the order in which they are added.

2. Null Elements Not Allowed: `Queue` does not permit null elements.

3. Basic Operations:

- `add()`: Inserts an element into the queue.

- `offer()`: Similar to `add()`, but returns false if the queue is full.

- `poll()`: Retrieves and removes the head of the queue.

- `peek()`: Retrieves but does not remove the head of the queue.

- `remove()`: Removes the head of the queue.

Queue Methods

- `boolean add(E e)`: Inserts the specified element into the queue. Throws an exception if capacity is exceeded.

- `boolean offer(E e)`: Inserts the specified element into the queue without throwing an exception if the capacity is exceeded.

- `E remove()`: Removes and returns the head of the queue. Throws an exception if the queue is empty.

- `E poll()`: Retrieves and removes the head of the queue, returning null if the queue is empty.

- `E element()`: Retrieves, but does not remove, the head of the queue. Throws an exception if the queue is empty.

- `E peek()`: Retrieves, but does not remove, the head of the queue, returning null if the queue is empty.

Example of Queue Implementation Using LinkedList

import java.util.Queue;
import java.util.LinkedList;

public class QueueExample {
    public static void main(String[] args) {
        Queue queue = new LinkedList<>();
        
        // Adding elements to the Queue
        queue.add("Element 1");
        queue.add("Element 2");
        queue.add("Element 3");
        
        System.out.println("Queue: " + queue);
        
        // Removing an element from the Queue
        System.out.println("Removed: " + queue.remove());
        
        // Accessing the front element of the Queue
        System.out.println("Front element: " + queue.peek());
        
        // Checking the state of the Queue after removal
        System.out.println("Queue after removal: " + queue);
    }
}

Output:

Queue: [Element 1, Element 2, Element 3]
Removed: Element 1
Front element: Element 2
Queue after removal: [Element 2, Element 3]

ArrayDeque in Java

The `ArrayDeque` class is a resizable array that implements the `Deque` interface, allowing elements to be added or removed from both ends (double-ended queue). It provides better performance than `Stack` and `LinkedList` for adding and removing elements at both ends of the queue.

java.util.Deque

public interface java.util.Deque extends java.util.Queue {
    public abstract void addFirst(E);
    public abstract void addLast(E);
    public abstract boolean offerFirst(E);
    public abstract boolean offerLast(E);
    public abstract E removeFirst();
    public abstract E removeLast();
    public abstract E pollFirst();
    public abstract E pollLast();
    public abstract E getFirst();
    public abstract E getLast();
    public abstract E peekFirst();
    public abstract E peekLast();
    public abstract boolean removeFirstOccurrence(java.lang.Object);
    public abstract boolean removeLastOccurrence(java.lang.Object);
    public abstract boolean add(E);
    public abstract boolean offer(E);
    public abstract E remove();
    public abstract E poll();
    public abstract E element();
    public abstract E peek();
    public abstract void push(E);
    public abstract E pop();
    public abstract boolean remove(java.lang.Object);
    public abstract boolean contains(java.lang.Object);
    public abstract int size();
    public abstract java.util.Iterator iterator();
    public abstract java.util.Iterator descendingIterator();
}

java.util.ArrayDeque:

public class java.util.ArrayDeque extends java.util.AbstractCollection 
implements java.util.Deque, java.lang.Cloneable, java.io.Serializable {
    transient java.lang.Object[] elements;
    transient int head;
    transient int tail;
    static final boolean $assertionsDisabled;
    public java.util.ArrayDeque();
    public java.util.ArrayDeque(int);
    public java.util.ArrayDeque(java.util.Collection);
    public void addFirst(E);
    public void addLast(E);
    public boolean offerFirst(E);
    public boolean offerLast(E);
    public E removeFirst();
    public E removeLast();
    public E pollFirst();
    public E pollLast();
    public E getFirst();
    public E getLast();
    public E peekFirst();
    public E peekLast();
    public boolean removeFirstOccurrence(java.lang.Object);
    public boolean removeLastOccurrence(java.lang.Object);
    public boolean add(E);
    public boolean offer(E);
    public E remove();
    public E poll();
    public E element();
    public E peek();
    public void push(E);
    public E pop();
    public int size();
    public boolean isEmpty();
    public java.util.Iterator iterator();
    public java.util.Iterator descendingIterator();
    public boolean contains(java.lang.Object);
    public boolean remove(java.lang.Object);
    public void clear();
    public java.lang.Object[] toArray();
    public  T[] toArray(T[]);
    public java.util.ArrayDeque clone();
    public java.util.Spliterator spliterator();
    public java.lang.Object clone() throws java.lang.CloneNotSupportedException;
    static boolean access$200(java.util.ArrayDeque, int);
    static {};
}

Key Points of ArrayDeque

1. Resizable Array: It acts like a dynamic array, growing and shrinking as needed.

2. Constant Time for Add/Remove: Efficient insertion and removal from both ends.

3. Allows Duplicates: Elements can be duplicated.

4. Not Thread-Safe: `ArrayDeque` is not synchronized.

5. No Null Elements: Does not allow `null` elements.

6. No Support for ListIterator: `ArrayDeque` does not support iterating with `ListIterator` or `Enumeration`.

Constructors of ArrayDeque

1. `ArrayDeque()`: Creates an empty `ArrayDeque` with an initial capacity of 16.

2. `ArrayDeque(int capacity)`: Creates an empty `ArrayDeque` with the specified capacity.

3. `ArrayDeque(Collection c)`: Creates a `Deque` containing all elements from the specified collection.

Example of ArrayDeque

import java.util.ArrayDeque;
import java.util.ArrayList;

public class ArrayDequeExample {
    public static void main(String[] args) {
        // Creating an ArrayDeque with default capacity
        ArrayDeque deque = new ArrayDeque<>();
        deque.add("Element 1");
        deque.addFirst("Element 0");
        deque.addLast("Element 2");
        
        System.out.println("ArrayDeque: " + deque);
        
        // Removing elements
        System.out.println("Removed First: " + deque.removeFirst());
        System.out.println("Removed Last: " + deque.removeLast());
        
        // Checking state after removal
        System.out.println("ArrayDeque after removal: " + deque);
    }
}

Output:

ArrayDeque: [Element 0, Element 1, Element 2]
Removed First: Element 0
Removed Last: Element 2
ArrayDeque after removal: [Element 1]

PriorityQueue` in Java

The `PriorityQueue` class in Java, part of the `java.util` package, is a specialized data structure used to process elements based on their priority. It is not a regular FIFO queue but allows elements to be processed based on their natural ordering or a custom ordering defined by a `Comparator`.

java.util.PriorityQueue:

public class java.util.PriorityQueue extends java.util.AbstractQueue 
implements java.io.Serializable {
    transient java.lang.Object[] queue;
    transient int modCount;
    public java.util.PriorityQueue();
    public java.util.PriorityQueue(int);
    public java.util.PriorityQueue(java.util.Comparator);
    public java.util.PriorityQueue(int, java.util.Comparator);
    public java.util.PriorityQueue(java.util.Collection);
    public java.util.PriorityQueue(java.util.PriorityQueue);
    public java.util.PriorityQueue(java.util.SortedSet);
    public boolean add(E);
    public boolean offer(E);
    public E peek();
    public boolean remove(java.lang.Object);
    boolean removeEq(java.lang.Object);
    public boolean contains(java.lang.Object);
    public java.lang.Object[] toArray();
    public  T[] toArray(T[]);
    public java.util.Iterator iterator();
    public int size();
    public void clear();
    public E poll();
    public java.util.Comparator comparator();
    public final java.util.Spliterator spliterator();
    static int access$100(java.util.PriorityQueue);
    static java.lang.Object access$200(java.util.PriorityQueue, int);
}

Key Points about `PriorityQueue`:

1. Priority-based Processing: Elements are processed based on their priority, not in the insertion order.

2. Sorting: It uses natural sorting (like the sorting order of numbers) or a custom sorting order defined by a `Comparator`.

3. Homogeneity in Natural Ordering: If the default sorting is used, all elements should be of the same type and implement the `Comparable` interface; otherwise, a `ClassCastException` will be thrown.

4. Custom Sorting: With a `Comparator`, the elements don’t need to be homogeneous or `Comparable`.

5. No Insertion Order Guarantee: Unlike other collections, the insertion order is not preserved.

6. Null Elements Not Allowed: Null values cannot be added to a `PriorityQueue`.

Example of Using a `PriorityQueue`

import java.util.PriorityQueue;

public class PriorityQueueExample {
    public static void main(String[] args) {
        PriorityQueue priorityQueue = new PriorityQueue<>();
        
        // Adding elements
        priorityQueue.add(101);
        priorityQueue.add(34);
        priorityQueue.add(67);
        priorityQueue.add(-90);
        priorityQueue.add(101); // Duplicate values are allowed
        
        // Printing PriorityQueue - note it does not follow insertion order
        System.out.println("PriorityQueue: " + priorityQueue);
    }
}

Output:

PriorityQueue: [-90, 34, 67, 101, 101]

In this example, the `PriorityQueue` organizes integers in ascending order, which is the natural ordering for integers.

Custom Comparator Example

You can define your own priority by using a `Comparator`. Here’s an example where we create a `PriorityQueue` of `Student` objects based on their marks in descending order.

Custom Comparator to Sort by Marks (Descending)

import java.util.Comparator;
import java.util.PriorityQueue;

class Student {
    int id;
    String name;
    float marks;

    public Student(int id, String name, float marks) {
        this.id = id;
        this.name = name;
        this.marks = marks;
    }

    @Override
    public String toString() {
        return "Student [ID=" + id + ", Name=" + name + ", Marks=" + marks + "]";
    }
}

// Comparator to sort students by marks in descending order
class MarksComparator implements Comparator {
    @Override
    public int compare(Student s1, Student s2) {
        return Float.compare(s2.marks, s1.marks);
    }
}

public class PriorityQueueWithComparator {
    public static void main(String[] args) {
        // Create a PriorityQueue with a custom comparator
        PriorityQueue studentQueue = new PriorityQueue<>
                                                      (new MarksComparator());

        // Adding students to the queue
        studentQueue.add(new Student(101, "Alice", 85.0f));
        studentQueue.add(new Student(102, "Bob", 90.0f));
        studentQueue.add(new Student(103, "Charlie", 70.0f));

        // Processing students based on descending marks
        while (!studentQueue.isEmpty()) {
            System.out.println(studentQueue.poll()); // Removes and prints highest-priority element
        }
    }
}

Output:

Student [ID=102, Name=Bob, Marks=90.0]
Student [ID=101, Name=Alice, Marks=85.0]
Student [ID=103, Name=Charlie, Marks=70.0]

Here, the `MarksComparator` sorts `Student` objects in descending order of marks.

Constructors of `PriorityQueue`

1. Default Constructor (`PriorityQueue()`):

- Creates an empty priority queue with a default capacity of 11 and natural ordering.

PriorityQueue pq = new PriorityQueue<>();

2. Capacity Constructor (`PriorityQueue(int initialCapacity)`):

- Creates a `PriorityQueue` with a specified initial capacity.

PriorityQueue pq = new PriorityQueue<>(20);

3. Comparator-based Constructor (`PriorityQueue(Comparator comparator)`):

- Constructs a priority queue with a custom `Comparator` for sorting.

PriorityQueue pq = new PriorityQueue<>(new MarksComparator());

4. Capacity + Comparator (`PriorityQueue(int initialCapacity, Comparator comparator)`):

- Creates a `PriorityQueue` with an initial capacity and custom comparator.

PriorityQueue pq = new PriorityQueue<>(20, new MarksComparator());

5. Collection-based Constructor (`PriorityQueue(Collection c)`):

- Creates a priority queue from an existing collection.

List list = Arrays.asList(3, 5, 1, 7);
PriorityQueue pq = new PriorityQueue<>(list);

Key Methods of `PriorityQueue`

1. `add(E element)`: Inserts the element into the queue.

2. `peek()`: Retrieves, but does not remove, the head of this queue, or returns `null` if the queue is empty.

3. `poll()`: Retrieves and removes the head of this queue, or returns `null` if the queue is empty.

4. `remove()`: Removes a specific element from the queue.

5. `clear()`: Removes all elements from the queue.

6. `size()`: Returns the number of elements in the queue.

7. `contains(Object o)`: Returns `true` if the queue contains the specified element.

8. `toArray()`: Returns an array containing all elements of the queue.

Conclusion

The `PriorityQueue` is an efficient way to manage elements based on priority instead of insertion order. It offers natural ordering or custom ordering through a `Comparator`. This makes it highly suitable for tasks like job scheduling, simulations, or any scenario where processing order depends on priority.

`Iterator` in Java

The `Iterator` interface, found in the `java.util` package, is a tool used to traverse elements of a collection, such as an `ArrayList`, `HashSet`, or any collection implementing `java.util.Collection`. It allows us to visit elements one by one, only in forward order.

Methods in `Iterator` Interface:

public interface java.util.Iterator {
    public abstract boolean hasNext();
    public abstract E next();
    public void remove();
    public void forEachRemaining(java.util.function.Consumer);
}

1. `hasNext()`:

- Returns `true` if there are more elements to iterate over.

2. `next()`:

- Returns the next element in the iteration.

- Throws `NoSuchElementException` if no more elements exist.

3. `remove()`:

- Removes the element that was returned by the last `next()` call.

- Throws `IllegalStateException` if called without a prior `next()` call or if `remove()` is called multiple times after one `next()` call.

4. `forEachRemaining(Consumer)`:

- Performs the specified action on each remaining element until all elements have been processed.

Important Points about Iterators:

- An `Iterator` can only traverse the collection in forward order.

- Once an `Iterator` is used to traverse the collection, it cannot be reused to traverse it again.

- Modifying a collection while iterating (i.e., adding or removing elements directly through the collection’s methods) results in a `ConcurrentModificationException`.

Example of Using an `Iterator`:

import java.util.ArrayList;
import java.util.Iterator;

public class IteratorExample {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add(101);
        list.add(202);
        list.add(303);
        list.add(404);
        list.add(505);

        // Create an iterator
        Iterator iterator = list.iterator();
        
        // Use the iterator to traverse the list
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        // Trying to reuse the same iterator doesn't work
        System.out.println("--------");
        while (iterator.hasNext()) {
            System.out.println(iterator.next()); // No output as iterator is exhausted
        }
    }
}

Output:

In this example, the iterator can only be used once. The second attempt to traverse the list using the same iterator produces no output because the iterator has already reached the end of the collection.

Handling Concurrent Modification Exception

When iterating over a collection, adding or removing elements directly through the collection will lead to a `ConcurrentModificationException`. The following example demonstrates this:

import java.util.ArrayList;
import java.util.Iterator;

public class ConcurrentModificationExample {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add(101);
        list.add(202);
        list.add(303);
        list.add(404);
        list.add(505);

        // Attempting to modify the collection while iterating
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
            // Uncommenting either of these lines will throw 
            // ConcurrentModificationException
            // list.remove(new Integer(303));
            // list.add(new Integer(606));
        }
    }
}

Output:

The program works fine until we try to modify the collection (`list.add()` or `list.remove()`) while iterating, which would throw a `ConcurrentModificationException`. This occurs because the structure of the collection is altered during iteration.

Removing Elements Using Iterator’s `remove()` Method

The `Iterator` interface provides the `remove()` method to safely remove elements while iterating through the collection.

Example: Removing Elements Using `Iterator`

import java.util.ArrayList;
import java.util.Iterator;

public class RemoveElementExample {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add(101);
        list.add(202);
        list.add(303);
        list.add(404);
        list.add(505);

        System.out.println("Before Iteration list: " + list);

        // Remove elements using iterator
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
            iterator.remove(); // Removes the current element
        }

        System.out.println("After Iteration list: " + list);
    }
}

Output:

Before Iteration list: [101, 202, 303, 404, 505]
101
202
303
404
505
After Iteration list: []

In this example, the `remove()` method of the `Iterator` is used to remove elements while iterating. The list is empty after the iteration is complete.

Summary of Important Methods in `Iterator`

1. `hasNext()`: Checks if there are more elements to iterate.

2. `next()`: Retrieves the next element in the collection.

3. `remove()`: Removes the element last returned by `next()`.

The `Iterator` interface is essential for traversing and manipulating collections in a safe and efficient manner, especially when removing elements from the collection while iterating. However, be cautious of concurrent modification errors if the collection is altered during iteration without using the `remove()` method.

`ListIterator` in Java

The `ListIterator` interface, available in the `java.util` package, extends the `Iterator` interface and is specifically designed for iterating over list-type collections. Unlike `Iterator`, which can only move forward through a collection, `ListIterator` can traverse a list in both forward and reverse directions.

Declaration of `ListIterator` Interface:

public interface java.util.ListIterator extends java.util.Iterator {
    public abstract boolean hasNext();
    public abstract E next();
    public abstract boolean hasPrevious();
    public abstract E previous();
    public abstract int nextIndex();
    public abstract int previousIndex();
    public abstract void remove();
    public abstract void set(E e);
    public abstract void add(E e);
}

Key Features of `ListIterator`:

1. Bidirectional Iteration: Unlike `Iterator`, which only allows forward iteration, `ListIterator` can iterate both forward and backward.

2. List-specific: `ListIterator` works only with list-type collections (`ArrayList`, `LinkedList`, etc.).

3. Supports Modifications: The `add()`, `set()`, and `remove()` methods allow modifying the list during iteration.

Example:

import java.util.ArrayList;
import java.util.ListIterator;

public class ListIteratorExample {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add(101);
        list.add(202);
        list.add(303);
        list.add(404);
        list.add(505);

        // Create a ListIterator
        ListIterator iterator = list.listIterator();

        // Forward iteration
        System.out.println("Forward iteration:");
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        // Reverse iteration
        System.out.println("Reverse iteration:");
        while (iterator.hasPrevious()) {
            System.out.println(iterator.previous());
        }
    }
}

Output:

Forward iteration:
101
202
303
404
505
Reverse iteration:
505
404
303
202
101

Important Methods of `ListIterator`:

1. `boolean hasNext()`:

- Checks if there are more elements while iterating in the forward direction.

2. `E next()`:

- Returns the next element in the list and moves the cursor forward. Throws `NoSuchElementException` if there are no more elements.

3. `boolean hasPrevious()`:

- Checks if there are more elements while iterating in reverse order.

4. `E previous()`:

- Returns the previous element in the list and moves the cursor backward. Throws `NoSuchElementException` if no more previous elements exist.

5. `int nextIndex()`:

- Returns the index of the element that would be returned by the next call to `next()`.

6. `int previousIndex()`:

- Returns the index of the element that would be returned by the next call to `previous()`.

7. `void remove()`:

- Removes the last element returned by `next()` or `previous()` from the list. It can only be called once after a call to `next()` or `previous()`.

8. `void set(E e)`:

- Replaces the last element returned by `next()` or `previous()` with the specified element. This can be called only if neither `remove()` nor `add()` has been called after the last call to `next()` or `previous()`.

9. `void add(E e)`:

- Inserts the specified element into the list at the current cursor position. The new element is inserted before the element that would be returned by `next()` and after the element that would be returned by `previous()`.

Example: Using `add()` and `remove()` Methods in `ListIterator`

import java.util.ArrayList;
import java.util.ListIterator;

public class ListIteratorAddRemove {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add(101);
        list.add(202);
        list.add(303);
        list.add(404);
        list.add(505);

        // Create a ListIterator
        ListIterator iterator = list.listIterator();

        // Add elements while iterating
        System.out.println("Adding element during iteration:");
        while (iterator.hasNext()) {
            Integer value = iterator.next();
            if (value == 303) {
                iterator.add(999);  // Adding 999 after 303
            }
            System.out.println(value);
        }

        // Removing elements while iterating
        iterator = list.listIterator();
        System.out.println("\nRemoving element during iteration:");
        while (iterator.hasNext()) {
            Integer value = iterator.next();
            if (value == 404) {
                iterator.remove();  // Removing 404
            }
            System.out.println(value);
        }

        // Final list
        System.out.println("\nFinal list: " + list);
    }
}

Output:

Adding element during iteration:
101
202
303
999
404
505
Removing element during iteration:
101
202
303
999
404
505
Final list: [101, 202, 303, 999, 505]

Key Differences between `Iterator` and `ListIterator`:

Summary:

- `ListIterator` provides additional functionality over `Iterator` by allowing bidirectional traversal and list modifications (`add()`, `set()`, and `remove()`).

-`ListIterator` is particularly useful when you need more control over the iteration process, such as moving both forward and backward, modifying elements, and inserting new elements at specific positions.

Enumeration in Java

1. Definition:

- `Enumeration` is an interface that allows for iterating over a collection of objects, specifically legacy collections in Java, such as `Vector`, `Hashtable`, `Properties`, `Stack`, and `Dictionary`.

2. Methods:

- The `Enumeration` interface defines two main methods:

public abstract boolean hasMoreElements();
public abstract E nextElement();

Important Points about `Enumeration`:

1. Legacy Collection Traversal:

- `Enumeration` is designed to work with legacy classes in the Java Collections Framework. This means it’s not suitable for the newer collection classes introduced in Java 2, like `ArrayList`, `HashSet`, etc.

2. One-way Traversal:

- You can only traverse collections in one direction (forward) with `Enumeration`. Unlike some other iterators, you cannot go backward or modify the traversal order.

3. Safe Modifications:

- While traversing a collection using `Enumeration`, you can add or remove elements without encountering exceptions (like `ConcurrentModificationException`), which is a limitation when using `Iterator` or `ListIterator`.

Example Code Explained:

Here’s the provided example code broken down:

import java.util.Enumeration;
import java.util.Vector;

public class JTC {
   public static void main(String[] args) {
      Vector vector = new Vector();
      vector.add(101);
      vector.add("Hello");
      vector.add(12.34f);
      vector.add(true);
      
      Enumeration enumeration = vector.elements();
      
      while (enumeration.hasMoreElements()) {
         System.out.println(enumeration.nextElement());
      }
      
      System.out.println("--------------------");
   }
}

Output:

101
Hello
12.34
true
--------------------

Breakdown:

1. Vector Creation:

- A `Vector` is instantiated, which is a legacy collection that can hold objects of any type.

2. Adding Elements:

- Various elements are added to the vector (an `Integer`, a `String`, a `Float`, and a `Boolean`).

3. Creating Enumeration:

- The `elements()` method of the `Vector` class is called, which returns an `Enumeration` object that allows traversal of the `Vector`.

4. Traversing the Vector:

- A `while` loop is used to traverse the `Vector`. The `hasMoreElements()` method checks if there are more elements to read.

- The `nextElement()` method retrieves the next element in the enumeration and prints it.

5. Output:

- The output shows each element added to the vector, followed by a separator line.

Important Methods of `Enumeration`:

1. `hasMoreElements()`:

- Returns `true` if there are more elements to iterate over; otherwise, it returns `false`.

2. `nextElement()`:

- Returns the next element in the enumeration. If there are no more elements, it throws a `NoSuchElementException`.

Conclusion

`Enumeration` is a simple interface for iterating over legacy collections, providing a straightforward way to traverse elements. However, because it is less flexible than modern iterators, it is often recommended to use `Iterator` for newer collection types when possible.

HashMap Overview

The `HashMap` in Java, part of the `java.util` package, is a widely used collection that stores data as key-value pairs. It is an implementation of the `Map` interface and provides constant-time performance for basic operations like `get` and `put`. Here’s a deep dive into the key features, methods, and internal workings of `HashMap`:

Key Points of `HashMap`

1. Key-Value Pair Storage: HashMap stores data in key-value pairs.

2. Heterogeneous Keys and Values: It allows keys and values of any type, including custom objects.

3. Duplicate Keys: Only one value is associated with each key, but duplicate values are allowed.

4. Null Keys and Values: One `null` key and multiple `null` values are allowed.

5. Unordered Storage: Elements are not stored in any specific order.

6. Not Synchronized: HashMap is not synchronized, making it unsafe for concurrent use without external synchronization.

7. Cloneable and Serializable: HashMap can be cloned and serialized.

8. Random Access: HashMap provides random access to elements.

Important Constructors

1. Default Constructor: Creates an empty `HashMap` with an initial capacity of 16 and a default load factor of 0.75.

HashMap map = new HashMap<>();

2. Parameterized Constructor (Capacity): Creates an empty `HashMap` with a specified initial capacity.

HashMap map = new HashMap<>(capacity);

3. Parameterized Constructor (Capacity and Load Factor): Creates a `HashMap` with specified capacity and load factor.

HashMap map = new HashMap<>(capacity, loadFactor);

4. Copy Constructor: Creates a `HashMap` with mappings identical to those in the specified map.

HashMap map = new HashMap<>(existingMap);

Common Methods

`put()`

Adds a key-value pair to the map. If the key already exists, the new value replaces the old one.

HashMap map = new HashMap<>();
map.put("key1", "value1");

`putAll()`

Copies all key-value pairs from another map to the current map.

HashMap map2 = new HashMap<>();
map2.putAll(map);

`remove()`

Removes a key (and its corresponding value) from the map.

map.remove("key1");

`keySet()`

Returns a `Set` view of the keys contained in the map.

Set keys = map.keySet();

`values()`

Returns a `Collection` view of the values contained in the map.

Collection values = map.values();

`entrySet()`

Returns a `Set` view of the key-value mappings.

Set> entries = map.entrySet();

`get()`

Retrieves the value associated with a given key. Returns `null` if the key is not found.

String value = map.get("key1");

`equals()`

Compares two maps for equality. Returns `true` if both maps contain the same key-value pairs.

boolean isEqual = map1.equals(map2);

`hashCode()`

Returns the hash code value for the map.

int hashCode = map.hashCode();

Internal Working of `HashMap`

1. Bucket Array: Internally, `HashMap` uses an array of `Node` objects (buckets) to store key-value pairs. Each bucket is a linked list (or a tree in case of high collision).

2. Hashing: The key’s hash code is computed using the `hash()` function and then the bucket index is determined using:

index = hash(key) & (n - 1);

where `n` is the length of the array (bucket).

3. Collision Handling: If two keys have the same hash code, they are placed in the same bucket. A linked list or a tree structure is used to store multiple entries in the same bucket.

4. Load Factor: The load factor (default is 0.75) determines when to increase the capacity of the bucket array. Once the size of the map exceeds `capacity loadFactor`, the array is resized.

5. Rehashing: During resizing, all entries are redistributed into the new bucket array.

Example: Simple `HashMap` Implementation

import java.util.HashMap;

public class HashMapExample {
   public static void main(String[] args) {
      HashMap map = new HashMap<>();
      map.put(1, "Apple");
      map.put(2, "Banana");
      map.put(3, "Cherry");

      System.out.println("Map: " + map);
      System.out.println("Value for key 2: " + map.get(2));
   }
}

Conclusion

`HashMap` is a powerful data structure for storing and retrieving key-value pairs with constant-time complexity for most operations. Understanding its internal working is essential for optimizing its use in scenarios involving large datasets, custom objects, and performance-sensitive applications.

LinkedHashMap

A `LinkedHashMap` is a hybrid between a `HashMap` and a doubly-linked list, combining the performance benefits of a `HashMap` with the order-preserving characteristic of a linked list. Let’s break down the important points you’ve shared:

Key Features of `LinkedHashMap`:

1. Node Representation: It stores its entries as nodes of type `LinkedHashMap.Entry`, which extends `HashMap.Node`. This class keeps links to both the previous and next entries, preserving the insertion order.

2. Key-Value Pairs: Just like other `Map` implementations, `LinkedHashMap` maps unique keys to values. The values can be duplicated, but keys must be unique.

3. Null Keys and Values: It supports `null` as both keys and values. This feature is consistent with `HashMap`.

4. Order of Elements: Unlike `HashMap`, the entries in a `LinkedHashMap` are ordered based on their insertion order. This makes it deterministic, so when you iterate over the map, you will get the keys in the same order in which they were inserted.

5. Non-Synchronized: Similar to `HashMap`, none of the methods are synchronized, meaning `LinkedHashMap` is not thread-safe by default. If thread-safety is required, it needs to be externally synchronized.

6. Clonable and Serializable: Since it extends `HashMap`, which implements both `Cloneable` and `Serializable`, it can be cloned and serialized.

Constructors of `LinkedHashMap`:

- Default Constructor: Creates a `LinkedHashMap` with a default initial capacity of 16 and a load factor of 0.75.

- Parameterized Constructors: Allow specifying initial capacity and load factor, similar to `HashMap`. There’s also a constructor that accepts a `Map` to create a `LinkedHashMap` initialized with the mappings of the given `Map`.

Internal Working of `LinkedHashMap`:

The internal structure of `LinkedHashMap` is based on a doubly linked list that maintains insertion order. Each entry in the map is represented by an instance of `LinkedHashMap.Entry`, which extends `HashMap.Node` and adds two additional references:

- `before`: Reference to the previous entry.

- `after`: Reference to the next entry.

The entry class looks like this:

static class Entry extends HashMap.Node { 
    Entry before, after; 
    Entry(int hash, K key, V value, Node next) { 
        super(hash, key, value, next); 
    } 
}

This structure ensures that all entries are linked together, maintaining the order of their insertion. The overhead of maintaining this linked list adds a slight performance cost compared to a standard `HashMap`, but the trade-off is the ability to iterate in insertion order.

Code Example:

The code you provided demonstrates how to add elements to a `LinkedHashMap` and then iterate over its entries:

LinkedHashMap map = new LinkedHashMap();
map.put((byte) 101, (byte) 201);
map.put((short) 202, (short) 202);
map.put((int) 303, (int) 303);
map.put((long) 404, (long) 404);
map.put(12.34f, 67.89f);
map.put(34.56, -678.90);
map.put(true, false);
map.put('K', 'V');
map.put("key", "value");
map.put(null, null);
map.put(new JTC(), new JTC());

It demonstrates:

- Storing different types of keys and values (primitives, objects, and even `null`).

- Iterating over the entries using an iterator.

Output:

When this code runs, it prints each entry in the insertion order, verifying that the `LinkedHashMap` preserves the order of elements as they were added.

Overall, `LinkedHashMap` provides an easy way to combine the constant-time performance of `HashMap` with a predictable iteration order. This makes it particularly useful in scenarios where order is important, such as in caching systems.

TreeMap

`TreeMap` is a class in the `java.util` package that implements the `NavigableMap` interface, and it stores data in a sorted key-value pair format. Let’s break down the essential details you’ve shared:

Key Features of `TreeMap`:

1. Key-Value Format: Like all maps, `TreeMap` stores data in key-value pairs, where each key is unique, and values can be duplicated.

2. Type Consistency for Keys: All keys in a `TreeMap` must be of the same type to allow sorting. Different types of values are allowed.

3. No Null Keys or Values: Unlike `HashMap` and `LinkedHashMap`, `TreeMap` does not allow `null` keys or values. Trying to insert a `null` key or value will result in a `NullPointerException`.

4. Sorted Order: The entries are stored in sorted order according to the natural ordering of the keys or by a specified `Comparator`. The natural order is defined by the `Comparable` interface (like the `compareTo()` method).

5. Non-Synchronized: Like other map implementations in Java, `TreeMap` is not synchronized. If multiple threads access a `TreeMap` concurrently, it must be externally synchronized.

6. Clonable and Serializable: Since `TreeMap` implements `Cloneable` and `Serializable`, it can be cloned and serialized for deep copying or persistent storage.

7. Red-Black Tree Data Structure: `TreeMap` internally uses a Red-Black Tree, which is a self-balancing binary search tree. This guarantees log(n) time complexity for basic operations like `get()`, `put()`, `remove()`, etc.

Constructors of `TreeMap`:

1. `TreeMap()`: Creates an empty `TreeMap` that sorts its elements according to the natural ordering of the keys. All key objects must implement `Comparable`.

Example 1: Integer Keys

TreeMap map = new TreeMap();
map.put(1, "V-1");
map.put(2, "V-2");
map.put(3, "V-3");
map.put(4, "V-4");
map.put(5, "V-5");
System.out.println("map :- " + map);

Output: The map will store entries sorted by the natural ordering of `Integer`, which is ascending order:

map :- {1=V-1, 2=V-2, 3=V-3, 4=V-4, 5=V-5}

Example 2: Custom Object with Natural Ordering

In this example, the `Student` class implements `Comparable` to define the natural sorting order based on student marks in descending order:

import java.util.TreeMap;

class Student implements Comparable {
   String sname;
   int marks;

   public Student(String sname, int marks) {
      this.sname = sname;
      this.marks = marks;
   }

   @Override
   public int compareTo(Student s) {
      return Integer.compare(s.marks, this.marks); // Descending order
   }

   @Override
   public String toString() {
      return "Student [sname=" + sname + ", marks=" + marks + "]";
   }
}

public class Main {
   public static void main(String[] args) {
      TreeMap map = new TreeMap<>();
      map.put(new Student("Vivek", 89), "V-1");
      map.put(new Student("Amit", 123), "V-2");
      map.put(new Student("Rahul", 93), "V-3");
      map.put(new Student("Nandan", 103), "V-4");
      map.put(new Student("Neha", 789), "V-5");

      System.out.println("map :- " + map);
   }
}

Using lambda function:

import java.util.Comparator;
import java.util.TreeMap;

class Student {
    String sname;
    int marks;

    public Student(String sname, int marks) {
        this.sname = sname;
        this.marks = marks;
    }

    @Override
    public String toString() {
        return "Student [sname=" + sname + ", marks=" + marks + "]";
    }
}

public class Main {
    public static void main(String[] args) {
        // TreeMap with a custom comparator using a lambda expression
        TreeMap map = new TreeMap<>(
            (s1, s2) -> Integer.compare(s2.marks, s1.marks) // Descending order
        );

        map.put(new Student("Vivek", 89), "V-1");
        map.put(new Student("Amit", 123), "V-2");
        map.put(new Student("Rahul", 93), "V-3");
        map.put(new Student("Nandan", 103), "V-4");
        map.put(new Student("Neha", 789), "V-5");

        System.out.println("map :- " + map);
    }
}

Output: The map will store the students sorted in descending order of marks (based on the `compareTo()` method):

map :- {Student [sname=Neha, marks=789]=V-5, Student [sname=Amit, marks=123]=V-2, Student [sname=Nandan, marks=103]=V-4, Student [sname=Rahul, marks=93]=V-3, Student [sname=Vivek, marks=89]=V-1}

Custom Comparator Example:

You can define a custom comparator to alter the sorting behavior. In this example, a `Comparator` is used to sort students in ascending order of marks:

class StudentMarksComparator implements Comparator {
   public int compare(Student s1, Student s2) {
      return Integer.compare(s1.marks, s2.marks); // Ascending order
   }
}

TreeMap map = new TreeMap(new StudentMarksComparator());
map.put(new Student("Vivek", 89), "V-1");
map.put(new Student("Amit", 123), "V-2");
map.put(new Student("Rahul", 93), "V-3");
map.put(new Student("Nandan", 103), "V-4");
map.put(new Student("Neha", 789), "V-5");
System.out.println("map :- " + map);

Output: Now the `TreeMap` will sort the students in ascending order based on the custom comparator:

map :- {Student [sname=Vivek, marks=89]=V-1, Student [sname=Rahul, marks=93]=V-3, Student [sname=Nandan, marks=103]=V-4, Student [sname=Amit, marks=123]=V-2, Student [sname=Neha, marks=789]=V-5}

Summary:

- Natural Ordering: When no comparator is provided, the keys are sorted based on their natural order (e.g., `Integer`, `String`).

- Custom Comparator: Allows you to define your own sorting logic.

- Null Keys/Values: Not allowed, unlike `HashMap` or `LinkedHashMap`.

- Red-Black Tree: Provides efficient performance with a time complexity of O(log n) for most operations.

This makes `TreeMap` ideal when you need sorted data (like range queries or when maintaining order is critical) and can tolerate the slightly higher overhead compared to `HashMap`.

`Hashtable` in Java

The `Hashtable` class, part of the `java.util` package, is a legacy data structure that stores key-value pairs in a hash table. It is one of the original implementations of a map in Java and has been retrofitted to implement the `Map` interface. While similar to `HashMap`, `Hashtable` is synchronized and does not allow `null` keys or values.

Key Features of `Hashtable`

1. Legacy Class: `Hashtable` is a legacy class from earlier versions of Java, now included in the Collections Framework.

2. Key-Value Storage: Stores elements as key-value pairs.

3. Heterogeneous Keys and Values: Allows different types for keys and values.

4. No Null Keys or Values: Does not allow `null` as keys or values.

5. Indexed Storage: Uses an internal index representation for storing elements.

6. Random Access: Provides random access to elements.

7. Synchronized Methods: All methods are synchronized, making it thread-safe.

8. Unordered Storage: Does not guarantee any specific order for its elements.

9. Uses Enumeration: Iterates over keys and values using `Enumeration`.

Constructors of `Hashtable`

1. `Hashtable()`:

- Creates an empty hashtable with a default initial capacity (11) and a default load factor (0.75).

Hashtable hashtable = new Hashtable<>();

2. `Hashtable(int initialCapacity)`:

- Creates a hashtable with the specified initial capacity and default load factor (0.75).

- Throws `IllegalArgumentException` if the initial capacity is negative.

Hashtable hashtable = new Hashtable<>(initialCapacity);

3. `Hashtable(int initialCapacity, float loadFactor)`:

- Creates a hashtable with the specified initial capacity and load factor.

- Throws `IllegalArgumentException` if the initial capacity is negative or the load factor is non-positive.

Hashtable hashtable = new Hashtable<>(initialCapacity, loadFactor);

4. `Hashtable(Map t)`:

- Creates a hashtable with the same mappings as the specified map.

- Throws `NullPointerException` if the specified map is `null`.

Map map = new HashMap<>();
Hashtable hashtable = new Hashtable<>(map);

Common Methods of `Hashtable`

1. `int size()`:

- Returns the number of key-value pairs in the hashtable.

int size = hashtable.size();

2. `boolean isEmpty()`:

- Checks if the hashtable is empty.

boolean empty = hashtable.isEmpty();

3. `Enumeration keys()`:

- Returns an enumeration of the keys.

Enumeration keys = hashtable.keys();

4. `Enumeration elements()`:

- Returns an enumeration of the values.

Enumeration values = hashtable.elements();

5. `boolean contains(Object value)`:

- Checks if the specified value is mapped in the hashtable.

- Throws `NullPointerException` if the value is `null`.

boolean containsValue = hashtable.contains("Value");

6. `boolean containsKey(Object key)`:

- Checks if the specified key exists.

- Throws `NullPointerException` if the key is `null`.

boolean containsKey = hashtable.containsKey("Key");

7. `V get(Object key)`:

- Retrieves the value associated with the specified key.

- Returns `null` if the key is not found.

- Throws `NullPointerException` if the key is `null`.

V value = hashtable.get("Key");

8. `V put(K key, V value)`:

- Maps the specified key to the specified value.

- Returns the previous value associated with the key or `null` if none.

- Throws `NullPointerException` if the key or value is `null`.

V previousValue = hashtable.put("Key", "Value");

9. `V remove(Object key)`:

- Removes the key (and its corresponding value) from the hashtable.

- Returns the value that was removed or `null` if the key didn’t exist.

- Throws `NullPointerException` if the key is `null`.

V removedValue = hashtable.remove("Key");

10. `void putAll(Map t)`:

- Copies all mappings from the specified map to this hashtable.

- Throws `NullPointerException` if the specified map is `null`.

hashtable.putAll(anotherMap);

11. `void clear()`:

- Clears the hashtable.

hashtable.clear();

12. `V getOrDefault(Object key, V defaultValue)`:

- Returns the value to which the specified key is mapped, or `defaultValue` if the key is not present.

- Throws `NullPointerException` if the key is `null`.

V value = hashtable.getOrDefault("Key", defaultValue);

Example Code

import java.util.Enumeration;
import java.util.Hashtable;

public class HashtableExample {
   public static void main(String[] args) {
      // Creating an empty Hashtable
      Hashtable hashtable = new Hashtable<>();

      // Adding elements using put() method
      hashtable.put("K-1", "V-1");
      hashtable.put(101, true);
      hashtable.put((byte) 78, 12.34f);
      hashtable.put('A', new HashtableExample());
      hashtable.put(new HashtableExample(), 'V');
      hashtable.put((byte) 78, 'N'); // Overwrites previous value for key 78

      // Displaying the hashtable
      System.out.println("Hashtable: " + hashtable);

      // Size of the hashtable
      System.out.println("Size: " + hashtable.size());

      // Check if hashtable is empty
      System.out.println("Is Empty: " + hashtable.isEmpty());

      // Enumerate keys
      System.out.println("-----Keys-----");
      Enumeration keys = hashtable.keys();
      while (keys.hasMoreElements()) {
         System.out.println(keys.nextElement());
      }

      // Enumerate values
      System.out.println("----Values-----");
      Enumeration values = hashtable.elements();
      while (values.hasMoreElements()) {
         System.out.println(values.nextElement());
      }

      // Check for a value
      System.out.println("Contains 'V-1': " + hashtable.contains("V-1"));
      System.out.println("Contains 'K-1': " + hashtable.contains("K-1"));

      // Check for a key
      System.out.println("Contains key 'K-1': " + hashtable.containsKey("K-1"));
      System.out.println("Contains key 'V-1': " + hashtable.containsKey("V-1"));

      // Retrieve a value
      System.out.println("Value for 'K-1': " + hashtable.get("K-1"));
      System.out.println("Value for 'V-1': " + hashtable.get("V-1"));

      // Remove a key
      System.out.println("Before Remove Operation: " + hashtable);
      System.out.println("Removed Value: " + hashtable.remove("K-1"));
      System.out.println("After Remove Operation: " + hashtable);
      System.out.println("Removed Value: " + hashtable.remove("V-1"));

      // Adding all the mappings from another hashtable
      Hashtable hashtable2 = new Hashtable<>();
      hashtable2.put('A', "Value - 1");
      hashtable2.put("Key-2", "Value-2");
      hashtable.put("Key-3", "Value-3");
      System.out.println("Hashtable2: " + hashtable2);

      hashtable.putAll(hashtable2);
      System.out.println("Updated Hashtable: " + hashtable);

      // Clear the second hashtable
      System.out.println("Hashtable2 size before clear: " + hashtable2.size());
      hashtable2.clear();
      System.out.println("Hashtable2 size after clear: " + hashtable2.size());

      // Using getOrDefault()
      System.out.println("Value for 'Key-2': " + hashtable.getOrDefault("Key-2", "DEFAULT_VALUE"));
      System.out.println("Value for 'Key-N': " + hashtable.getOrDefault("Key-N", "DEFAULT_VALUE"));
   }
}

Explanation of the Code

- Adding Elements:

- Various key-value pairs are added using the `put()` method.

- Overwriting a value: Adding a new value with an existing key replaces the old value.

- Note: Attempting to use `null` as a key or value will throw a `NullPointerException`.

- Size and Emptiness:

- `size()` returns the number of entries.

- `isEmpty()` checks if the hashtable is empty.

- Enumerations:

- `keys()` and `elements()` return enumerations of the keys and values, respectively.

- Containment Checks:

- `contains(Object value)` checks if a value exists.

- `containsKey(Object key)` checks if a key exists.

- Retrieval and Removal:

- `get(Object key)` retrieves the value associated with a key.

- `remove(Object key)` removes the key-value pair and returns the value.

- Merging Hashtables:

- `putAll(Map t)` adds all mappings from another hashtable.

- Clearing:

- `clear()` removes all entries from the hashtable.

- Default Values:

- `getOrDefault(Object key, V defaultValue)` returns the value associated with the key or the default value if the key is not found.

Sample Output

Hashtable: {A=HashtableExample@15db9742, HashtableExample@6d06d69c=V, K-1=V-1,
 101=true, 78=N}
Size: 5
Is Empty: false
 - - -Keys - - -
A
HashtableExample@6d06d69c
K-1
101
78
 - - Values - - -
HashtableExample@15db9742
V
V-1
true
N
Contains 'V-1': true
Contains 'K-1': false
Contains key 'K-1': true
Contains key 'V-1': false
Value for 'K-1': V-1
Value for 'V-1': null
Before Remove Operation: {A=HashtableExample@15db9742, 
HashtableExample@6d06d69c=V, K-1=V-1, 101=true, 78=N}
Removed Value: V-1
After Remove Operation: {A=HashtableExample@15db9742, 
HashtableExample@6d06d69c=V, 101=true, 78=N}
Removed Value: null
Hashtable2: {A=Value - 1, Key-2=Value-2}
Updated Hashtable: {A=Value - 1, HashtableExample@6d06d69c=V,
 101=true, 78=N, Key-2=Value-2, Key-3=Value-3}
Hashtable2 size before clear: 2
Hashtable2 size after clear: 0
Value for 'Key-2': Value-2
Value for 'Key-N': DEFAULT_VALUE

Important Notes

- Null Keys and Values:

- `Hashtable` does not allow `null` keys or values.

- Attempting to insert a `null` key or value will result in a `NullPointerException`.

- Thread Safety:

- All methods in `Hashtable` are synchronized.

- Suitable for single-threaded applications or simple multi-threaded scenarios.

- May lead to performance overhead in highly concurrent applications.

- Enumeration vs. Iterator:

- `Hashtable` uses `Enumeration` for traversal, which is considered legacy.

- Modern collections use `Iterator` or `Iterator` with generics for type safety.

- Ordering:

- `Hashtable` does not guarantee any specific order of its elements.

- If ordering is required, consider using `LinkedHashMap`.

When to Use `Hashtable`

- Legacy Systems: When maintaining older Java applications that already use `Hashtable`.

- Simple Thread Safety: When you need a thread-safe map without external synchronization and the performance impact is acceptable.

Alternatives

- `HashMap`:

- Not synchronized, allows `null` keys and values.

- Better performance in single-threaded environments.

- `ConcurrentHashMap`:

- Thread-safe and optimized for concurrent access.

- Does not allow `null` keys or values.

- `LinkedHashMap`:

- Maintains insertion order.

- Not synchronized, allows `null` keys and values.

Conclusion

The `Hashtable` class provides a synchronized key-value data structure that is part of Java’s legacy collections. While newer implementations like `HashMap` and `ConcurrentHashMap` offer improved performance and flexibility, understanding `Hashtable` is important for maintaining legacy code and understanding the evolution of Java’s Collections Framework. When thread safety is required without the need for `null` keys or values, and performance is not the primary concern, `Hashtable` can still be a suitable choice.

Properties

The `Properties` class in Java, part of the `java.util` package, is used to store key-value pairs where both the key and value are `String` objects. It extends `Hashtable`, offering additional functionality specifically for managing property files. These files are often used to store configuration details in a Java application.

Key Features of the `Properties` Class:

1. String-only key-value pairs: The keys and values in the `Properties` class must be `String` objects.

2. File Operations: Provides methods for reading from and writing to property files or XML files.

3. Default Values: A `Properties` object can be created with a default `Properties` object to provide fallback values.

4. Synchronization: Methods in the `Properties` class are synchronized, making it thread-safe.

Important Constructors:

1. `Properties()`: Creates an empty property list.

2. `Properties(Properties defaults)`: Creates a property list with specified default properties.

Key Methods:

1. `setProperty(String key, String value)`: Maps the specified key to the specified value, returning the previous value associated with the key if one exists.

2. `getProperty(String key)`: Returns the value associated with the specified key. If the key is not found, it returns `null`.

3. `getProperty(String key, String defaultValue)`: Returns the value associated with the key or the default value if the key is not found.

4. `load(InputStream inStream)`: Reads a property list from the input stream in a simple line-oriented format.

5. `loadFromXML(InputStream in)`: Loads properties from an XML file.

6. `store(OutputStream out, String comments)`: Writes the properties to an output stream, optionally with comments.

7. `storeToXML(OutputStream os, String comment)`: Stores the properties in an XML format.

8. `propertyNames()`: Returns an enumeration of all the keys in the property list.

9. `stringPropertyNames()`: Returns a set of keys where both the key and corresponding value are strings.

Example:

This program demonstrates basic usage of `Properties`, including reading from a file and saving properties:

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

public class PropertiesExample {
    public static void main(String[] args) throws IOException {
        // Create a Properties object
        Properties properties = new Properties();

        // Load properties from a file
        properties.load(new FileInputStream("config.properties"));

        // Display property values
        System.out.println("Username: " + properties.getProperty("UserName"));
        System.out.println("Password: " + properties.getProperty("Password"));

        // Add a new property
        properties.setProperty("Theme", "Dark");

        // Store updated properties back to the file
        properties.store(new FileOutputStream("config.properties"), "Updated theme setting");

        // Store properties in XML format
        properties.storeToXML(new FileOutputStream("config.xml"), "Application Settings");
    }
}

Working with `.properties` File:

A `.properties` file is a text file where each line represents a key-value pair, often used for configuration purposes in applications.

Sample `.properties` File:

UserName=JTC
Password=JTC@123
Theme=Dark

XML Format:

The `Properties` class can also store and load properties in an XML format, providing a more structured alternative to the traditional `.properties` format.




    Application Settings
    JTC
    JTC@123
    Dark

Practical Uses:

- Configuration Management: Storing and retrieving application settings like database connection strings, user preferences, etc.

- Internationalization: Managing language-specific resources.

This overview provides a clear understanding of the `Properties` class and how to use it in various file formats.

JAVA Basics

Pratik T — Tue, 08 Oct 2024 07:05:31 GMT

1. Introduction to Java

Java is a high-level, object-oriented programming language developed by Sun Microsystems (now owned by Oracle) in 1995. It is platform-independent, meaning you can write Java code on one system and run it on any other system that supports Java.

Key Features of Java:

Object-Oriented: Java supports concepts such as inheritance, encapsulation, polymorphism, and abstraction.
Platform-Independent: Java’s “Write Once, Run Anywhere” capability allows code to run on any device that has the Java Virtual Machine (JVM).
Secure: Java has built-in security features like bytecode verification and a security manager.
Robust: It handles memory management and supports garbage collection to prevent memory leaks.
Multi-threaded: Java supports multithreading, allowing multiple tasks to run concurrently.

2. Setting Up the Java Development Environment

Installing Java

Download and install the Java Development Kit (JDK) from the Oracle website or use OpenJDK (an open-source implementation of Java).
Set the environment variable JAVA_HOME to the installation directory of the JDK.
Add the bin directory of the JDK to your system's PATH environment variable.

Setting Up an Integrated Development Environment (IDE)

Popular IDEs for Java development:

Eclipse (eclipse.org)
IntelliJ IDEA (jetbrains.com)
NetBeans (netbeans.apache.org)

You can also use a simple text editor and run Java code from the command line if you prefer.

3. Basic Syntax

Writing Your First Java Program

Here is a simple Java program that prints “Hello, World!” to the console:

public class Demo {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Explanation:

1. Class Declaration

Example: `public class Demo`

- Access Modifier:

- Definition: Indicates the visibility of the class.

- Types:

- public: Accessible from any other class.

- private: Accessible only within the defined class.

- protected: Accessible within the same package and by subclasses.

- default: No modifier; accessible only within the same package.

- In Our Example: `public` allows `Demo` to be accessed from anywhere.

- Class Keyword:

- `class` is a reserved keyword in Java.

- It must be in lowercase.

- Every Java program must define a class.

- Class Name:

- The name of the class (`Demo` in this case) should start with a capital letter by convention.

- The file name should match the class name (`Demo.java`).

- Class names can include letters, digits, `$`, and `_`, but must begin with a letter.

2. Defining the Main Method

Example: `public static void main(String args[])`

- Access Modifier: Similar to the class, here it is `public`, allowing the method to be accessible from anywhere.

- Non-Access Modifier:

- static: This allows the method to be called without creating an instance of the class. It belongs to the class itself.

- Non-static methods require an object of the class to be called.

- Return Type:

- `void` indicates that this method does not return a value.

- Method Name:

- The name `main` is predefined in Java as the entry point for any Java application.

- Any method name can be identified by parentheses `()`.

- Command Line Arguments:

- `String args[]` allows the program to accept command line arguments.

- This can also be written as:

1. `String args[]`

2. `String[] args`

3. `String [] args`

- The capital `S` in `String` is crucial, as Java is case-sensitive.

3. Printing Statement

Example: `System.out.println(“This is my first program”);`

- System Class:

- `System` is a predefined class in Java.

- Dot Operator (.):

- Used to access members (methods or variables) of a class.

- Out Object:

- `out` is a static member of the `System` class, which is an instance of `PrintStream`.

- println() Method:

- A method of `PrintStream` that prints the provided string followed by a new line.

- String Literal:

- `”Hello World”` is the message to be printed. It is enclosed in double quotes.

Compiling and Running Java Code

Compile: javac HelloWorld.java
Run: java HelloWorld

1) Difference Between C and Java Programs:

Key differences between C and Java revolve around their design, usage, and features:

- Platform Independence:

- C: C programs are compiled into machine-specific binary code, meaning a C program compiled on one platform cannot run on another without recompilation.

- Java: Java is platform-independent, as it is compiled into an intermediate bytecode that can run on any system with a Java Virtual Machine (JVM).

- Memory Management:

- C: In C, memory management is manual. The programmer has to explicitly allocate and deallocate memory using functions like malloc() and free().

- Java: Java has automatic memory management with its Garbage Collector, which automatically frees up memory when objects are no longer in use.

- Syntax:

- C: C uses procedural programming, and concepts like pointers and structures play a significant role.

- Java: Java uses object-oriented programming (OOP), where the focus is on classes, objects, and inheritance. Java does not have pointers or structures as C does.

- Execution Model:

- C: C compiles directly to machine code, which is specific to the processor.

- Java: Java code is compiled into bytecode, which is interpreted or compiled by the JVM at runtime.

- Low-Level Operations:

- C: C allows low-level programming (e.g., direct memory access via pointers), making it suitable for system programming.

- Java: Java abstracts away low-level operations, so direct memory access is not allowed for security and simplicity.

2) How Java Is Platform Independent:

Java is platform-independent because of its use of bytecode and the Java Virtual Machine (JVM). Here’s how it works:

1. Source Code Compilation: Java source code (.java files) is compiled into bytecode (.class files) by the Java compiler (javac). This bytecode is not machine-specific.

2. Bytecode Execution: The bytecode can run on any machine that has a JVM. The JVM interprets or JIT compiles the bytecode into machine code that is specific to the platform it is running on (Windows, Linux, macOS, etc.).

3. Write Once, Run Anywhere (WORA): Because the JVM is platform-specific but the bytecode is the same across platforms, the same compiled Java program can run on any device with a JVM, making Java platform-independent.

3) Why Native Code is Available in C but Not in Java:

- C Programs: C programs are compiled into native machine code that is specific to the operating system and processor architecture. This means that the code can directly interact with the hardware, giving C high performance but making the code non-portable across platforms without recompilation.

- Java Programs: Java does not compile into native code directly. Instead, Java compiles to bytecode, which runs on the JVM. This abstraction allows Java to be platform-independent. While Java can still call native code using the Java Native Interface (JNI), Java’s design avoids directly compiling into platform-specific machine code to maintain portability.

4) How to Compile and Run Java Programs Using Command Prompt:

To compile and run a Java program using the command prompt:

1. Write the Java Program:

Create a Java file (HelloWorld.java) with the following content:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
  }
}

2. Compile the Program:

Open the command prompt and navigate to the directory where the .java file is saved. Use the following command to compile the program:

javac HelloWorld.java

This will create a HelloWorld.class file (bytecode).

3. Run the Program:

After compiling, run the program using:

java HelloWorld

Note: Do not include the .class extension while running the program with the java command.

5) What Happens if We Save a Blank File as a .java File?

- If you save a blank file with a .java extension and try to compile it using javac, the compiler will return an error:

error: Class names, 'filename.java', are only accepted if annotation 
processing is explicitly requested

A .java file must contain at least one class or interface declaration. A blank file will not be considered a valid Java program by the compiler.

6) Can We Perform Changes in Bytecode? What Are the Issues?

Yes, you can make changes to bytecode manually, but it’s highly discouraged due to several issues:

- How Bytecode Can Be Modified:

- You can use bytecode editors or tools like javap (Java bytecode disassembler) to decompile and modify .class files.

- Libraries like ASM or Javassist allow programmatic manipulation of bytecode during runtime.

- Issues with Modifying Bytecode:

- Complexity: Bytecode is a low-level representation of Java code, and modifying it directly is error-prone and difficult to manage.

- ClassLoader Violations: Tampering with bytecode can lead to issues with the Java ClassLoader, especially if the changes break the internal structure or violate the Java specification.

- Security Risks: Bytecode manipulation opens up the program to security vulnerabilities, as malicious code could be injected.

- Loss of Original Source Mapping: Changes made directly to bytecode will not be reflected in the original Java source code, which can lead to confusion during debugging.

In general, bytecode manipulation should be reserved for advanced use cases like creating dynamic proxies or frameworks (e.g., AOP) and should be handled with great care.

Java Character Set

What is a Character Set?

A character set is a collection of characters that Java can recognize and work with. These characters are letters, numbers, symbols, and whitespace that are used in Java programs. Every character is internally stored using a numeric code in a character set, and Java supports Unicode, which makes it compatible with characters from different languages.

Java’s Character Set

Java uses Unicode as its character set. Unicode is a universal character encoding standard that assigns a unique number to every character, regardless of platform, language, or program. Java originally used 16-bit Unicode characters (UTF-16), allowing it to support many world languages.

Unicode can represent over 140,000 characters, including alphabets like Latin, Greek, Cyrillic, Han (Chinese characters), and more. Java specifically supports the UTF-16 encoding by default.

Why Unicode?

Java chose Unicode to make the language truly platform-independent and suitable for internationalization. As Java applications are used worldwide, Unicode provides a standardized way of encoding all the world’s characters.

Data Types in Java

A data type is a classification of data that informs the compiler or interpreter how the data will be used in a program. Each data type specifies a range of values it can store and the operations that can be performed on that data. Programming languages typically support various data types like integers, floating-point numbers, characters, strings, and booleans.

Data Types in Java

Data types in Java are divided into two main categories:

1. Primitive Data Types (Built-In Data Types)

2. User-Defined Data Types (Non-Primitive Data Types)

Primitive Data Types (Built-In Data Types)

Java supports eight primitive data types, which are the basic data types built into the language. These data types are predefined by Java and named by a keyword. They are used to store simple values directly.

Explanation of Code Example

Here is a Java program demonstrating some primitive data types:

package com.jtcindia.org;

/* Size of Data Type */

public class Jtc {
    public void dataType2() {
        System.out.println("---dataType2() in Jtc class---");
        byte b11 = 127;
        byte b22 = -128;
        // byte b33 = 128; // Error: 128 is out of range for byte
        // byte b44 = -129; // Error: -129 is out of range for byte
        int i11 = 2147483647;
        int i12 = -2147483648;
        // int i13 = 2147483648; // Error: 2147483648 is out of range for int
        // long l14 = 2147483649; // Error: 2147483649 is interpreted as int by default
        long l12 = 2147483648L; // Correct usage for long type
        // float f11 = 11.11; // Error: 11.11 is interpreted as double by default
        float f12 = 11.11f; // Correct usage for float type
        double d11 = 11.12;
        double d12 = 11.13d;
        
        System.out.println(b11);
        System.out.println(b22);
        System.out.println(i11);
        System.out.println(i12);
        System.out.println(l12);
        System.out.println(f12);
        System.out.println(d12);
    }

    public static void main(String[] args) {
        Jtc jtc = new Jtc();
        jtc.dataType2();
    }
}

Explanation of the Errors in the Commented Code:

1. `byte b33 = 128;`

- Error: `128` is outside the range of the `byte` data type, which can only hold values from `-128` to `127`.

2. `byte b44 = -129;`

- Error: `-129` is also outside the range of the `byte` data type.

3. `int i13 = 2147483648;`

- Error: `2147483648` is out of range for the `int` type, which supports values from `-2147483648` to `2147483647`.

4. `long l14 = 2147483649;`

- Error: Although `2147483649` fits within the `long` range, it is treated as an `int` by default in Java. Adding an `L` at the end like `2147483648L` tells the compiler to treat it as a `long`.

5. `float f11 = 11.11;`

- Error: By default, decimal numbers in Java are treated as `double`. To store a value as a `float`, you must append `f` or `F` at the end, like `11.11f`.

Range of Primitive Data Types

The range of a data type defines the maximum and minimum values that the type can hold. Here is another example demonstrating the range of different data types in Java:

package com.jtcindia.org;

/* Data Type Minimum and Maximum value */

public class Jtc {
    public void dataType3() {
        System.out.println("Byte Range: " + Byte.MIN_VALUE + " to " + Byte.MAX_VALUE);
        System.out.println("Short Range: " + Short.MIN_VALUE + " to " + Short.MAX_VALUE);
        System.out.println("int Range: " + Integer.MIN_VALUE + " to " + Integer.MAX_VALUE);
        System.out.println("Long Range: " + Long.MIN_VALUE + " to " + Long.MAX_VALUE);
        System.out.println("Float Range: " + Float.MIN_VALUE + " to " + Float.MAX_VALUE);
        System.out.println("Double Range: " + Double.MIN_VALUE + " to " + Double.MAX_VALUE);
    }

    public static void main(String[] args) {
        Jtc jtc = new Jtc();
        jtc.dataType3();
    }
}

User-Defined Data Types (Non-Primitive Data Types)

User-defined data types in Java are created by the programmer to store multiple values, either of the same or different types. They include:

1. Classes: A class is a blueprint for creating objects with fields (variables) and methods (functions).

- Syntax:

class ClassName {
    // fields
    // methods
}

2. Interfaces: An interface is a fully abstract data type that defines a contract for classes. An interface can contain abstract methods and constants.

- Syntax:

interface InterfaceName {
    // abstract methods
    // constants
}

3. Enums: An enum is a special data type that represents a group of constants (unchangeable values).

- Syntax:

enum EnumName {
    VALUE1, VALUE2, VALUE3
}

Enum Example

enum Day {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}

public class Jtc {
    public static void main(String[] args) {
        Day today = Day.SUNDAY;
        System.out.println(today);
    }
}

Using print and println

print(): Outputs text on the same line.
println(): Outputs text and then moves to the next line.

Example:

System.out.print("Hello, ");
System.out.println("World!");

// Output:
// Hello, World!

Commenting Code in Java

Comments are notes ignored by the compiler, useful for explaining code.

Single-line comment: // This is a single-line comment
Multi-line comment

/*
This is a 
multi-line comment
*/

Documentation comment (used in JavaDoc):

/**
 * This is a documentation comment
 * which can be used for JavaDoc.
 */

Interview Questions Related to Java Basics

Can we change the syntax of the main method?

No, JVM recognizes public static void main(String[] args) as the entry point, so it must remain unchanged for Java applications to run.

Can we keep the main method as private?

No, because JVM needs to access the main method from outside the class. If it’s private, the program will compile but not execute, resulting in an error.

Can we keep the main method non-static?

No, main is static so JVM can call it without creating an object. If it’s non-static, JVM cannot call it directly, and the program will not execute.

Why do we need f for float literals?

By default, decimal numbers are considered double. Adding f tells Java to treat the number as a float.

Keywords in Java

Keywords are predefined, reserved words in Java that have special meanings. You cannot use keywords as identifiers (like variable names, class names, etc.). Here are a few important ones:

- Control flow: if, else, switch, for, while, do, break, continue, return

- Modifiers: public, private, protected, static, final, abstract

- Object-oriented keywords: class, interface, extends, implements, this, super

- Exception handling: try, catch, finally, throw, throws

- Others: void, null, true, false

Java has a total of 50+ keywords, and each serves a specific role in program flow, object creation, and behavior definition.

Identifiers in Java

In Java, identifiers are names given to various elements in a program, such as classes, methods, variables, and packages. Identifiers are essential as they help distinguish different parts of a program and make code more readable. They are defined by the programmer and must follow specific rules and conventions.

Examples of Identifiers

- Class name: `MyClass`

- Variable name: `totalSum`

- Method name: `calculateInterest`

- Package name: `com.example.application`

Rules and Conventions for Identifiers

Rules (mandatory):

1. Character Set: Identifiers can include letters (A-Z, a-z), digits (0–9), dollar signs (`$`), and underscores (`_`).

- Example: `myValue`, `total_sum`, `$price`

2. No Spaces: Spaces are not allowed within identifiers.

- Invalid Example: `my Value`, `public static void display details`

- Valid Example: `myValue`, `displayDetails`

3. Cannot Start with Digits: Identifiers cannot begin with a number.

- Invalid Example: `1stVariable`, `10a`

- Valid Example: `variable1`, `a10`

4. Cannot Use Keywords: Keywords in Java, such as `int`, `class`, `static`, etc., cannot be used as identifiers.

- Invalid Example: `class className {}`, `int static;`

- Valid Example: `className`, `isStatic`

Conventions (recommended but not enforced):

1. Class Names: Begin with an uppercase letter. If the name contains multiple words, capitalize the first letter of each word (Pascal case).

- Example: `MyFirstProgram`, `CustomerOrder`

2. Variable and Method Names: Begin with a lowercase letter. If the name contains multiple words, capitalize the first letter of each subsequent word (camel case).

- Example: `totalAmount`, `calculateInterest`

3. Package Names: Use lowercase letters. If multiple words are used, separate them by dots.

- Example: `com.mycompany.application`

4. Constants: Use uppercase letters with words separated by underscores for constant values.

- Example: `MAX_HEIGHT`, `MIN_AGE`

Important Notes

1. Default Access Modifier: Java does not have a keyword `default` as an access modifier, but it exists as a meaning. For example:

2. Non-Static Members: The term “non-static” isn’t a keyword in Java, but any member that is not defined with the `static` keyword is implicitly non-static. For example:

3. Java Keywords: All Java keywords are lowercase, so any identifier starting with uppercase letters will not conflict with keywords.

Rules for Multi-Word Identifiers

1. No Spaces in Identifiers: If the identifier contains multiple words, use conventions like Pascal case for classes and camel case for variables and methods.

- Invalid Example: `class My program {}`

- Valid Example: `class MyProgram {}`

2. Method and Variable Naming Conventions: When using multiple words in method or variable names, capitalize the first letter of each subsequent word (camel case).

- Example: `int myTotalMarks;`

- Method Example: `public void calculateInterest() {}`

Declaring Variables

Variables in Java can be declared with the following syntax:

For example:

int number;
String name;

Final Keyword

The `final` keyword in Java is used to create constants. When a variable is declared as `final`, its value cannot be changed once it is initialized. Attempting to modify a `final` variable will result in a compilation error.

Example of a final variable:

class Jtc {
    public static void main(String[] args) {
        final int a = 10;
        System.out.println(a);
        // a = 4000; // Error: cannot assign a value to a final variable
        // a = -56;  // Error: cannot assign a value to a final variable
    }
}

Explanation:

- The variable `a` is declared as `final` and initialized with a value of `10`.

- Once `a` is declared as `final`, any attempt to modify its value (e.g., `a = 4000` or `a = -56`) will result in a compilation error.

Types of Variables in Java

Variables in Java can be classified into the following types:

1. Class Level Variables

2. Local Variables

Class Level Variables

- Class level variables are declared directly within a class but outside of any method, constructor, or block.

- They can be accessed from any method or block within the class.

- Memory for class-level variables is allocated in the heap.

- If not initialized, they are assigned default values by the Java Virtual Machine (JVM).

Class level variables are further divided into:

1. Instance Variables: Variables that are specific to each object of a class.

2. Static Variables: Variables that are shared among all objects of a class.

Example of Class Level Variables:

public class JtcClassLevelVariableExample {
    public static void main(String[] args) {
        Variable vl = new Variable();
        vl.variable_m2();
    }
}

class Variable {
    // Class level variables
    byte b;
    short s;
    int i;
    long l;
    float f;
    double d;
    boolean bl;
    char c;

    void variable_m2() {
        System.out.println("byte : " + b);
        System.out.println("short : " + s);
        System.out.println("int : " + i);
        System.out.println("long : " + l);
        System.out.println("float : " + f);
        System.out.println("double : " + d);
        System.out.println("boolean : " + bl);
        System.out.println("char : " + c);
    }
}

Output:

byte : 0
short : 0
int : 0
long : 0
float : 0.0
double : 0.0
boolean : false
char :

Explanation:

- The variables are not explicitly initialized, so the JVM assigns them default values.

- The default values depend on the data type (e.g., `0` for integers, `false` for boolean, etc.).

Let’s break down the conclusion points regarding static and non-static members in Java, explaining each point in detail.

Conclusion

1. Static Variables Can Be Accessed Directly in Static Methods

- Static variables belong to the class rather than any specific instance. Therefore, they can be accessed directly within static methods, as both are associated with the class.

2. Static Variables Can Be Accessed Directly in Non-Static Methods

- Non-static methods are associated with instances of the class but still have access to static variables. They can directly access static variables without needing to create an instance.

3. Non-Static Variables Cannot Be Accessed Directly in Static Methods

- Non-static variables belong to specific instances of a class. Static methods do not have an instance context, so they cannot access non-static variables directly.

4. Non-Static Variables Can Be Accessed Directly in Non-Static Methods

- Non-static methods have access to both static and non-static variables. They can access non-static variables directly because they operate within the context of an instance.

5. Static Methods Can Be Called Directly from Static Methods

- Since both methods are associated with the class itself, a static method can directly call another static method without creating an instance.

6. Static Methods Can Be Called Directly from Non-Static Methods

- Non-static methods can call static methods directly because they have access to the class context, which includes static methods.

7. Non-Static Methods Cannot Be Called Directly from Static Methods

- Static methods do not have access to instance-specific data, so they cannot call non-static methods directly without an instance of the class.

8. Non-Static Methods Can Be Called Directly from Non-Static Methods

- Non-static methods can freely call each other because they operate within the context of the same instance of the class.

Local Variables

- Local variables are declared within a method, constructor, or block.

They must be initialized before use, as they do not have default values.

Is Intialisation of local variable is mandatory ??
Yes,it is mandatory to intialise local variables, if we did not intialise we will get compile time error saying that“Variable might not intialised”.

- Memory for local variables is allocated only when the method or block is executed and is released when it ends.

-Local variables can only be default or final i.e we cannot declare a local variable as private,public or protected

Example of Local Variables:

package com.jtcindia.org;

class LocalVariable {
    int a = 10; // Class level variable

    void localVariable_m1() {
        int b = 20; // Local variable
        System.out.println("--localVariable_m1() in LocalVariable class--");
        System.out.println(b);
    }

    void localVariable_m2() {
        int c = 30; // Local variable
        System.out.println("--localVariable_m2() in LocalVariable class--");
        System.out.println(c);
    }

    void localVariable_m3() {
        int d = 40; // Local variable
        System.out.println("--localVariable_m3() in LocalVariable class--");
        System.out.println(d);
    }
}

public class Jtc {
    public static void main(String[] args) {
        System.out.println(new LocalVariable().a);
        new LocalVariable().localVariable_m1();
        new LocalVariable().localVariable_m2();
        new LocalVariable().localVariable_m3();
    }
}

Output:

10
 - localVariable_m1() in LocalVariable class - 
20
 - localVariable_m2() in LocalVariable class - 
30
 - localVariable_m3() in LocalVariable class - 
40

Explanation:

- The variable `a` is a class level variable, while `b`, `c`, and `d` are local variables declared within different methods.

- Local variables must be explicitly initialized before they are used.

Key Differences Between Class Level and Local Variables:

Q. What if local variable and global variable names are same?
A. If local var and global var names are same first priority is always given to local variables because they are inside method and nearer for execution to JVM.

Conclusion

- Class Level Variables are used when you need to store data that can be accessed across multiple methods.

- Local Variables are used for temporary storage of data within a specific method or block.

- Using the `final` keyword makes a variable a constant that cannot be changed after its initial assignment.

Constants in Java

Constants are fixed values that cannot be changed once assigned. Java supports constants using the final keyword. A final variable cannot be re-assigned a new value after initialization.

Example:

final int MAX_VALUE = 100;

Once you declare MAX_VALUE as final, it cannot be modified.

Final Variables in Java

A final variable is a constant, and its value can’t be changed once it’s initialized.

Can we change the value of a final variable?

No, you cannot change the value of a final variable once it’s initialized. If you try to, the compiler will throw an error.

Is it necessary to initialize the value of a final variable at the time of declaration?

No, it’s not necessary to initialize a final variable at the time of declaration. However, it must be initialized before the constructor finishes execution, ensuring that the final variable gets a value before the object is fully constructed.

This covers the basics of Java character set, data types, keywords, identifiers, variables, constants, and final variables. Let me know if you need more detail on any section!

Java Literals

Literals in Java are values that can be directly assigned to variables. These values can be used in the program as per the requirement. They come in different types, and each type has its own rules for representation.

Types of Literals:

1. Integral Literals

2. Floating-Point Literals

3. Boolean Literals

4. Character Literals

5. Null Literals

6. String Literals

1. Integral Literals

Integral literals are exact numeric values without a decimal point. They can be positive or negative, such as `234`, `-56`, `+45`. Integral literals are represented using different number systems:

- Decimal literals: A standard number system (0–9). It should not start with `0`.

- Octal literals: Values represented in base 8 (digits 0–7) and must start with `0`.

- Hexadecimal literals: Represented in base 16 (0–9 and a-f/A-F). It must start with `0x` or `0X`.

- Binary literals: Introduced in JDK 1.7, uses base 2 (0 and 1) and must start with `0b` or `0B`.

Example:

public class IntegralLiterals {
    public static void main(String[] args) {
        int decimal = 12345; // Valid decimal literal
        int octal = 012345; // Valid octal literal, starts with 0
        // int invalidOctal = 018; // Not valid, 8 is not an octal digit
        int hex = 0xABC; // Valid hexadecimal literal, starts with 0x
        // int invalidHex = 123AF; // Not valid, missing 0x prefix for hexadecimal
        int binary = 0b10101; // Valid binary literal, starts with 0b
        // int invalidBinary = 2b10101; // Not valid, must start with 0b

        System.out.println("Decimal: " + decimal);
        System.out.println("Octal: " + octal);
        System.out.println("Hexadecimal: " + hex);
        System.out.println("Binary: " + binary);
    }
}

2. Floating-Point Literals

Floating-point literals represent values with a decimal point. They can be specified using `float` or `double` data types:

- A float literal should end with `F` or `f`.

- A double literal can optionally end with `D` or `d`, but it is the default for decimal values.

- Scientific notation is also supported using `E` or `e`.

Example:

public class FloatingPointLiterals {
    public static void main(String[] args) {
        double d1 = 12.34; // Valid double literal
        float f1 = 12.34f; // Valid float literal with suffix 'f'
        // float invalidFloat = 12.34; // Not valid, float requires 'f' suffix
        double scientificNotation = 1.23e2; // Valid scientific notation

        System.out.println("Double d1: " + d1);
        System.out.println("Float f1: " + f1);
        System.out.println("Scientific Notation: " + scientificNotation);
    }
}

3. Boolean Literals

Boolean literals have only two values: `true` or `false`. In Java, you cannot represent `true` by `1` and `false` by `0`.

Example:

public class BooleanLiterals {
    public static void main(String[] args) {
        boolean isJavaFun = true; // Valid boolean literal
        boolean isFishTasty = false; // Valid boolean literal
        // boolean invalidBoolean = 1; // Not valid, Java does not accept 1 as true
        // boolean anotherInvalidBoolean = 0; // Not valid, Java does not accept 0 as false

        System.out.println("Is Java fun? " + isJavaFun);
        System.out.println("Is fish tasty? " + isFishTasty);
    }
}

4. Character Literals

Character literals are enclosed in single quotes, like ’A’. Rules for character literals include:

- They cannot be empty.

- They must contain only one character.

- Special characters can be represented using escape sequences like `\n`, `\t`, etc.

public class CharacterLiterals {
    public static void main(String[] args) {
        char ch1 = 'A'; // Valid character literal
        char ch2 = ' '; // Valid character literal with space
        char ch3 = '\n'; // Valid escape sequence for new line
        // char invalidChar1 = ''; // Not valid, empty character literal
        // char invalidChar2 = 'AB'; // Not valid, multiple characters in single quotes

        System.out.println("Character ch1: " + ch1);
        System.out.println("Character ch2 (space): [" + ch2 + "]");
        System.out.println("Character ch3 (newline): [" + ch3 + "]");
    }
}

- Escape sequences: Character literals can include escape sequences like \n (new line), \t (tab), \’ (single quote), \” (double quote), \\ (backslash), etc.

char newLine = '\n';
char singleQuote = '\'';

- Unicode characters: You can also use Unicode values for characters by using the \u prefix followed by the 4-digit hexadecimal value.

char unicodeChar = '\u0041'; // Unicode representation of 'A'

5. Null Literals

Null literals represent the absence of a value for reference types. They are used to signify that a variable does not reference any object.

public class NullLiterals {
    String str;
    NullLiterals nl;
    System s1;

    public static void main(String[] args) {
        NullLiterals obj = new NullLiterals();
        System.out.println("str: " + obj.str); // Prints null
        System.out.println("nl: " + obj.nl); // Prints null
        System.out.println("s1: " + obj.s1); // Prints null
    }
}

6. String Literals

String literals are enclosed in double quotes, like `”Hello”`. Strings are not primitive data types but are treated as objects of the `String` class.

Examples

public class StringLiterals {
    public static void main(String[] args) {
        String s1 = "Hello, World!"; // Valid string literal
        String s2 = ""; // Valid empty string
        String s3 = "Hello \n Java"; // Valid string with escape sequence
        String s4 = "C:\\Program Files\\Java"; // Valid string with escaped backslashes
        // String invalidString = "Hello"; // Incorrect escape sequence

        System.out.println("String s1: " + s1);
        System.out.println("String s2 (empty): [" + s2 + "]");
        System.out.println("String s3 (with newline): " + s3);
        System.out.println("String s4 (with path): " + s4);
    }
}

Explanation:

String invalidString = "Hello\";: This is incorrect due to improper use of escape sequences. In Java, double quotes inside strings must be escaped using \".
String invalidString = "Hello\";: This is incorrect due to improper use of escape sequences. In Java, double quotes inside strings must be escaped using \".

- Underscore in numeric literals: Since Java 7, you can use underscores to improve the readability of large numbers.It should be not be used before or just after decimal.

int largeNumber = 1_000_000; // Same as 1000000

Detailed Examples of Java Literals

public class LiteralExample {
    public static void main(String[] args) {
        // Integer Literals
        int decimal = 100;         // Decimal literal
        int octal = 0144;          // Octal literal
        int hex = 0x64;            // Hexadecimal literal
        int binary = 0b1100100;    // Binary literal
        // Floating-point Literals
        double pi = 3.14159;       // Double literal (default)
        float gravity = 9.81f;     // Float literal
        
        // Character Literals
        char letter = 'A';         // Character literal
        char newLine = '\n';       // Escape sequence
        char unicodeChar = '\u0041'; // Unicode literal
        
        // String Literals
        String message = "Hello, World!";  // String literal
        String empty = "";                // Empty string
        
        // Boolean Literals
        boolean isJavaFun = true;  // Boolean literal (true)
        boolean isTired = false;   // Boolean literal (false)
        
        // Null Literal
        String nullString = null;  // Null literal
        
        // Printing literals
        System.out.println("Decimal Literal: " + decimal);
        System.out.println("Octal Literal: " + octal);
        System.out.println("Hexadecimal Literal: " + hex);
        System.out.println("Binary Literal: " + binary);
        
        System.out.println("Double Literal: " + pi);
        System.out.println("Float Literal: " + gravity);
        
        System.out.println("Character Literal: " + letter);
        System.out.println("New Line: " + newLine);
        System.out.println("Unicode Literal: " + unicodeChar);
        
        System.out.println("String Literal: " + message);
        System.out.println("Empty String Literal: " + empty);
        
        System.out.println("Boolean Literal (true): " + isJavaFun);
        System.out.println("Boolean Literal (false): " + isTired);
        
        System.out.println("Null Literal: " + nullString);
    }
}

Output:

Decimal Literal: 100
Octal Literal: 100
Hexadecimal Literal: 100
Binary Literal: 100
Double Literal: 3.14159
Float Literal: 9.81
Character Literal: A
New Line:
Unicode Literal: A
String Literal: Hello, World!
Empty String Literal:
Boolean Literal (true): true
Boolean Literal (false): false
Null Literal: null

- Integer Literals: Represent whole numbers and can be in decimal, octal, hexadecimal, or binary format.

- Floating-point Literals: Represent numbers with fractional parts, default to double, and use the f suffix for float.

- Character Literals: Represent single characters and can include escape sequences and Unicode characters.

- String Literals: Represent sequences of characters, enclosed in double quotes.

- Boolean Literals: Represent logical values (true or false).

- Null Literal: Represents a null reference or no object.

Each type of literal has its purpose and allows you to express values clearly in Java code.

Key Points:

- No Empty Character Literal: You cannot create an empty character literal. For instance, char c = ‘’ will cause a compile-time error.

// This will give a compile-time error

char emptyChar = ‘’; // Error: unexpected type

- Valid Examples:

char letter = ‘a’;

char digit = ‘1’;

char symbol = ‘$’;

2. String Literals

Key Points:

- Strings are Objects: Unlike character literals, string literals are objects of the String class, which is part of the java.lang package.

String greeting = “Hello, World!”;

- Output: When printed, the string literal displays the text on the console.

System.out.println(greeting); // Output: Hello, World!

- Escape Sequences: Certain characters in strings need to be escaped, such as newlines (\n), tabs (\t), or quotes (\”).

String withEscape = “Line1\nLine2”; // \n creates a new line

System.out.println(withEscape);

3. Handling Null and Reference Variables

- Character Reference Variable: If you declare a character reference variable, you can assign it null, which indicates it doesn’t point to any character.

Character ch6 = null; // Valid: ch6 is a reference variable

- Null Assignment: Unlike primitive types, you can assign null to an object reference, which means it currently does not reference any object.

4. Compiler Behavior and Comments

- Comments: Lines that are commented out (using // or / /) are ignored by the compiler in terms of execution, but the compiler does not validate the syntax of these comments.

// This line is a comment and will not affect compilation

// char invalidChar = ‘’; // Error: unexpected type

Summary

- Character Literals: Use single quotes for single characters. No empty literals allowed.

- String Literals: Use double quotes. Strings are objects of the String class.

- Escape Sequences: Use backslashes to represent special characters.

- Reference Variables: You can assign null to reference variables, which is different from primitive types.

Operators in Java

Operators are symbols used to perform operations on variables and values. Operators act on operands (the values they manipulate) and return a result. There are several types of operators in Java, each serving different purposes.

1. Arithmetic Operators

Arithmetic operators perform basic mathematical operations such as addition, subtraction, multiplication, division, and modulus.

Common Arithmetic Operators:

- + : Addition

- — : Subtraction

- : Multiplication

- / : Division

- % : Modulus (returns remainder of division)

Example:

public class ArithmeticOperator {
    public static void main(String[] args) {
        int a = 100;
        byte b = 20;
        
        System.out.println(a + b);  // 120
        System.out.println(a - b);  // 80
        System.out.println(a * b);  // 2000
        System.out.println(a / b);  // 5
        System.out.println(a % b);  // 0
    }
}

In the above code, basic arithmetic operations are performed on two variables a and b.

Arithmetic with Boolean:

Arithmetic operations cannot be performed on non-numeric types like boolean. Attempting to do so will result in a compilation error.

public class ArithmeticOperator {
    public static void main(String[] args) {
        int a = 100;
        boolean b = true;
        System.out.println(a + b);  // Error: incompatible types
    }
}

Note:-

-The issue with performing byte b11 = b1 + b2 in Java (or similar languages) arises from the fact that the result of the addition of two byte values is promoted to an int. This means that the sum of b1 and b2 can exceed the range of a byte, which is from -128 to 127.

Here’s what happens in detail:

1. Promotion to int: When you add two byte values, Java first converts them to int. This is part of Java’s rules for arithmetic operations involving smaller data types.

2. Potential overflow: Since the result is an int, it can exceed the range of a byte. If the sum is greater than 127 or less than -128, you can’t directly assign that int value back to a byte without an explicit cast, which can lead to loss of data.

To correctly perform this operation while ensuring that it fits within the byte range, you should do the following:

byte b11 = (byte) (b1 + b2);

This way, you’re explicitly casting the result back to a byte, but be aware that if the sum exceeds the byte range, it will wrap around due to overflow.

-When you add two char values in Java, they are treated similarly to byte values in that they undergo numeric promotion. Here’s what happens:

1. Promotion to int: When you add two char values, they are first promoted to int. This means the addition is performed using their integer values (which correspond to their Unicode code points).

2. Result type: The result of the addition will be of type int. This can exceed the range of char, which is from 0 to 65535 (since char in Java is unsigned).

3. No implicit casting: You cannot directly assign the result of the addition back to a char without an explicit cast. If you try to do something like:

char c1 = 'A'; // Unicode 65
char c2 = 'B'; // Unicode 66
char c3 = c1 + c2; // This will cause a compilation error

This will result in a compilation error because you’re trying to assign an int to a char.

4. Correct way: If you want to store the result in a char, you should explicitly cast it:

char c3 = (char) (c1 + c2); // c3 will be assigned the value of 131 (which corresponds to '')

5. Handling overflow: Be mindful that if the sum exceeds 65535, the resulting value will wrap around due to overflow, which may lead to unexpected characters.

In summary, adding two char values results in an int, and you need to handle the conversion back to char explicitly, being cautious of the range and potential overflow.

Operator Overloading in Java

Definition: Operator overloading is a feature that allows operators to have different meanings based on the context in which they are used. In many programming languages, this means that the same operator can perform different operations depending on the types of its operands.

Java’s Approach

Java does not support operator overloading in the way that some other languages (like C++ or Python) do. This design decision was made to keep the language simple and avoid ambiguity. However, the `+` operator is an exception, as it can serve two different roles: addition and concatenation.

1. Addition with the `+` Operator

When used with numeric types, the `+` operator performs addition. This applies to various numeric data types:

- Integers:

- Example:

int result = 122 + 233; // result = 355

- Floating Point Numbers:

- Example:

double result = 445.33 + 556; // result = 1001.33

- Mixed Types:

- Java automatically converts types to perform the operation:

float result = 667 + 45.3f; // result = 712.3

Numeric Type Conversions

Java supports arithmetic operations between different numeric types, like `int`, `float`, `double`, etc. The following rules apply:

- When two different numeric types are used, Java converts them to the larger type before performing the operation (e.g., `int` to `double`).

2. Character Addition

Java treats characters as numeric values based on their Unicode representations.

- Character Arithmetic:

- Characters can be added together:

char ch = 'A'; // Unicode 65
int sum = ch + 65; // 65 + 65 = 130 widen to int
System.out.println(sum); // Prints 130
char ch1 = 'a'; // Unicode 97
char ch2 = 'z'; // Unicode 122
int combined = ch1 + ch2; // 97 + 122 = 219
System.out.println(combined); // Prints 219

- Casting Character to Char:

- If you assign a numeric value to a `char`, it will represent the corresponding character:

char ch = 65; // 'A'
System.out.println(ch); // Prints 'A'

3. Concatenation with the `+` Operator

When one of the operands is a `String`, the `+` operator behaves as a concatenation operator. This means it combines strings instead of performing arithmetic addition.

- String Concatenation:

- Example:

String s = "java";
int a = 123;
System.out.println(s + a); // "java123"

- Multiple Strings:

- Concatenation can be chained:

System.out.println("I am " + s + " developer"); // "I am java developer"

- Result Type:

- After concatenation, the result is always a `String`, even if the other operand is a number:

System.out.println(123 + " "); // "123 "

Type Casting in Java

Type casting in Java is the process of converting a variable from one data type to another. Java supports two types of casting:

1. Widening Casting (Automatic): Converting a smaller data type to a larger data type (e.g., byte to int). This is done automatically by Java without any explicit cast.

2. Narrowing Casting (Explicit): Converting a larger data type to a smaller data type (e.g., int to byte). This requires an explicit cast because it can lead to data loss.

Example: byte b1 = 10;

Here, you are declaring a byte variable b1 and initializing it with the value 10. The byte data type can hold values from -128 to 127.

Case: b1 += 10;

Now, when you perform the operation b1 += 10, here’s what happens:

1. Promotion: The += operator is a compound assignment operator. When you use b1 += 10, Java first promotes b1 to an int to perform the addition. This is because the right-hand side (10 in this case) is treated as an int.

2. Result Calculation: The addition is performed: 10 + 10, which equals 20.

3. Assignment: The result of the addition (20, which is an int) is then assigned back to b1. However, since b1 is a byte, Java automatically casts the int result back to byte.

4. No Explicit Cast Needed: In this case, no explicit cast is necessary because the result (20) is within the range of byte (-128 to 127).

Conclusion

- The operation b1 += 10 is valid and results in b1 holding the value 20.

- If you were to use a regular addition, like b1 = b1 + 10;, this would require an explicit cast back to byte because the expression b1 + 10 results in an int. Thus, it would look like this:

b1 = (byte) (b1 + 10);

In summary, b1 += 10 is a shorthand that handles type promotion and casting automatically, making it convenient for operations like this.

2. Assignment Operator (=)

The assignment operator assigns the value on the right-hand side (source) to the left-hand side (destination). The general syntax is:

destination = source;

Example:

public class AssignmentOperator {
    public static void main(String[] args) {
        int a = 10;
        int b = a;  // Assign value of 'a' to 'b'
        System.out.println(b);  // 10
    }
}

Type Casting

Type casting is the process of converting one data type into another. It can be:

- Implicit Type Casting: Happens automatically when assigning a smaller type to a larger type.

- Explicit Type Casting: Must be specified by the programmer when assigning a larger type to a smaller type.

Implicit Casting Example:

public class AssignmentOperator {
    public static void main(String[] args) {
        byte b1 = 10;
        short s1 = b1;  // Implicit casting: byte to short
        System.out.println(s1);  // 10
    }
}

Explicit Casting Example:

public class AssignmentOperator {
    public static void main(String[] args) {
        short s2 = 260;
        byte b2 = (byte) s2;  // Explicit casting: short to byte
        System.out.println(b2);  // Output may show data loss (result: 4)
    }
}

Since byte can only hold values from -128 to 127, converting 260 causes data loss.

3. Relational Operators

Relational operators are used to compare two values. They return a boolean value (true or false).

Relational Operators:

- > : Greater than

- < : Less than

- >= : Greater than or equal to

- <= : Less than or equal to

- == : Equal to

- != : Not equal to

Example:

public class RelationalOperator {
    public static void main(String[] args) {
        int a = 20;
        int b = 10;
        
        System.out.println(a > b);  // true
        System.out.println(a < b);  // false
        System.out.println(a == b);  // false
    }
}

Relational Operators with Boolean:

Relational operators cannot be used with boolean values.

public class RelationalOperator {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        
        System.out.println(a > b);  // Error: cannot compare booleans
    }
}

4. Logical Operators

Logical operators are used to perform logical operations on boolean expressions. They are:

- && : Logical AND

- || : Logical OR

- ! : Logical NOT

Example:

public class LogicalOperators {
    public static void main(String[] args) {
        boolean x = true;
        boolean y = false;
        System.out.println(x && y);  // false
        System.out.println(x || y);  // true
        System.out.println(!x);  // false
    }
}

Logical operators can be used to combine multiple conditions.

5. Bitwise Operators

Bitwise operators work on binary representations of integers. They perform bit-level operations.

Common Bitwise Operators:

- & : Bitwise AND

- | : Bitwise OR

- ^ : Bitwise XOR

- << : Left shift

- >> : Right shift

- ~ : Bitwise NOT

Example:

public class BitwiseOperator {
    public static void main(String[] args) {
        int number1 = 5;  // 00000101 in binary
        int number2 = 7;  // 00000111 in binary
        System.out.println(number1 & number2);  // Bitwise AND: 00000101 -> 5
        System.out.println(number1 | number2);  // Bitwise OR: 00000111 -> 7
        System.out.println(number1 ^ number2);  // Bitwise XOR: 00000010 -> 2
    }
}

The XOR (exclusive OR) operation is a fundamental binary operation that compares two bits and produces a result based on their values. Here’s how it works:

- Input: Two bits (0 or 1).

- Output: The result is 1 if the bits are different, and 0 if they are the same.

Truth Table for XOR

Explanation

- If both bits are 0 (0 XOR 0), the result is 0.

- If one bit is 0 and the other is 1 (0 XOR 1 or 1 XOR 0), the result is 1.

- If both bits are 1 (1 XOR 1), the result is 0.

Properties of XOR

1. Commutative: A XOR B = B XOR A

2. Associative: (A XOR B) XOR C = A XOR (B XOR C)

3. Identity: A XOR 0 = A

4. Self-inverse: A XOR A = 0

Example

Let’s say you want to perform XOR on two 4-bit binary numbers:

- A = 1101

- B = 1011

You would compare each corresponding bit:

1 1 0 1
XOR
1 0 1 1
-----------
0 1 1 0

So, 1101 XOR 1011 = 0110.

Note:-

The logical AND (&&) and bitwise AND (&) operators serve different purposes and are used in different contexts in programming. Here’s a breakdown of their differences:

Logical AND (&&)

1. Usage: Primarily used with boolean expressions.

2. Short-circuiting: If the first operand evaluates to false, the second operand is not evaluated. This means if the first condition is false, the overall expression is guaranteed to be false, and the second condition is not checked.

3. Return type: Always returns a boolean value (true or false).

4. Example:

boolean result = (a > 0) && (b < 10);

If a is not greater than 0, the condition (b < 10) won’t be evaluated.

Bitwise AND (&)

1. Usage: Can be used with integer types (like int, byte, char, etc.) as well as boolean types.

2. No short-circuiting: Both operands are always evaluated, regardless of the value of the first operand. This means that both bits (or boolean values) are always checked.

3. Return type: When used with integers, it returns an integer; when used with booleans, it returns a boolean.

4. Example with integers:

int result = a & b; // Performs a bitwise AND on the binary representations 
                    // of a and b.

If a is 5 (binary 0101) and b is 3 (binary 0011), the result would be 1 (binary 0001).

6. Ternary Operator (?:)

This operator is a shorthand for if-else statements. It evaluates a boolean expression and returns one of two values depending on whether the expression is true or false.

Syntax:

condition ? value_if_true : value_if_false;

Example:

public class TernaryOperator {
    public static void main(String[] args) {
        int a = 10, b = 20;
        int result = (a > b) ? a : b;  // Returns b if a is not greater than b
        System.out.println(result);  // 20
    }
}

Example of a Nested Ternary Operator

Here’s a simple example that determines a grade based on a score:

int score = 85;
String grade = (score >= 90) ? "A" :
               (score >= 80) ? "B" :
               (score >= 70) ? "C" :
               (score >= 60) ? "D" : "F";
System.out.println("Grade: " + grade);

Explanation

- First Condition: If score >= 90, the grade is ”A”.

- Second Condition: If the first condition is false, it checks score >= 80. If true, the grade is ”B”.

- Third Condition: If both previous conditions are false, it checks score >= 70. If true, the grade is ”C”.

- Fourth Condition: If all previous conditions are false, it checks score >= 60. If true, the grade is ”D”.

- Else: If none of the conditions are true, the grade is ”F”.

Output

For a score of 85, the output will be:

Grade: B

7. Increment/Decrement Operator

These are used to increase or decrease a value by one.

- ++ : Increment

- — : Decrement

They can be used in two forms:

- Pre-Increment/Pre-Decrement: ++a or — a

- Post-Increment/Post-Decrement: a++ or a —

Example:

public class IncrementDecrement {
    public static void main(String[] args) {
        int a = 10;
        System.out.println(++a);  // Pre-increment: 11
        System.out.println(a++);  // Post-increment: 11 (prints before increment)
        System.out.println(a);    // 12
    }
}

Note :-

1. Using 10++

In programming languages like Java, the expression 10++ is invalid. Here’s why:

- Literal Value: 10 is a literal constant, and you cannot increment a literal value. The increment operator (++) is intended to be used with variables, not constants.

- Increment Operator: The ++ operator increases the value of a variable by 1. Since 10 cannot be modified (it’s a fixed value), attempting to apply ++ to it results in a compilation error.

Example of Correct Usage:

Instead, you should use the increment operator with a variable:

int num = 10;
num++; // This is valid and increments num to 11.

2. Can it be Used with a final Variable?

You cannot use the increment operator with a final variable in Java. A final variable is a constant that cannot be modified once assigned. Therefore, attempting to use ++ on a final variable will result in a compilation error.

Example:

final int num = 10;
num++; // This will cause a compilation error.

3. What About ++i++?

The expression ++i++ is also invalid. Here’s why:

- Postfix and Prefix Increment: The expression tries to apply both prefix (++i) and postfix (i++) increment operators on the same variable i in a single statement. This is not allowed because the increment operators are not meant to be nested like this.

- Evaluation Order: The postfix increment (i++) returns the current value of i before incrementing, while the prefix increment (++i) increments the value of i before returning it. Combining these leads to ambiguity.

Example:

int i = 5;
++i++; // This will cause a compilation error.

The new operator is used to create new objects in Java.

Example:

public class NewOperator {
    public static void main(String[] args) {
        String str = new String("Hello");
        System.out.println(str);
    }
}

9. instanceof Operator

The instanceof operator checks whether an object is an instance of a specific class or subclass.

Example:

public class NewOperator {
    public static void main(String[] args) {
        String str = new String("Hello");
        System.out.println(str);
    }
}

In Java, both instanceof and the isInstance method (part of the Class class) are used to check if an object is an instance of a specified class. However, they have different syntax and use cases. Here’s a breakdown of their differences:

instanceof

1. Syntax:

object instanceof ClassName

2. Usage:

- Used in conditional expressions (like if statements).

- Directly checks whether the object is an instance of a specified class or its subclasses.

3. Example:

class Animal {}
class Dog extends Animal {}
Animal animal = new Dog();
if (animal instanceof Dog) {
    System.out.println("animal is a Dog");
}

4. Compile-time Check:

- The type on the right side of instanceof is checked at compile time for type safety.

- If the left operand is not compatible with the right operand, it results in a compile-time error.

isInstance

1. Syntax:

ClassName.class.isInstance(object)

2. Usage:

- A method of the Class class, allowing for more dynamic type checking.

- Useful when the class type is not known at compile time, such as when working with reflection or generic programming.

3. Example:

Class clazz = Dog.class;
Animal animal = new Dog();
if (clazz.isInstance(animal)) {
    System.out.println("animal is an instance of Dog");
}

4. Dynamic Check:

- More flexible, as you can determine the class type at runtime, which is especially useful in situations involving reflection.

Key Differences

1. Syntax: instanceof is an operator, while isInstance is a method of the Class class.

2. Flexibility:

- isInstance can be more dynamic, allowing you to check against class types determined at runtime.

- instanceof is more straightforward and generally easier to read for simple type checks.

3. Compile-time vs. Runtime:

- instanceof performs a compile-time check for type safety.

- isInstance does not provide compile-time type safety, as the class type can be determined at runtime.

Summary

- Use instanceof for straightforward type checks when the class type is known at compile time.

- Use isInstance when you need dynamic type checking or when dealing with reflection, where the class type may not be known until runtime.

Control Statements in Java

In Java, control statements manage the flow of program execution. By default, the code execution follows a top-to-bottom order, but using control statements, you can alter this flow based on your requirements. Control statements are crucial for making decisions, repeating code, or jumping to specific parts of the program. Java control statements can be categorized into three main types:

1. Conditional Control Statements

Conditional statements execute code based on certain conditions (evaluated as true or false). If the condition is true, a specific block of code runs; if false, a different block may execute or the execution may skip that part entirely.

Types of Conditional Control Statements:

1. If Statement

- The simplest form of decision-making. It checks a condition and executes a block of code only if the condition is true.

Syntax:

if (condition) {
    // block of code
}

Example:

if (number1 > number2) {
  System.out.println("number1 is greater than number2");
}

2. If-Else Statement

- Extends the if statement by adding an else block that executes if the condition is false.

Syntax:

if (condition) {
    // code if condition is true
} else {
    // code if condition is false
}

Example:

if (number1 < number2) {
    System.out.println("number1 is less than number2");
} else {
    System.out.println("number1 is greater than number2");
}

3. Nested If Statement

- You can place an if statement inside another if to create complex decision-making scenarios.

Syntax:

if (condition1) {
    if (condition2) {
        // code if both condition1 and condition2 are true
    }
}

4. If-Else Ladder

- Multiple if-else statements chained together. Useful when you need to test several conditions.

Syntax:

if (condition1) {
    // code if condition1 is true
} else if (condition2) {
    // code if condition2 is true
} else {
    // code if none of the above are true
}

5. Switch Statement

- Useful when a variable can take multiple distinct values. The switch statement selects one of many blocks of code to execute.

Syntax:

switch (variable) {
    case value1:
        // code block
        break;
    case value2:
        // code block
        break;
    default:
        // code block
}

Example:

switch (input) {
    case "A":
        // Add operation
        break;
    case "S":
        // Subtract operation
        break;
    default:
        // Invalid option
}

In Java, the switch statement allows you to execute different blocks of code based on the value of a variable or expression. However, there are specific types of elements that are permitted in a switch statement:

1. Primitive Data Types

- int: You can use int (including byte, short, and char as they can be implicitly converted to int).

- char: The char type is allowed, representing single 16-bit Unicode characters.

- byte and short: Both can be used as they can fit within an int.

2. Wrapper Classes

- Integer: You can use Integer (the wrapper class for int).

- Character: You can use Character (the wrapper class for char).

3. String

- String: You can use String objects in a switch statement starting from Java 7. This allows for more readable code when working with string values.

4. Enums

- enum Types: You can use enum types, which are special Java types that represent a fixed set of constants. Each enum constant can be treated as a distinct case.

5. Disallowed Types

- float, double, long: These types are not allowed in a switch statement.

- boolean: The boolean type cannot be used in a switch statement.

- Any Object Type: While String and enums are allowed, other object types cannot be directly used.

Can We Use Variables in Case Statements?

In Java, you cannot use variables in the case labels of a switch statement. The case labels must be constant expressions, which means they must be known at compile time. This includes:

- Literals: Such as 1, ”Monday”, or Color.RED.

- Constant Variables: These are variables declared with the final keyword that have a fixed value.

Example of Valid Case Labels

final int ONE = 1;
final int TWO = 2;
int number = 2;
switch (number) {
    case ONE: // Valid
        System.out.println("One");
        break;
    case TWO: // Valid
        System.out.println("Two");
        break;
    default:
        System.out.println("Not One or Two");
}

Example of Invalid Case Labels

int variable = 3;
switch (number) {
    case variable: // Invalid: cannot use variable in case label
        System.out.println("This will cause a compile-time error.");
        break;
}

Example of a Switch Statement

Here’s an example using different allowed types:

int number = 2;
switch (number) {
    case 1:
        System.out.println("One");
        break;
    case 2:
        System.out.println("Two");
        break;
    default:
        System.out.println("Not One or Two");
}
String day = "Monday";
switch (day) {
    case "Monday":
        System.out.println("Start of the week");
        break;
    case "Friday":
        System.out.println("End of the week");
        break;
    default:
        System.out.println("Midweek day");
}
enum Color { RED, GREEN, BLUE }
Color color = Color.RED;
switch (color) {
    case RED:
        System.out.println("Red color");
        break;
    case GREEN:
        System.out.println("Green color");
        break;
}

2. Looping Control Statements

These statements allow executing a block of code repeatedly until a certain condition is met or a certain number of times.

Types of Looping Control Statements:

1. For Loop

- Repeats a block of code a specific number of times.

Syntax:

for (initialization; condition; update) {
    // code block
}

Example:

for (int i = 1; i <= 100; i++) {
    if (i % 7 == 0) {
        sum += i;
    }
}

2. While Loop

- Repeats code while a condition is true. It checks the condition before executing the loop body.

Syntax:

while (condition) {
    // code block
}

Example:

while (i <= 10) {
    System.out.println("2 x " + i + " = " + (2 * i));
    i++;
}

3. Do-While Loop

- Similar to the while loop, but it checks the condition after executing the loop body, ensuring it runs at least once.

Syntax:

do {
    // code block
} while (condition);

Example:

do {
    System.out.println("Count is: " + count);
    count++;
} while (count < 11);

3. Unconditional Control Statements

These statements cause the program to jump from one point to another unconditionally. They don’t check for conditions to decide the flow.

Types of Unconditional Control Statements:

1. Break Statement

- Used to exit a loop or switch statement prematurely.

Example:

for (int i = 0; i <= 10; i++) {
    if (i == 5) {
        break;
    }
    System.out.println("i -> " + i);
}

2. Continue Statement

- Skips the current iteration of the loop and moves on to the next iteration.

Example:

for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        continue;  // skips when i is 5
    }
    System.out.print("i -> " + i);
}

Summary:

- Conditional statements control the flow based on conditions (if, if-else, switch).

- Looping statements repeat code (for, while, do-while).

-Unconditional statements manage abrupt changes in control (break, continue).

Array in Java

An array is a collection of similar data types stored in contiguous memory locations. Java arrays are objects and offer a structured way to store and access large amounts of data efficiently. Below is a detailed explanation of arrays in Java:

Salient Features of Java Array:

- Index-based storage: Each element in the array is stored at a specific index, and indexing begins from 0. For example, the first element is stored at index 0, the second at index 1, and so on.

- Preserves order: Arrays in Java follow the order in which elements are added. The first element is stored at index 0, and each subsequent element is stored at the next index.

- Random Access: You can access any element directly using its index, making arrays suitable for applications where fast retrieval is important.

- Homogeneous data type: Arrays store elements of the same type (e.g., int[] stores integers).

- Heap memory storage: Arrays are objects in Java and are stored in heap memory, which is managed by the JVM.

- Dynamic memory allocation: The size of an array is determined at runtime. JVM calculates the memory needed and allocates accordingly.

- Array length: The length property holds the number of elements in the array. This is a fixed value once the array is created.

- Maximum size: The maximum size of an array in Java is ²³¹ — 1, which equals 2,147,483,647.

Types of Array Declaration in Java

1. Static Array:

The array is initialized at the time of declaration with known values.

Syntax:

 [] = {value1, value2, value3, …};

Example:

int[] arr = {10, 20, 30, 40, 50};

In this example, arr is an integer array of length 5, and it holds the values 10, 20, 30, 40, and 50.

2. Dynamic Array:

The array is initialized without knowing the exact values but specifying the size, and values can be added later dynamically.

Syntax:

 [] = new [size];

Example:

int[] arr = new int[5];

In this case, arr is an array of integers with a length of 5, but initially, it holds the default values for int (which is 0).

Types of Arrays

1. Single-Dimensional Array

A single-dimensional array stores elements linearly.

Example:

public class Example {
    public static void main(String[] args) {
        int[] arr = {5, 6, 3, 2, 1};
        for (int i = 0; i < arr.length; i++) {
            System.out.println("Index: " + i + ", Value: " + arr[i]);
        }
    }
}

Output:

Index: 0, Value: 5
Index: 1, Value: 6
Index: 2, Value: 3
Index: 3, Value: 2
Index: 4, Value: 1

In the example above, an integer array arr is initialized, and each element is printed using a for-loop.

2. Multi-Dimensional Array

A multi-dimensional array stores references to other arrays, which allows for representing matrices or higher-dimensional data.

Two-Dimensional Array (2D Array):

Syntax:

 [][] = {{value1, value2}, {value3, value4}, …};

Example:

int[][] matrix = {{101, 202, 303}, {404, 505, 606}, {707, 808, 909}};
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.print("matrix[" + i + "][" + j + "] = " + matrix[i][j] + " ");
    }
    System.out.println();
}

Output:

matrix[0][0] = 101 matrix[0][1] = 202 matrix[0][2] = 303
matrix[1][0] = 404 matrix[1][1] = 505 matrix[1][2] = 606
matrix[2][0] = 707 matrix[2][1] = 808 matrix[2][2] = 909

Three-Dimensional Array (3D Array):

Syntax:

 [][][] = {{{value1, value2}, {value3, value4}}, …};

Example:

int[][][] arr = {{{1, 2, 3}, {4, 5, 6}}, {{7, 8, 9}, {10, 11, 12}}};
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        for (int k = 0; k < arr[i][j].length; k++) {
            System.out.print(arr[i][j][k] + " ");
        }
        System.out.println();
    }
}

Output:

Command-Line Arguments

In Java, the main method accepts an array of strings (String[] args). These strings are the command-line arguments passed to the program during execution.

Example:

public class CommandLineExample {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("arg[" + i + "] = " + args[i]);
        }
    }
}

Execution from Command Line:

java CommandLineExample Hello World 123

Output:

arg[0] = Hello
arg[1] = World
arg[2] = 123

Command-line arguments are passed as strings. If necessary, they can be converted into other data types using methods like Integer.parseInt(), Double.parseDouble(), etc.

Why the main method parameter is a String Array?

The JVM allows the main method to accept a String[] because strings are versatile and can represent any kind of input data (numbers, characters, booleans, etc.) in textual form. This allows the user to pass diverse data formats at runtime via the command line.

Object-Oriented Programming (OOP) in Java

1. Class:

A class in Java is a blueprint or template that defines the structure and behavior (data members and methods) for objects. It is a user-defined data type. The syntax for defining a class in Java is:

class  {
    // Members (variables, methods, etc.)
}

- Class members: The text lists members of a class, which include:

- Variables: Used to store data (e.g., int sid, String sname).

- Blocks: Sections of code (e.g., static blocks or instance initializer blocks).

- Methods: Functions that define behaviors.

- Constructors: Special methods that initialize objects.

- Enums: Used to define a set of named constants.

- Inner Classes: Classes defined within another class.

- Interfaces: Used to define a contract for implementing classes.

Example:

A class named Student is defined to represent a student and contains fields for storing student data (ID, name, and email):

class Student {
    int sid;
    String sname;
    String semail;
}

This class defines a category (students), and these fields represent the information to be stored for each student.

Points to Remember

1. Multiple Classes in a Program

- In Java, a program can consist of multiple classes. Each class defined will result in a separate `.class` file after compilation.

Example:

class A {
    // Class A code
}

class B {
    // Class B code
}

class User {
    public static void main(String[] args) {
        // Main method code
    }
}

- After Compilation: This program will generate three files:

- `A.class`

- `B.class`

- `User.class`

- File Naming Convention: The program should be saved as `User.java` since it contains the `main()` method, which serves as the entry point for execution.

2. Public Class and Main Method

- When multiple classes exist in a single program, only one class should be declared as `public`, and this class should contain the `main()` method.

- The filename must match the name of the public class.

Example:

class A {
    public static void main(String[] args) {
        // Code for class A
    }
}

class B {
    public static void main(String[] args) {
        // Code for class B
    }
}

public class User {
    public static void main(String[] args) {
        // Code for main logic
    }
}

- File Naming: This should be saved as `User.java`.

3. Executing Classes with Main Methods

- If there are multiple classes in a program, each with its own `main()` method, only one class should be public. Each class can still be executed individually if required.

Example:

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

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

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

- File Naming: Save as `C.java`.

- Execution: You can compile and execute each class individually:

- `java A`

- `java B`

- `java C`

4. Class Types

- Business Logic Class: A class that does not contain the `main()` method but contains business logic. These classes are often designed for specific tasks, such as data processing or calculations, and are used by user logic classes.

- User Logic Class: A class that contains the `main()` method. This is where the program execution begins and typically coordinates calls to business logic classes.

2. Object:

An object is an instance of a class. It is created dynamically and allocated memory on the heap. Each object stores its data and can access the class’s methods and attributes. Objects are referenced using reference variables.

- Object Creation: When we create an object, it is done using the new keyword.

Example:

Student s1 = new Student();

- s1 is the reference variable that holds the memory address of the Student object.

- new Student() allocates memory for a Student object and initializes it.

Objects are used to store and manipulate class-specific data.

3. Class Loading Concept:

Class loading refers to the process of loading a class into Java Virtual Machine (JVM) memory. Java uses Class Loaders to load classes dynamically when they are required by the program. Classes are not loaded all at once, but only when they are needed during the program’s execution.

Situations when a class is loaded:

1. Object Creation: When an object of a class is created, the JVM checks if the class is already loaded. If not, the class loader loads it first.

Example:

Student s1 = new Student(); // loads the Student class if not already loaded

2. Running a class with a main method: When the JVM starts an application, it loads the class containing the main() method and executes it.

3. Accessing static members: If a class’s static members (variables or methods) are accessed, the class is loaded if not already done so.

Dynamic Class Loading:

In Java, classes can be loaded dynamically at runtime using the Class.forName() method. This is useful when you want to load a class based on some runtime condition.

- The forName() method takes a class name as a string and loads that class into the JVM.

Example:

Class.forName("A");

- This method attempts to load the class A into memory. If the class is found, it is loaded; otherwise, a ClassNotFoundException is thrown.

Static Block Execution:

When a class is loaded into memory, any static blocks (code inside static { } block) are executed immediately.

Example:

class A {
    static {
        System.out.println("SB in class A");
    }
}

When Class.forName(“A”) is called, the static block inside class A is executed, printing “SB in class A.”

4. ClassNotFoundException:

When attempting to load a class that doesn’t exist (e.g., Class.forName(“ABC”)), Java throws a ClassNotFoundException. This is an exception that occurs when the JVM cannot locate the specified class file at runtime.

Example:

Class.forName("ABC");

Output:

Exception in thread "main" java.lang.ClassNotFoundException: ABC

Instance variables and static variables

1. Instance Variable:

An instance variable is a variable declared inside a class but outside any method and without the static keyword. It is also called a non-static variable. Each object of the class gets its own copy of the instance variable, meaning the value of the instance variable can differ between objects.

Key Points:

- Instance variables are created when an object of the class is instantiated.

- Each object of the class has its own separate memory allocation for instance variables.

-These variables hold unique data for each object.

-Instance variable cannot be directly accessed inside any static context.

Example:

class Student {
    int sid;       // Instance variable for student ID
    String sname;  // Instance variable for student name
    String semail; // Instance variable for student email
}
class JTC {
    public static void main(String[] args) {
        // Creating two objects of the Student class
        Student s1 = new Student();
        s1.sid = 101;
        s1.sname = "Vivek";
        s1.semail = "vivek@jtcindia.org";
        Student s2 = new Student();
        s2.sid = 102;
        s2.sname = "Rahul";
        s2.semail = "rahul@jtcindia.org";
        // Displaying details for both students
        System.out.println("----Student Details----");
        System.out.println("s1.sid: " + s1.sid);
        System.out.println("s1.sname: " + s1.sname);
        System.out.println("s1.semail: " + s1.semail);
        System.out.println("----Student Details----");
        System.out.println("s2.sid: " + s2.sid);
        System.out.println("s2.sname: " + s2.sname);
        System.out.println("s2.semail: " + s2.semail);
    }
}

Explanation:

- sid, sname, and semail are instance variables that hold unique data for each student.

- When two objects (s1 and s2) are created, each has its own memory space for sid, sname, and semail.

- The output shows that s1 and s2 have different values for these instance variables.

Output:

- - Student Details - - 
s1.sid: 101
s1.sname: Vivek
s1.semail: vivek@jtcindia.org
 - - Student Details - - 
s2.sid: 102
s2.sname: Rahul
s2.semail: rahul@jtcindia.org

2. Static Variable:

A static variable is a class-level variable that is shared by all instances (objects) of the class. It is declared using the static keyword. Static variables are not specific to any object and get memory allocated when the class is loaded, rather than when objects are created.

Key Points:

- A static variable is shared by all objects of the class.

- It gets memory allocation once when the class is loaded, and its value is the same for all objects.

- Static variables are used to store data that is common across all instances of a class.

Example:

class Student {
    int sid;             // Instance variable for student ID
    String sname;        // Instance variable for student name
    String semail;       // Instance variable for student email
    static String snationality = "Indian"; // Static variable shared by all students
}
class JTC {
    public static void main(String[] args) {
        // Creating two objects of the Student class
        Student s1 = new Student();
        s1.sid = 101;
        s1.sname = "Vivek";
        s1.semail = "vivek@jtcindia.org";
        Student s2 = new Student();
        s2.sid = 102;
        s2.sname = "Rahul";
        s2.semail = "rahul@jtcindia.org";
        // Displaying details for both students, including the static variable
        System.out.println("s1.sid: " + s1.sid);
        System.out.println("s1.sname: " + s1.sname);
        System.out.println("s1.semail: " + s1.semail);
        System.out.println("s1.snationality: " + s1.snationality);
        System.out.println("s2.sid: " + s2.sid);
        System.out.println("s2.sname: " + s2.sname);
        System.out.println("s2.semail: " + s2.semail);
        System.out.println("s2.snationality: " + s2.snationality);
    }
}

Explanation:

- sid, sname, and semail are instance variables and differ for each object.

- snationality is a static variable that is shared by all instances of the Student class. Its value, “Indian”, is the same for both s1 and s2.

- All objects of the class share the same snationality value, as it is static.

Output:

s1.sid: 101
s1.sname: Vivek
s1.semail: vivek@jtcindia.org
s1.snationality: Indian
s2.sid: 102
s2.sname: Rahul
s2.semail: rahul@jtcindia.org
s2.snationality: Indian

3. Accessing Static Variables:

Static variables can be accessed in three different ways:

1. Using the class name:

- Access the static variable directly through the class name.

System.out.println(A.a);

2. Using a class reference variable (even if it contains a null value):

- A reference variable can be used to access a static variable, even if the reference variable is null.

A a1 = null;
System.out.println(a1.a); // Still accesses the static variable

3. Using a class object:

- Static variables can also be accessed using an object of the class.

A a2 = new A();
System.out.println(a2.a);

Example of Static Variable Access:

class A {
    static int a = 10; // Static variable
}
class JTC {
    public static void main(String[] args) {
        // Accessing static variable using the class name
        System.out.println("A.a: " + A.a);
        // Accessing static variable using a reference variable with a null value
        A a1 = null;
        System.out.println("a1.a: " + a1.a);
        // Accessing static variable using an object
        A a2 = new A();
        System.out.println("a2.a: " + a2.a);
    }
}

Output:

A.a: 10
a1.a: 10
a2.a: 10

Explanation:

- The static variable a is accessed in all three ways, and the value 10 is printed each time because it is the same across all accesses.

Note:-

Instance and static variable both can be declared as final variable.
Instance and static variable cannot be declared inside any local context and only local variable can be declared.
It means we can use static variable in static context(method and block-early binding).
Variable defined under instance or static block would be consided as local variable.
So, inside instance block or method we can access both.

Thus we can say that,

- Instance Variables: Unique to each object, and memory is allocated when the object is created.

-Static Variables: Shared by all objects of the class, and memory is allocated once when the class is loaded. They can be accessed using the class name, a null reference, or an object of the class.

Note:-

In Java, a final variable is a variable whose value cannot be changed once it is assigned. Here’s a breakdown of how final and static final variables can be initialized:

Final Variables
1. At the time of declaration:

final int x = 10;

2. Using a block:

final int y;
 {
   y = 20; // Initialized in an instance initializer block
 }

3. In a constructor:

final int z;
MyClass(int value) {
   z = value; // Initialized in the constructor
 }

Static Final Variables
For static final variables, they must be initialized as follows:

At the time of declaration:

static final int a = 100;
Static block:

static final int b;
static {
  b = 200; // Initialized in a static block
}

If a static final variable is not initialized in either of these ways, it will lead to a compilation error. This ensures that the variable has a constant value at the class level.

-In Java, you can declare local variables as final, but you cannot declare them as private.

Final Local Variables

When you declare a local variable as final, it means that once it is initialized, its value cannot be changed. For example:

public void myMethod() {
    final int number = 10;
    // number = 20; // This would cause a compile-time error
}

Private Local Variables

Local variables are inherently not associated with an access modifier like private, protected, or public. Access modifiers apply to class members (fields, methods) but not to local variables defined within methods or blocks. Local variables are only accessible within the scope of the method or block in which they are defined.

Summary

- You can declare local variables as final.

- You cannot declare local variables as private. They are already limited in scope to the method in which they are defined.

Blocks in Java

A Block in Java is a group of statements enclosed within curly braces {}. Blocks can be declared in different parts of a class, including inside methods, constructors, or directly within the class. Java has three types of blocks:

1. Instance Block or Non-Static Block

2. Static Block

3. Local Block

1. Instance Block or Non-Static Block

- A block declared inside a class without the static keyword is called an instance block or non-static block.

- It is executed every time an object of the class is created.

- Multiple instance blocks can be declared within a class, and they are executed in the order they are written.

- Instance blocks can access both instance and static members of the class.

-Instance blocks are typically used to execute code during object initialization.

Use Case: Useful for initializing instance variables or executing code that needs to run for every instance of a class.

Example:

class JTC{
    public static void main(String arg[]){
        A a1 = new A();
        A a2 = new A();
        A a3 = new A();
    }
}
class A {
    int a = 10; // Instance Variable
    static int b = 20; // Static Variable
    
    // Instance Block 1
    {
        System.out.println("IB-1 in A class");
        System.out.println("a :- " + a);
        System.out.println("b :- " + b);
    }
    
    // Instance Block 2
    {
        System.out.println("IB-2 in A class");
        System.out.println("a :- " + a);
        System.out.println("b :- " + b);
    }
}

Output:

IB-1 in A class
a :- 10
b :- 20
IB-2 in A class
a :- 10
b :- 20
…

2. Static Block

- A block declared with the static keyword is called a static block.

- Static blocks are executed once, when the class is loaded into memory (before any objects are created).

- Static blocks can only access static members directly. To access instance members, an object of the class must be created.

- Static blocks are useful when you want to perform operations at class loading time (e.g., initializing static variables).

Use Case: Ideal for initializing static variables or performing actions that need to occur once for the class, such as loading configuration settings.

Example:

class JTC{
    public static void main(String arg[]){
        new A();
    }
}
class A {
    int a = 10; // Instance Variable
    static int b = 20; // Static Variable
    
    // Static Block
    static {
        System.out.println("SB in A class");
        System.out.println("b :- " + b);
    }
    
    // Instance Block
    {
        System.out.println("IB in A class");
        System.out.println("a :- " + a);
        System.out.println("b :- " + b);
    }
}

Output:

SB in A class
b :- 20
IB in A class
a :- 10
b :- 20

3. Local Block

- A local block is a block of code defined inside a method or constructor.

- It is not static or an instance block and is executed when the containing method or constructor is invoked.

- Local blocks are typically used for block-level synchronization or scoping local variables.

-We cannot declare them as final.

Example:

class JTC{
    public static void main(String arg[]){
        new A().m1();
    }
}
class A {
    void m1(){
        System.out.println("m1 method in A class");
        System.out.println("Before Local Block");
        
        // Local Block
        {
            System.out.println("Local Block in m1 method");
        }
        
        System.out.println("After Local Block");
    }
}

Output:

m1 method in A class
Before Local Block
Local Block in m1 method
After Local Block

Dynamic Class Loading

Java provides a mechanism to load classes dynamically at runtime using the Class.forName() method. This method loads the class and executes the static blocks (if present) when the class is loaded. If the class is not found, it throws a ClassNotFoundException.

Example:

class JTC{
    public static void main(String arg[]) throws ClassNotFoundException {
        Class.forName("A");
        Class.forName("B");
    }
}
class A {
    static {
        System.out.println("SB in A class");
    }
}
class B {
    static {
        System.out.println("SB in B class");
    }
}

Output:

SB in A class
SB in B class

In this example, both A and B classes are dynamically loaded at runtime, and their static blocks are executed.

Methods

In Java, methods are blocks of code designed to perform specific tasks, and they are central to how programs are structured and executed.

1. Method Declaration and Syntax:

A method in Java is declared using the following syntax:

  () {
    // Method body
}

- Access Modifier: Determines the visibility of the method (e.g., public, private, protected).

- Return Type: The type of data the method returns to the caller (int, String, void, etc.).

- Method Name: A unique identifier used to invoke the method.

- Parameters: (Optional) Input values to the method, declared as a comma-separated list of types and names.

Access Modifiers in Java

Access modifiers in Java are keywords used to define the visibility and accessibility of classes, methods, and variables. They play a crucial role in encapsulation, allowing developers to control how the data is accessed and modified. There are four main access modifiers in Java:

1. Public

- Definition: The public access modifier allows the class, method, or variable to be accessible from any other class in any package.

- Use Case: When you want to expose a method or variable to be usable by any other code.

2. Private

- Definition: The private access modifier restricts the visibility of the method or variable to within the class itself. No other class can access private members.

- Use Case: Used to encapsulate data and provide a level of protection, ensuring that sensitive data is not accessible outside its class.

3. Protected

The protected access modifier in Java plays a crucial role in inheritance and encapsulation. It allows you to define the visibility of class members (fields and methods) in a way that balances accessibility and protection.

Characteristics of protected

1. Visibility:

- Members declared as protected are accessible within the same package.

- They are also accessible in subclasses, even if those subclasses are located in different packages.

2. Use in Inheritance:

- The primary use of protected is to allow subclasses to inherit and access members of a superclass while still preventing access from unrelated classes outside of the package.

3. Default Behavior:

- If no access modifier is specified, the default (package-private) access level applies, which allows access only within the same package. protected extends this visibility to subclasses, thus offering a more flexible approach.

Example of protected

Here’s an example to illustrate how the protected access modifier works:

// Superclass
class Animal {
    protected void makeSound() {
        System.out.println("Animal makes a sound");
    }
}
// Subclass in the same package
class Dog extends Animal {
    public void bark() {
        makeSound(); // Accessing protected method from superclass
        System.out.println("Dog barks");
    }
}
// Subclass in a different package
package anotherPackage;
import somePackage.Animal; // Importing superclass
class Cat extends Animal {
    public void meow() {
        makeSound(); // Accessing protected method from superclass
        System.out.println("Cat meows");
    }
}

Accessing protected Members

- Within the Same Package:

Classes in the same package can access protected members of other classes within the same package.

- From Subclasses:

Subclasses can access protected members, even if they are in a different package.

- From Non-Subclass in Different Package:

Non-subclass classes in different packages cannot access protected members.

Example Demonstration

// File: Animal.java
package somePackage;
public class Animal {
    protected void makeSound() {
        System.out.println("Animal makes a sound");
    }
}
// File: Dog.java
package somePackage;
public class Dog extends Animal {
    public void bark() {
        makeSound(); // Accessing protected method from superclass
        System.out.println("Dog barks");
    }
}
// File: Cat.java
package anotherPackage;
import somePackage.Animal;
public class Cat extends Animal {
    public void meow() {
        makeSound(); // Accessing protected method from superclass
        System.out.println("Cat meows");
    }
}
// File: Main.java
package anotherPackage;
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.bark(); // Works fine
        Cat cat = new Cat();
        cat.meow(); // Works fine
    }
}

Key Points

1. Encapsulation: Using protected can help maintain encapsulation while allowing subclasses to inherit and utilize superclass behavior.

2. Design Choice: protected is often used in class libraries and frameworks where you want to provide extensibility but still control how the members are accessed.

3. Avoid Overuse: While protected allows for more flexibility than private, it can lead to tighter coupling between classes. Consider the implications on design and maintainability before using it extensively.

4. Default (Package-Private)

- Definition: If no access modifier is specified, it defaults to “package-private,” meaning the class, method, or variable is accessible only within its own package.

- Use Case: When you want to restrict access to classes and methods to only those within the same package.

Example:

class DefaultExample {
    void display() {
        System.out.println("Default method can only be accessed within the same package.");
    }
}

Summary of Access Modifiers

2. Method Types:

Java methods can be classified into two main types:

a. Instance Methods (Non-Static Methods):

- These are declared without the static keyword and are associated with object instances.

- Instance methods work on late-binding (i.e., tied to specific instances of the class).

- Instance methods can access both instance and static members of the class directly.

- To invoke an instance method, an object of the class is required.

Example:

class A {
    int a = 10;
    void display() {
        System.out.println("a: " + a);
    }
}
public class Test {
    public static void main(String[] args) {
        A obj = new A();
        obj.display();  // Calls instance method 'display()'
    }
}

b. Static Methods:

- These are declared with the static keyword and belong to the class, not the instance.

- Static methods work on early-binding (executed when the class is loaded).

- They can only access static members of the class directly.

- A static method can be invoked using the class name or an object.

Example:

class A {
    static int b = 20;
    static void show() {
        System.out.println("b: " + b);
    }
}
public class Test {
    public static void main(String[] args) {
        A.show();  // Calls static method 'show()'
    }
}

3. Method Return Type:

The return type of a method indicates what type of value it will return to the caller:

- Primitive types: The method can return values like int, float, boolean, etc.

- Reference types: The method can return objects, arrays, or user-defined types.

- Void: If a method has a void return type, it does not return any value.

4. Method Invocation:

When invoking a method, you need to ensure that:

- The number of arguments matches the number of parameters.

- The types of arguments match the parameter types.

- The order of arguments corresponds to the parameter list.

class Calculator {
    int add(int x, int y) {
        return x + y;
    }
}
public class Test {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        int result = calc.add(10, 20);  // Invokes the 'add' method with arguments
        System.out.println("Result: " + result);
    }
}

5. Memory Management of Methods:

- When a method is invoked, it gets memory allocated in the stack area as a stack frame.

- The method’s stack frame is created when the method is called and released once it completes execution.

- Java stack follows the Last-In-First-Out (LIFO) principle, meaning the last method invoked will be the first to complete.

Method chaining example:

class A {
    void m1() {
        System.out.println("m1 starts");
        m2();
        System.out.println("m1 ends");
    }
    
    void m2() {
        System.out.println("m2 starts");
        m3();
        System.out.println("m2 ends");
    }
    
    void m3() {
        System.out.println("m3 executes");
    }
}
public class Test {
    public static void main(String[] args) {
        A obj = new A();
        obj.m1();
    }
}

Output:

m1 starts
m2 starts
m3 executes
m2 ends
m1 ends

6. Method Chaining:

Method chaining refers to calling multiple methods sequentially within another method, as demonstrated in the above example with m1, m2, and m3. The execution sequence depends on the order in which the methods are called.

Note:-

we can access method inside method but we cannot create method inside method

main method

In Java, the main method is the entry point of any standalone application. Its signature is:

public static void main(String[] args)

Calling the main Method Explicitly

You can indeed call the main method explicitly from another method. For example:

public class MainExample {
    public static void main(String[] args) {
        System.out.println("Main method called");
    }
    public static void anotherMethod() {
        main(new String[]{"arg1", "arg2"}); // Calling main explicitly
    }
    public static void main(String[] args) {
        anotherMethod();
    }
}

In this example, calling main from anotherMethod will execute the main method again with the provided arguments.

Overloading the main Method

You can overload the main method by creating methods with the same name but different parameters. For example:

public class OverloadedMain {
    public static void main(String[] args) {
        System.out.println("Main method with String[] args");
        main(5); // Calling the overloaded method
    }
    public static void main(int number) {
        System.out.println("Overloaded main method with int: " + number);
    }
}

In this case, when you run the program, it will only recognize the main method with the String[] args signature as the entry point. The overloaded main(int number) can be called from within the main method or other methods, but it won’t be invoked automatically by the Java runtime.

Multiple main Methods in Different Classes

If you have multiple classes each containing a main method, only the main method of the class specified when running the program will be executed. For example:

public class FirstClass {
    public static void main(String[] args) {
        System.out.println("First Class Main");
    }
}
public class SecondClass {
    public static void main(String[] args) {
        System.out.println("Second Class Main");
    }
}

When you run the program, you specify which class to execute:

java FirstClass

This will output:

First Class Main

If you run:

java SecondClass

You will see:

Second Class Main

Q. Can we overload final methods ?
A. Yes, we can overload final methods because final keyword says do not
change implementation and in overloading we are not changing
implementation rather we are changing arguments.

Q. Can we overload private methods or not ?
A. Yes, we can overload private methods because private methods are
accessible everywhere in same class and overloading also happens within
class.

Q. Can we overload non static methods or not ?
A. Yes, we can overload non static methods but to call them we have to
create an Object.

Overview of the Scanner Class

- Purpose: The Scanner class is a predefined class in Java used for reading input from various sources, such as the keyboard (System.in), files, or strings. It enables programs to accept user input at runtime, making applications interactive.

Steps to Use the Scanner Class

1. Importing the Scanner Class

- To use the Scanner class, you first need to import it from the `java.util` package. This can be done with one of the following statements:

import java.util.Scanner; // Import only Scanner class

import java.util.*; // Import all classes in the java.util package

- Package: A package is like a folder that groups related classes together. Importing is necessary to use classes defined in other packages.

2. Creating an Object of the Scanner Class

- After importing, you create an instance of the Scanner class to start reading input:

Scanner s = new Scanner(System.in);

- Here, `System.in` indicates that the input will be read from the standard input stream (usually the keyboard).

3. Using Scanner Class Methods

- The Scanner class provides various methods to read different types of input. Some commonly used methods include:

- `nextByte()`: Reads a byte value.

- `nextBoolean()`: Reads a boolean value (true/false).

- `nextShort()`: Reads a short integer.

- `nextInt()`: Reads an integer.

- `nextFloat()`: Reads a float value.

- `nextDouble()`: Reads a double value.

- `nextLong()`: Reads a long integer.

- `next()`: Reads a single word (string without spaces).

- `nextLine()`: Reads a whole line (string with spaces).

Example Program

Here’s a simple Java program using the Scanner class to collect student details:

import java.util.Scanner;

class StdDetails {
    public static void main(String args[]) {
        Scanner s = new Scanner(System.in);

        System.out.println("Enter name: ");
        String name = s.nextLine();

        System.out.println("Enter age: ");
        int age = s.nextInt();

        System.out.println("Enter percentage: ");
        float percentage = s.nextFloat();

        System.out.println("Enter result status (true/false): ");
        boolean result = s.nextBoolean();

        System.out.println("Enter contact number: ");
        long contact = s.nextLong();

        System.out.println("Enter Gender: ");
        char gender = s.next().charAt(0);

        System.out.println("Student Details Entered by you are:");
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("Gender: " + gender);
        System.out.println("Contact: " + contact);
        System.out.println("Score: " + percentage);
        System.out.println("Result: " + result);

        s.close(); // It's good practice to close the scanner
    }
}

Example Output

When you run the program, it will prompt you to enter details:

Enter name: 
Pratik
Enter age: 
27
Enter percentage: 
86.80
Enter result status (true/false): 
true
Enter contact number
12345678
Enter Gender: 
M
Student Details Entered by you are:
Name: Pratik
Age: 27
Gender: M
Contact: 12345678
Score: 86.8
Result: trueCopy code

Important Notes

InputMismatchException: If the user provides an input of a type that doesn’t match the expected type, a java.util.InputMismatchException will be thrown. For example, if you enter a float when an integer is expected:

Enter age:  44.5
Exception in thread "main" java.util.InputMismatchException

No nextChar() Method: There is no method named nextChar(). Instead, to get a character input, you can read a string using next() and then use charAt(index) to retrieve the desired character.
For example, if you input “Abcd”:

char gender = s.next().charAt(0); // 'A'

Constructor Overview

Need of Constructor
Non static variables plays a special role in every program i.e. non
static refers to muliple copies which means that for every object there
is a seperate memory allocated for non static variable, which means
programmer can intialise everytime new value to non static variable.

A constructor is a special method in Java used to initialize objects. It is distinct from normal methods due to the following properties:

1. Constructor Name: Must be the same as the class name.

2. No Return Type: A constructor cannot have a return type, not even void. If a return type is specified, it becomes a regular method.

3. Automatic Invocation: Unlike normal methods, constructors are invoked automatically when an object is created using the new keyword.

4. Parameters: Constructors can have parameters similar to methods, and these are used to initialize object properties during object creation.

Key Points about Constructors:

- No Explicit Invocation: Constructors are called automatically during object creation and cannot be called explicitly.

- Argument Matching: When a constructor is invoked, the number, types, and order of arguments passed must match the parameters defined in the constructor.

Example: Constructor Basics

class LMS {
    public static void main(String[] args) {
        A a1 = new A();  // Invokes constructor A()
    }
}
class A {
    A() {  // Constructor
        System.out.println("Constructor in A class");
    }
    
    void A() {  // This is a method, not a constructor
        System.out.println("It is not a constructor, it is a method.");
    }
}

Output:

Constructor in A class

In this example, the constructor A() is called when an object of class A is created. The method void A() is not a constructor because it has a return type (void).

Constructor with Parameters

⦁ One of the drawbacks of no argument constructor is, it provides
same value for every object.
⦁ Therefore to overcome this drawback, we go for parameterized
constructor.

Constructors can accept parameters, which are used to initialize object properties:

class JTC {
    public static void main(String[] args) {
        Student s1 = new Student(101, "Vishal", "124@gmail.com", "Indian");
        Student s2 = new Student(102, "Rohan", "r456@gmail.com", "USA");
        s1.show();
        s2.show();
    }
}
class Student {
    int sid;
    String sname;
    String semail;
    static String snationality;
    // Constructor with parameters
    Student(int id, String name, String email, String nationality) {
        sid = id;
        sname = name;
        semail = email;
        snationality = nationality;
    }
    void show() {
        System.out.println("----Student Details----");
        System.out.println("sid :- " + sid);
        System.out.println("sname :- " + sname);
        System.out.println("semail :- " + semail);
        System.out.println("snationality :- " + snationality);
    }
}

Here, each Student object is initialized with different values for sid, sname, and semail, but since snationality is a static variable, the last assigned value is shared across all objects.

Default Constructor

If no constructor is explicitly defined in a class, Java provides a default constructor that takes no parameters. However, if a parameterized constructor is defined, the default constructor is not automatically provided:

class A {
    int a;
    void m1() {}
    public static void main(String[] args) {}
}

Generated Default Constructor

class A {
    int a;
    A();  // Default constructor added by compiler
    void m1();
    public static void main(String[] args);
}

If a constructor is defined explicitly, the default constructor is not generated:

class A {
    int a;
    A(int a) {}  // Explicit constructor
    void m1() {}
    public static void main(String[] args) {}
}

Here, no default constructor is generated because A(int a) is explicitly defined.

Constructor Chaining

Constructor chaining occurs when one constructor calls another constructor in the same class using this():

class JTC {
    public static void main(String[] args) {
        A a1 = new A(10, 20);  // Invokes the 2-parameter constructor
    }
}
class A {
    A() {
        System.out.println("No-parameter constructor in A class");
    }
    
    A(int a) {
        this();  // Calls the no-parameter constructor
        System.out.println("1-parameter constructor in A class");
    }
    A(int a, int b) {
        this(a);  // Calls the 1-parameter constructor
        System.out.println("2-parameter constructor in A class");
    }
}

Output:

No-parameter constructor in A class
1-parameter constructor in A class
2-parameter constructor in A class

In this example:

1. The 2-parameter constructor A(int a, int b) calls the 1-parameter constructor A(int a) using this(a).

2. The 1-parameter constructor then calls the no-parameter constructor A() using this().

Rules for Constructor Chaining:

1. this() must be the first statement in the constructor.

2. Only one constructor call is allowed in each constructor.

3. Cyclic constructor calls are not allowed.

Note:-

You can declare a constructor as final or static in certain contexts, but it’s important to clarify what that means.

Final Constructor

In Java, you cannot declare a constructor as final. The final keyword is used to prevent inheritance of a class or overriding of a method, but it doesn’t apply to constructors. Constructors cannot be inherited, so making a constructor final is redundant and will result in a compilation error.

Static Constructor

Similarly, you cannot declare a constructor as static. Constructors are special methods used to initialize instances of a class and cannot be static. Static methods belong to the class itself rather than any specific instance. Since constructors are meant to create instances, they cannot be static.

Summary

- Final Constructor: Not allowed (will result in a compilation error).

- Static Constructor: Not allowed (will also result in a compilation error).

However, you can have static methods in your class (like a factory method) that can be used to create instances, and you can control access to the constructor by making it private (as in the Singleton example).

Note:-

You can declare a constructor as private in Java, and it’s actually quite common in certain design patterns like Singleton or Factory patterns. Let’s break down the concepts one by one.

1. Private Constructor in Java

A private constructor restricts the instantiation of a class from outside the class itself. This means that objects of the class cannot be created directly using the new keyword from outside the class. The main reasons for using a private constructor include:

- Singleton Pattern: Ensures that a class has only one instance and provides a global point of access to that instance.

- Factory Pattern: Controls how objects are created by using static methods to return instances.

- Utility Classes: Prevents instantiation of classes that only contain static methods (e.g., Math class in Java).

Example of a Singleton Pattern with a Private Constructor

public class Singleton {
    private static Singleton instance;
    // Private constructor to prevent instantiation
    private Singleton() {}
    // Public method to provide access to the single instance
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

In this example:

- The constructor is private, so no other class can create an instance of Singleton.

- The only way to get the instance of the class is through the getInstance() method, which ensures only one instance is created.

Benefits of Using a Constructor for Initialization

Using a constructor for initializing an object’s state has several benefits:

1. Mandatory Initialization: Constructors allow you to make certain fields mandatory by requiring their values to be provided when the object is created. This prevents the object from being in an incomplete or invalid state.

2. Convenience: Initialization through constructors can be more concise and clear than using multiple setter methods.

3. Immutable Objects: If you only initialize fields through a constructor and don’t provide setters, you can create immutable objects. Immutability is a desirable property for objects in many situations, especially in multi-threaded applications.

Example of Using a Constructor for Initialization

public class Student {
    private int id;
    private String name;
    // Constructor for initializing fields
    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }
    // Getters
    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }
}

This approach ensures that both id and name must be provided when creating a Student object, making it clear what the state of the object will be.

Constructor vs. Getters and Setters for Initialization

Both constructors and getter/setter methods have their own use cases and benefits. Let’s compare them:

When to Use Constructors and When to Use Getters and Setters

- Use Constructors:

- When you need to ensure that an object is fully initialized at the time of creation.

- When you want to create immutable objects.

- When you need to initialize many fields at once.

- Use Getters and Setters:

- When you need to allow modification of fields after object creation.

- When you have optional fields that may or may not be set.

- When you need to perform specific actions or validation logic each time a field is changed.

Example Using Setters

public class Student {
    private int id;
    private String name;
    // No-argument constructor
    public Student() {}
    // Setters for initialization
    public void setId(int id) {
        this.id = id;
    }
    public void setName(String name) {
        this.name = name;
    }
    // Getters
    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }
}

This approach allows you to create a Student object and then set its fields later:

Student student = new Student();
student.setId(101);
student.setName("John Doe");

Which One Is Better?

- Use Constructors if you have fields that must be initialized for the object to be in a valid state. Constructors ensure that objects are created with all necessary data.

- Use Getters and Setters if you want to allow flexible object creation or if the object fields might need to be changed or updated after object creation.

In most scenarios, combining constructors with getters and setters provides a balanced approach. Use constructors to ensure required fields are initialized, and use setters for optional fields or to allow modifications after the object is created.

Difference between method and constructor

Variable Arguments (Var-Args) in Java

Variable Arguments, commonly known as var-args, allow methods to accept zero or more arguments of a specified type. This feature is particularly useful when you want to pass a varying number of arguments to a method. Before var-args were introduced in Java (starting with JDK 5), method overloading was necessary to handle methods with different numbers of parameters.

Key Points About Var-Args:

1. Syntax:

- The syntax of a variable argument is … .

- Example: int… nums or String… words.

2. Internal Representation:

- Var-args are internally handled as a one-dimensional array. You can use array-style access to manipulate the arguments.

3. Order of Storage:

- Arguments are stored in the order in which they are passed.

4. Number of Arguments:

- You can pass any number of arguments, or even no arguments at all, and the method will still work. However, the arguments must be of the correct data type.

5. Restrictions:

- Positioning: The var-args parameter must always be the last in the parameter list. You cannot define another parameter after a var-args parameter.

- One Var-Args per Method: You can only have one var-args parameter in a method.

Example of Var-Args:

class JTC {
    public static void main(String[] args) {
        A obj = new A();
        obj.m1();  // No argument
        obj.m1(10);  // One argument
        obj.m1(10, 20);  // Two arguments
        obj.m1(10, 20, 30, 40);  // Multiple arguments
    }
}
class A {
    void m1(int... a) {
        System.out.println("m1(int... a) called.");
        for (int i = 0; i < a.length; i++) {
            System.out.println("Index: " + i + " Value: " + a[i]);
        }
    }
}

Output:

m1(int… a) called.
m1(int… a) called.
Index: 0 Value: 10
m1(int… a) called.
Index: 0 Value: 10
Index: 1 Value: 20
m1(int… a) called.
Index: 0 Value: 10
Index: 1 Value: 20
Index: 2 Value: 30
Index: 3 Value: 40

Combining Var-Args with Regular Parameters:

You can combine regular parameters and var-args in a method, but remember the var-args must always be the last parameter:

void m1(String s, int... nums) {
    System.out.println("String: " + s);
    for (int i = 0; i < nums.length; i++) {
        System.out.println("Index: " + i + " Value: " + nums[i]);
    }
}

this Keyword in Java

The this keyword is a reference to the current object, the instance on which a method or constructor is being invoked. It is primarily used to distinguish between instance variables and parameters when they have the same names.

Key Characteristics of this:

1. Final Reference Variable: It is a final reference variable, meaning it always refers to the current object, and you cannot change its reference.

2. Usage:

- this can be used to access instance variables.

- It can also be used to call constructors from other constructors within the same class (constructor chaining).

3. Restrictions:

- this cannot be used in static methods or static contexts because static methods are class-level methods and do not have a reference to any instance.

Example Using this:

class Student {
    int sid;
    String sname;
    String scity;
    Student(int sid, String sname, String scity) {
        this.sid = sid;
        this.sname = sname;
        this.scity = scity;
    }
    void show() {
        System.out.println("Sid: " + sid);
        System.out.println("Sname: " + sname);
        System.out.println("Scity: " + scity);
    }
}
class JTC {
    public static void main(String[] args) {
        Student s1 = new Student(101, "Vivek", "Noida");
        s1.show();
    }
}

Output:

Sid: 101
Sname: Vivek
Scity: Noida

In this example, this.sid = sid; ensures that the constructor parameter sid assigns its value to the instance variable sid.

Common Misconception:

If you do not use this in the constructor, like in the example below, the values won’t be assigned to the instance variables:

Student(int sid, String sname, String scity) {
    sid = sid;
    sname = sname;
    scity = scity;
}

This will result in the default values being printed (0 for integers and null for Strings) because the local variables (parameters) are being assigned to themselves, and the instance variables remain uninitialized.

Components of Object-Oriented Programming (OOP)

Object-Oriented Programming (OOP) is a programming paradigm that uses “objects” to design applications and software. It provides a clear modular structure, making it easier to understand, debug, and modify code. The four core principles of OOP are Encapsulation, Abstraction, Inheritance, and Polymorphism. Let’s go through each of these components in detail.

1. Encapsulation

Encapsulation is the concept of bundling data (variables) and methods (functions) that operate on the data into a single unit called an object. It restricts direct access to some of the object’s components, which is known as data hiding. Encapsulation helps in maintaining data integrity and makes code more modular.

- Example: If you have a Car object, the data (attributes like speed, fuel) and methods (like accelerate(), brake()) are bundled together within that object.

Key Concepts:

- Access Modifiers: Encapsulation often involves using access modifiers (such as private, public, and protected) to control access to the data.

- Getter and Setter Methods: These are used to access and modify private variables in a controlled way.

class Car {
    private int speed; // Encapsulated data (private variable)
    // Getter method
    public int getSpeed() {
        return speed;
    }
    // Setter method
    public void setSpeed(int speed) {
        this.speed = speed;
    }
}

2. Abstraction

Abstraction is the concept of hiding the complex implementation details of a system and exposing only the necessary and relevant parts to the user. It reduces complexity by allowing the user to interact with an interface without knowing its underlying implementation.

- Example: When you drive a car, you only need to know how to use the steering wheel, accelerator, and brake. You don’t need to understand how the engine or brake system works internally.

Key Concepts:

- Abstract Classes and Interfaces: In Java, abstraction is implemented using abstract classes and interfaces.

- Abstract methods in an abstract class have no body and must be implemented by subclasses.

abstract class Vehicle {
    abstract void start(); // Abstract method
}
class Car extends Vehicle {
    void start() {
        System.out.println("Car starts with a key.");
    }
}

3. Inheritance

Inheritance is a mechanism that allows one class to inherit properties (fields and methods) from another class. The class that is inherited from is called the parent or superclass, and the class that inherits is called the child or subclass. Inheritance promotes code reusability.

4. Polymorphism

Polymorphism is the ability of an object to take on multiple forms. It allows methods to do different things based on the object it is acting upon, even if they share the same name. Polymorphism is achieved in two ways: Method Overloading and Method Overriding.

Types of Polymorphism:

1. Compile-time Polymorphism (Method Overloading): Multiple methods have the same name but different parameters. The method to be called is determined at compile time.

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

2. Runtime Polymorphism (Method Overriding): A subclass provides a specific implementation of a method that is already defined in its superclass. The method to be called is determined at runtime.

class Animal {
    void makeSound() {
        System.out.println("Animal makes a sound");
    }
}
class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Dog barks");
    }
}
public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();
        myAnimal.makeSound(); // Outputs: Dog barks
    }
}

Summary of OOP Components

Benefits of OOP

1. Reusability: Code can be reused through inheritance.

2. Modularity: Each object can function as an independent entity.

3. Scalability: Easier to manage and scale large software systems.

4. Maintainability: Easy to update and modify code with minimal impact on other parts of the program.

These four principles form the foundation of Object-Oriented Programming and make it a powerful tool for designing software systems that are more structured, scalable, and easier to understand.

Understanding Object Creation in Java

When you create an object of a class in Java, several key processes occur regarding memory allocation, variable initialization, and the execution of various blocks and constructors. Here’s a breakdown of what happens step by step, including both static and instance variables, as well as static and instance initializer blocks.

1. Class Loading

When the class is referenced for the first time (e.g., when an object is created), the Java Virtual Machine (JVM) loads the class into memory. During this process:

- Memory Allocation for Static Variables: Memory is allocated in the method area (also called the static area) for all static variables. Each static variable is associated with the class itself rather than any instance.

- Static Block Execution: Any static blocks in the class are executed in the order they appear. This is where you can perform static initialization.

2. Memory Allocation for the Object

When you create an object using the new keyword (e.g., MyClass obj = new MyClass();):

- Memory Allocation on the Heap: Memory is allocated for the new object on the heap. This memory will hold the instance variables declared in the class.

3. Initialization of Instance Variables

Once memory is allocated for the object:

- Default Initialization: All instance variables of the object are initialized to their default values:

- Numeric types (e.g., int, double) are initialized to 0.

- boolean types are initialized to false.

- Object references are initialized to null.

4. Execution of Instance Initializer Blocks

If there are any instance initializer blocks in the class, they are executed in the order they appear, immediately after the default initialization of instance variables.

5. Execution of the Constructor

After all instance initializer blocks have been executed, the constructor is called. The constructor can perform further initialization, including setting values for instance variables based on parameters passed to it.

6. Finalization of Object Creation

Once the constructor has completed its execution, the object is fully constructed, and a reference to the newly created object is returned. You can then use this reference to interact with the object.

Memory Layout Overview

1. Static Variables:

- Location: Method area (static area of the heap).

- Initialization: Allocated and initialized when the class is loaded.

2. Instance Variables:

- Location: Heap (allocated when an object is created).

- Initialization: Initialized to default values, then possibly modified by initializer blocks or constructors.

Complete Example

Here’s a complete example that includes static variables, static blocks, instance variables, instance initializer blocks, and constructors:

public class Example {
    static int staticVar; // Static variable
    static {
        staticVar = 20; // Static block initializing static variable
        System.out.println("Static block executed: staticVar = " + staticVar);
    }
    int instanceVar; // Instance variable
    // Instance initializer block
    {
        instanceVar = 10; // Initializing instance variable
        System.out.println("Instance initializer block executed: instanceVar = " + instanceVar);
    }
    // Constructor
    public Example(int value) {
        this.instanceVar = value; // Initializing instance variable with constructor parameter
        System.out.println("Constructor executed: instanceVar = " + instanceVar);
    }
    public static void main(String[] args) {
        Example obj1 = new Example(30);
        System.out.println("obj1: staticVar = " + Example.staticVar + ", instanceVar = " + obj1.instanceVar);
        Example obj2 = new Example(40);
        System.out.println("obj2: staticVar = " + Example.staticVar + ", instanceVar = " + obj2.instanceVar);
    }
}

Expected Output

Static block executed: staticVar = 20
Instance initializer block executed: instanceVar = 10
Constructor executed: instanceVar = 30
obj1: staticVar = 20, instanceVar = 30
Instance initializer block executed: instanceVar = 10
Constructor executed: instanceVar = 40
obj2: staticVar = 20, instanceVar = 40

Explanation of Output

1. Static Block Execution: The static block executes first when the class Example is loaded, initializing staticVar to 20.

2. First Object Creation (obj1):

- The instance initializer block executes, initializing instanceVar to 10.

- The constructor is called with the argument 30, setting instanceVar to 30.

- The values of staticVar and instanceVar are printed.

3. Second Object Creation (obj2):

- The instance initializer block executes again, initializing instanceVar to 10 (as part of the new object creation).

- The constructor is called with the argument 40, setting instanceVar to 40.

- The values are printed again.

Summary

- Static Variables: Shared across all instances of a class, stored in the method area, and initialized when the class is loaded.

- Static Blocks: Used for static initialization, executed when the class is loaded.

- Instance Variables: Unique to each instance, initialized when an object is created.

- Instance Initializer Blocks: Executed after default initialization of instance variables and before the constructor.

- Constructors: Called to further initialize an object after the instance initializer blocks.

Note:-1) Constructor cannot be defined under local context.

2) When accessing static variables in Java, the initialization behavior varies based on how the static variables are defined:

Static Variable with Static Block:
— If you declare a static variable (like b) and initialize it in a static block, that block is executed when the class is loaded. Therefore, if you access b using the class name, the static block will be processed first.

class Example {
 static int a = 10;
 static int b;
 static {
 b = 20; // Static block is executed when the class is loaded
 }
 }

2. Static Final Variable at Declaration:
— If you declare a static final variable (like c) and initialize it at the time of declaration, its value is available immediately, and there’s no need for a static block. Therefore, when you access c, it directly provides the initialized value without processing any static block.

class Example {
 static final int c = 30; // Initialized at declaration
 }

Execution Process Overview

When you execute a Java program, the Java Virtual Machine (JVM) creates two main memory areas:

1. Stack Area (Execution Area)

2. Heap Area (Storage Area)

These areas play crucial roles in managing memory for static and non-static members, method calls, and variable storage.

Detailed Execution Steps

1. JVM Enters the Stack Area

- The JVM starts by entering the stack area to manage method calls and local variables.

2. Class Loader Invocation

- The JVM calls the class loader, a special function responsible for loading classes into memory.

- Its main job is to load all static members of the class into the Static Pool Area (SPA).

3. Static Pool Area (SPA)

- SPA is a part of the heap area where all static variables and static methods are stored.

- The class loader loads the static members and prepares them for use.

4. Class Loader Completes Its Job

- After loading all static members, the class loader exits the stack area, as its task is complete.

5. JVM Calls the `main` Method

- The JVM locates the `main` method, which serves as the entry point of the program, and loads it into the stack area.

6. Method Area in the Stack

- When a method is called, it is placed in the stack area under the method area. The method’s local variables and parameters will be stored here.

7. Execution of `main` Method Begins

- The execution of the `main` method starts. This is where the program’s logic is processed.

8. Completion of `main` Method Execution

- Once all statements in the `main` method are executed, it exits the stack area, indicating that the method’s execution is complete.

9. Garbage Collection Call

- Before the JVM exits the stack area, it invokes the garbage collector. The garbage collector’s role is to clean up any unused memory, preparing for the next execution.

Important Memory Management Points

1. Static Members Availability

- Static methods and static variables are loaded into the SPA before execution begins, making them accessible without needing to create an object.

2. Non-Static Members Accessibility

- Non-static members (variables and methods) are not available until an object is created. You must use the `new` keyword to instantiate an object, which loads non-static members into memory.

3. Loading of Non-Static Members

- Non-static variables and methods are stored together in the object created. This is why non-static methods can access non-static variables directly, as they belong to the same instance.

4. Single Copy of Static Members

- Static members are loaded only once in the SPA, which is why they are referred to as single copies.

5. Multiple Copies of Non-Static Members

- Non-static members are loaded each time an object is created, resulting in multiple copies of these members across different instances.

6. Local vs. Global Variables

- Local variables (e.g., method parameters) reside in the stack area, while global variables (like static and instance variables) are stored in the heap area.

7. Location of Static and Non-Static Variables

- Static variables are stored in the SPA within the heap, whereas non-static variables are part of the object in the heap.

8. Reference Variables as Local Variables

- All reference variables (pointers to objects) are considered local variables and reside in the stack area.

9. Scope of Local Variables

- Local variables exist only during the execution of a method. Once the method completes, the local variables are removed from the stack, hence their scope is limited to the method itself.

Volatile modifier in Java

The volatile modifier in Java is used to ensure visibility and ordering of variables across multiple threads in a multi-threaded environment. When you declare a variable as volatile, you are telling the Java Virtual Machine (JVM) that this variable’s value may be modified by different threads and that any changes made to it should be visible to all other threads immediately.

Key Characteristics of volatile Modifier

1. Visibility:

- Normally, each thread in Java has its own local cache of variables. When one thread updates a variable, other threads might not see this change immediately.

- A volatile variable ensures that the value is always read from the main memory, not from a thread’s local cache. This means any update to a volatile variable by one thread is immediately visible to all other threads.

2. Ordering:

- The volatile keyword ensures that read and write operations on the variable are performed in order. It prevents the reordering of instructions by the compiler or the processor, which can sometimes occur to optimize performance.

Use Cases for volatile

1. Flags:

- One of the most common use cases for volatile is for flags or status indicators that are checked and modified by multiple threads.

public class VolatileExample {
    private volatile boolean running = true;
    public void runTask() {
        while (running) {
            // Do some work
        }
    }
    public void stop() {
        running = false; // This change will be visible to the runTask() method
    }
}

2. Double-Checked Locking Singleton:

- volatile is used in the implementation of the Singleton pattern to prevent the reordering of instructions.

public class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton(); // Prevents reordering issues
                }
            }
        }
        return instance;
    }
}

Important Points to Remember

1. Atomicity:

- volatile does not guarantee atomicity of operations. For example, incrementing a volatile variable is not atomic.

volatile int count = 0;
count++; // This operation is not atomic

For atomic operations, you should use classes like AtomicInteger from the java.util.concurrent.atomic package.

2. Volatile vs. Synchronized:

- volatile ensures visibility of changes to variables across threads, while synchronized provides both visibility and mutual exclusion.

- synchronized blocks or methods are more expensive in terms of performance compared to using volatile.

- If you only need visibility without locking, use volatile. If you need atomicity and thread safety, use synchronized.

3. When to Use volatile:

- Use volatile when:

- You have a single variable being accessed and modified by multiple threads.

- The variable does not depend on its previous value (no compound actions like count++).

- You do not need to perform complex operations on the variable that require locking.

Example of Using volatile

public class VolatileExample {
    private volatile boolean flag = true;
    public void printMessage() {
        while (flag) {
            System.out.println("Running...");
        }
    }
    public void stopPrinting() {
        flag = false; // This change will be visible to the printMessage method immediately
    }
    public static void main(String[] args) {
        VolatileExample example = new VolatileExample();
        new Thread(example::printMessage).start();
        try {
            Thread.sleep(1000); // Let the thread run for a second
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        example.stopPrinting(); // Stops the running thread
    }
}

In this example:

- The flag variable is marked as volatile.

- The changes to the flag variable in the stopPrinting() method are immediately visible to the printMessage() method.

Summary

- volatile ensures that updates to a variable are immediately visible to other threads and prevents reordering of instructions.

- It does not provide atomicity, so it should be used when only visibility is required.

- It’s suitable for simple flags or status variables but not for complex operations that require synchronization.

Using the volatile keyword correctly can help in designing efficient multi-threaded applications without unnecessary synchronization overhead.

Inheritance

Inheritance is a key concept in object-oriented programming (OOP) that allows the creation of a new class using the properties and methods of an existing class. It helps in code reusability and the establishment of relationships between different classes. Below, let’s go through the details of inheritance concepts, its types, and some examples.

Inheritance Overview

- Definition: Inheritance allows a new class (called a derived class, child class, or subclass) to acquire properties and behavior from an existing class (called a base class, parent class, or superclass).

- Purpose: It is used to establish relationships between categories based on the logic of your application. It helps in reusing existing code, making software development more efficient.

- How It Works: In most programming languages like Java, inheritance is implemented using the extends keyword. This keyword indicates that a class is inheriting the features of another class.

Terminology

- Superclass (Parent Class / Base Class): The class whose properties and methods are inherited by another class.

- Subclass (Child Class / Derived Class): The class that inherits properties and methods from another class.

Important Notes on Inheritance

- The subclass contains all the functionalities of its superclass.

- The subclass can access all non-private members of the superclass.

- Private members of a superclass are not directly accessible from the subclass.

Types of Inheritance

1.Single Level
2.Multi Level
3.Hierarchical
4.Multiple
5.Hybrid

1. Single Inheritance

- A subclass inherits from one superclass.

Example:

class A {
    int a = 10;
}
class B extends A {
    void display() {
        System.out.println("Value of a: " + a);
    }
}
public class Test {
    public static void main(String[] args) {
        B obj = new B();
        obj.display();  // Output: Value of a: 10
    }
}

- In this example, class B inherits the properties of class A.

2. Multiple Inheritance

- A class inherits from more than one class at the same time.

- Note: Java does not support multiple inheritance with classes to avoid ambiguity problems, but it can be achieved using interfaces.

- Example (Ambiguity Problem):

class A { int a = 10; }
class B { int a = 20; }
// class C extends A, B { } // This is not allowed in Java

3. Multi-Level Inheritance

- A class is derived from another class, which is also derived from another class.

- Example:

class A {
    int a = 10;
}
class B extends A {
    int b = 20;
}
class C extends B {
    int c = 30;
}
public class Test {
    public static void main(String[] args) {
        C obj = new C();
        System.out.println("a: " + obj.a + ", b: " + obj.b + ", c: " + obj.c);
        // Output: a: 10, b: 20, c: 30
    }
}

4. Hierarchical Inheritance

- More than one class inherits from the same base class.

- Example:

class A {
    int a = 10;
}
class B extends A {
    int b = 20;
}
class C extends A {
    int c = 30;
}
public class Test {
    public static void main(String[] args) {
        B objB = new B();
        C objC = new C();
        System.out.println("B: a = " + objB.a + ", b = " + objB.b);
        System.out.println("C: a = " + objC.a + ", c = " + objC.c);
        // Output:
        // B: a = 10, b = 20
        // C: a = 10, c = 30
    }
}

5. Hybrid Inheritance

- It is a combination of two or more types of inheritance (e.g., multi-level and hierarchical).

- Java does not directly support hybrid inheritance using classes to avoid complexity but supports it using interfaces.

6. Cyclic Inheritance

- In cyclic inheritance, a class is inherited from itself or two classes extend each other, which is not allowed.

- Example:

class A extends A { } // Not allowed
class B extends C { }
class C extends B { }

Understanding the super Keyword

- Purpose: The super keyword is used to access members (variables and methods) of the superclass.

- Usage: It can be used to call the superclass’s constructor and to differentiate between superclass and subclass members if they have the same name.

Accessing Superclass Methods

You can use super to call methods defined in the superclass. This is especially useful if the subclass overrides a method and you still want to access the original method from the superclass.

class Parent {
    void display() {
        System.out.println("Display from Parent");
    }
}
class Child extends Parent {
    void display() {
        super.display(); // Calls the Parent's display method
        System.out.println("Display from Child");
    }
}

2. Accessing Superclass Constructors

You can use super() to call a constructor from the superclass. This must be the first statement in the subclass constructor. If you don’t explicitly call a superclass constructor, Java will automatically call the no-argument constructor of the superclass.

class Parent {
    Parent(int value) {
        System.out.println("Parent Constructor: " + value);
    }
}
class Child extends Parent {
    Child(int value) {
        super(value); // Calls Parent's constructor with an argument
        System.out.println("Child Constructor");
    }
}

3. Accessing Superclass Fields

You can use super to access fields (variables) of the superclass, especially if they are shadowed by fields in the subclass.

class Parent {
    int number = 10;
}
class Child extends Parent {
    int number = 20;
    void display() {
        System.out.println("Child number: " + number);      // Prints 20
        System.out.println("Parent number: " + super.number); // Prints 10
    }
}

Summary

- super(): Calls a superclass constructor.

- super.methodName(): Calls a method from the superclass.

- super.fieldName: Accesses a field from the superclass.

Using super allows you to build upon the functionality of a parent class while still leveraging its existing methods and properties.

Constructors and the super() Statement

- If a constructor is not explicitly defined in the subclass, Java automatically calls the superclass’s no-argument constructor using super().

- The super() statement must always be the first line in the subclass constructor.

- If the superclass does not have a no-argument constructor, you must explicitly call the appropriate superclass constructor.

Question. Can we inherit constructor?

No we cannot inherit constructors because they are not member of a
class(members of classs are methods and variables) and constructors
are mainly used for intialistion of Non‐static variable.
Constructors cannot be inherited but they can be invoked by using
call to super.

Note:-

Object Class in Java
In Java, every class implicitly extends the java.lang.Object class, making it the root of the class hierarchy. When you extend a class, most of its members (methods and variables) are inherited, except for:
— private members: These are not accessible in the subclass.
— local members: These are not inherited because they are confined to the method where they are defined.
— final classes: A class declared as final cannot be inherited.

Using super in Static Context
— The super keyword is used to refer to the superclass and can only be used in instance contexts. You cannot use super in a static context (e.g., inside a static method or static block).
— Additionally, you cannot write super.super.variable, as Java does not support multi-level access to superclasses in this manner.

Thus,

We can inherit public,protected and default methods.
2. We cannot inherit private method because they are accessible only
within class.
3. We can inherit non static, final and abstract methods.
4. We cannot inherit static methds because they will be loaded only once
in SPA.
5. We cannot inherit constructors because they are mainly used for
initialisation and they are not member of class.

Interview question: Tell me in ur Project where you used inheritance ??

Constructor Invocation Order in Multi-Level Inheritance
In a multi-level inheritance scenario, the order of constructor invocation is from the top-most superclass to the subclass. For example:

class A {
    A() {
        System.out.println("Constructor of A");
    }
}
class B extends A {
    B() {
        System.out.println("Constructor of B");
    }
}
class C extends B {
    C() {
        System.out.println("Constructor of C");
    }
}

When you create an object of class C, the output will be:
Constructor of A
Constructor of B
Constructor of C
This shows that the constructors are invoked in the order of inheritance.

Default Constructor Behavior
When you create an object of class Hello, the JVM checks for the presence of a default constructor. If none is found, it inserts a default constructor that includes a super() call to invoke the superclass’s default constructor. If the superclass does not have a default constructor and only has parameterized constructors, the JVM cannot provide an implicit call to the superclass constructor, resulting in a compilation error.

Declaring a Class as Private
In Java, top-level classes cannot be declared as private. However, you can declare inner classes as private. A private inner class is only accessible within its enclosing class.

Difference Between super and this
— super:
— Refers to the superclass of the current object.
— Used to access superclass methods and constructors.

— this:
— Refers to the current object.
— Used to access instance variables and methods of the current class.

S-A Relationship (is-a relationship): This represents inheritance in Java. If class B extends class A, then B is a type of A. For example, Dog is an Animal.

Coupling: Refers to the degree of interdependence between software modules. Low coupling is desirable as it allows modules to be understood and modified independently.
Aggregation: A form of association representing a “whole-part” relationship where the part can exist independently of the whole. For example, a Library has Books, but books can exist without the library.

Polymorphism

Polymorphism in Java allows objects to be treated as instances of their parent class, making code more flexible and easier to maintain. The concept has two primary forms:

1. Compile-Time Polymorphism (Static Polymorphism)

2. Run-Time Polymorphism (Dynamic Polymorphism)

Compile-Time Polymorphism (Static Polymorphism)

Technical definition :
a. The process of resolving call to overloaded method during compile
time depending on type of arguments is called compile time
polymorphism.
b. It is also called as static polymorphism or compile time binding.

1. Compile time binding :

• The process of connecting method signature with method implementation during compile time is called as compile time binding.
• Since, binding is happening before execution it is called as Early
binding.
• All static and final methods will get binded during compile time
i.e,during compilation only method will come to know what is its
implementation.

Compile-time polymorphism is achieved using method overloading, where multiple methods share the same name but differ in their parameter lists.

Key points about Method Overloading:

- Method name: Must be the same for all overloaded methods.

- Parameters: Must differ in type, number, or order.

- Return type and access modifier: Can be different but do not affect overloading.

Example

class A {
    void m1() {
        System.out.println("m1() in A class");
    }
    int m1(int a) {
        System.out.println("m1(int) in A class");
        return a;
    }
    public void m1(byte b) {
        System.out.println("m1(byte) in A class");
    }
}

Here, the m1 method is overloaded with different parameter types. The compiler decides which method to call based on the argument types during method invocation.

2. Runtime Polymorphism (Dynamic Polymorphism)

Technical definition :
a. The process of resolving call to overridden method during run time
depending on type of object we create is called run time polymorphism.
b. It is also called dynamic binding or dynamic polymorphism.

Run time binding / Dynamic Binding:
• The process of connecting method signature with method implementation
during execution time is called as run time binding.
• Since binding is happening during execution it is called as Late
binding.
• All Non static and abstract methods will get binded during run time
i.e, until program will reason Non static and abstarct method can be
overridden.

Runtime polymorphism is achieved through method overriding and dynamic method dispatch.

Method Overriding

During Inheritance subclass has complete previlege to change the
(method)implementation of super class, this process is known as Method
Overriding.

Q. Why do we go for Overriding ??
A. When subclass want the properties of super class but does not want the
implementation of it. In such case, sub class can change implementation
by means of Overriding.

Key points about Method Overriding:

- The method in the subclass must have the same name, return type, and parameters as in the superclass.

- The access modifier of the overridden method must be the same or less restrictive than the superclass method.

In Java, the rules for overriding methods are as follows:

1. Private Methods:
— Cannot be overridden: Private methods are not visible to subclasses, so they cannot be overridden. They can be redefined in a subclass, but this is not overriding; it’s method hiding.

2. Static Methods:
— Cannot be overridden: Static methods are associated with the class rather than instances of the class. They can be redefined in a subclass (method hiding), but this does not constitute overriding. The static method of the superclass is not replaced by the subclass’s static method when called on an instance of the superclass.

3. Final Methods:
— Cannot be overridden: Final methods are declared with the final keyword, which prevents them from being overridden in subclasses. This is intended to maintain specific behavior in the superclass.

Summary:
— Private methods: Cannot be overridden (only redefined).
— Static methods: Cannot be overridden (only hidden).
— Final methods: Cannot be overridden.

These rules ensure encapsulation and control over method behavior in inheritance.

Dynamic Method Dispatch

Dynamic dispatch allows a superclass reference to refer to a subclass object, enabling the overridden method in the subclass to be called at runtime.

Example

class A {
    void m1() {
        System.out.println("m1 in A class");
    }
}
class B extends A {
    @Override
    void m1() {
        System.out.println("m1 in B class");
    }
}
public class JTC {
    public static void main(String[] args) {
        A a = new B(); // Superclass reference to subclass object
        a.m1(); // Calls the overridden method in class B
    }
}

Output:

m1 in B class

This code demonstrates how the method m1 from the subclass B is called even though the reference is of type A. This behavior is determined at runtime.

1. Dynamic Dispatch refers to the process of determining which method to execute at runtime based on the object’s actual type rather than the type of the reference variable.

2. Class Relationships:
— Superclass (A): A general class.
— Subclass (B): A specialized class that extends the superclass.

Code Examples Explained

1. Object Creation:
— A a1 = new A(); // ok
This is straightforward as you are creating an instance of A and assigning it to a reference of type A.

- B b1 = new B(); // ok
Similarly, this is valid because you are creating an instance of B, which is a subclass of A, and assigning it to a reference of type B.

2. Upcasting:
— A a2 = new B(); // ok
This is an example of upcasting. You can assign a subclass object (B) to a superclass reference (A). This is valid because a B is an A.

3. Downcasting:
— B b2 = new A(); // not ok
This is invalid because you cannot assign a superclass object to a subclass reference. A does not guarantee that it is a B.

Additional Class Examples

// Superclass
class Hello {
    // Method in the superclass
    public void greet() {
        System.out.println("Hello from the Hello class!");
    }
}

// Subclass
class Hai extends Hello {
    // Method in the subclass
    public void greet() {
        System.out.println("Hello from the Hai class!");
    }

    // Additional method in the subclass
    public void sayHai() {
        System.out.println("Hai from the Hai class!");
    }
}

- Hai hai2 = new Hello(); // ok
This is again upcasting, where a Hello object is assigned to a Hai reference.

- Hello h2 = new Hai(); // not ok
Similar to the previous example, you cannot downcast a superclass object (Hai) to a subclass reference (Hello).

Type Casting

- Upcasting: Allowed implicitly without type casting (e.g., Hai hai2 = new Hello();).

- Downcasting: Must be explicit and is only valid if the object is actually an instance of the subclass:
— Hello h5 = (Hello) hai2; // not ok if hai2 is not an instance of Hello

- ClassCastException: This runtime exception occurs when you try to downcast a superclass reference that doesn’t actually point to an instance of the subclass:
— In the case of Hello h3 = (Hello) hai1;, it throws a ClassCastException because hai1 is an instance of Hai, not Hello.

Summary of Rules

1. Upcasting (subclass to superclass) is safe and implicit.
2. Downcasting (superclass to subclass) requires explicit casting and can fail at runtime if the object isn’t of the expected subclass type.
3. Always check the actual type of an object before downcasting to avoid runtime exceptions.

Understanding these principles is crucial for effective use of inheritance and polymorphism in object-oriented programming.

Benefits of Polymorphism

- Code Reusability: Allows a general method to work on objects of different classes.

- Maintainability: Simplifies code updates and changes, as you can work with the superclass reference instead of individual subclass references.

- Flexibility: Makes it easy to introduce new classes without changing existing code.

Method Overloading vs. Overriding

- Method Overloading: Involves methods with the same name but different signatures within the same class. It’s determined at compile time.

- Method Overriding: Involves a subclass providing a specific implementation of a method that is already defined in its superclass. It’s determined at runtime.

Using these principles, Java enables robust and scalable applications, supporting a structured approach to code design that can handle complexity efficiently.

Note:-

Calling Methods with Superclass Reference

Method Availability:
— When you call a method using a superclass reference that points to a subclass object, the method signature must be defined in the superclass. If the method is not present in the superclass, the compiler will throw an error.

class Superclass {
       void display() {
           System.out.println("Superclass display");
       }
   }
   class Subclass extends Superclass {
       void show() {
           System.out.println("Subclass show");
       }
   }
   Superclass obj = new Subclass();
   obj.display(); // This works, but obj.show(); will give an error.

2. Method Resolution:
— When invoking a method on a superclass reference pointing to a subclass object, the JVM first checks if the method signature exists in the superclass. If it does, it then checks if there’s an overridden implementation in the subclass.
— If an overridden method exists in the subclass, that implementation will be executed (demonstrating runtime polymorphism).

Static Methods

1. Static Method Behavior:
— If you call a static method using a superclass reference that points to a subclass object, the superclass’s static method implementation will always be executed. This is because static methods are bound at compile time (early binding).

2. No Runtime Polymorphism with Static Methods:
— Static methods cannot be overridden; they can only be hidden. This means if a subclass defines a static method with the same name, it doesn’t override the method from the superclass — it hides it.
— This results in static methods being resolved at compile time, hence supporting early binding.

Binding Concepts

- Early Binding (Static Binding):
— Applies to static methods and method calls on primitive types and references. The method to be executed is determined at compile time.

- Late Binding (Dynamic Binding):
— Applies to instance methods. The method to be executed is determined at runtime, allowing for the flexibility of polymorphism.

Summary

-Method Availability: Superclass reference must have the method defined for it to be callable.
— Method Resolution: JVM checks superclass first, then subclass for method implementations.
— Static Methods: Always call the superclass’s static method when accessed via a superclass reference; they do not support runtime polymorphism and are resolved at compile time.

Note:-

package Polymorphism5;
class Hello {
    void m1() {
        System.out.println("m1 in Hello");
    }
    void m2() {
        System.out.println("m2 in Hello");
    }
    void m3() {
        System.out.println("m3 in Hello");
    }
}
class Hai extends Hello {
    void m1() {
        System.out.println("m1 in Hai");
    }
    void m2() {
        System.out.println("m2 in Hai");
        super.m2(); // Calls the superclass implementation of m2
    }
}
public class Jtc114 {
    public static void main(String[] args) {
        Hai hai = new Hai();
        hai.m1(); // Calls m1 in Hai
        hai.m2(); // Calls m2 in Hai, which also calls m2 in Hello
        hai.m3(); // Calls m3 in Hello
    }
}

The output of the program is:

m1 in Hai
m2 in Hai
m2 in Hello
m3 in Hello

Conceptual Explanation

1. Method Overriding:
— m1() Method:
— The m1() method in the Hai class overrides the m1() method in the Hello class. When hai.m1() is called, it executes the overridden version in Hai, resulting in m1 in Hai.

2. Using super to Access Superclass Implementation:
m2() Method:
— The m2() method in the Hai class overrides the m2() method in the Hello class. Inside this method, super.m2() is called, which invokes the m2() method in the Hello class.
— As a result, when hai.m2() is executed, it first prints m2 in Hai, then calls super.m2(), which prints m2 in Hello.
No Overriding:
m3() Method:
— The m3() method is not overridden in the Hai class. Therefore, when hai.m3() is called, it directly invokes the implementation in the Hello class, resulting in m3 in Hello.
— This illustrates that if you want to retain the superclass’s behavior, you can simply not override the method in the subclass.

Summary

Override to Change Behavior: If you want to change the behavior of a method from the superclass, you override it in the subclass (like m1()).
— Use super to Combine Behavior: If you want to extend the behavior (use both superclass and subclass implementations), you override the method and use super to call the superclass version (like m2()).
— Inherit as-is: If you want to use the superclass implementation without any changes, you simply don’t override the method (like m3()).

This structure allows for flexible and powerful use of polymorphism in Java, enabling you to define and refine behavior across class hierarchies.

-You cannot override the main method in Java in the way you might be thinking. The main method serves as the entry point for any Java application, and it has a specific signature:

public static void main(String[] args)
Key Points:

1. Static Context: The main method is static, meaning it belongs to the class itself rather than instances of the class. Because of this, it cannot be overridden in the traditional sense. Static methods can be hidden, but not overridden.

2. Method Hiding: If you define another main method in a subclass with the same signature, it won’t override the superclass’s main method; instead, it hides it. This means that when you run the program, the JVM will still call the main method of the class you specify on the command line.

3. Calling Main from Main: You can call the main method of the same class or a different class within the main method, but this does not constitute overriding. It simply involves invoking another method.

Example:

Here’s a simple example:

class Parent {
    public static void main(String[] args) {
        System.out.println("Main method in Parent");
        Child.main(args); // Calling Child's main
    }
}
class Child extends Parent {
    public static void main(String[] args) {
        System.out.println("Main method in Child");
    }
}

Output:

Main method in Parent
Main method in Child

In this example:
— The main method in Parent calls the main method in Child, but this does not mean Child overrides Parent’s main.
— The main method of Parent runs because it’s the one called when the program starts.

Encapsulation

Encapsulation is the practice of bundling the data (attributes) and methods (functions) that operate on the data into a single unit, typically a class. This approach helps protect the integrity of the data by restricting direct access to it.

Key Concepts of Encapsulation

1. Data Hiding: By making class attributes private, you prevent external code from accessing them directly.

2. Controlled Access: Use public methods (getters and setters) to allow controlled access to the private data.

Why Use Encapsulation?

- Protect Data: Prevent invalid data from being set.

- Maintain Control: Ensure that only valid data is assigned to attributes.

- Flexibility: Change internal implementations without affecting other parts of the code.

Example 1: Simple Encapsulation

Unencapsulated Class

class App {
    int monthnum; // Not protected
}

public class Demo {
    public static void main(String[] args) {
        App a1 = new App();
        a1.monthnum = 22; // Invalid value for month
        System.out.println("Month number is " + a1.monthnum); // Outputs 22
    }
}

Problem: The user can set `monthnum` to an invalid value (like 22).

Encapsulated Class

class Calendar {
    private int monthnum; // Data member is private

    // Setter method
    public void setMonthNum(int monthnum) {
        if (monthnum >= 1 && monthnum <= 12) {
            this.monthnum = monthnum; // Valid month
        } else {
            System.out.println("Invalid month number"); // Prevents invalid assignment
        }
    }

    // Getter method
    public int getMonthNum() {
        return monthnum; // Returns the valid month number
    }
}

public class UserCal {
    public static void main(String[] args) {
        Calendar c1 = new Calendar();
        c1.setMonthNum(22); // Invalid input
        System.out.println("Month number is " + c1.getMonthNum()); // Outputs 0 (default value)
        
        c1.setMonthNum(5); // Valid input
        System.out.println("Month number is " + c1.getMonthNum()); // Outputs 5
    }
}

Explanation

- Private Data Member: The `monthnum` variable is private, so it can’t be accessed directly outside the `Calendar` class.

- Setter Method: `setMonthNum` checks if the input is valid (between 1 and 12) before assigning it.

- Getter Method: `getMonthNum` returns the value of `monthnum`.

Java Bean Class

A Java Bean class is a reusable software component that adheres to specific conventions in its structure. It encapsulates its properties (data members) and provides methods to access and modify those properties through getter and setter methods. This design promotes encapsulation and helps in maintaining data integrity.

Characteristics of a Java Bean Class

1. Private Data Members: All properties of the bean class should be declared private to restrict direct access from outside the class.

2. Public Setter and Getter Methods:

- Each private data member should have a corresponding setter method (to set the value) and a getter method (to retrieve the value).

Setter Method

A setter method is used to assign a value to a private data member. The characteristics of a setter method are:

1. Public Accessibility: The method must be declared `public` so that it can be accessed from outside the class.

2. No Return Type: The setter method does not return any value; its return type is `void`.

3. Arguments: It accepts one argument, which should be of the same type as the data member it is setting.

4. Naming Convention: The method name should start with “set” followed by the name of the data member (with the first letter capitalized).

Example of a Setter Method:

public void setEidPF(long eidPF) {
    this.eidPF = eidPF; // 'this' keyword distinguishes the class member from the parameter
}

Getter Method

A getter method retrieves the value of a private data member. The characteristics of a getter method are:

1. Public Accessibility: Like setters, getters must also be public.

2. Return Type: The return type must match the data type of the data member.

3. No Arguments: The getter method does not accept any parameters.

4. Naming Convention: The method name should start with “get” followed by the name of the data member (with the first letter capitalized).

Example of a Getter Method:

public long getEidPF() {
    return eidPF; // Returns the value of eidPF
}

Example of a Java Bean Class

Here’s a complete example that illustrates the concept of a Java Bean class using an `EPF` (Employee Provident Fund) class:

import java.util.Scanner;

class EPF {
    private long eidPF; // Employee ID
    private String pwd; // Password

    // Setter method for eidPF
    public void setEidPF(long eidPF) {
        this.eidPF = eidPF;
    }

    // Getter method for eidPF
    public long getEidPF() {
        if (eidPF == 101123458L) {
            System.out.println("Processing your EID, please wait...");
            return eidPF;
        } else {
            System.out.println("Incorrect EID");
            return 0;
        }
    }

    // Setter method for pwd
    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    // Getter method for pwd
    public String getPwd() {
        if (pwd.equals("Hari123")) {
            System.out.println("Processing your password, please wait...");
            return "Password is Correct";
        } else {
            System.out.println("Incorrect Password");
            return "Please check your Password again";
        }
    }
}

public class EmployeeEP {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        EPF e1 = new EPF();

        System.out.println("Please Enter your Employee PF-EID:");
        long eid = sc.nextLong();
        e1.setEidPF(eid);
        System.out.println(e1.getEidPF());

        System.out.println("Please Enter your Password:");
        String pwd = sc.next();
        e1.setPwd(pwd);
        System.out.println(e1.getPwd());
    }
}

Output

When this program is executed, it will prompt the user for their Employee PF-EID and password, and return appropriate messages based on the inputs.

Types of Encapsulation

1. Fully Encapsulated Class: All data members are private, and access is controlled through getter and setter methods.

class A {
    private int i;
    private float f;
    private String s;
    // Getter and Setter methods
}

2. Partially Encapsulated Class: At least one data member is public, allowing direct access.

class A {
    private String name;
    public int age; // Direct access allowed
}

3. No Encapsulated Class: All data members are public, allowing direct access without any control.

class A {
    public String name;
    public int age;
}

Advantages of Encapsulation

- Data Security: Protects the integrity of the data by restricting access.

- Control Over Data: You can enforce validation rules in setter methods.

- Flexibility: You can change the internal implementation without affecting external code.

- Read-Only or Write-Only: You can create classes that allow only reading (getters) or writing (setters).

Disadvantages of Encapsulation

- Increased Code Length: Requires more boilerplate code due to the need for getters and setters.

Performance Overhead: Potentially slight overhead due to method calls, though usually negligible.

Object Casting in Java

Object casting is the process of converting one type of object into another. In Java, this involves working with class hierarchies where classes can inherit from one another. There are two primary types of object casting: upcasting and downcasting

1. Upcasting

Definition: Upcasting refers to converting a subclass object to a superclass reference type. Essentially, you create an object of a subclass and store it in a reference variable of the superclass type.

Characteristics:

- Only the superclass’s methods are directly visible when upcasting.

- Subclass behavior is hidden (not accessible directly).

- Upcasting is implicit, meaning it does not require an explicit cast.

Example:

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

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

public class UpcastingExample {
    public static void main(String[] args) {
        Animal animal = new Dog(); // Upcasting
        animal.sound(); // Outputs: Dog barks
    }
}

Note: Even though the reference type is `Animal`, the actual object type is `Dog`. Therefore, the `Dog` class’s overridden `sound` method is execute

2. Downcasting

Definition: Downcasting is the process of converting a superclass reference back to a subclass reference. This allows access to the subclass-specific methods and properties.

Characteristics:

- Both superclass and subclass methods are accessible after downcasting.

- Downcasting is explicit, meaning you need to explicitly cast the reference.

Example:

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

class Dog extends Animal {
    void sound() {
        System.out.println("Dog barks");
    }
    
    void fetch() {
        System.out.println("Dog fetches the ball");
    }
}

public class DowncastingExample {
    public static void main(String[] args) {
        Animal animal = new Dog(); // Upcasting
        animal.sound(); // Outputs: Dog barks
        
        Dog dog = (Dog) animal; // Downcasting
        dog.fetch(); // Outputs: Dog fetches the ball
    }
}

Note: The downcast is done using `(Dog) animal`. This allows you to access `Dog`-specific methods.

Important:

- If you try to downcast an object that is not an instance of the subclass, a `ClassCastException` will occur.

Type Casting in Java

In addition to object casting, Java supports type casting for primitive data types. This is divided into two types: widening and narrowing.

1. Widening (Implicit Casting)

Definition: Converting a smaller primitive data type to a larger one.

Types:

- `byte` → `short` → `int` → `long` → `float` → `double`

Characteristics:

- No loss of data.

- Automatic conversion by the compiler.

Example:

byte byteValue = 10;
int intValue = byteValue; // Widening
System.out.println(intValue); // Outputs: 10

2. Narrowing (Explicit Casting)

Definition: Converting a larger primitive data type to a smaller one.

Types:

- `double` → `float` → `long` → `int` → `short` → `byte`

Characteristics:

- Possible loss of data.

- Requires explicit casting by the programmer.

Example:

double doubleValue = 9.78;
int intValue = (int) doubleValue; // Narrowing
System.out.println(intValue); // Outputs: 9

Abstraction in Java

Abstraction is one of the core principles of Object-Oriented Programming (OOP) that focuses on hiding the complex implementation details while exposing only the necessary features to the user. This helps simplify the interaction with the software and enhances usability.

Key Points:

- Hiding Implementation: The internal workings of a method or a class are hidden from the user, who only needs to know how to interact with it.

- Simplification: By exposing only essential features, abstraction makes systems easier to use and understand.

Everyday Examples:

1. Email: When sending an email, the user interacts with a “send” button. The underlying process of how the email is sent (through servers, protocols, etc.) is hidden from the user.

2. Remote Controls: When using a remote for a TV or an AC, users operate it through buttons, without knowing the complex electronics and programming involved.

3. Driving a Car: A driver knows how to accelerate or brake, but they don’t need to understand the intricate mechanics of the car’s engine or braking system.

Achieving Abstraction in Java

In Java, abstraction can be achieved in two main ways:

1. Abstract Classes

2. Interfaces

An abstract class is a blueprint for other classes, allowing shared methods and properties to be defined in a way that provides a foundation for more specific classes. Let’s delve into the core concepts with an emphasis on the rules, usage, and structure of abstract classes and methods.

What is an Abstract Class?

An abstract class is a class that contains at least one abstract method, making it incomplete by nature. The keyword `abstract` signals this incompleteness and indicates that subclasses must provide the specific implementations for any abstract methods within the class.

Abstract Method vs. Concrete Method

1. Abstract (Incomplete) Method:

- This is a method declared with only its signature (the method name and parameters) but without a body or implementation.

- It must be marked with the `abstract` keyword, and it should end with a semicolon (`;`).

- Example:

abstract public void run();

2. Concrete (Complete) Method:

- This type of method includes both the method signature and the method body, containing actual logic.

- Example:

public void fly() {
  System.out.println("Fly away");
}

Rules for Abstract Classes and Methods

1. Instantiation:

- We cannot create an instance of an abstract class directly because it contains incomplete methods without bodies.

- Example:

abstract class Vehicle {
    abstract public void noOfWheels();
}
// Vehicle v1 = new Vehicle(); // This would cause a compile-time error.

2. Inheritance:

- A subclass can extend an abstract class and must provide implementations for all abstract methods.

- If a subclass does not implement all abstract methods, it must also be declared as abstract.

- This rule provides two approaches:

1. Implement all abstract methods in the subclass.

2. Declare the subclass as abstract and leave further implementation to subsequent subclasses.

3. Constructors:

- An abstract class can contain constructors, allowing initialization of instance variables, even though it cannot be instantiated directly.

- Example:

abstract class Student {
    String name;
    int id;
    
    public Student(String name, int id) {
        this.name = name;
        this.id = id;
    }
    
    abstract public void details();
}

4. Static, Non-static, and Final Members:

- An abstract class can include static, non-static, and final variables, allowing shared constants or values that subclasses can access without instantiation.

5. Absence of Abstract Methods:

- It’s possible for an abstract class not to have any abstract methods. This is often done if the class serves only as a superclass (like a blueprint), with only static methods or for providing shared functionality.

Restrictions with Abstract Classes

1. Final Keyword:

- An abstract class cannot be marked as `final` because final classes cannot be inherited, which conflicts with the purpose of an abstract class.

2. Static Abstract Methods:

- Abstract methods cannot be static because they are meant to be overridden in subclasses, while static methods belong to the class itself, not to instances.

3. Multiple Inheritance:

- Java does not support multiple inheritance for classes, including abstract classes, so a class cannot extend more than one abstract class.

Example Implementations

Example Using Rule 1 (Complete All Abstract Methods)

abstract class Vehicle {
    abstract public void price();
    abstract public void noOfWheels();
}

class RoyalEnfield extends Vehicle {
    @Override
    public void price() {
        System.out.println("1.6 Lakhs");
    }
    
    @Override
    public void noOfWheels() {
        System.out.println("Two wheels");
    }
    
    public static void main(String[] args) {
        RoyalEnfield r = new RoyalEnfield();
        r.noOfWheels();
        r.price();
    }
}

Example Using Rule 2 (Declare Subclass as Abstract)

abstract class Vehicle {
    abstract public void price();
    abstract public void noOfWheels();
    abstract public void model();
}

abstract class RoyalEnfield extends Vehicle {
    @Override
    public void price() {
        System.out.println("1.6 Lakhs");
    }
    
    @Override
    public void noOfWheels() {
        System.out.println("Two wheels");
    }
}

class EnfieldModel extends RoyalEnfield {
    @Override
    public void model() {
        System.out.println("Classic 350");
        System.out.println("Interceptor 650");
    }
    
    public static void main(String[] args) {
        EnfieldModel r = new EnfieldModel();
        r.noOfWheels();
        r.price();
        r.model();
    }
}

Key Points on Abstract Classes

- Partial Abstraction: Since abstract classes can contain both concrete and abstract methods, they offer partial abstraction (0–100% abstraction).

- Interfaces for Full Abstraction: To achieve full (100%) abstraction, interfaces are preferred over abstract classes because they only declare methods without implementing them.

FAQ on Abstract Classes

1. Can we declare an abstract class without abstract methods?

Yes, an abstract class may not contain any abstract methods. It’s typically done if we don’t want instances of the class, or we want a base class for other classes.

2. Can we declare an abstract class as final?

No, because making a class `final` prevents it from being subclassed, which contradicts the purpose of an abstract class (which is to be extended).

3. Can an abstract method be declared as final?

No, because `final` methods cannot be overridden, but abstract methods must be overridden in subclasses.

4. Can an abstract method be declared as static?

No, because static methods belong to the class, not instances, and abstract methods are meant to be overridden.

5. Can we achieve multiple inheritance with abstract classes?

No, Java does not support multiple inheritance with classes, abstract or otherwise. However, multiple inheritance can be achieved through interfaces.

Key Points to remember:

- Abstract classes are used to provide a template for other classes.

- You cannot create an instance of an abstract class.

- Subclasses of an abstract class must override its abstract methods or be declared as abstract themselves.

- Abstract classes can have both abstract methods and concrete methods.

- Illegal Combinations:
— You cannot use the combinations “static abstract”, “final abstract”, or “private abstract”.
— Static methods belong to the class rather than instances, while abstract methods are meant to be implemented by subclasses, creating a contradiction.
— Final methods cannot be overridden, which conflicts with the purpose of an abstract method, and private abstract methods can’t be accessed in subclasses.

2. Method Availability:
— When calling a method on a superclass reference that points to a subclass object, the method signature must be defined in the superclass.
— If the method is not present in the superclass, you will receive an error when trying to call it.

3. Constructors in Abstract Classes:
— You cannot instantiate an abstract class directly, which means you can’t create objects of that class.
— However, when you create an object of a subclass that extends the abstract class, the constructor of the abstract class is still invoked.
— If the subclass does not define a constructor, the Java compiler automatically inserts a default constructor and a call to the superclass constructor (using super()).
— This ensures that any initialization logic in the abstract class’s constructor is executed when creating the subclass object.

Thus,

- Abstract Class: Cannot be instantiated directly, but its constructor is called when a subclass object is created.
- Method Signature Requirement: Any method called through a superclass reference must exist in the superclass.
- Constructor Behavior: Subclass constructors implicitly call the superclass constructor unless specified otherwise, ensuring proper initialization of inherited properties.

Conclusion

Abstract classes in Java allow for partial abstraction, meaning we can have both abstract and concrete methods within the same class, which leads to 0 to 100% abstraction. To achieve 100% abstraction, where all methods are abstract, interfaces should be used instead of abstract classes.

Interface in Java

An interface in Java is a blueprint of a class that can contain static constants and abstract methods. It is a way to define a contract for what methods a class must implement, without specifying the implementation itself. Let’s discuss its features, characteristics, and how it is used in Java.

Key Characteristics of Interfaces

1. Declaration: Interfaces are declared using the interface keyword.

interface I1 { }

2. Compilation: Like classes, interfaces get compiled into .class files.

3. Variables in Interfaces: All variables in an interface are implicitly public, static, and final.

4. Methods in Interfaces: All methods in an interface are implicitly public and abstract unless explicitly defined as default or static (from Java 8 onwards).

Example of Variables in Interfaces

interface I1 {
    int a = 10; // Equivalent to public static final int a = 10;
}
class JTC {
    public static void main(String[] args) {
        System.out.println(I1.a); // Accessing the static variable
        // I1.a = 1000; // Error: cannot assign a value to a final variable
    }
}

Explanation: The variable a in interface I1 is treated as public static final. Hence, it is a constant, and its value cannot be changed.

Methods in Interfaces

All methods in an interface are abstract by default. You cannot provide a body for these methods directly in the interface.

interface I1 {
  void m2(); // Equivalent to public abstract void m2();
}

If you try to provide a method body in the interface, it will cause a compilation error because methods in interfaces are abstract by default.

Implementing an Interface

To use the methods of an interface, you need to create a class that implements the interface. The implements keyword is used for this purpose.

interface I1 {
    int m1();
    void m2();
}
abstract class A implements I1 {
    public int m1() {
        System.out.println("m1 in A class");
        return 10;
    }
}
class B extends A {
    public void m2() {
        System.out.println("m2 in A class");
    }
}
class JTC {
    public static void main(String[] args) {
        I1 i1 = new B();
        int a = i1.m1();
        i1.m2();
        System.out.println("a :- " + a);
    }
}

Output:

m1 in A class
m2 in A class
a :- 10

Explanation:

- Class A implements the I1 interface but does not implement all its methods, so it is declared as abstract.

- Class B extends A and provides the implementation for the remaining method, making it a concrete class.

Multiple Inheritance with Interfaces

Interfaces allow Java to support multiple inheritance. A class can implement multiple interfaces, gaining the ability to inherit behavior from more than one interface.

interface I1 {
    int a = 10;
}
interface I2 {
    int b = 20;
}
interface I3 {
    int c = 30;
}
class A implements I1, I2, I3 {
    void m1() {
        System.out.println("m1 in A class");
        System.out.println("a :- " + a);
        System.out.println("b :- " + b);
        System.out.println("c :- " + c);
    }
}
class JTC {
    public static void main(String[] args) {
        A a1 = new A();
        a1.m1();
    }
}

Output:

m1 in A class
    a :- 10
    b :- 20
    c :- 30

Explanation: Class A implements multiple interfaces, accessing variables from all the interfaces without any ambiguity.

Handling Ambiguity in Multiple Interfaces

If multiple interfaces have variables with the same name, you can resolve the ambiguity by specifying the interface name.

interface I1 {
    int a = 10;
}
interface I2 {
    int a = 20;
}
interface I3 {
    int a = 30;
}
class A implements I1, I2, I3 {
    void m1() {
        System.out.println("m1 in A class");
        System.out.println("I1.a :- " + I1.a);
        System.out.println("I2.a :- " + I2.a);
        System.out.println("I3.a :- " + I3.a);
    }
}
class JTC {
    public static void main(String[] args) {
        A a1 = new A();
        a1.m1();
    }
}

Explanation: By using the interface names I1.a, I2.a, and I3.a, we can differentiate between the variables with the same name.

Inheritance of Interfaces

An interface can inherit other interfaces using the extends keyword.

interface I1 {
    int a = 10;
}
interface I2 {
    int b = 20;
}
interface I3 extends I1, I2 {
    int c = 30;
}
class A implements I3 {
    void m1() {
        System.out.println("m1 in A class");
        System.out.println("a :- " + a);
        System.out.println("b :- " + b);
        System.out.println("c :- " + c);
    }
}
class JTC {
    public static void main(String[] args) {
        A a1 = new A();
        a1.m1();
    }
}

Explanation: Interface I3 extends interfaces I1 and I2, so when class A implements I3, it inherits all the members of I1 and I2.

Conflict Resolution in Interfaces

In Java, if a class implements multiple interfaces that contain methods with the same signature, there could be a conflict. Java handles this through explicit rules that guide how to resolve these conflicts.

Scenario 1: Multiple Interfaces with the Same Method Signature

If a class implements multiple interfaces that define the same method, there’s no conflict if the method does not have a default implementation in either interface. The implementing class only needs to provide a single implementation.

interface A {
    void show();
}

interface B {
    void show();
}

class C implements A, B {
    public void show() {
        System.out.println("Show method implemented in class C");
    }
}

In this case, class `C` provides a single implementation for the `show()` method, fulfilling the contract of both interfaces `A` and `B`.

Scenario 2: Multiple Default Methods with the Same Signature

If a class implements multiple interfaces with a default method of the same name and parameters, Java will throw a compilation error due to ambiguity. The implementing class must override the method and provide its own implementation to resolve the conflict.

interface A {
    default void display() {
        System.out.println("Display from A");
    }
}

interface B {
    default void display() {
        System.out.println("Display from B");
    }
}

class C implements A, B {
    // Resolving conflict by overriding
    @Override
    public void display() {
        System.out.println("Display resolved in class C");
    }
}

In this example, class `C` must override the `display()` method to resolve the conflict between `A` and `B`. If it doesn’t, a compilation error will occur.

Scenario 3: Calling a Specific Interface’s Default Method

In cases where you want to specifically call a default method from one of the interfaces, you can use the following syntax within the overriding method:

class C implements A, B {
    @Override
    public void display() {
        A.super.display();  // Calls display() from interface A
    }
}

Here, `A.super.display()` explicitly calls the `display()` method from interface `A`, providing a way to choose which default method to invoke.

Conflict Resolution Summary

1. Same Method Signature: If the interfaces have the same method signature without default implementations, there’s no conflict, and the class must implement the method.

2. Same Default Methods: If the interfaces have default methods with the same signature, the class must override the method to resolve ambiguity.

3. Choosing a Specific Interface’s Default Method: Use `InterfaceName.super.methodName()` to invoke a specific interface’s default method within the overriding method.

These rules help ensure that Java avoids ambiguity while allowing flexibility in using multiple interfaces.

Default and Static Methods in Interfaces (Java 8+)

From Java 8 onwards, interfaces can have methods with implementations using the default and static keywords.

interface I1 {
    default void m1() {
        System.out.println("m1 in I1 interface");
    }
    
    static int m2() {
        System.out.println("m2 in I1 interface");
        return 10;
    }
}
class A implements I1 { }
class JTC {
    public static void main(String[] args) {
        A a1 = new A();
        a1.m1(); // Calls the default method in the interface
        int i = I1.m2(); // Calls the static method in the interface
        System.out.println("i :- " + i);
    }
}

Explanation:

- Default Methods: Allow you to add new methods to interfaces without breaking the existing code.

- Static Methods: Can be called directly using the interface name and are not inherited by implementing classes.

Key Points

- Interface variables are public static final by default.

- Interface methods are public abstract by default (unless declared as default or static).

- A class uses the implements keyword to inherit an interface.

- Interfaces support multiple inheritance.

- Default and static methods in interfaces were introduced in Java 8.

Interfaces provide a way to achieve abstraction and multiple inheritance, making them an essential tool for designing flexible and maintainable code in Java.

Types of interfaces in Java:

1. Marker Interface

A Marker Interface is an interface without any methods or fields. It acts as a “marker” or “tag” to provide some metadata about the class implementing it. Marker interfaces are used to indicate that a class has a certain property or behavior. Java’s standard library includes a few well-known marker interfaces:

- Serializable: Marks a class as capable of being serialized, meaning its state can be converted into a byte stream and saved to a file or sent over a network.

- Cloneable: Marks a class as being capable of cloning, allowing `Object.clone()` to be called on it without throwing a `CloneNotSupportedException`.

- Remote: Marks a class as capable of being accessed remotely in Java RMI (Remote Method Invocation).

Example:

public interface MarkerInterface {} // No methods or fields

2. Functional Interface

A Functional Interface has exactly one abstract method, making it a target for lambda expressions in Java. This is particularly useful in functional programming paradigms introduced with Java 8. Functional interfaces can have multiple default or static methods, but only one abstract method is allowed.

The `@FunctionalInterface` annotation is used to indicate that an interface is a functional interface, helping prevent accidental addition of other abstract methods.

- Runnable: Contains the `run()` method, commonly used in multithreading.

- Comparable: Contains the `compareTo()` method for sorting objects.

- Predicate: Contains the `test()` method, often used in streams for filtering elements.

Example:

@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);  // Single abstract method

    default void print(String message) {
        System.out.println(message);
    }
}

3. SAM (Single Abstract Method) Interface

SAM interfaces are another name for Functional Interfaces, meaning they have one single abstract method (SAM). Any interface with one abstract method can be treated as a SAM interface and used as a target for lambda expressions.

- ActionListener in Swing: Contains a single method, `actionPerformed(ActionEvent e)`.

Example:

@FunctionalInterface
interface Operation {
    void perform();
}

4. Tagging or Metadata Interface

The Tagging Interface is synonymous with the Marker Interface, as it doesn’t contain any methods or fields. Its purpose is to mark or tag a class with a certain property, allowing classes to be handled differently in certain contexts. For example, `Serializable` is both a Marker and Tagging Interface.

5. Normal Interface

A Normal Interface (or Pure Interface) is any standard interface in Java that contains multiple abstract methods. These interfaces are designed to define a set of related operations that implementing classes must provide.

Example:

public interface Animal {
    void eat();
    void sleep();
    void makeSound();
}

6. Abstract Interface

Technically, Abstract Interface isn’t a formal term in Java, but some developers refer to interfaces that use `default` and `static` methods as “abstract interfaces.” These types of interfaces provide a combination of abstract methods and implementations within default or static methods.

Example:

public interface Vehicle {
    void drive();

    default void startEngine() {
        System.out.println("Engine started");
    }

    static void honk() {
        System.out.println("Honk honk!");
    }
}

Summary

Each type of interface serves a different purpose:

- Marker/Tagging Interface: No methods, adds metadata to classes.

- Functional Interface (SAM Interface): Single abstract method, enables lambda expressions.

- Normal Interface: Multiple abstract methods, for defining complete behaviors.

- Abstract Interface: Combination of abstract methods and default/static methods, allowing partial implementation.

This variety helps Java provide flexibility, enabling both object-oriented and functional programming styles.

Can We Extend a Class and Implement an Interface at the Same Time?
Yes, in Java, a class can extend a superclass and implement one or more interfaces at the same time. This allows for a combination of inheritance from a class and adherence to a contract defined by interfaces. However, a class can only extend one superclass due to Java’s single inheritance model.

Difference Between extends and implements

Inner classes in Java

Inner classes in Java are classes defined within another class or within a method, which allows for logically grouping code to make it more readable and maintainable. They also provide more control over class visibility and help in creating more sophisticated data structures or objects. Let’s go through the key types of inner classes and their characteristics in detail:

Types of Inner Classes in Java:

1. Non-Static Inner Class (Instance Inner Class)

2. Static Inner Class

3. Method Local Inner Class

4. Anonymous Inner Class

1. Non-Static Inner Class (Instance Inner Class)

- Definition: An inner class that does not have the static modifier.

- Characteristics:

- It is an instance member of the outer class, meaning it needs an instance of the outer class to be created.

- It can access all the members (both static and non-static) of the outer class.

- Cannot be accessed directly; requires an object of the outer class.

Example:

class OuterClass {
    int outerField = 10;
    class InnerClass {
        void display() {
            System.out.println("Outer Field: " + outerField);
        }
    }
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.display();
    }
}

Output:

Outer Field: 10

2. Static Inner Class

- Definition: An inner class that has the static modifier.

- Characteristics:

- Does not require an instance of the outer class to be instantiated.

- Can only access static members of the outer class.

- Acts as a regular top-level class except for being nested within another class.

Example:

class OuterClass {
    static int staticOuterField = 20;
    static class StaticInnerClass {
        void display() {
            System.out.println("Static Outer Field: " + staticOuterField);
        }
    }
    public static void main(String[] args) {
        OuterClass.StaticInnerClass staticInner = new OuterClass.StaticInnerClass();
        staticInner.display();
    }
}

Output:

Static Outer Field: 20

3. Method Local Inner Class

- Definition: A class defined within a method or a block of code.

- Characteristics:

- Can only be accessed within the method or block where it is defined.

- Can access local variables of the enclosing method only if they are declared as final or effectively final.

- Primarily used for scenarios where you need to perform a specific function that’s local to a method.

Example:

class OuterClass {
    void outerMethod() {
        int localVariable = 30;
        class LocalInnerClass {
            void display() {
                System.out.println("Local Variable: " + localVariable);
            }
        }
        LocalInnerClass localInner = new LocalInnerClass();
        localInner.display();
    }
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.outerMethod();
    }
}

Output:

Local Variable: 30

4. Anonymous Inner Class

- Definition: An inner class that does not have a name.

- Characteristics:

- Declared and instantiated all in one statement.

- Usually used when extending a class or implementing an interface with only one method.

- Often used for providing specific implementations to listeners or callbacks.

Example:

abstract class Animal {
    abstract void sound();
}
public class Main {
    public static void main(String[] args) {
        Animal dog = new Animal() { // Anonymous inner class
            void sound() {
                System.out.println("Woof Woof");
            }
        };
        dog.sound();
    }
}

Output:

Woof Woof

Benefits of Using Inner Classes

1. Encapsulation: Inner classes can group related classes together, leading to better data encapsulation.

2. Code Organization: They help in logically organizing code that is only relevant in the context of the outer class.

3. Enhanced Readability: By grouping related code, inner classes can improve the readability and maintainability of code.

When to Use Inner Classes

- Instance Inner Classes: Use when the inner class requires access to the instance variables or methods of the outer class.

- Static Inner Classes: Use when the inner class does not need access to the outer class’s instance variables or methods.

- Method Local Inner Classes: Use for scenarios that require a class only within a single method.

- Anonymous Inner Classes: Use for implementing interfaces or abstract classes on the fly, especially for callbacks or event handling.

Inner classes are a powerful tool in Java that help in structuring code more elegantly and ensuring modular design. They can make your code more intuitive by linking closely related classes together.

Important Points to remember

1. How many `.class` files will be created if a class contains an inner class?

When a Java class contains an inner class, each inner class generates its own separate `.class` file upon compilation. For example, if you have an outer class `OuterClass` with an inner class `InnerClass`, the following `.class` files will be created:

- `OuterClass.class` (for the outer class)

- `OuterClass$InnerClass.class` (for the inner class)

This naming convention is used to represent the relationship between the outer class and the inner class.

2. Can we write an inner class inside another inner class?

Yes, you can write an inner class inside another inner class. This is known as a nested inner class or multi-level inner class. There is no limit to how deeply you can nest inner classes. Here’s an example:

class OuterClass {
    class InnerClass1 {
        class InnerClass2 {
            void display() {
                System.out.println("Inside InnerClass2");
            }
        }
    }
}

In this example, `InnerClass2` is nested within `InnerClass1`, which is nested within `OuterClass`.

3. Can we write a class within any interface?

Yes, you can declare a class inside an interface in Java. This is completely valid. By default, the class inside an interface is implicitly `public` and `static`. Here’s an example:

interface MyInterface {
    class InnerClass {
        void display() {
            System.out.println("InnerClass inside Interface");
        }
    }
}

You can access this inner class without needing an instance of the interface since it is `static` by default:

MyInterface.InnerClass obj = new MyInterface.InnerClass();
obj.display();

4. Can we declare an inner class as private?

Yes, you can declare an inner class as `private`. When you do so, it can only be accessed within the outer class in which it is defined. For example:

class OuterClass {
    private class InnerClass {
        void display() {
            System.out.println("This is a private inner class");
        }
    }

    void show() {
        InnerClass inner = new InnerClass();
        inner.display();
    }
}

In this case, `InnerClass` is private and can only be accessed from within `OuterClass`.

5. Can we declare an outer class as static?

No, you cannot declare an outer class as `static` in Java. Only nested (inner) classes can be declared as `static`. Declaring an outer class as static would not make sense because static is related to members and their association with the instance of a class.

6. Where exactly is memory allocated for instance and static variables of static inner classes?

- Instance Variables: Memory for instance variables of a static inner class is allocated when you create an object of that static inner class.

- Static Variables: Memory for static variables of a static inner class is allocated when the outer class is loaded into memory, similar to how static members of regular classes are handled.

7. Is the `Object` class the superclass of all inner classes too?

Yes, the `Object` class is the superclass of all classes in Java, including inner classes. Every class in Java (whether it’s an inner class, nested class, or top-level class) implicitly extends the `Object` class unless it explicitly extends another class.

8. Between an interface and an abstract class, which one should be chosen?

The choice between using an interface and an abstract class depends on the design requirements:

- Use an Interface if:

- You need to define a contract for unrelated classes to implement.

- Multiple inheritance is required (as a class can implement multiple interfaces).

- All methods in the contract are abstract by default (with Java 8, you can also have default and static methods in interfaces).

- Use an Abstract Class if:

- You want to share code among closely related classes.

- You have a class hierarchy where you need to define common methods and allow subclasses to provide specific implementations.

- You need to maintain state (i.e., have instance variables) or use constructors.

9. What is an Adapter class?

An Adapter class in Java is a design pattern that provides a default implementation of an interface, allowing you to create subclasses without needing to implement all methods in that interface. It acts as a bridge between an interface and a concrete class, simplifying the process of handling interfaces with many methods.

Key Features of an Adapter Class

1. Partial Implementation: An adapter class provides empty or default implementations for all the methods of an interface. You can extend the adapter class and override only the methods you are interested in.

2. Convenience: It allows you to avoid writing boilerplate code for methods you do not need, making your code cleaner and easier to manage.

3. Usage with Listener Interfaces: Adapter classes are commonly used with listener interfaces in Java’s event-handling system. Many interfaces, like `MouseListener` or `KeyListener`, have multiple methods, even if you only need one or two of them.

Example: MouseListener Interface with an Adapter Class

Suppose you want to handle mouse events in a Java GUI application. The `MouseListener` interface has five methods:

- `mouseClicked()`

- `mousePressed()`

- `mouseReleased()`

- `mouseEntered()`

- `mouseExited()`

If you implement `MouseListener` directly, you must provide implementations for all five methods, even if you only need one of them. This is where an adapter class, `MouseAdapter`, becomes useful.

Example Without Adapter Class

import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

public class MyMouseListener implements MouseListener {
    @Override
    public void mouseClicked(MouseEvent e) {
        System.out.println("Mouse clicked");
    }

    @Override
    public void mousePressed(MouseEvent e) {}

    @Override
    public void mouseReleased(MouseEvent e) {}

    @Override
    public void mouseEntered(MouseEvent e) {}

    @Override
    public void mouseExited(MouseEvent e) {}
}

In this example, you had to provide empty implementations for all the other methods, even if you didn’t need them.

Example With Adapter Class

Using the `MouseAdapter` class simplifies the code:

import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

public class MyMouseListener extends MouseAdapter {
    @Override
    public void mouseClicked(MouseEvent e) {
        System.out.println("Mouse clicked");
    }
}

Explanation: By extending the `MouseAdapter` class, you only need to override the method you’re interested in (`mouseClicked()`), and you don’t have to provide implementations for the other methods.

Commonly Used Adapter Classes in Java

Java provides several adapter classes that correspond to specific listener interfaces, such as:

- `MouseAdapter` for the `MouseListener` and `MouseMotionListener` interfaces

- `KeyAdapter` for the `KeyListener` interface

- `WindowAdapter` for the `WindowListener` interface

- `FocusAdapter` for the `FocusListener` interface

These adapter classes provide default (empty) implementations of all methods in their respective listener interfaces.

Advantages of Using Adapter Classes

1. Code Simplification: You don’t have to implement all the methods of an interface, only those that are relevant to your use case.

2. Readability: Adapter classes make the code cleaner and more readable by reducing unnecessary code.

3. Flexibility: It makes it easier to create custom event handling by overriding only the specific methods you need.

When to Use Adapter Classes

- Use adapter classes when working with interfaces that have multiple methods, but you only need to implement a few of them.

- It is especially useful when working with Java’s event-handling framework.

Important Note

Adapter classes are primarily used when implementing listener interfaces. If an interface has only one or two methods, using an adapter class might not be necessary. In that case, implementing the interface directly is often more straightforward.

Example Scenario: Using `WindowAdapter`

Here’s an example using `WindowAdapter` to handle window closing in a GUI application:

import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.swing.JFrame;

public class MyFrame extends JFrame {
    public MyFrame() {
        setTitle("Adapter Class Example");
        setSize(300, 200);
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.out.println("Window is closing");
                System.exit(0);
            }
        });
    }

    public static void main(String[] args) {
        MyFrame frame = new MyFrame();
        frame.setVisible(true);
    }
}

Explanation: Here, we only handle the `windowClosing()` method using the `WindowAdapter` class, ignoring the rest of the methods of the `WindowListener` interface.

Summary

- An adapter class provides a default implementation of an interface’s methods, allowing you to extend it and override only the methods you need.

- It is useful when you only want to handle specific events in Java’s event-handling system without implementing all methods of the interface.

- Adapter classes reduce boilerplate code, making the code cleaner and more maintainable.Java Packages

In Java, a package is a mechanism used to group related classes, interfaces, and sub-packages together. It helps organize code, manage large projects, and avoid naming conflicts. Let’s go through the different aspects of packages in Java.

Key Points About Packages

1. What is a Package?

- A package in Java is essentially a folder that organizes a set of related classes, interfaces, or sub-packages.

- When you compile a Java program, packages are created automatically in the folder structure corresponding to the package’s name.

2. Purpose of Packages

- Packages help to avoid naming conflicts by grouping related classes together.

- They make the code easier to find, use, and maintain.

- They provide access protection, restricting certain classes to be accessed only within the package.

3. Default Package

- If you don’t explicitly define a package in your Java program, all classes will belong to the default package (usually the current working directory).

- The classes that are part of the default package do not require an explicit import when accessed by other classes in the same directory.

Example Without a Package

Here’s an example of Java code that does not use a package:

class LMS {
    public static void main(String[] args) {
        Hello h1 = new Hello();
        Hai hai = new Hai();
        h1.m1();
        hai.show();
    }
}

class Hello {
    void m1() {
        System.out.println("m1 in Hello");
    }
}

class Hai {
    void show() {
        System.out.println("show in Hai");
    }
}

Output:

m1 in Hello
show in Hai

- After compiling this code, you’ll get three `.class` files: `LMS.class`, `Hello.class`, and `Hai.class`.

- Since we have not specified any package, these `.class` files will be located in the current working directory.

Creating Your Own Package

You can create your own package in Java using the following syntax:

package com.P1.P2;

The package declaration must be the first line in the source file.

Compilation with Package

When using packages, you must compile your Java code with the `-d` flag to specify the directory structure:

- Example: `javac -d . Test.java`

- The `-d` flag instructs the compiler to create the necessary directories to match the package structure in the current directory.

- Example: `javac -d d:\ Test.java`

- This command creates the directory structure on the specified drive (`D:` in this case).

Running the Program with Package

To run a Java program that uses a package, you must specify the fully qualified name of the class:

- Example: `java com.P1.P2.LMS`

This ensures that Java can locate the class file in the correct package.

Example With a Package

Here’s an example where we create a package named `com.P1.P2`:

package com.P1.P2;

class JTC {
    public static void main(String[] args) {
        Hello h1 = new Hello();
        Hai hai = new Hai();
        h1.m1();
        hai.show();
    }
}

class Hello {
    void m1() {
        System.out.println("m1 in Hello");
    }
}

class Hai {
    void show() {
        System.out.println("show in Hai");
    }
}

Output:

m1 in Hello
show in Hai

- After compiling, a directory structure will be created as `com -> P1 -> P2`, where all `.class` files (`LMS.class`, `Hello.class`, and `Hai.class`) will be stored in the `P2` folder.

Accessing Classes from Another Package

Java enforces rules to access classes from different packages to ensure encapsulation. If you need to access a class from another package, you must use either the fully qualified name or the import statement.

Using Fully Qualified Names

package com.P2;

public class JTC {
    public static void main(String[] args) {
        com.P1.A a1 = new com.P1.A(); // Using the fully qualified name
        a1.m1();
    }
}

Using the import Statement

package com.P2;

import com.P1.A; // Importing class A from the com.P1 package

public class JTC {
    public static void main(String[] args) {
        A a1 = new A();
        a1.m1();
    }
}

This approach is more readable because you don’t have to type the full package name each time.

Importing an Entire Package

You can also import all classes in a package using the following syntax:

import com.P1.*; // Imports all classes in the com.P1 package

This way, you can use all classes (`A`, `B`, `C`, etc.) in the `com.P1` package without explicitly importing each one.

Static Import in Java

Static import allows you to import static members of a class directly so you can use them without the class name.

Example

package com.P2;

import static com.P1.A.a; // Importing static variable 'a'
import static com.P1.A.m1; // Importing static method 'm1'

public class JTC {
    public static void main(String[] args) {
        System.out.println("a :- " + a); // Using static variable 'a' directly
        m1(); // Calling static method 'm1' directly
    }
}

Summary of Key Points

1. Packages group related classes and help avoid naming conflicts.

2. Use the `-d` flag during compilation to create the package directory structure.

3. To access classes from another package, you must use the fully qualified name or the `import` statement.

4. You can import static members using the `static import` statement.

5. The package declaration must always be the first statement in a Java source file.

Packages are crucial for organizing code in Java, especially in large-scale applications, making them more modular and easier to maintain.

Access Modifiers in Java

Access modifiers in Java are keywords used to define the accessibility or visibility of variables, methods, constructors, and classes. They help manage access control and set the level of access for different parts of a program. In Java, there are four main access modifiers:

1. Public

2. Protected

3. Default (no keyword)

4. Private

Let’s go through each in detail.

1. Public Access Modifier

- Keyword: `public`

- Description: When a member (variable, method, or class) is declared as `public`, it is accessible from any other class, whether in the same package or in a different package.

- Scope:

- Same class: Yes

- Different class in the same package: Yes

- Different class in different package: Yes (through inheritance or directly)

- Outside the package: Yes

- Access Privilege: It has the highest access privilege among all modifiers.

Example:

package com.P1;

public class A {
    public int a = 10;

    public void display() {
        System.out.println("Public member accessed");
    }
}

2. Protected Access Modifier

- Keyword: `protected`

- Description: Members declared with `protected` are accessible in the same package and can also be accessed in subclasses in different packages using inheritance.

- Scope:

- Same class: Yes

- Different class in the same package: Yes

- Different class in different package: Yes (only through inheritance)

- Outside the package: No (unless accessed through inheritance)

- Note: Objects of a class in a different package cannot directly access protected members without inheritance.

Example:

package com.P1;

public class A {
    protected int b = 20;

    protected void show() {
        System.out.println("Protected member accessed");
    }
}

3. Default (No Modifier) Access Modifier

- Keyword: No keyword (`default` is not a keyword)

- Description: When no access modifier is specified, the member is considered to have default access. It is only accessible within the same package.

- Scope:

- Same class: Yes

- Different class in the same package: Yes

- Different class in different package: No

- Outside the package: No

- Note: You cannot explicitly use the `default` keyword.

Example:

package com.P1;

class A {
    int c = 30; // Default access

    void print() {
        System.out.println("Default member accessed");
    }
}

4. Private Access Modifier

- Keyword: `private`

- Description: Private members are only accessible within the class in which they are declared. They are not visible to any other class, even subclasses or classes within the same package.

- Scope:

- Same class: Yes

- Different class in the same package: No

- Different class in different package: No

- Outside the package: No

- Access Privilege: It has the lowest access privilege among all modifiers.

Example:

package com.P1;

public class A {
    private int d = 40; // Private access

    private void secret() {
        System.out.println("Private member accessed");
    }
}

Example Scenarios

To better understand how these access modifiers work in practice, let’s explore some scenarios using the classes defined above.

Example 1: Accessing from the Same Package

package com.P1;

public class B {
    public static void main(String[] args) {
        A a1 = new A();
        System.out.println(a1.a); // Public access
        System.out.println(a1.b); // Protected access
        System.out.println(a1.c); // Default access
        // System.out.println(a1.d); // Error: Private access
    }
}

Output:

10
20
30

Example 2: Accessing from a Different Package Using Object

package com.P2;
import com.P1.A;

public class C {
    public static void main(String[] args) {
        A a1 = new A();
        System.out.println(a1.a); // Public access
        // System.out.println(a1.b); // Error: Protected access
        // System.out.println(a1.c); // Error: Default access
        // System.out.println(a1.d); // Error: Private access
    }
}

Output:

Example 3: Accessing from a Different Package Using Inheritance

package com.P2;
import com.P1.A;

public class D extends A {
    public static void main(String[] args) {
        D d1 = new D();
        System.out.println(d1.a); // Public access
        System.out.println(d1.b); // Protected access
        // System.out.println(d1.c); // Error: Default access
        // System.out.println(d1.d); // Error: Private access
    }
}

Output:

10
20

Summary Table of Access Modifier Visibility

This table summarizes the visibility of each access modifier for different scenarios, helping you decide which one to use based on your needs.

Explain early binding and late binding concept ?

In Java, early binding and late binding are concepts related to method invocation, specifically to when and how the method that should be called is determined by the Java Virtual Machine (JVM). Let’s go into detail about each concept.

1. Early Binding (Static Binding)

- Definition: Early binding, also known as static binding, occurs when the method to be called is determined at compile time. In other words, the method invocation is resolved by the compiler, and the address of the method is linked to the method call before the program runs.

- Use cases: Early binding happens with:

- Static methods

- Private methods

- Final methods

- Methods in the same class without using inheritance

These methods are resolved at compile time because they cannot be overridden.

- Example:

class Animal {
    static void makeSound() {  // Static method
        System.out.println("Some generic animal sound");
    }
}

class Dog extends Animal {
    static void makeSound() {  // Static method, doesn't override
        System.out.println("Bark");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.makeSound();  // Early binding occurs here
    }
}

Output:

Some generic animal sound

Explanation: In this example, even though the object `animal` refers to an instance of `Dog`, the `makeSound()` method from the `Animal` class is called because it’s a static method. The method is resolved at compile time, which is why it’s known as early binding.

- Advantages: Early binding has a performance advantage because the method to be executed is determined during compilation, reducing the overhead at runtime.

2. Late Binding (Dynamic Binding)

- Definition: Late binding, also known as dynamic binding, occurs when the method to be called is determined at runtime based on the object’s type. This happens because the JVM defers the method resolution until the program runs.

- Use cases: Late binding occurs with:

- Instance methods that can be overridden (non-static and non-final)

- Methods that rely on polymorphism

This enables polymorphic behavior, where the appropriate method for the object type is called at runtime.

Example:

class Animal {
    void makeSound() {  // Instance method
        System.out.println("Some generic animal sound");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {  // Overridden method
        System.out.println("Bark");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.makeSound();  // Late binding occurs here
    }
}

- Output:

Bark

Explanation: In this case, `animal` is a reference of type `Animal` but is actually pointing to an instance of `Dog`. At runtime, the JVM looks at the actual object (`Dog`) and calls the `makeSound()` method of the `Dog` class, which is why we get the output `Bark`.

- Advantages: Late binding supports polymorphism, allowing code to be more flexible and extensible. It enables overriding methods, where the method called depends on the object’s runtime type.

Key Differences Between Early Binding and Late Binding

Why Early and Late Binding Matter in Java

- Efficiency: Early binding is faster because method calls are resolved at compile time, which makes the code execute more quickly.

- Flexibility: Late binding provides flexibility and extensibility in the code by allowing polymorphism, where the method that gets called depends on the runtime object.

Real-World Example Scenario

Consider an example of a payment system:

- Early Binding: If you have a `final` method that checks the status of a payment, it cannot be overridden by subclasses. This method is bound at compile time, ensuring that the correct version of the method is always used.

- Late Binding: If you have different types of payments like `CreditCardPayment` and `PaypalPayment` that inherit from a superclass `Payment`, and they override a method `processPayment()`, the method that gets called depends on the type of payment object created at runtime.

When to Use Early Binding and Late Binding

- Use early binding when the method does not need to be overridden, as it improves performance by avoiding runtime method lookups.

- Use late binding when you need polymorphic behavior, and the method should behave differently based on the actual object type.

Understanding the differences between early binding and late binding helps in designing efficient and flexible Java programs that leverage both compile-time and runtime capabilities.

How to create singleton class ?

Creating a singleton class in Java ensures that a class has only one instance and provides a global point of access to it. Here are a few common methods to implement a singleton in Java:

1. Lazy Initialization (Thread-Safe)

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // private constructor to prevent instantiation
    }

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

2. Eager Initialization

public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() {
        // private constructor to prevent instantiation
    }

    public static Singleton getInstance() {
        return instance;
    }
}

3. Thread-Safe Singleton with Double-Checked Locking

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {
        // private constructor to prevent instantiation
    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

4. Enum Singleton

Using an enum is the simplest way to create a singleton in Java. It is inherently thread-safe and prevents serialization issues.

public enum Singleton {
    INSTANCE;

    // Any additional methods can be added here
}

Summary

- Lazy Initialization is useful if the instance is resource-intensive and may not be needed immediately.

- Eager Initialization is simple and safe, but creates the instance at startup.

- Double-Checked Locking provides a balance of lazy initialization and thread safety.

- Enum Singleton is the recommended approach for its simplicity and built-in serialization protection.