Java Core Concepts: Features, OOP, and Memory Management

Posted on Nov 8, 2025 in Computer Engineering in Information Technologies Engineering

Java Core Features and Characteristics

Java is renowned for its robust set of features that make it suitable for enterprise-level development:

• Object-Oriented: Java strictly follows OOP principles: encapsulation, inheritance, polymorphism, and abstraction.
• Platform-Independent: Java runs on any system equipped with a Java Virtual Machine (JVM), adhering to the “Write Once, Run Anywhere” (WORA) philosophy.
• Simple and Easy to Learn: Java simplifies development by eliminating complex features found in other languages, such as explicit pointers and operator overloading.
• Security: Java enhances security by restricting direct memory access and utilizing public-key encryption for authentication.
• Robust: The language is robust due to strong memory management, automatic garbage collection, and comprehensive exception handling features.
• Multithreaded: Java supports multithreading, allowing multiple tasks to run concurrently, leading to improved performance.
• High Performance: Performance is achieved through Just-In-Time (JIT) compilation, which translates bytecode into native machine code during execution.
• Distributed Computing: Java supports distributed applications using technologies like Remote Method Invocation (RMI) and Enterprise JavaBeans (EJB).
• Dynamic and Portable: Java can adapt to new environments and run on different platforms without requiring modification.

Java vs. C++: Key Differences

While both are powerful languages, Java and C++ differ significantly in their architecture and usage:

Java Characteristics

• OOP Model: Java is a purely object-oriented programming language (though it uses primitive types).
• Platform Dependency: Java is platform-independent, relying on the JVM.
• Memory Management: Java uses automatic memory management with built-in garbage collection.
• Speed: Generally slower than C++ due to the JVM abstraction layer.
• Pointers: Java does not support explicit pointers, enhancing security.
• Typical Use: Commonly used for web applications, enterprise software, mobile apps (Android), and cloud computing.

C++ Characteristics

• OOP Model: C++ is a hybrid language, supporting both procedural and object-oriented programming.
• Platform Dependency: C++ is platform-dependent; compiled code runs only on the specific operating system it was compiled for.
• Memory Management: C++ requires manual memory management using new and delete operators.
• Speed: Generally faster because it is compiled directly into machine code.
• Pointers: C++ supports pointers, allowing direct memory manipulation.
• Typical Use: Widely used for system programming, game development, embedded systems, and high-performance applications.

Understanding Java Command-Line Arguments

Definition:

Command-line arguments are inputs passed to a Java program during execution via the terminal or command prompt.

Storage:

These arguments are stored as an array of strings in the args parameter of the main() method (public static void main(String[] args)).

Usage:

Each argument can be accessed using its index (e.g., args[0], args[1]).

What is Java Bytecode?

Definition:

Bytecode is an intermediate representation of Java source code generated by the Java compiler.

Platform Independence:

It is the key to Java’s platform independence. Bytecode runs on any system with a Java Virtual Machine (JVM), fulfilling the “Write Once, Run Anywhere” principle.

Java Constructors: Purpose and Invocation

Definition:

A constructor is a special method used to initialize objects when they are created. It must have the same name as the class and does not have a return type (not even void).

Main Purpose:

The primary purpose is to set initial values for object attributes and ensure the object is properly constructed before use.

How to Invoke a Constructor:

A constructor is automatically called when an object is instantiated using the new keyword.

Automatic Memory Management: Java Garbage Collection

Definition:

Garbage collection (GC) is an automatic memory management process in Java that identifies and removes objects that are no longer referenced by the program, thereby freeing up memory.

Purpose:

GC prevents memory leaks and optimizes application performance by reclaiming memory occupied by unused objects.

Essential Java Math Class Methods

The java.lang.Math class provides methods for performing basic numeric operations. Here are three examples:

1. Math.sqrt(double a)

Purpose:

Returns the square root of a given number.

Syntax and Example:

// Syntax
double result = Math.sqrt(25);

// Example
public class MathExample {
    public static void main(String[] args) {
        System.out.println("Square Root of 25: " + Math.sqrt(25));
    }
}
// Output: Square Root of 25: 5.0
        

2. Math.pow(double a, double b)

Purpose:

Returns the value of a raised to the power of b (a^b).

Syntax and Example:

// Syntax
double result = Math.pow(2, 3);

// Example
public class MathExample {
    public static void main(String[] args) {
        System.out.println("2 raised to power 3: " + Math.pow(2, 3));
    }
}
// Output: 2 raised to power 3: 8.0
        

3. Math.abs(int a)

Purpose:

Returns the absolute (positive) value of a number.

Syntax and Example:

// Syntax
int result = Math.abs(-10);

// Example
public class MathExample {
    public static void main(String[] args) {
        System.out.println("Absolute value of -10: " + Math.abs(-10));
    }
}
// Output: Absolute value of -10: 10
        

Java Access Modifiers Explained

Access modifiers in Java define the visibility and accessibility of classes, methods, and variables. They are crucial for implementing encapsulation and restricting access to certain parts of the code. Java provides four types of access modifiers:

1. Public (public)
   • Access Level: A member declared as public is accessible from anywhere in the program.
   • Usage: Suitable for methods and classes that need to be accessed globally.
2. Private (private)
   • Access Level: A member declared as private is accessible only within the same class.
   • Usage: Used for data hiding to prevent direct manipulation from outside the class.
3. Protected (protected)
   • Access Level: A member declared as protected is accessible within the same package and by subclasses (even if the subclass is in a different package).
   • Usage: Used primarily in inheritance to allow access in child classes while maintaining package-level restriction otherwise.
4. Default (No Modifier)
   • Access Level: If no access modifier is specified, the member has default (package-private) access, meaning it is accessible only within the same package.
   • Usage: Suitable for package-level access where members should not be exposed outside the package boundary.

The ‘this’ Keyword in Java

The this keyword in Java refers to the current instance of the class. It is essential for managing object state and interactions within the class definition.

Main Uses of the this Keyword

1. Resolving Variable Name Conflict: Used to differentiate between instance variables and method parameters when they share the same name (shadowing).
2. Invoking Current Class Constructor: The this() keyword can be used to call another constructor within the same class (constructor chaining).
3. Passing Current Object as Argument: The this keyword can be used to pass the current object instance to another method.

Methods for Creating Objects in Java

An object is an instance of a class that represents real-world entities with attributes and behaviors. Objects can be created in several ways:

1. Using the new Keyword: This is the most common and standard method for object instantiation.
2. Using newInstance() Method: Used for reflection-based object creation (available in Class and Constructor classes).
3. Using Object Cloning: Creates a shallow copy of an existing object using the clone() method.
4. Using Deserialization: Restores an object from a saved state (reading an object from a file or stream).
5. Using Factory Methods: Static methods within a class that return an instance of that class or a subclass.

Access Modifiers and Inheritance Impact

Visibility modifiers dictate how members of a parent class are accessed or inherited by a subclass:

1. Public Modifier

• Access Level: Accessible everywhere, including subclasses in different packages.
• Effect on Inheritance: Public members are fully inherited by the subclass and can be accessed directly. They can also be overridden.

2. Private Modifier

• Access Level: Accessible only within the defining class.
• Effect on Inheritance: Private members are not inherited by subclasses in the sense of direct access. Access requires public or protected getters/setters.

3. Protected Modifier

• Access Level: Accessible within the same package and in subclasses outside the package.
• Effect on Inheritance: Protected members are inherited by subclasses and can be accessed directly within the subclass implementation. They can also be overridden.

4. Default (No Modifier)

• Access Level: Accessible only within the same package (package-private).
• Effect on Inheritance: Default members are inherited by subclasses only if the subclass resides in the same package as the parent class. They cannot be accessed in subclasses outside that package.

The ‘super’ Keyword in Java Inheritance

The super keyword in Java is used within a subclass to refer to the immediate parent class (superclass). It is essential for managing interactions between inherited and overridden members.

1. Accessing Parent Class Methods: If a subclass overrides a method from the parent class, super.methodName() can be used to call the original implementation from the superclass.
2. Accessing Parent Class Attributes: If a subclass has an attribute with the same name as the parent class, super.attributeName helps access the parent class’s attribute, resolving the naming conflict.
3. Calling Parent Class Constructor: The super() keyword is used as the first statement in a subclass constructor to explicitly invoke a constructor of the parent class.

Interfaces vs. Abstract Classes in Java

An interface in Java is a blueprint for a class that defines a set of abstract methods (and constants). It allows multiple classes to implement the same behavior, achieving abstraction and supporting multiple inheritance of type.

Difference Between Interface and Abstract Class

Implementing Multiple Interfaces in Java

Yes, a class in Java can implement multiple interfaces. This capability is a core feature of Java’s design, allowing it to achieve multiple inheritance of behavior (polymorphism) without the complexities associated with multiple class inheritance (like the Diamond Problem).

Why Implement Multiple Interfaces?

• Achieves Multiple Inheritance: Since Java does not support inheriting from multiple classes, interfaces provide a mechanism to inherit behavior definitions from multiple sources.
• Encapsulates Behaviors: Different functionalities or contracts can be defined in separate interfaces, promoting modularity.
• Flexibility: A single class can adhere to multiple contracts simultaneously, making the design highly flexible and adaptable.