Understanding Programming Methodologies: A Comprehensive Guide Introduction Programming methodologies define structured approaches to writing code, improving efficiency, maintainability, and scalability. Different methodologies provide distinct ways of thinking about problem-solving, organizing logic, and structuring applications. This blog explores various programming methodologies, their advantages, drawbacks, applications, and best use cases. 1. Procedural Programming Procedural programming follows a step-by-step approach where code is structured as procedures or functions. Characteristics: Based on the concept of procedure calls. Follows a linear, top-down execution model. Uses variables, loops, and control structures. Languages: C, Pascal, Fortran Sample Code (C): #include <stdio.h> void greet() { printf("Hello, World!\n"); } int main() { greet(); return 0; } Applications: Embedded systems (e.g., firmware, microcontrollers) Operating systems (e.g., Li...
In Java, there are two primary ways to create threads:
1. Extending the `Thread` class: You can create a new class that extends the `Thread` class and override its `run()` method to define the code that the thread will execute.
2. Implementing the `Runnable` interface: You can create a class that implements the `Runnable` interface and provide the implementation for its `run()` method. Then, you can pass an instance of this class to a `Thread` object.
Let's see examples for both approaches:
1. Extending the `Thread` class:
class MyThread extends Thread {
public void run() {
// Code to be executed by the thread
for (int i = 0; i < 5; i++) {
System.out.println("Thread: " + i);
try {
Thread.sleep(1000); // Pause execution for 1 second
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Main {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start(); // Start the thread
}
}
2. Implementing the `Runnable` interface:
class MyRunnable implements Runnable {
public void run() {
// Code to be executed by the thread
for (int i = 0; i < 5; i++) {
System.out.println("Runnable: " + i);
try {
Thread.sleep(1000); // Pause execution for 1 second
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Main {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start(); // Start the thread
}
}
Both approaches will create a separate thread of execution, allowing the code within the `run()` method (defined in either the `Thread` subclass or the `Runnable` implementation) to run concurrently with the main program.
Remember to call the `start()` method on the `Thread` object to start the execution of the thread. Do not call the `run()` method directly, as it will execute in the same thread as the caller, not in a separate thread.
Comments
Post a Comment