DEV Community: Rajan S

this and super(keyword in java)

Rajan S — Thu, 11 Sep 2025 15:03:51 +0000

this keyword

1.What is this?

this is a refers to the current object of a class.

2.Why use this?

To avoid confusion between instance variables and parameters.

To call other constructors in the same class.

To pass the current object as an argument.

To return the current object.

To access current class members (fields, methods) inside the class.

3.When to use this?

When method or constructor parameters shadow instance variables.

When chaining constructors using this().

When returning the current object from a method.

Where is this used?

Inside non-static methods and constructors of a class.

Cannot be used in static context (like static methods) because this refers to an object, and static context belongs to class.

5.How to use this?

class Student {
    int id;
    String name;

    Student(int id, String name) {
        this.id = id;        // 'this' differentiates between field and parameter
        this.name = name;
    }

    void display() {
        System.out.println(this.id + " " + this.name);  // refers to current object
    }

    Student getStudent() {
        return this;  // returns current object
    }
}

super Keyword
1.What is super?

super is a reference variable used to refer to immediate parent class object.

Why use super?

To access parent class:

Constructors

Methods

Fields

To avoid method or variable shadowing.

To call overridden methods from parent class.

3.When to use super?

When subclass overrides a parent method but still wants to call the original version.

When you want to access a parent variable that’s hidden by a child variable.

When subclass constructor must call parent class constructor explicitly.

Where is super used?

Inside subclass constructors and methods.

Can’t be used in static context.

Must be the first statement in a constructor if used to call a parent constructor.

5.How to use super?

class Animal {
    String color = "Brown";

    void sound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {
    String color = "Black";

    void printColor() {
        System.out.println(super.color);  // access parent class variable
    }

    void sound() {
        super.sound();  // call parent class method
        System.out.println("Dog barks");
    }
}

Java Constructors

Rajan S — Wed, 03 Sep 2025 17:34:23 +0000

what is constructor in java

In Java, a constructor is a special type of method used to initialize objects when they are created.
It is called automatically when an instance of a class is created using the new keyword.

Basic program of constructor in java:

 class Bike{

 String make;
 String model;
 int   year ;
 String color;
 int  gear  ;

 Bike(String make,String model,int year,String color,int gear)
{

 this.make=make;
 this.model=model;
 this.year=year;
 this.color=color;
 this.gear=gear;
}

void GetBike(){

System.out.println("make:"+make);
System.out.println("model:"+model);

}

void GetStructure(){
System.out.println("year:"+year);

}

void GetDep(){

System.out.println("color:"+color);
System.out.println("gear:"+gear);

}

public static void main(String[]args){

  Bike b1=new Bike("cramy","royal enfield",2020,"red",5);

  b1.GetBike();
  b1.GetStructure();
  b1.GetDep();
 }
}

Output:

Polymorphism and its types

Rajan S — Tue, 02 Sep 2025 16:11:46 +0000

*what is polymorphism in java *

Polymorphism in Java is a core concept of Object-Oriented Programming (OOP) that allows objects to take on "many forms,"derived from the Greek words "poly" (many) and "morph" (forms).

Key features of polymorphism:

Multiple Behaviors: The same method can behave differently depending on the object that calls this method.
Method Overriding: A child class can redefine a method of its parent class.
Method Overloading: We can define multiple methods with the same name but different parameters.
Runtime Decision: At runtime, Java determines which method to call depending on the object's actual class.

Types of Polymorphism in Java

In Java Polymorphism is mainly divided into two types:

Compile-Time Polymorphism (Static)
Runtime Polymorphism (Dynamic)

Compile-time Polymorphism (Static Polymorphism):

This type of polymorphism is resolved during the compilation phase.
It is achieved primarily through Method Overloading.
Method Overloading: involves defining multiple methods within the same class that share the same name but have different parameters (different number of parameters, different types of parameters, or a combination of both). The compiler determines which overloaded method to invoke based on the arguments provided during the method call.

class MathOperations {
// Method to add two integers
int add(int a, int b) {
return a + b;
}
// Method to add three integers
int add(int a, int b, int c) {
return a + b + c;
}
// Method to add two double values
double add(double a, double b) {
return a + b;
}
}
public class CompileTimePolymorphismExample {
public static void main(String[] args) {
MathOperations math = new MathOperations();
System.out.println("Sum of two integers: " + math.add(5, 10));
System.out.println("Sum of three integers: " + math.add(5, 10, 15));
System.out.println("Sum of two doubles: " + math.add(5.5, 10.5));
}
}

Runtime Polymorphism (Dynamic Polymorphism):

This type of polymorphism is resolved during the execution (runtime) of the program.
It is achieved primarily through Method Overriding.
Method Overriding: occurs when a subclass provides a specific implementation for a method that is already defined in its superclass. When an overridden method is called through a reference variable of the superclass, the actual method invoked is determined at runtime based on the actual object type being referred to by the reference variable (Dynamic Method Dispatch). This often involves Upcasting, where a subclass object is referred to by a superclass reference.

class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
void sound() {
System.out.println("Dog barks");
}
}
class Cat extends Animal {
void sound() {
System.out.println("Cat meows");
}
}
public class RuntimePolymorphismExample {
public static void main(String[] args) {
Animal myAnimal;
myAnimal = new Dog();
myAnimal.sound(); // Outputs: Dog barks
myAnimal = new Cat();
myAnimal.sound(); // Outputs: Cat meows
}
}

Inheritance of java &types

Rajan S — Fri, 29 Aug 2025 10:44:17 +0000

Java Inheritance is a fundamental concept in OOP(Object-Oriented Programming). It is the mechanism in Java by which one class is allowed to inherit the features(fields and methods) of another class. In Java, Inheritance means creating new classes based on existing ones. A class that inherits from another class can reuse the methods and fields of that class

types of inheritance

Single Inheritance
Multilevel Inheritance
Hierarchical Inheritance
Multiple Inheritance
Hybrid Inheritance

Single Inheritance

class vehicle{

void bike()
{
    System.out.println("bike comfort for two person");
}

}

class car extends vehicle {

void red()
{
    System.out.println("car comfort for four person");
}

}

public class Single {
public static void main(String args[]) {

car c1 = new car ();

c1.bike();
c1.red();

}

}

Output

bike comfort for two person
car comfort for four person

Multilevel Inheritance

class vehicle{

void bike()
{
    System.out.println("bike comfort for two person");
}

}

class car extends vehicle {

void red()
{
    System.out.println("car comfort for four person");
}

}

class bicycle extends car {

void black ()
{
    System.out.println("i like so much");
}

}

public class Multilevel {

public static void main(String args[]) {

bicycle b1 = new bicycle();

b1.bike();
b1.red();
b1.black();

}

}

output

bike comfort for two person
car comfort for four person
i like so much

Hierarchical Inheritance

class vehicle{

void bike()
{
    System.out.println("bike comfort for two person");
}

}

class car extends vehicle {

void red()
{
    System.out.println("car comfort for four person");
}

}

class van extends car {

void white ()
{
    System.out.println("van comfort in more person");
}

}

public class Hierarchical {

public static void main(String args[]) {

van v1 = new van();

v1.bike();
v1.red();
v1.white();

}

}

output

bike comfort for two person
car comfort for four person
van comfort in more person

Operator in Java

Rajan S — Thu, 28 Aug 2025 16:22:57 +0000

operator
In Java, operators are special symbols that perform specific operations on one or more operands (variables or values). They are fundamental to writing code that performs calculations, comparisons, and logical evaluations

*Types of Operator *

Arithmetic Operator
Assignment Operator
Relational Operator
Logical Operator
Bitwise Operator
Ternary Operator

Arithmetic Operators in Java:

Arithmetic operators are used to perform mathematical operations like addition, subtraction, multiplication, etc. The following table shows the Types of Arithmetic Operators in Java:

Assignment Operators in Java:

Java assignment operator is used to assign the value on its right to the operand on its left. The following table shows the Types of Assignment Operators in Java.

Relational Operators in Java:

Relational Operators in Java are also known as Comparison Operators. It determines the relationship between two operands and returns the Boolean results, i.e. true or false after the comparison. The following table shows the Types of Relational Operators in Java.

Logical Operators in Java:

Logical Operators in Java are mainly used in conditional statements and loops for evaluating a condition. They are basically used with binary numbers. The following table shows the types of Logical Operators in Java.

Bitwise Operators in Java:

The Bitwise Operators in Java perform bit-by-bit processing. They can be used with any of the integer types. The following table shows the Types of Bitwise Operators in Java.

Ternary Operator in Java:

Ternary Operator in Java is also known as the Conditional Operator. It is the shorthand of the if-else statement. It is the one-liner replacement of the if-else statement in Java. It is called ternary because it has three operands. The general format of the ternary operator is: Condition ? if true : if false

Parameter Method in Java

Rajan S — Wed, 27 Aug 2025 11:19:38 +0000

Java Method Parameters

Parameters are variables defined in the method declaration after the method name, inside the parentheses. This includes primitive types such as int, float, boolean, etc, and non-primitive or object types such as an array, String, etc.

Today day class is parameters method topic taken in the class .

What is a Parameter in a Method

A parameter is a variable in the method definition that accepts a value (called an argument) when the method is called.

Types of Parameters
Formal Parameters
Defined in the method declaration.
Example: int a, int b in add(int a, int b)

*Actual Parameters *(Arguments)
Passed when calling the method.
Example: add(5, 3) – here 5 and 3 are actual parameters.

https://www.geeksforgeeks.org/java/java-method-parameters/

Today complete my task
class Hello {

int num1;
int num2;
int num3;

Hello(int x,int y, int z) {
num1 = x;
num2 = y;
num3 = z;

}
int addTwo(){
return num1 + num2;
}
int addThree(){
return num1 + num2 + num3;
}

int subTwo(){
return num1 - num2;
}
int subThree(){
return num1 - num2 - num3;
}
int multiplicationTwo(){
return num1 * num2;
}
int multiplicationThree(){
return num1 * num2 * num3;
}
int diviTwo(){
return num1 / num2;
}
int diviThree(){
return num1 / num2 / num3;
}
int modulusTwo(){
return num1 % num2;
}
int modulusThree(){
return num1 % num2 % num3;
}
void displayDetails(){

    System.out.println("Numbers: " + num1 + " , " + num2 + " , " + num3);

    System.out.println("Add num1 + num2 = " + addTwo());

    System.out.println("Add num1 + num2 + num3 = " + addThree());

    System.out.println("Sub num1 - num2 = " + subTwo());

    System.out.println("Sub num1 - num2 - num3 = " + subThree());

    System.out.println("Multiplication num1 * num2 = " + multiplicationTwo());

    System.out.println("Multiplication num1 * num2 * num3 = " + multiplicationThree());

    System.out.println("Divi num1 / num2 = " + diviTwo());

    System.out.println("Divi num1 / num2 / num3 = " + diviThree());

    System.out.println("Modulus num1 % num2 = " + modulusTwo());

    System.out.println("Modulus num1 % num2 % num3 = " + modulusThree());

}
}

public class Calcul {
public static void main(String args[]){

Hello h1 = new Hello(414,524,656);
h1.displayDetails();
}
}

output

Numbers: 414 , 524 , 656
Add num1 + num2 = 938
Add num1 + num2 + num3 = 1594
Sub num1 - num2 = -110
Sub num1 - num2 - num3 = -766
Multiplication num1 * num2 = 216936
Multiplication num1 * num2 * num3 = 142310016
Divi num1 / num2 = 0
Divi num1 / num2 / num3 = 0
Modulus num1 % num2 = 414
Modulus num1 % num2 % num3 = 414

Type casting

Rajan S — Tue, 26 Aug 2025 14:08:41 +0000

Java Type Casting

*java type casting *

Type casting in Java is the process of converting one data type into another. It is essential when you want to perform operations between different data types or when you need to store a value of one type into a variable of another type. Java supports two types of casting: implicit (automatic) casting and explicit (manual) casting.

Type casting is when you assign a value of one primitive data type to another type.

In Java, there are two types of casting:

Widening Casting(implicit) (automatically) - converting a smaller type to a larger type size byte -> short -> char -> int -> long -> float -> double

Here’s an example to illustrate widening type casting in Java

Narrowing Casting(explicit)
(manually) - converting a larger type to a smaller size type
double -> float -> long -> int -> char -> short -> byte
1. Widening or Automatic type converion

Automatic Type casting take place when,

the two types are compatible

the target type is larger than the source type

Example:

2.Narrowing or Explicit type conversion

When you are assigning a larger type value to a variable of smaller type, then you need to perform explicit type casting. If we don't perform casting then compiler reports compile time error.

Example :

Example of Explicit Conversion

Here, we have one more example of explicit casting, double type is stored into long, long is stored into int etc.