In Java, you can create your own custom exceptions by extending the built-in Exception class or one of its subclasses. Here's how you can create and use a custom exception:

1. Create Custom Exception Class:
   First, create a new class that extends Exception or one of its subclasses. You can define constructors and methods specific to your custom exception.

   public class CustomException extends Exception {
       public CustomException() {
           super("Custom exception message");
       }
       
       public CustomException(String message) {
           super(message);
       }
   }
   Copy

2. Throw Custom Exception:
   In your code, when you encounter a situation that warrants throwing your custom exception, use the throw keyword followed by an instance of your custom exception class.

   public void someMethod() throws CustomException {
       // Condition that triggers the exception
       if (condition) {
           throw new CustomException("Custom message for the exception");
       }
   }
   Copy

3. Handle Custom Exception:
   When calling the method that can throw your custom exception, handle it using a try-catch block.

   try {
       someObject.someMethod();
   } catch (CustomException e) {
       // Handle the custom exception
       System.out.println("Custom exception occurred: " + e.getMessage());
   }
   Copy

Putting it all together, here's an example demonstrating the creation, throwing, and handling of a custom exception:

// CustomException.java
public class CustomException extends Exception {
    public CustomException() {
        super("Custom exception message");
    }

    public CustomException(String message) {
        super(message);
    }
}
Copy

// Example.java
public class Example {
    public void someMethod() throws CustomException {
        // Simulating a condition that triggers the custom exception
        boolean condition = true;
        if (condition) {
            throw new CustomException("Custom message for the exception");
        }
    }
}
Copy

// Main.java
public class Main {
    public static void main(String[] args) {
        Example example = new Example();
        try {
            example.someMethod();
        } catch (CustomException e) {
            System.out.println("Custom exception occurred: " + e.getMessage());
        }
    }
}
Copy

In this example, we define a custom exception CustomException and then throw and handle it in the Example and Main classes, respectively.

• ! AI Generated :
  In Java, you can achieve multitasking, multiprocessing, and multithreading using various features of the language and the Java Runtime Environment (JRE). Let's explore each concept in the context of Java:

1. Multitasking in Java:

   • Java supports multitasking through its multithreading capabilities. You can run multiple threads within a single Java process, allowing you to perform multiple tasks concurrently.
   • Multitasking in Java is typically achieved by creating and managing multiple threads using the Thread class or implementing the Runnable interface.
2. Multiprocessing in Java:

   • Multiprocessing, which involves utilizing multiple CPUs or CPU cores, can be achieved indirectly in Java by running multiple Java Virtual Machine (JVM) instances on a multicore system.
   • Each JVM instance runs as a separate process and can execute Java applications independently. Therefore, if you have multiple CPU cores, you can run multiple Java processes concurrently, effectively achieving multiprocessing.
3. Multithreading in Java:

   • Multithreading is a fundamental feature of Java, allowing you to create and manage multiple threads within a single Java process.
   • Java provides built-in support for multithreading through the Thread class and the java.util.concurrent package.
   • You can create threads by extending the Thread class or implementing the Runnable interface and then starting these threads using the start() method.
   • Java also provides high-level concurrency utilities such as ExecutorService, ThreadPoolExecutor, and ConcurrentHashMap to simplify multithreaded programming and manage thread execution, synchronization, and communication.
   • Java provides predefined APIs for multithreading, for e.g. : Thread, Runnable, ThreadGroup, Concurrency, ThreadPool etc.

Here's a simple example demonstrating multithreading in Java:

class MyThread extends Thread {
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
            try {
                Thread.sleep(1000); // Simulate some work
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();

        thread1.start(); // Start the first thread
        thread2.start(); // Start the second thread
    }
}
Copy

This example creates two threads (thread1 and thread2) that execute concurrently, each printing numbers from 0 to 4 with a 1-second delay between each iteration.

In summary:

• Multitasking refers to running multiple tasks concurrently on a single CPU.
• Multiprocessing involves using multiple CPUs or CPU cores to execute tasks concurrently.
• Multithreading involves running multiple threads within a single process to achieve concurrency.
  • Executing multiple threads (subtasks) at a single time is known as multithreading.
  • It is used in various softwares, games, animations etc.

These concepts are fundamental to understanding how modern computer systems handle concurrent execution and optimize resource utilization.