Object Oriented Programming Using JAVA

  Experiment No: 1   Aim: Study   of Java run time environment (JRE) Theory: Java is a programming language and a platform. Platform Any hardware or software environment in which a program runs, known as a platform. Since Java has its own Runtime Environment (JRE) and API, it is called platform. The history of Java is a fascinating journey that began in the early 1990s and continues to shape the modern software development landscape. Here's an overview of the key milestones and events in the history of Java: Origins (Early 1990s): Java's story begins with a team of engineers at Sun Microsystems, led by James Gosling, Mike Sheridan, and Patrick Naughton. Their goal was to create a programming language that could be used to develop software for consumer electronic devices, such as set-top boxes and interactive television. Green Project (1991): The project, initially known as the "Green Project," aimed to develop a language that could addr...

 JUnit is a popular testing framework for Java programming language. It provides a simple and efficient way to write unit tests for your Java code, allowing you to ensure that your code functions as expected and continues to work correctly as you make changes. Key Features of JUnit: 1. Annotations:  JUnit uses annotations to identify methods that specify test cases and setup/teardown operations. Annotations include `@Test`, `@Before`, `@After`, `@BeforeClass`, and `@AfterClass`. 2. Assertions:  JUnit provides a set of assertion methods such as `assertEquals`, `assertTrue`, `assertFalse`, `assertNotNull`, etc., to validate expected outcomes of tests. 3. Test Runners:  JUnit includes various test runners that execute test cases and report results. The default runner is `BlockJUnit4ClassRunner`, but JUnit also supports parameterized tests and suites. 4. Parameterized Tests:  JUnit allows you to write parameterized tests using the `@ParameterizedTest` annotation, wh...

In Java, you can create custom exceptions by extending the `Exception` class or one of its subclasses like `RuntimeException`. Custom exceptions are useful when you want to define your own exception types to represent specific error conditions in your application. Syntax for creating a custom exception: public class CustomException extends Exception {     // Constructors, methods, and additional members can be defined here } Example of a custom exception: public class InvalidAgeException extends Exception {     public InvalidAgeException(String message) {         super(message);     } } public class AgeValidator {     public static void validateAge(int age) throws InvalidAgeException {         if (age < 0) {             throw new InvalidAgeException("Age cannot be negative");         }         if (age < 18) {       ...

 Chained exceptions, also known as nested exceptions, allow you to associate one exception with another. This feature is useful when you want to provide more context or information about the cause of an exception. In Java, you can chain exceptions using constructors that take a `Throwable` (or its subclasses) as an argument. Syntax: try {     // Code that may throw an exception } catch (ExceptionType1 e1) {     throw new ExceptionType2("Additional information", e1); } Explanation: - Inside a `catch` block, you can create a new exception object and pass the original exception (`e1`) as the cause. - The chained exception (`ExceptionType2`) includes a message and the original exception (`e1`) as its cause. - This technique allows you to preserve the original exception's stack trace and context while providing additional information about the higher-level exception. - Chained exceptions can be caught and processed at higher levels of the call stack, allowing for bet...

 In Java, the `throw` statement is used to explicitly throw an exception within a method or block of code. It is typically used when an exceptional condition occurs that the method cannot handle itself, and it wants to signal to the calling code that something went wrong. Syntax: throw throwableObject; Explanation: - The `throw` statement requires an argument, which is usually an instance of a subclass of `Throwable` (either an exception or an error). - The argument passed to `throw` can be any expression that results in a throwable object. - When a `throw` statement is executed, the program flow is immediately transferred out of the current method or block and back to the calling code. - The caller can then catch the thrown exception using a `try-catch` block or propagate it further up the call stack. Example: public class AgeValidator {     public static void validateAge(int age) {         if (age < 0) {             t...

 The `finally` block in Java is used to define a block of code that will be executed regardless of whether an exception is thrown or not within the `try` block. It provides a way to perform cleanup tasks such as closing resources, releasing locks, or finalizing operations. Syntax: try {     // Code that may throw an exception } catch (ExceptionType ex) {     // Code to handle the exception } finally {     // Code to be executed regardless of whether an exception occurs or not } Explanation: - The `finally` block is optional and can appear after the `try` block or after the last `catch` block. - The code inside the `finally` block will always be executed, irrespective of whether an exception occurs in the `try` block or whether it's caught by a `catch` block. - The `finally` block is often used to release resources that were acquired in the `try` block, ensuring they are properly released even if an exception occurs. - If an exception occurs in the `try...

 The `catch` blocks in Java are used to handle exceptions that occur within a `try` block. Each `catch` block specifies the type of exception it can handle, allowing you to provide different handling logic for different types of exceptions. Syntax: try {     // Code that may throw an exception } catch (ExceptionType1 ex1) {     // Code to handle ExceptionType1 } catch (ExceptionType2 ex2) {     // Code to handle ExceptionType2 } finally {     // Cleanup code (optional) } ``` Explanation: - Each `catch` block specifies the type of exception it can handle, denoted by `ExceptionType`. If an exception of that type (or a subtype) occurs in the `try` block, the corresponding `catch` block is executed. - You can have multiple `catch` blocks to handle different types of exceptions. - The order of `catch` blocks is important, as Java checks them sequentially from top to bottom. It's recommended to catch subclasses before their superclasses to avoid un...