DEV Community: ViGnEsH

Abstraction in Java

ViGnEsH — Fri, 17 Jul 2026 04:56:23 +0000

July 17 2026

Abstraction:

Abstraction in Java is the core Object-Oriented Programming (OOP) process of hiding internal implementation details and showing only the essential function to the user.

Real-world example:

TV remote control: You press the power button to turn it ON,
But you do not need to understand the internal circuitry or single transmission to make it happen.

How to Achieve Abstraction in Java

Java provides two mechanisms to implement abstraction:

1. Abstract Classes (0% to 100% Abstraction)

Abstract methods: Methods declared without a body (no curly braces, end with a semicolon).

TV (Super class)

I. Can't use the Abstract method. This error comes.

 error: missing method body, or declare abstract
  public void powerOn();

II. One or more methods in the abstract class are not abstract and do not override the abstract method

error: TV is not abstract and does not override abstract method powerOn() in TV
public class TV{
       ^

III. We can't create an object in the main method because it is an empty method.

 error: TV is abstract; cannot be instantiated
  TV tv = new TV();
          ^

Remote (Sub class)

IV. The error "Remote is not abstract and does not override abstract method powerOn() in TV".
Superclass abstract subclass also changes the abstract method.

Method value is decided, no more use abstract.

 error: Remote is not abstract and does not override abstract method powerOn() in TV
public class Remote extends TV{
       ^

V. Same for again now Remote class is abstract can't creater object.

error: Remote is abstract; cannot be instantiated
     Remote ch =new Remote();

Concrete methods: Standard methods containing an actual implementation body.

2. Interfaces (100% Abstraction)

Will explain in the next blog.

TV Code

Remote Code

Output

Encapsulation in Java

ViGnEsH — Thu, 16 Jul 2026 06:59:08 +0000

July 16 2026

Encapsulation is one of the four fundamental pillars of object-oriented programming (OOP) alongside abstraction, inheritance, and polymorphism.

What is Encapsulation in Java?

Encapsulation in Java refers to the process of wrapping data (variables) and the methods that act on that data into a single unit called a class.

By declaring class variables as private and accessing them via public getter and setter methods,

Java ensures that object fields are hidden from other classes and only modifiable through well-defined interfaces.

How to Achieve Encapsulation in Java

Here are the simple steps to implement it:

Declare class variables as private.

Provide public getter and setter methods to access and update the value of the private variables.

Syntax

public class GRT
{
//pojo
private int price = 13190;

public int getPrice(){
 return this.price;
}

public void setPrice(int price){

  if (price >= 125000){
    this.price = price;
  }
}

}

public class Customer
{

public static void main(String[] args)
{
   GRT grt = new GRT(); 
   System.out.println(grt.getPrice());

   grt.setPrice (10000);
    System.out.println(grt.getPrice());

}

}

Why Use Encapsulation?

Encapsulation is used for the following reasons:

Data Hiding: Internal object details are hidden from the outside world.
Control Access: You define exactly how important variables can be accessed or modified.
Increased Flexibility: You can change the internal implementation without affecting external code.
Improved Maintainability: Cleaner, more modular code is easier to debug and update.
Security: Sensitive data can only be accessed through well-defined methods.
These points are typically cited as key advantages of encapsulation in Java, especially in large-scale enterprise applications.

Method Overriding?

ViGnEsH — Wed, 15 Jul 2026 04:55:51 +0000

July 15 2026

What is Method Overriding?

Method Overriding is an Object-Oriented Programming (OOP) feature where a child class provides its own implementation of a method that already exists in the parent class.

Parent class

Child class

Output:

Child class (use super key)

Output:

What is the super Keyword in Java?

The super keyword is used to refer to the parent (superclass) object from a child class.
It allows a child class to access the parent class's methods, variables, and constructors.
Buy public class Child extends Parent Parent object works, but the Child value no longer runs,
-created Child object works in parent and child

Key Points

Same method name.
Same parameters.
The parent class method is redefined in the child class.
The child class method is executed when called on a child object.

Simple Errors

Variable Error

Why Does This Happen?

In Java, each local variable must have a unique name within the same method.

Here, the variable buy is declared twice.

Access Modifier. When to Use and When Not to Use for class, method, variable, and constructors.

ViGnEsH — Tue, 14 Jul 2026 04:02:00 +0000

July 14 2026

Access modifiers Definition :

Access modifiers in Java are keywords that control the visibility and accessibility of classes, methods, variables, and constructors.
They play a fundamental role in enforcing encapsulation (data hiding).

There are four types of Access modifiers

1. Private

The private access modifier in Java .
Members marked as private can only be accessed within the exact same class where they are declared.

2. Default (Package-Private)

When you do not specify an explicit access modifier, Java automatically applies the default access level.
Components are accessible only by classes residing in the same package.

3. Protected

Accessible within the same class, package, and subclasses.
Also, access different package subclasses (Child class)
Cannot allow a different package non-subclass

4. Public

Components are accessible from anywhere in the program

https://www.sitesbay.com/java/images/access-modifiers-in-java.png

When to Use and When Not to Use for class, method, variable, and constructors.

Key Points

Access Modifiers for Classes
public Accessible from anywhere.
Default (no modifier) Accessible only within the same package.
Private and protected cannot be used with top-level classes.

Access Modifiers for method
public Accessible from anywhere.
protected Accessible within the same package and by subclasses in other packages.
Default (no modifier) Accessible only within the same package.
private Accessible only within the same class.

Access Modifiers for variables
public Accessible from anywhere.
protected Accessible within the same package and by subclasses in other packages.
Default (no modifier) Accessible only within the same package.
private Accessible only within the same class.

*Access Modifiers for Constructors *
public The constructor can be called from anywhere.
protected Constructor can be called within the same package and by subclasses in other packages.
Default (no modifier) Constructor can be called only within the same package.
private → Constructor can be called only within the same class.

Constructor

ViGnEsH — Thu, 09 Jul 2026 09:14:08 +0000

July 08 2026

Constructor

A constructor in Java is a special block of code, similar to a method, that is automatically called when an instance (object) of a class is created.

Constructor Java Code

This refers to a global variable
ShopConstr Constructor method class name

main method inside

Classname objectCreatedname1 = new Classname("oil",95,5)
Classname objectCreatedname2 = new Classname("rice",1.500,10)

Called automatically when the object is created
No return type required
Should be the same as the class name
constructor job // initializing object-specific values
All classes have a default constructor (jvm => created) ii. no argument constructor ( we are created)

Output

Static vs Non-Static in Java

ViGnEsH — Fri, 03 Jul 2026 09:19:14 +0000

July 3 2026

Static

Static refers to class-specific information; only one memory copy is needed.

Memory is allocated only once.
It can be accessed without creating an object.
Shared by all objects of the class.

Example

class Fruits
{

static String fruitName ="Apple";
static String fruitName1 ="Mango";

public static void main(String[] args){

System.out.println("1 "+Fruits.fruitName+" $" +Fruits.price);
}
}

Non-Static

Non-static used has object-specific information
(or)
Object is a memony refers of class`

Each object has its own copy.
You must create an object to access it.
Different objects can store different values.

`java
class Fruits
{
String fruitName2 = "Banana";
int price2 = 10;

public static void main(String[] args){

Fruits basket = new Fruits();
System.out.println("3 "+basket.fruitName2+" $ "+basket.price2);

}
}
`

Java Data Types

ViGnEsH — Wed, 01 Jul 2026 11:08:33 +0000

Primitive Data Types

Primitive data types are the most basic data types available in Java. There are eight primitive data types, each serving a specific purpose:

1. byte:

Size: 8-bit
Range: -128 to 127
Usage: Memory-efficient storage in large arrays.

byte b = 100;

2. short:

Size: 16-bit
Range: -32,768 to 32,767
Usage: Suitable for saving memory in large arrays.

short s = 10000;

3. int:

Size: 32-bit
Range: -(2 to 231-1
Usage: Default choice for integer values.

int i = 100000;

4. long:

Size: 64-bit
Range: -263 to 263-1
Usage: For large integer values.

long l = 100000L;

5. float:

Size: 32-bit
Usage: For fractional numbers, with single precision.

float f = 234.5f;

6. double:

Size: 64-bit
Usage: For fractional numbers, with double precision.

double d = 123.4;

7. boolean:

Values: true or false
Usage: For simple flags and conditions.

boolean flag = true;

8. char:

Size: 16-bit
Range: 0 to 65,535 (Unicode characters)
Usage: For storing characters.

char c = 'A';

Non-Primitive Data Types

Non-primitive data types in Java include Strings, Arrays, Classes, Objects, Interfaces, and Collections. They store references to data, support methods and properties, and are used to represent more complex information than primitive data types.

Java Programming

Output:

Platform Architecture of Java, node.js, python

ViGnEsH — Tue, 30 Jun 2026 10:14:39 +0000

June 30 2026

Programming languages

Choosing the right programming language for backend development is one of the most important decisions in software development.
Among the most popular choices are Java, Node.js, and Python.
Although all three can build powerful applications.

Their architectures and execution models are very different.

Java Architecture

Java follows the principle "Write Once, Run Anywhere (WORA)."

Architecture Flow

Java Source Code (.java)
        │
        ▼
Java Compiler (javac)
        │
        ▼
Bytecode (.class)
        │
        ▼
Java Virtual Machine (JVM)
        │
        ▼
Operating System
        │
        ▼
Hardware

Node.js Architecture

Node.js is a JavaScript runtime built on Google's V8 JavaScript engine.

Architecture Flow

JavaScript Code
        │
        ▼
Node.js Runtime
        │
 ┌───────────────────┐
 │ V8 Engine         │
 │ Event Loop        │
 │ Libuv             │
 └───────────────────┘
        │
        ▼
Operating System
        │
        ▼
Hardware

Python Architecture

Python is an interpreted programming language known for its simplicity.

Architecture Flow

Python Source Code (.py)
        │
        ▼
Python Interpreter
        │
        ▼
Python Bytecode (.pyc)
        │
        ▼
Python Virtual Machine (PVM)
        │
        ▼
Operating System
        │
        ▼
Hardware

Comparison

Feature	Java	Node.js	Python
Language	Java	JavaScript	Python
Runtime	JVM	Node.js Runtime	Python Interpreter
Compilation	Bytecode	JIT to Machine Code	Bytecode
Execution Model	JVM	Event Loop	Python Virtual Machine
Performance	High	Very High	Moderate
Concurrency	Multithreading	Event-driven	Threads, Processes, Async
Platform Independent	Yes	Yes	Yes
Best For	Enterprise Systems	APIs & Real-time Apps	AI, Automation, Data Science

Platform Architecture of Java, node.js, python

ViGnEsH — Fri, 26 Jun 2026 09:26:32 +0000

June 26 2026

Programming languages

Choosing the right programming language for backend development is one of the most important decisions in software development.
Among the most popular choices are Java, Node.js, and Python.
Although all three can build powerful applications.

Their architectures and execution models are very different.

Java Architecture

Java follows the principle "Write Once, Run Anywhere (WORA)."

Architecture Flow

Java Source Code (.java)
        │
        ▼
Java Compiler (javac)
        │
        ▼
Bytecode (.class)
        │
        ▼
Java Virtual Machine (JVM)
        │
        ▼
Operating System
        │
        ▼
Hardware

Node.js Architecture

Node.js is a JavaScript runtime built on Google's V8 JavaScript engine.

Architecture Flow

JavaScript Code
        │
        ▼
Node.js Runtime
        │
 ┌───────────────────┐
 │ V8 Engine         │
 │ Event Loop        │
 │ Libuv             │
 └───────────────────┘
        │
        ▼
Operating System
        │
        ▼
Hardware

Python Architecture

Python is an interpreted programming language known for its simplicity.

Architecture Flow

Python Source Code (.py)
        │
        ▼
Python Interpreter
        │
        ▼
Python Bytecode (.pyc)
        │
        ▼
Python Virtual Machine (PVM)
        │
        ▼
Operating System
        │
        ▼
Hardware

Comparison

Feature	Java	Node.js	Python
Language	Java	JavaScript	Python
Runtime	JVM	Node.js Runtime	Python Interpreter
Compilation	Bytecode	JIT to Machine Code	Bytecode
Execution Model	JVM	Event Loop	Python Virtual Machine
Performance	High	Very High	Moderate
Concurrency	Multithreading	Event-driven	Threads, Processes, Async
Platform Independent	Yes	Yes	Yes
Best For	Enterprise Systems	APIs & Real-time Apps	AI, Automation, Data Science

Java programming

ViGnEsH — Thu, 25 Jun 2026 07:13:37 +0000

25 June 2026

What is Java?

Java is a popular, high-level, object-oriented programming language.
Developed by James Gosling at Sun Microsystems in 1995

platform independence

Opps is a important topic in java, which is a type of Paradigm,

Paradigm

Java is a programming paradigm, a fundamental style, approach, or mindset used to structure, design, and write computer code

object-oriented programming language.

The features of an Object-Oriented Programming (OOP) language revolve around classes and objects,
Built upon four fundamental pillars:
Inheritance, Polymorphism, Encapsulation, Abstraction

Inheritance
In Java, it is possible to inherit attributes and methods from one class to another.

inheritance concept into two categories:

Superclass (Parent): The class whose features are inherited.
Subclass (Child): The class that inherits from the superclass. It can reuse parent fields/methods and add its own.

Java is a case-sensitive and structured programming language

ViGnEsH — Thu, 25 Jun 2026 06:50:41 +0000

June 24, 2026

errer 1

Current code

Output

Java is a case-sensitive and structured programming language

ViGnEsH — Wed, 24 Jun 2026 09:46:31 +0000

June 24, 2026

Error 1

Error 2

Error 3

Error 4

Error 5

Error 6

Error 7

Error 8

Error 9

Error 10

Current code

Output