Java Paradigm

Java is widely known for its platform independence, object-oriented nature, and robust design. In this section, we will delve into the Java programming paradigm, providing in-depth explanations and examples of its core concepts.

Object-Oriented Programming (OOP)

Programming languages that employ objects are known as object-oriented programming, or OOPs. These languages use objects as their main source for implementing code. The viewer or user sees objects carrying out your specified activities. Real-world concepts like inheritance, hiding, and polymorphism are intended to be implemented in programming through object-oriented programming.

Class

A class is a blueprint or template used in object-oriented programming or OOP. Classes describe the behaviors (methods/functions) and characteristics (data) that an object will possess. Objects are instances of these classes. As an object-oriented language, Java greatly depends on the idea of classes to structure and organize code.

Object

In object-oriented programming (OOP), an object is a basic building element that symbolizes a real-world entity with properties (data) and actions (functions/methods). Classes act as blueprints or templates for the creation of objects, of which objects are instances. The Object class in Java serves as the root class for all other classes. In Java, every class derives either directly or indirectly from the Object class.

In Java, all classes inherit some common methods from the Object class. These functions consist of getClass(), hashCode(), equals(), and toString(). In Java, a newly created class implicitly extends the Object class.

Encapsulation

Encapsulation is the process of combining methods that manipulate data with data into a single unit known as a class. By limiting direct access, this unit makes sure that data modifications are limited to well-defined procedures.

Encapsulation.java

class Student {
    private String n;
    private int a;
    public void setn(String n) {
        this.n = n;
    }
    public void seta(int a) {
        if (a > 0) {
            this.a = a;
        }
    }
    public String getn() {
        return n;
    }
    public int geta() {
        return a;
    }
}
public class Encapsulation {
    public static void main(String[] args) {
        Student student = new Student();
        student.setn("Alice");
        student.seta(20);
        System.out.println("Name Of the Student: " + student.getn());
        System.out.println("Age Of the Student: " + student.geta());
    }
}

Output:

Name: Alice
Age: 20

Inheritance

Inheritance allows a class to inherit the properties and behaviors (fields and methods) of another class. This promotes code reusability and hierarchical organization of classes.

Inheritance.java

class Vehicle {
    protected String brand;
    protected int year;
    public Vehicle(String brand, int year) {
        this.brand = brand;
        this.year = year;
    }
    public void start() {
        System.out.print("vehicle started."+ " ");
    }
}
class Car extends Vehicle {
    private int doors;
    public Car(String brand, int year, int doors) {
        super(brand, year);
        this.doors = doors;
    }
    public void accelerate() {
        System.out.println("Car is accelerating.");
    }
}
public class Inheritance
 {
    public static void main(String[] args) {
        Car myCar = new Car("BMW", 2023, 4);
        myCar.start();
        myCar.accelerate();
    }
}

Output:

vehicle started 
Car is accelerating.

Polymorphism

It is possible to regard objects of different classes as belonging to the same superclass thanks to polymorphism. It is realized through method overriding and interfaces in Java.

Example:

Polymorphism.java

interface Shape {
    double area();
}
class Circle implements Shape {
    private double radius;
    public Circle(double radius) {
        this.radius = radius;
    }
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}
public class Polymorphism {
    public static void main(String[] args) {
        Shape circle = new Circle(5.0);
        System.out.println("Circle Area: " + circle.area());
    }
}

Platform Independence

By employing a Java Virtual Machine (JVM), Java source code can be compiled to produce bytecode, an intermediate format that can execute on any platform.Java following the "Write Once, Run Anywhere" (WORA) principle.

PlatformIndependence.java

public class PlatformIndependence{
    public static void main(String[] args) {
        System.out.print(" Java Language ");
    }
}

Output:

Java Language

Strongly Typed Language

Java is a strongly typed language, meaning variable types must be declared explicitly, and type checking is enforced during compilation.

Example:

int num = 42;    
double pi = 3.14; 

Garbage Collection

Java incorporates automatic memory management through garbage collection. It tracks and reclaims memory that is no longer in use, preventing memory leaks and manual memory management errors.

Exception Handling

Exception handling is crucial in Java to manage errors gracefully. The language provides a structured way to handle exceptions using try, catch, and finally blocks.

ExceptionExample.java

public class ExceptionExample{  
  public static void main(String args[]){  
   try{  
      int data=100/0;  
   }catch(ArithmeticException ex)
   {
       System.out.println(ex);
   }  
   // remaining code of the program   
   System.out.println(" Code ");  
  }  
} 

Output:

java.lang.ArithmeticException: / by zero
 Code

Multi-Threading

Java allows for the simultaneous execution of several threads thanks to its multi-threading capability. This is necessary to create applications that are effective and responsive.

MultiThreadExample.java

class MyThread extends Thread {
    public void run() {
	int a=1;
	while(a<=5)
{
	System.out.println("Thread " + a);
	a++;
}
    }
}
public class MultiThreadExample {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        t1.start();
        t2.start();
    }
}

Output:

Thread 1
Thread 1
Thread 2
Thread 2
Thread 3
Thread 4
Thread 3
Thread 4
Thread 5
Thread 5

Imperative Programming

Under the paradigm of imperative programming, the description of a program's functionality is the main goal. The basic idea is to provide a series of statements to run, each of which modifies the state of the program. Imperative programming in Java is accomplished by using statements such as conditional constructions (if-else) and loops (for, while).

ImperativeExample.java

public class ImperativeExample {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 10; i++) {
            sum += i;
        }
        System.out.println("Sum: " + sum);
    }
}

Output:

Declarative Programming

Declarative programming, on the other hand, focuses more on the goals of the program than on the means of achieving them. With frameworks like JavaFX for creating user interfaces and tools like SQL for database queries, Java offers declarative programming.

Declarative.java

import java.util.*;
import java.util.stream.Collectors;
public class Declarative {
    public static void main(String[] args) {
        // Creating a list of numbers
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        // Declarative programming to find the square of each number
        List<Integer> squares = numbers.stream()
                .map(n -> n * n)
                .collect(Collectors.toList());
        // Printing the result
        System.out.println("Original List: " + numbers);
        System.out.println("Squares: " + squares);
    }
}

Output:

Original List: [1, 2, 3, 4, 5]
Squares: [1, 4, 9, 16, 25]

Functional Programming

Functional programming stays away from changing-state and mutable data and instead views computation as the evaluation of mathematical functions. Lambda expressions and the Stream API were added to Java 8 to bring functional programming tools to the platform.

Functional.java

import java.util.*;
public class Functional {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        int sum = numbers.stream().reduce(0, Integer::sum);
        System.out.println("Sum: " + sum);
    }
}

Output:

Sum: 15

Conclusion

To sum up, the Java programming paradigm provides a flexible and popular method for creating applications. Its object-oriented programming, platform freedom, and heavy emphasis on security and resilience highlight the "Write Once, Run Anywhere" tenet. Java is a great option for a variety of applications, including web development, mobile apps, and enterprise-level systems. Its vast library and frameworks make complicated jobs simpler. Encapsulation, inheritance, polymorphism, and an automated garbage collection mechanism for memory management are among the fundamental components of this paradigm.

Next TopicLower Bound in Java

← prev next →