Search for a command to run...
Hello! I’m Pratik Upreti, a seasoned software engineer with a rich background in languages like C#, Java, JavaScript, Python, SQL, and MySQL, I bring a diverse skill set to the table. I excel in backend and server technologies, including Node.js, Django, GraphQL, and Prisma ORM, and am adept in frontend development with Next.js, React.js and Tailwind CSS. Professionally, contributing at Brilliant Infotech.
Thank you.
In Java, strings play a crucial role in most applications, ranging from simple text manipulation to complex data processing. One of the fundamental characteristics of strings in Java is their immutability. This blog delves into what immutability mean...
In Java, understanding the various components of a class structure is fundamental to mastering the language. Here, we'll break down a sample class, ClassStructure, to explore static variables, instance variables, static blocks, instance blocks, const...
Introduction Welcome to the world of Java programming! If you've been curious about what the static keyword does in Java, you're in the right place. This guide is tailored for beginners but packed with enough detail to elevate your understanding to a...
Recap : Day 1 In Day 1 of our JavaScript journey, you set up your development environment, cooked your first JavaScript "Hello World".Today, we're going to take a closer look at a fundamental aspect of JavaScript: variables. Variables are like contai...
Object-Oriented Programming (OOP) in Java leverages key principles like Abstraction and Encapsulation to create efficient and maintainable code. Understanding these concepts is fundamental for any Java developer. Let's explore them in detail with intuitive examples.
Abstraction in Java is the process of hiding the complex implementation details and showing only the necessary functionalities to the user.
Abstraction in Java is implemented using abstract classes and interfaces.
Abstract Classes: These are classes that cannot be instantiated. They can have abstract methods (methods without a body) and concrete methods (methods with an implementation).
Interfaces: An interface in Java is a completely "abstract class" that is used to group related methods with empty bodies.
Consider a simple example of a shape. We know every shape has an area, but the formula to calculate the area is different for each shape. Here, we can create an abstract class Shape with an abstract method calculateArea().
javaCopy codeabstract class Shape {
// Abstract method
abstract double calculateArea();
// Concrete method
public void display() {
System.out.println("Displaying the shape details.");
}
}
class Circle extends Shape {
private double radius;
Circle(double r) {
radius = r;
}
// Implementation of abstract method
double calculateArea() {
return 3.14 * radius * radius;
}
}
class Rectangle extends Shape {
private double length;
private double width;
Rectangle(double l, double w) {
length = l;
width = w;
}
// Implementation of abstract method
double calculateArea() {
return length * width;
}
}
In this example, Shape is an abstract class that provides a common abstraction (calculateArea()) for different shapes. The specific implementation of area calculation is provided in the subclasses Circle and Rectangle.
Encapsulation is about keeping the internal state of an object hidden from the outside world while exposing a controlled interface to interact with that state.
Encapsulation in Java is achieved using access modifiers: private, protected, and public. By setting fields as private and providing public getter and setter methods, we control access to the data.
Consider the example of a bank account:
javaCopy codeclass BankAccount {
private double balance;
// Constructor
BankAccount(double initialBalance) {
balance = initialBalance;
}
// Getter method
public double getBalance() {
return balance;
}
// Methods to modify the balance
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
}
}
public void withdraw(double amount) {
if (amount <= balance) {
balance -= amount;
}
}
}
In this example, the balance field is encapsulated within the BankAccount class. External access to the balance field is controlled through methods like deposit() and withdraw(), ensuring the integrity of the balance's state.
In Java, abstraction simplifies complex reality by providing relevant interfaces, while encapsulation protects the data integrity and hides the implementation details. Both principles are crucial in creating robust, reusable, and maintainable code.
Remember, abstraction in Java is like defining a template (like the Shape class), while encapsulation is like safeguarding the internal state of an object (like the balance in BankAccount) and exposing only what is necessary.