PROGRAM:1

Use Java compiler and eclipse platform to write and execute java program.
Here's a step-by-step guide on how to write and execute a Java program using the Eclipse IDE:

1. **Install Eclipse**: If
you haven't already, download and install Eclipse from the official website:
[Link]

2. **Open Eclipse**: After installing, open Eclipse from your desktop or start menu.

3. **Create a New Java Project**:

- Go to "File" > "New" > "Java Project".
- Enter a project name (e.g., "MyJavaProject").
- Click "Finish".

4. **Create a New Java Class**:

- Right-click on the "src" folder within your project.
- Go to "New" > "Class".
- Enter a class name (e.g., "Main") and check the "public static void main(String[] args)" option.
- Click "Finish".

5. **Write Your Java Code**:

- Eclipse should automatically open the newly created class file.
- Write your Java code inside the `main` method.

Example:

public class Main {

public static void main(String[] args) {
[Link]("Hello, world!");
}
}
6. **Save Your Java File**: Make sure to save your Java file (usually Ctrl + S or Command + S on macOS).
7. **Compile and Execute**:
- Eclipse automatically compiles your code in the background.
- To run the program, right-click on your Java file.
- Go to "Run As" > "Java Application".
- Alternatively, you can click the green "Run" button in the toolbar.

8. **View Output**:
- The output of your program will be displayed in the "Console" view at the bottom of the Eclipse window .

OUTPUT :-
Hello, world!
PROGRAM:2
Creating simple java programs using command line arguments

public class CommandLineArgumentsExample {

public static void main(String[] args) {
// Check if any command line arguments are provided
if ([Link] == 0) {
[Link]("No command line arguments provided.");
} else {
[Link]("Command line arguments:");
// Iterate through the command line arguments and print them
for (int i = 0; i < [Link]; i++) {
[Link]((i + 1) + ": " + args[i]);
}
}
}
}
OUTPUT :-

 (No args)
No command line arguments provided.

 (With args: A B)
Command line arguments:
1: A
2: B
PROGRAM:3
Understand OOP concepts and basics of Java programming.

Object-Oriented Programming (OOP) is a programming paradigm that revolves around the concept of "objects,"
which can contain data and code to manipulate that data. Java is a widely used programming language that fully
supports OOP principles. Here's an overview of some key OOP concepts and how they are implemented in Java:

1. **Classes and Objects**:

- A class is a blueprint for creating objects. It defines the properties (fields) and behaviors (methods) that objects of
that type will have.
- In Java, classes are declared using the `class` keyword. For example:

public class Car {

// Fields
String model;
int year;

// Constructor
public Car(String model, int year) {
[Link] = model; [Link] =
year;
}

// Method
public void drive() {
[Link]("Driving the " + year + " " + model);
}
}

- Objects are instances of classes. They are created using the `new` keyword followed by a call to the class
constructor. For example:

Car myCar = new Car("Toyota Camry", 2020);

2. **Encapsulation**:
- Encapsulation is the concept of bundling data (fields) and methods that operate on that data within a single
unit (a class).
- In Java, you can control access to class members using access modifiers such as `public`, `private`, and
`protected`.

3. **Inheritance**:
- Inheritance allows a class (subclass or derived class) to inherit fields and methods from another class (superclass
or base class).
- In Java, you can achieve inheritance using the `extends` keyword. For example:

public class ElectricCar extends Car {

// Additional fields and methods specific to ElectricCar
 }

4. **Polymorphism**:
- Polymorphism allows objects of different classes to be treated as objects of a common superclass.
- In Java, polymorphism can be achieved through method overriding and method overloading.

5. **Abstraction**:
- Abstraction refers to the process of hiding the implementation details and showing only the essential features of
an object.
- In Java, you can use abstract classes and interfaces to achieve abstraction.

OUTPUT :-

Driving the 2020 Toyota Camry

PROGRAM:4
Create Java programs using inheritance and polymorphism.
Here's an example of Java programs that demonstrate inheritance and polymorphism:

# Inheritance Example:

// Parent class
class Animal {
String name;

// Constructor
public Animal(String name) {
[Link] = name;
}

// Method
public void sound() {
[Link]("Animal sound");
}
}

// Child class inheriting from Animal class

Dog extends Animal {
// Constructor
public Dog(String name) { //
Call to superclass constructor
super(name);
}

// Method overriding
@Override public
void sound() {
[Link](name + " barks");
}
}

public class InheritanceExample {

public static void main(String[] args) {
// Creating objects of parent and child classes
Animal animal = new Animal("Generic Animal");
Dog dog = new Dog("Buddy");

// Calling methods [Link](); //

Output: Animal sound
[Link](); // Output: Buddy barks
}
}
# Polymorphism Example:

// Parent class class

Shape {
public void draw() {
[Link]("Drawing a shape");
}
}

// Child class 1
class Circle extends Shape {
@Override
public void draw() {
[Link]("Drawing a circle");
}
}

// Child class 2
class Rectangle extends Shape {
@Override
public void draw() {
[Link]("Drawing a rectangle");
}
}
public class PolymorphismExample { public static void main(String[] args) {
// Creating objects of child classes
Shape circle = new Circle();
Shape rectangle = new Rectangle();

// Polymorphic method calls

[Link](); // Output: Drawing a circle
[Link](); // Output: Drawing a rectangle
}
}
In the inheritance example, the `Dog` class extends the `Animal` class, inheriting its properties and methods. The
`sound()` method is overridden in the `Dog` class to provide a specific implementation.

In the polymorphism example, both `Circle` and `Rectangle` classes inherit from the `Shape` class, and they both
override the `draw()` method to provide specific implementations. The `Shape` reference can hold objects of `Circle`
and `Rectangle` classes, and the `draw()` method calls are resolved dynamically at runtime, depending on the actual
object being referred to.

OUTPUT :-
 (Inheritance) • (Polymorphism)
Animal sound Drawing a circle
Buddy barks Drawing a rectangle
PROGRAM:5
Implement error-handling techniques using exception handling and multithreading

Below are examples demonstrating error handling using exception handling and multithreading in Java.

# Exception Handling Example:

import [Link]; import

[Link];
import [Link];

public class ExceptionHandlingExample {

public static void main(String[] args) {
try {
// Attempt to read a file that does not exist
File file = new File("nonexistent_file.txt");
Scanner scanner = new Scanner(file);
} catch (FileNotFoundException e) {
// Handle the exception
[Link]("File not found: " + [Link]());
}
}
}

In this example, we attempt to read from a file that does not exist. The `FileNotFoundException` is caught in a `try-
catch` block, and we handle it by printing an error message.

# Multithreading Example:

public class MultithreadingExample {

public static void main(String[] args) {
// Creating threads
Thread thread1 = new Thread(new MyRunnable(), "Thread 1");
Thread thread2 = new Thread(new MyRunnable(), "Thread 2");

// Starting threads
[Link](); [Link]();
}

// Runnable implementation static class

MyRunnable implements Runnable {
@Override
public void run() { //
Simulate some work for
(int i = 0; i < 5; i++) {
[Link]([Link]().getName() + ": " + i);
try {
 // Introducing a delay
[Link](1000);
} catch (InterruptedException e) {
// Handle interruption if necessary
[Link]();
}
}
}
}
}

In this example, we create two threads (`thread1` and `thread2`) that execute instances of the `MyRunnable` class
concurrently. Each thread simulates some work by printing numbers from 0 to 4 with a delay of 1 second between
each print statement.

If you run this code, you'll see both threads executing concurrently and printing numbers alternately.

These examples demonstrate the basics of error handling using exception handling and multithreading in Java. It's
essential to handle exceptions to make your programs robust, and multithreading allows you to perform concurrent
tasks efficiently.

OUTPUT :-

 (Exception)
File not found: nonexistent_file.txt

 (Multithreading)
Thread 1: 0
Thread 2: 0
Thread 1: 1
Thread 2: 1
... (continues till 4)
PROGRAM:6
Create java program with the use of java packages.
Below is an example of a Java program that uses packages:

# Directory Structure:
MyPackageDemo/
├── src/
│ ├── com/
│ │ └── mypackage/
│ │ ├── [Link]
│ │ └── [Link]

# [Link]:

package [Link];

public class MyClass {

public void display() {
[Link]("This is MyClass in [Link]");
}
}

# [Link]:

package [Link];

public class AnotherClass {

public void show() {
[Link]("This is AnotherClass in [Link]");
}
}

# [Link] (outside the package):

import [Link];
import [Link];

public class Main {

public static void main(String[] args) {
MyClass obj1 = new MyClass();
AnotherClass obj2 = new AnotherClass();

[Link]();
[Link]();
}
}

In this example:
- `MyClass` and `AnotherClass` are part of the package `[Link]`. - We import `MyClass` and
`AnotherClass` into the `Main` class from the `[Link]` package.
- `Main` class is outside the `[Link]` package.
- We create objects of `MyClass` and `AnotherClass` and call their methods from the `Main` class.

To compile and run this program:

1. Navigate to the directory containing the `src` folder.
2. Compile all `.java` files using `javac src/com/mypackage/*.java [Link]`.
3. Run the program using `java Main`.

You should see the following output:

This is MyClass in [Link]

This is AnotherClass in [Link]

This demonstrates how to create and use Java packages in a program.

OUTPUT :-

This is MyClass in [Link]

This is AnotherClass in [Link]
PROGRAM:7
Construct java program using Java I/O package.
Below is an example of a Java program that utilizes the Java I/O package to read from a file and write to another
file:

import [Link]; import

[Link]; import
[Link]; import
[Link]; import
[Link];
import [Link];

public class FileIOExample { public

static void main(String[] args) {
// Define file paths
String inputFile = "[Link]";
String outputFile = "[Link]";

try {
// Create FileReader and FileWriter objects
FileReader reader = new FileReader(inputFile);
FileWriter writer = new FileWriter(outputFile);

// Create BufferedReader and BufferedWriter objects for efficient reading and writing
BufferedReader bufferedReader = new BufferedReader(reader);
BufferedWriter bufferedWriter = new BufferedWriter(writer);

// Read from input file line by line and write to output file
String line;
while ((line = [Link]()) != null) {
[Link](line); [Link]();
// Add newline character
}

// Close the resources

[Link]();
[Link]();

[Link]("File copied successfully!");

} catch (IOException e) {
[Link]("An error occurred: " + [Link]());
}
}
}

In this example:
- We import classes from the `[Link]` package to handle file input and output operations.
- We define two file paths: `inputFile` for the file to read from and `outputFile` for the file to write to.
- Inside the `try` block, we create `FileReader` and `FileWriter` objects to read from and write to files, respectively.
- We create `BufferedReader` and `BufferedWriter` objects for efficient reading and writing.
- We use a `while` loop to read from the input file line by line using `readLine()` method of `BufferedReader`, and
write each line to the output file using `write()` method of `BufferedWriter`. We also add a newline character
after each line.
- Finally, we close the resources (file readers and writers) using `close()` method to release any system resources
associated with them.
- We handle any `IOException` that may occur during file operations.

Make sure you have an `[Link]` file in the same directory as the program, which contains the content you want to
copy. After running this program, it will create an `[Link]` file with the same content as `[Link]`.

OUTPUT :-

File copied successfully!

PROGRAM:8
Create industry oriented application using Spring Framework.

Creating a complete industry-oriented application using the Spring Framework involves several steps and
components. For the sake of brevity, I'll outline a simplified example of a web-based e-commerce application using
Spring Boot, which is a popular module of the Spring Framework for creating stand-alone, productiongrade Spring-
based applications.

Let's create a basic e-commerce application with the following features:

1. User authentication and authorization.

2. Product management (CRUD operations).
3. Shopping cart functionality.

### Technologies Used:

- Spring Boot
- Spring Security
- Spring Data JPA
- Thymeleaf (for server-side templating)
- H2 Database (in-memory database)
- Maven (for dependency management)
- HTML/CSS (for frontend)

### Steps:

1. **Project Setup**:
- Set up a new Spring Boot project using your preferred IDE or Spring Initializr ([Link]
- Add dependencies for Spring Security, Spring Data JPA, Thymeleaf, and H2 Database.

2. **User Authentication and Authorization**:

- Configure Spring Security to handle user authentication and authorization.
- Implement user registration, login, and logout functionalities.
- Define roles (e.g., USER and ADMIN) and restrict access to certain endpoints based on roles.

3. **Product Management**:
- Create a `Product` entity with attributes like id, name, price, description, etc.
- Implement CRUD (Create, Read, Update, Delete) operations for products using Spring Data JPA.
- Develop RESTful APIs to expose product endpoints for managing products.

4. **Shopping Cart Functionality**:

- Implement shopping cart functionality for users to add products to their carts.
- Persist shopping cart data in the session or database.
- Allow users to view their cart, add/remove items, and proceed to checkout.

5. **Frontend**:
- Create HTML/CSS templates using Thymeleaf for user interface components like login/register forms, product
listings, shopping cart, etc.
- Integrate frontend with backend by making AJAX calls to RESTful APIs for fetching and updating data.
6. **Testing**:
- Write unit tests and integration tests to ensure the correctness of your application logic.
- Test different scenarios like user authentication, product CRUD operations, shopping cart functionality, etc.

7. **Deployment**:
- Package your application into a WAR or JAR file.
- Deploy the application to a web server like Apache Tomcat or use cloud platforms like AWS, Heroku, or Azure
for deployment.

8. **Continuous Integration/Continuous Deployment (CI/CD)**:

- Set up CI/CD pipelines to automate the build, test, and deployment process.
- Use tools like Jenkins, Travis CI, or GitLab CI for CI/CD pipelines.

9. **Monitoring and Logging**:

- Implement logging using SLF4J and Logback to record application events and errors.
- Set up monitoring tools like Prometheus, Grafana, or ELK stack for monitoring application performance and
health.

10. **Security and Scalability**:

- Ensure proper security measures are in place to protect against common security threats like SQL injection,
cross-site scripting (XSS), etc.
- Design your application for scalability by using distributed caching, load balancing, and horizontal scaling
techniques.

Remember, this is a simplified example, and a real-world industry-oriented application may involve more
complexities and additional features. You can further enhance the application by adding features like payment
gateway integration, order management, user reviews, recommendation systems, etc., based on your requirements
and use case.

OUTPUT :-

No console output (Web application runs on server)

PROGRAM:9
Test RESTful web services using Spring Boot.

Testing RESTful web services in Spring Boot involves writing integration tests to ensure that the endpoints behave
as expected. Below is an example of how you can test RESTful endpoints using Spring Boot's testing framework:

Let's say we have a simple RESTful API for managing products with endpoints like `/products` for fetching all
products, `/products/{id}` for fetching a specific product by its ID, and `/products` for creating a new product.

### Example Test Class:

import [Link];
import [Link];
import [Link];
import [Link]; import
[Link]; import
[Link]; import
[Link]; import
[Link];
import [Link]; import
[Link]; import
[Link];

import static [Link].*;

@SpringBootTest
@AutoConfigureMockMvc
@ExtendWith([Link])
public class ProductControllerIntegrationTest {

@Autowired
private MockMvc mockMvc;

@Autowired private
ObjectMapper objectMapper;

@Test
public void testGetAllProducts() throws Exception {
[Link]([Link]("/products")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON))
.andExpect(jsonPath("$.length()").value(2)) // Assuming we have 2 products
.andExpect(jsonPath("$[0].name").value("Product1"));
// Add more assertions as needed
}
 @Test
public void testGetProductById() throws Exception {
[Link]([Link]("/products/{id}", 1)
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON))
.andExpect(jsonPath("$.id").value(1))
.andExpect(jsonPath("$.name").value("Product1"));
// Add more assertions as needed
}

@Test
public void testCreateProduct() throws Exception {
Product product = new Product(); [Link]("New
Product");
// Add more fields as needed

String jsonProduct = [Link](product);

MvcResult mvcResult = [Link]([Link]("/products")

.contentType(MediaType.APPLICATION_JSON)
.content(jsonProduct))
.andExpect(status().isCreated())
.andReturn();

String response = [Link]().getContentAsString();

// Parse the response and verify if the product is created successfully
}
}

In this example:
- We use the `@SpringBootTest` annotation to indicate that this is an integration test that loads the complete
application context.
- We use `@AutoConfigureMockMvc` to automatically configure the `MockMvc` instance.
- We write individual test methods for each endpoint, where we perform HTTP requests using `MockMvc` and
assert the expected responses using Hamcrest matchers.
- We use `MockMvcRequestBuilders` to construct requests for GET, POST, etc., operations.
- We use `ObjectMapper` to convert Java objects to JSON format for sending request bodies.
- We verify the HTTP status codes, content types, and response bodies using Hamcrest matchers like `status()`,
`contentType()`, `jsonPath()`, etc.

Ensure that you have appropriate error handling in your RESTful controller classes to handle different scenarios like
resource not found, validation errors, etc., and include corresponding assertions in your test cases. Additionally, you
may need to mock dependencies or external services using frameworks like Mockito for more complex scenarios.

OUTPUT :-
Tests passed successfully (Status 200/201)
PROGRAM:10
Test Frontend web application with Spring Boot

Testing a frontend web application integrated with Spring Boot involves writing tests to ensure the correct behavior
of the user interface and its interaction with backend services. Below is an example of how you can test a frontend
web application with Spring Boot using Selenium WebDriver for end-to-end testing:

### Example Test Class:

import [Link]; import

[Link]; import
[Link]; import [Link];
import [Link]; import
[Link]; import
[Link]; import
[Link]; import
[Link]; import
[Link];

import static [Link];

@SpringBootTest(webEnvironment = [Link].RANDOM_PORT) public

class FrontendIntegrationTest {

@LocalServerPort
private int port;

private WebDriver driver;

@BeforeEach
public void setUp() {
// Configure Chrome WebDriver
[Link]("[Link]", "path/to/chromedriver");
ChromeOptions options = new ChromeOptions(); [Link]("--
headless"); // Run in headless mode (no GUI) driver = new
ChromeDriver(options);
}

@AfterEach public
void tearDown() { if
(driver != null) {
[Link]();
}
}
 @Test public void
testLoginPage() { //
Navigate to the login page

OUTPUT :-

Frontend test executed

successfully