DEV Community: Ranjith Ranjith

this and super

Ranjith Ranjith — Wed, 04 Jun 2025 13:01:31 +0000

this
this refers to a reference of the current class.
Java Object-Oriented Pr
this Keyword in Java
The this keyword in Java is a reference variable that refers to the current object.
It is used within an instance method to access members of the current object such as instance variables, methods, .

Usage
The this keyword is primarily used in the following scenarios:

 *To refer to the current class instance variable.
  *
    *To pass the current object as a parameter to a method.

To return the current object from a method.
Ex
public class ThisExample {
int a;
int b;

ThisExample(int a, int b) {
    this.a = a;
    this.b = b;
}

void display() {
    System.out.println("a: " + this.a + ", b: " + this.b);
}

public static void main(String[] args) {
    ThisExample obj = new ThisExample(10, 20);
    obj.display();
}

Super ::
super Keyword in Java
The super keyword in Java is used to refer to the immediate parent class object.
It is commonly used to access parent class methods and constructors, enabling a subclass to inherit and reuse the functionality of its superclass.

Usage
*To access a method from the superclass that has been overridden in the subclass

To be discus ::To invoke the current class method.

Reffer ::https://www.datacamp.com/doc/java/this

typecasting

Ranjith Ranjith — Sun, 01 Jun 2025 15:20:55 +0000

1) norowning (long->byte)

  1) arrowing in Java, also known as explicit type casting or downcasting, involves converting a value from a larger data type to a smaller one. 
  2)This process requires explicit syntax because it can potentially lead to data loss or precision reduction.

Why is it needed in arrowing?
Memory Management:

When dealing with , using smaller data types can optimize memory usage. Specific Operations:
- some operations might require specific data types, necessitating a conversion even if it's a narrowing one. Data Loss:
  - Narrowing can result in loss of precision (e.g., decimal part truncation) or unexpected values due to overflow. *Careful Usage: Use narrowing conversions with caution, ensuring that the potential loss of data is acceptable for your specific use case. ex: double d = 123.45; int i = (int) d; // i will be 123 (decimal part is truncated)

broadning (int->long)

also known as implicit conversion or upcasting, in Java refers to the automatic conversion of a smaller data type to longer date type

Ex
int myInt = 10;
long myLong = myInt; // Implicit conversion from int to long
double myDouble = myInt; // Implicit conversion from int to double
Access modifiers
access modifiers are essential tools that define how the members of a class, like variables, methods, and even the class itself can be accessed from other parts of our program.

Types of Access Modifiers
There are 4 types of access modifiers available in Java:

Default
Private
Protected
Public

Default
*declarations are visible only within the package (package private)
Private

* declarations are visible within the class only
Protected

*declarations are visible within the package or all subclasses
Public

* declarations are visible everywhere

Refffer tha webset
https://www.geeksforgeeks.org/strings-in-java/

https://www.w3schools.com/java/java_modifiers.asp

Differents between float & double

Ranjith Ranjith — Sat, 31 May 2025 07:25:20 +0000

float

Purpose: float is designed to store fractional numbers or numbers with decimal points.
Size: It occupies 4 bytes (32 bits) of memory.
Precision: float offers approximately 6 to 7 decimal digits of precision. This means that after a certain number of decimal places, the value may become less accurate due to the limitations of its 32-bit representation.
Range: The approximate range for float is from 1.4E-45 to 3.4E+38.
Literal Suffix: When assigning a literal value to a float variable, it is necessary to append the letter f or F to the number.

    double

Purpose: It is primarily used for storing decimal numbers that require a high degree of precision and a wide range of values.
This makes it suitable for scientific calculations, financial applications, and complex mathematical computations.
Size: A double occupies 8 bytes (64 bits) of memory.
Precision: It offers higher precision compared to the float data type, which is a single-precision 32-bit floating-point number.
Range: The approximate range for double values is from 4.9e-324 to 1.7e+308.
Default Choice: For most decimal values in Java, double is the generally recommended and default choice due to its balance of precision and range.

  Primitive data types are the fundamental building blocks for storing and manipulating data in the Java programming language. They are predefined by the language itself and represent basic values like numbers, characters, and true/false statements. Unlike non-primitive data types, they are not objects and don’t have any associated methods.

primitive data types offer a set of predefined, immutable building blocks for storing and manipulating fundamental values.
These simple and efficient types have fixed sizes, reside directly in memory for faster access, and avoid object overhead for memory efficiency.
However, their limited functionality and lack of inheritance capabilities mean they are well-suited for basic data operations but may not be ideal for complex data structures or advanced functionalities, which are better handled by non-primitive data types like classes and interfaces.

Primitive data types in Java excel in performance and memory efficiency.
Their direct memory access, lack of object overhead, and smaller sizes allow for faster operations, comparisons, and manipulations by the CPU. Additionally, their efficient caching contributes to quicker retrieval.
Furthermore, since they don’t require object-related memory allocations, they consume less memory compared to non-primitive data types.
However, it’s essential to remember that choosing the right data type involves a balance between performance and memory usage.
While primitive types offer these advantages, their capabilities and range may be limited compared to non-primitive types like String.
Therefore, selecting the appropriate data type requires careful consideration of both performance requirements and memory constraints.

Primitive Data Types

byte: Stores small whole numbers (8 bits) ranging from -128 to 127.
short: Stores whole numbers (16 bits) ranging from -32,768 to 32,767.
int: The most commonly used integer type (32 bits) with a range of -2,147,483,648 to 2,147,483,647.
long: Stores larger whole numbers (64 bits) ranging from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807.
float: Stores single-precision floating-point numbers (32 bits) for decimal values, offering less precision than double.
double: Stores double-precision floating-point numbers (64 bits) for decimal values, offering more precision than float.
char: Stores single characters using Unicode (16 bits).
boolean: Represents true or false (1 bit).

Float and double are two primitive data types in Java that are used to store floating-point numbers. Floating-point numbers are numbers that can have a decimal point, such as 3.14159 or 1.23456789e10.

Float is a 32-bit floating-point number, which means that it can store up to 7 decimal digits accurately.
Double is a 64-bit floating-point number, which means that it can store up to 15 decimal digits accurately.

Float

The float keyword in Java is a primitive data type, and its size limit is 4 byte or 32 bits (1 byte = 8 bits) single-precision IEEE 754 (Standard for Floating-Point Arithmetic) floating-point number, that is it can allow up to 6 digits precision after the decimal.
We use this float keyword to declare the variable and methods. It usually stores the value in decimals or fractions.
We use this Float data type, if we want to use the memory efficiently, or if the number is in the small range. As the Float consumes less memory in comparison to the Double data type. By default, Java treats any decimal or float numbers as double type, so in case, if we want to define any value as float, we need to manually typecast it using the 'f' or 'F' keyword in the suffix of the number.

For example, if we define a float number as:

float weight = 70.645;

In the above code in Java, the declaration of the float variable will throw a compilation error of possible lossy conversion from double to float, but we can fix the error by adding the character 'f' or 'F' in the suffix of the number.

float weight = 70.645f;
or
float weight = 70.645F;

double
The double keyword in Java is also a primitive data type, and its size limit is 8 byte or 64 bits double-precision IEEE 754 floating-point number, that is it can allow up to 15 digits precision after the decimal. . We often use this keyword when we have a larger floating value and if we want a more precise and accurate value. As the Double data type consumes more memory in comparison to the Float data type, but it gives more accurate values of up to 15 digits of precision than the float data type. By default, Java considers any decimal or float values of double type, so we do not need to typecast any decimal value to double manually. Hence, adding the suffix 'd' or 'D' in the number is optional in the case of Double data type values.

For example, we define a double number as:

double weight = 70.6458763;
or
double weight = 70.6458763d;
or
double weight = 70.6458763D;

Key Difference Between Float and Double in Java
The main difference between Java Float and Double is their precision and range.

Float is a 32-bit floating-point number, which means that it can store up to 7 decimal digits accurately while Double is a 64-bit floating-point number, which means that it can store up to 15 decimal digits accurately.

Second major difference lies in their memory usage. Double variables take up twice as much memory as float variables.

Difference Between Float and Double in Java
Now let us look at the Float vs Double comparison table.

BASIS FOR COMPARISON Floatand   Double 
 Definition The float keyword in Java is a primitive data type, single-precision 32-bit.    
The double keyword in Java is a primitive data type, double-precision 64-bit

Usage The float data type is less precise, that is, it is used where accuracy is not a big factor, and storage is limited.

The double data type is more precise, that is, it is used where accuracy is a big factor, and we want to avoid data compression or bit loss.
Storage: The float data type consumes 4 byte or 32 bits for storing a variable

The double data type consumes 8 byte or 64 bits for storing a variable
Benefits

The float data type have ample support libraries. Open source and community development. The double data type has more uses for web development, and is more web focused
Academics The float data type is a 32-bit IEEE 754 floating point A double is a 64-bit IEEE 754 floating point.
Precision The float data type precision is up to 6 to 7 decimal digits. The double data type can provide precision up to 15 to 16 decimal digits.
Range The float data type range lies between 3.4e-038 to 3.4e+038, and it has a lower range as compared to the double data type. The double data type range lies between 1.7e-308 to 1.7e+308, and it has a higher range as compared to the float data type.
Keyword Used To define a number as float, we mention the float keyword. To define a number as double, we mention the double keyword.
Wrapper Class The float data type wrapper class is java.lang.Float. The double data type wrapper class is java.lang.Double.
Default Data Type Java does not use float as the default data type for floating point numbers. Java use the double as the default data type for floating point numbers.
Data Loss If we convert any float type value from float to double, there will be no data loss. If we convert any double type value from double to float, there will be data loss.
Suffix The float data type uses 'f' or 'F' as a suffix. It is mandatory to mention the suffix if we want the number to be of float type. The double data type uses 'd' or 'D' as a suffix. It is not mandatory to mention the suffix if we want the number to be of double type.
Representation 28.96f or 28.96F 12.5 or 12.5D or

Reffer
Www.Scaler.com

Float vs Double — Explanation:
Size :4 bytes 8 bytes.
Accuracy: 7 digits approx ,15 digits approx.
Speed: Faster (uses less memory) Little slower (more memory used)

Example:

float a = 3.1415926f;

double b = 3.141592653589793;

Day 7 (instance variable,local variable,static variable ,static method )

Ranjith Ranjith — Fri, 30 May 2025 07:50:00 +0000

1) What is an instance variable
Instance variable is a variable declared inside a class, but outside methods, and it belongs to each object (instance) of that class.

Every time you create a new object, a new copy of instance variable is created.

2) Where is an instance variable declared
Instance variable is declared inside the class, but outside any method.

class Student {
String name; // instance variable
int age; // instance variable
}
3) Use of instance variable (Why useful)?
To store object-specific data.

Every object will have its own values.

Example: Different students have different names and ages.

Example:

class Student {
String name; // instance variable
int age; // instance variable

// Constructor to initialize instance variables
Student(String n, int a) {
    name = n;
    age = a;
}

void display() {
    System.out.println("Name: " + name);
    System.out.println("Age: " + age);
}

public static void main(String[] args) {
    Student s1 = new Student("Arun", 20);
    Student s2 = new Student("Divya", 22);

    s1.display();
    s2.display();
}

}
Output:

Name: Arun
Age: 20
Name: divya
Age:22

Instance variable is a variable that is specific to an object (instance) of a class.
Each object will have its own copy of that variable.

Class is like a blueprint.
Object is something created using that blueprint.
Instance variable is the data stored inside each object.

2) Where is an instance variable

Instance variable is defined inside a class, but inside methods using self.

class Student:
def init(self, name, age):
self.name = name # instance variable
self.age = age # instance variable

self.name and self.age are instance variables.

They belong to a particular object of the Student class.

3) Use of instance variable (Why it's useful)?

To store data unique to each object.

Example: Every student has different name and age — so you store them as instance variables.

Example:

class Student:
def init(self, name, age):
self.name = name # instance variable
self.age = age # instance variable

def display(self):
    print("Name:", self.name)
    print("Age:", self.age)

Creating objects (instances)

student1 = Student("Arun", 20)
student2 = Student("Divya", 22)

student1.display()
student2.display()

Output:
Name: Arun
Age: 20
Name: Divya
Age:22

  2] Local variable

1) What is a Local Variable
A local variable is a variable that is declared inside a method, constructor, or block, and it can be used only inside that method or block.

2) Where is Local Variable
Local variables are created inside methods and disappear when the method finishes. They are not accessible outside the method.

3) Use of Local Variable

Example

public class Main {
public static void main(String[] args) {
int number = 10; // local variable
System.out.println("Number is: " + number);
}
}
3] Static variable

1) What is a static variable

Tamil Explanation:
static variable ஒரு class level variable. Object-ஓட property இல்ல. Class-ஓட common variable.

class Example {
static int count = 0; // This is a static variable
}

3) Use of static variable
Static variable useful when you want to share common data between all objects.

Ex.

class Student {
int id;
String name;

// Static variable
static String college = "ABC College";

// Constructor
Student(int i, String n) {
    id = i;
    name = n;
}

void display() {
    System.out.println(id + " " + name + " " + college);
}

}

public class TestStaticVariable {
public static void main(String[] args) {
Student s1 = new Student(1, "Ravi");
Student s2 = new Student(2, "Priya");

    s1.display();
    s2.display();
}

}

Output:

1 Ravi ABC College
2 Priya ABC College

college is a static variable

Learn to Code, Prepare for Interviews, and Get Hired
By DotNetTricks
Learn to Code, Prepare for Interviews, and Get Hired
By DotNetTricks
Live Training
Job Oriented Training
DSA Problems
Free Courses
Free Books
Membership Plans
Explore
Tutorials
Cart

Summer Sale is Live! Unlock 40% OFF on All Job-Oriented Training Programs – Limited Time Only! Offer Ending in00 D05 H30 M54 S Get Now
Home
Tutorials
Java
Types Of Variables In Jav..
Types of variables in Java with examples: Local, Instance & Static
Types of variables in Java with examples: Local, Instance & Static
27 May 2025
Beginner
15.3K Views
18 min read

Learn with an interactive course and practical hands-on labs
Free Java Course With Certificate
A variable in Java is like a container or box that stores some values, such as numbers, text, or any data. You give the box a name, and you can use and change the value stored inside it during a program.

In this Java tutorial, we'll get into the details of Java variables. Java Online Training is a convenient option for gaining expertise in Java and harnessing its power for various applications.

Start coding with confidence—join our Java Certification Course for Free and gain hands-on experience.

Read More - Top 50 Java Interview Questions For Freshers

What is a Variable in Java?
A variable in Java is a name for a memory location used to store data. It must be declared with a data type like int, String, or float. A variable in Java can hold only one type of data, and its value can be changed during the program. You should always initialize the variable before using it. Overall, variable in Java helps in storing, changing, and reusing data throughout the program.

Declaration of Variable in Java
A variable in Java is used to store different types of data like numbers, text, or true/false values. Based on the type of data, there are different ways to declare a variable in Java.

String is used to store text, like "Hello World".
int is used to store whole numbers without decimals, like 10 or 100.
float is used to store numbers with decimal points, like 3.14 or 5.75.
char is used to store single characters, like 'x' or 'y', and is always written in single quotes.
boolean is used to store only two values: true or false.
To declare a variable in Java, programmers must follow two main parts:

Data type: This tells what kind of data the variable will store, such as int, float, or String.
Variable name: This is the name you give to the variable, so you can use it later in your code.
In short, declaring a variable in Java helps you store data in a proper format and use it again when needed.

Rules for Declaring Variables in Java
When you declare a variable in Java, you need to follow some simple rules to avoid errors. Let’s look at them one by one.

A variable in Java must start with a letter (like a or B), a dollar sign ($), or an underscore (_). You cannot start it with other special characters like @ or #. int $count = 5; or int _total = 10; are valid.
A variable in Java cannot have more than 64 characters in its name.int studentMarksInMathAndScience = 90; is okay, but avoid names that are too long.
You are not allowed to use blank spaces in the name of a variable in Java.int student age = 20; is wrong. You should write it as studentAge.
You cannot use Java's reserved keywords (like class, public, static) as variable names. int class = 10; is not allowed because class is a keyword.
The name of the variable must come before the assignment operator (=). int age = 25; is correct, but 25 = age; is incorrect.
Let's look at the variable declaration in our Java Playground.

Example
class Example
{
public static void main ( String[] args )
{
long payAmount = 184; //the declaration of the variable

System.out.println("The variable contains: " + payAmount );
}
}
Run Code >>
Output
Long payAmount = 184;
Variable Initialization
To initialize a variable in Java, there are three main components:

Data type: It defines the type of data that will be stored, such as int, float, String, etc.
Variable name: This is the specific name given to the variable so you can use it in the program.
Value: This is the actual data that you assign to the variable when initializing it.

Day 6 (interface )

Ranjith Ranjith — Thu, 29 May 2025 03:22:42 +0000

1] what is Interfaces:

 1)Like abstract classes, interfaces cannot be used to create objects

(in examabove, it is not possible to create an "Animal" object in the MyMainClass)

 2) Interface methods do not have a body - the body is provided by the "implement" class

  3)On implementation of an interface, you must override all of its methods

Interface methods are by default abstract and public

  4)Interface attributes are by default public, static and final

An interface cannot contain a constructor (as it cannot be used to create objects)

2] Why use interface :

  1)interfaces are used to define contracts for classes, enabling abstraction, polymorphism, and multiple inheritance. 
  2) They specify a set of methods that a class must implement, ensuring that all implementing classes share a common behavior.
   3)This allows for loose coupling and flexible code design. 


3] Where do we use an interface : 

  interface keyword in Java is used to declare a special type of class that only contains abstract methods, default methods, static methods, and final variables

Day 6 (interface and implement ) task .

Ranjith Ranjith — Thu, 29 May 2025 01:59:13 +0000

1) Interface

 First right for a content

Car =start, stop, accelerate, break

Governmenttransportdepartment
Followrules, payTak, insurance, passpulltionchick

publicinterfaceCar {

    void start();
    void stop();
    void accelerate();
    void break();
   }

}

public interface Governmenttransportdepartment{
void followrules();
void paytax();
void insurance();
void passpullictioncheck();
}
}

Next wright tha implement
1) Maruthisuzuki =swift
2)benz

public maruthisuzuki implement car,governmenttransportdeparment

public void start();
System.out.println("swift is start"){
}
public void stop();
System.out.println("swift is stop"){
}
public void accelerate();
System.out.println("swift is accelerate"){
}
public void break();
System.out.println("swift is break"){
}

public void paytak();
System.out.println("swift is paytax "){
}
public void followrules();
System.out.println("swift is followeules"){
}
public void passpullictioncheck();
System.out.println("swift passpullictioncheck"){
}
public void insurance();
System.out.println("swift is pay insurance"){

Public static void main(String[]args)
Maruthisuzuki swift=new maruthisuzuki();

    Swift.start();
    Swift.stop();
    Swift.accelerate();
    Swift.break();
    Swift.paytax();
    Swift.insurance();
    Swift.passpullictioncheck();
    Swift.followrules();

public class Benz implements Car, GovernmentTransportDepartment {

public void start() {
    System.out.println("Benz is starting");
}
    public void stop() {
    System.out.println("Benz is stopping");
}

public void accelerate() {
    System.out.println("Benz is accelerating");
}

public void brake() {
    System.out.println("Benz is braking");
}

public void followRules() {
    System.out.println("Benz follows traffic rules.");
}

public void payTax() {
    System.out.println("Benz road tax is paid.");
}

public void getInsurance() {
    System.out.println("Benz has insurance.");
}

public void passPollutionCheck() {
    System.out.println("Benz passed pollution check.");
}

public static void main(String[] args) {
    Benz benz = new Benz();
    benz.start();
    benz.accelerate();
    benz .brake();
    benz.stop();
    benz.followRules();
    benz.payTax();
    benz.getInsurance();
    benz.passPollutionCheck();
}

}

Day 5 (abstract )

Ranjith Ranjith — Tue, 27 May 2025 17:26:34 +0000

What is abstract: class or method is complete and much be __finished later
Ex

abstract class student{
Void study();
Class physics student extends student
Void study();
System.out.println("studying in physics subject ")

What is Dynamic bonding :(method call is detarmind at run based actual object not tha reference type.

ex:
class Teacher {
void answerQuestion() {
System.out.println("Teacher check and answer.");
}

class MathTeacher extends Teacher {
void answerQuestion() {
System.out.println("Math Teacher: The answer in algebra!");
}

class EnglishTeacher extends Teacher{
void answerQuestion() {
System.out.println("English Teacher: Let's answer the poem.");
}
}

public static void main(String[] args) {

Teacher t=newEnglishTeacher();

t.answerQuestion();  
System.out.println(english teacher check answer tha poem)      
t.answerQuestion();
 System.out.println(maths teacher answer tha algebra)
}

}

Dynamic binding is also referred to as a run-time polymorphism. In this type of binding, the functionality of the method call is not decided at compile-time. In other words, it is not possible to decide which piece of code will be executed as a result of a method call at compile-time

Binding is a mechanism creating link between method call and method actual implementation. As per the polymorphism concept in Java, object can have many different forms. Object forms can be resolved at compile time and run time.

Day 4 (overloding and overriding)

Ranjith Ranjith — Mon, 26 May 2025 17:41:58 +0000

Overloading =same method name different parameter s is called overloading
Ex
class Calculator {
int add(int a, int b) {
return a + b;
}

double add(double a, double b) {
    return a + b;
}

}
Explain :1) add name same
2)different parameters

Overriding = same parameters same method and different classes is called overriding
Ex
class Animal {
void sound() {
System.out.println("Animal sound");
}
}

class Dog extends Animal {
void sound() {
System.out.println("Dog barks");
}
}
Explain :dog barks,animal sound
This Overriding

Day 3 (return type )

Ranjith Ranjith — Sun, 25 May 2025 14:16:22 +0000

With return type(Value returnதரும்)

With return type tel as tha what kind of value function give bake after it
Runs
Example. a=5 ,b=2
int add(int a,int b){
System.out.println(a+b);
return (5+2);

without return type=(value return தராது)

kind of value function does not give bake any value
Example
public void hello(){
System.out.println("Hello")

[Boost]

Ranjith Ranjith — Sun, 25 May 2025 13:49:20 +0000

[Boost]

Ranjith Ranjith — Sun, 25 May 2025 13:30:21 +0000

[Boost]

Ranjith Ranjith — Sun, 25 May 2025 13:18:15 +0000