DEV Community: Karthick M

Polimorphism

Karthick M — Mon, 16 Feb 2026 18:01:41 +0000

Types of Polimorphism:
1.Method overriding or runtime polymorphism.
2.Method overloading or compile-time polymorphism.

Method overriding: Method overriding means defining a method in the child class with the same name, same parameters, and same return type as the method in the parent class.

It is used to provide a specific implementation in the child class.
1.Rules for Method Overriding
2.Method name must be same
3.Parameters must be same
4.Return type must be same
5.Must have inheritance (extends)
6.Happens between parent and child class

Example:
class Animal {
void sound() {
System.out.println("Animal makes sound");
}
}

class Dog extends Animal {
@override
void sound() {
System.out.println("Dog barks");
}
}

public class Main {
public static void main(String[] args) {
Dog d = new Dog();
d.sound();
}
}

Method overloading: Method overloading means creating multiple methods with the same name in the same class, but with different parameters.

Why we use Method Overloading?

Improves code readability
Same method name for similar operations
No need to create different method names

Rules for Method Overloading:
Methods must differ in at least one of these:
1.Number of parameters
2.Type of parameters
3.Order of parameters

Example:
class Calculator {

void add(int a, int b) {
    System.out.println(a + b);
}

void add(int a, int b, int c) {
    System.out.println(a + b + c);
}

}

public class Main {
public static void main(String[] args) {
Calculator c = new Calculator();
c.add(10, 20); // calls first method
c.add(10, 20, 30); // calls second method
}
}

Types of Inhertance

Karthick M — Mon, 16 Feb 2026 17:48:23 +0000

Types:

Single Inheritance (using extends keyword)
Multilevel Inheritance (grand parent-->parent-->child)
Hierarchical Inheritance (single parent multiple child)
Multiple Inheritance (Not supported in java)
Hybrid Inheritance (combination of all other inheritance)

Java supports Single, Multilevel, and Hierarchical inheritance using classes. Multiple and Hybrid inheritance are not supported using classes but can be achieved using interfaces.

parent
/ \
Dog Cat

Multilevel Inheritance

A class inherits from a class, and another class inherits from that class. Example: class Animal { void eat() { System.out.println("Animal eats"); } }

class Dog extends Animal {
void bark() {
System.out.println("Dog barks");
}
}

class Puppy extends Dog {
void weep() {
System.out.println("Puppy weeps");
}
}

Multiple Inheritance:

it will not supported in java. because of ambiquity issue will come.
One child class inherits from multiple parent classes.

Inheritance

Karthick M — Mon, 16 Feb 2026 17:07:35 +0000

child object behaving as a parent object.
by using Extends keyword we wil achive the inheritance
If we want to create a relationship between two or more classes, we use Inheritance in Java.

What is Inheritance?
Inheritance is a mechanism in Java where one class acquires the properties and behaviors (variables and methods) of another class.

Advantages of using inheritance:

code reusability(less code duplication).

Example:
parent class:
package inheritance;

public class Employee {

int empId;
int salary;
public static void main(String[] args) {

}

public void work() {

    System.out.println("Employee Work");
}

}

Child class:
package inheritance;

public class Developer extends Employee{
public static void main(String[] args) {
Developer dev1 = new Developer();
dev1.empId=101;
dev1.salary=10000;

    System.out.println(dev1.empId);
    System.out.println(dev1.salary);

    dev1.work();
    dev1.devwork();
}

public void devwork() {

    System.out.println("Coding");
}

}

Constructor

Karthick M — Sat, 14 Feb 2026 19:23:41 +0000

Constructor name should be the class name.
Constructor is a special method used to initialize the value for instance variable when the object created.
when we create an object contructor will automatically run.
we cannot manually run/call the contructor.
this is the java keyword.

Costructor types:
1.Default constructor
2.No-Argument Constructor
3.Parameterized constructor

Example:
class Bank {

int accountNo;
String name;
int balance;

Bank(int accountNo, String name , int balance)
{
    this.accountNo = accountNo;
    this.name = name;
    this.balance = balance;
}

public static void main(String[] args)
{

    Bank accholder = new Bank(101,"kumar",1000);
    System.out.println(accholder.accountNo);//101

    Bank accholder1 = new Bank(102,"hari",1000);
    System.out.println(accholder1.accountNo); //102

}

}

What is the purpose of constructor?
Used to initial the values for instance variables at the object creation. By using *this * keyword, we can access/assign values to the instance varaiable inside constructor. this refers to current object only. So this keyword is used to differentiate instance variables from local variables.
what is constructor over loading?
while we are creating more than one contructor, arguments will differ for each contructors.
example:
public class Payilagam {

String name;
String email;
String password;

Payilagam(String name, String email, String password)
{
this.name = name;
this.email = email;
this.password = password;
}

Payilagam( String email, String password)
{
```
this.email = email;
this.password = password;
```
}

public static void main(String[] args)
{
Payilagam user1 = new Payilagam("kumar","abc.com","kumar@123");
System.out.println(user1);
```
Payilagam user2 = new Payilagam("abc.com","kumar@123");
System.out.println(user2);
```
}

}

Operators

Karthick M — Sun, 08 Feb 2026 11:45:40 +0000

Operator is a special symbol used to perform some operations like add, sub, div.. etc..
types od operators:

Assignment operator: = 2.Arithmetic operators: +,-,*,/,%
Unary operators: ++ -> incremental operator -- -> decrement operator no++ -> post increment ++no -> pre increment no-- -> post decrement --no -> pre decrement

4.Equality and relational operators: ==,!=,<,>,<=,>=

Conditional operators: &&,|| && = AND operator || = OR operator Operator: symbol Operand: value

Instance variable, Local variable, static variable and global variable

Karthick M — Sun, 08 Feb 2026 11:33:08 +0000

Instance variable:
we can declare variable in the class level not in the method level.
inside the method we can initialize the value for that variable declared.
Example:
public class School {

// Instance(Object) variable
int std;
int age;

public static void main(String[] args) {

    // Object or Instance
    School akshaya = new School();
    akshaya.std = 10;
    akshaya.age = 15;

    System.out.println(akshaya.std);
    System.out.println(akshaya.age);

School kiruthika = new School();
kiruthika.std = 7;
kiruthika.age = 12;
System.out.println(kiruthika.std);
System.out.println(kiruthika.age);
School karthick = new School();
karthick.std = 12;
karthick.age = 17;

    System.out.println(karthick.std);
    System.out.println(karthick.age);

Local variable:
It is inside the class and also inside the method that is called a local variable.
we cannot able to access from the different method.

Static variable:
It is initialized in the class level not a method level.
It is common for all the objects. we can use that variable in all the object if needed.
example:
public class School {
// static variable
static String school_name = "abc hr sec school";
public static void main(String[] args) {
School akshaya = new School();
System.out.println(School.school_name);
}
}

Global variable:
We can access the variable in side the any methodor all method.

Example for all:
package moduleOne;

public class School {

// Instance(Object) variable
int std;
int age;

// static variable
static String school_name = "abc hr sec school";

// Global variable
String leave = "10th standard";

public static void main(String[] args) {

    // Object or Instance
    School akshaya = new School();
    akshaya.std = 10;
    akshaya.age = 15;

    System.out.println(akshaya.std);
    System.out.println(akshaya.age);
    akshaya.calculate(60, 70, 50, 80, 95);
    System.out.println(School.school_name);

    School kiruthika = new School();
    kiruthika.std = 7;
    kiruthika.age = 12;

    System.out.println(kiruthika.std);
    System.out.println(kiruthika.age);
    kiruthika.calculate(40, 75, 85, 50, 75);

    School karthick = new School();
    karthick.std = 12;
    karthick.age = 17;

    System.out.println(karthick.std);
    System.out.println(karthick.age);
    karthick.calculate(45, 56, 59, 40, 94);
}

public void calculate(int tamil, int english, int maths, int science, int social) {

    // Local variable
    int total = tamil + english + maths + science + social;
    System.out.println(total);
}

}

Looping Statement

Karthick M — Sat, 07 Feb 2026 11:17:22 +0000

While loop:
A while loop checks the condition before executing the loop body.
When to use while loop:
When you don’t know in advance how many times the loop will run
When the condition depends on user input or runtime values
For loop
A for loop is used when you know how many times the loop should run.
When to use for loop:
When the number of iterations is fixed or known
do-while loop
A do-while loop in Java is a loop that executes the code at least once, even if the condition is false.
the condition is checked after the loop body runs.
Example-while loop:
public class LoopingStatement {

public static void main(String[] args) {
int i=1;
while(i<=5)
{
System.out.println(i);
i++;
}

}
}
Example-for loop:
public class LoopingStatement {

public static void main(String[] args) {
```
for(int i=1; i<=10; i++) 
{
    if(i%2 == 0)
    {
        System.out.println("even numbers :"+ i);
    }
    else
    {
        System.out.println("odd numbers :"+ i); 
    }
}
```
}
}
Example-do-while:

Switch case

Karthick M — Sat, 07 Feb 2026 09:44:19 +0000

A switch case is a control statement that lets you run different blocks of code based on the value of a variable or expression.
It’s often cleaner and easier to read than writing many if–else statements.
It allows only the local variable.
We use break; to stop the execution after the expected result is executed. Intead of break; we can use ->. ex: case 1: System.out.println("Monday"); break; instead of this we can use below(from java 12th version) case 1 -> System.out.println("Monday");
In the primitive data types it allows only int, byte, short, char.
It allows non-primitive data type String(from java 8 released) .
Example-1:
public static void main(String[] args) {
```
int day=5;
```
//primitive data type - it allows only int, byte, short, char
//non-primitive data type - it allows String
```
switch (day) //Expression
{
case 1:
    System.out.println("Monday");
break;
case 2:
    System.out.println("Tuesday");
    break;
case 3:
    System.out.println("Wednesday");
    break;
default:
    System.out.println("Holiday");
}
```
}
}
Example-2:
package moduleTwo;

public class SwitchCaseTest {

public static void main(String[] args) {

    String say="hello";

    switch (say) //Expression
    {
    case "hi":
        System.out.println("hey");
    break;
    case "hello":
        System.out.println("Good morning");
        break;
    default:
        System.out.println("unknown");
    }
}

}
Example-3:
public class SwitchCaseTest {

public static void main(String[] args) {

String grade="B";
switch (grade) //Expression
{
case "A","B" ->System.out.println("pass");
case "C" -> System.out.println("fail");
default -> System.out.println("no result");
}

}
}

Decision making statement(if, else if, else)

Karthick M — Sat, 07 Feb 2026 09:02:59 +0000

*decision making statement is take a decision based on given condition.

Example:
package moduleTwo;

public class Sample {

public static void main(String[] args) {

    int mark = 34;
    if(mark >=90)
    {
        System.out.println("A Grade");
    }

    else if(mark>=80)
    {
        System.out.println("B Grade");
    }
    else if(mark>=50)
    {
        System.out.println("C Grade");
    }
    else
    {
        System.out.println("Fail");
    }
}

}

Output:
Fail

Java Variable

Karthick M — Tue, 03 Feb 2026 19:23:36 +0000

*Variable is a container it stores data in memory. Each variable has a name, data type and a value.
*Variable name should start with small letter.
*It is Case-sensitive.
*The type of data that can be stored in a variable is defined by data type.
*It is stored in Stack memory.
Ex :
int value = 27;
int -> data type
value -> variable name
= -> assignment operator
27 -> data
; -> end of statement

// Declaration and Assignment in different line:
int count; // Declaration
count = 20; // Assignment of a value

//Declared and initialized in one line:
int value = 20;
String class = "Java";

Day-4 Data Types

Karthick M — Fri, 30 Jan 2026 14:22:53 +0000

Data types

Data types is type of information or data stored in a variable (like Numbers, character, true/false etc..)
2 types of data types

Primitive data type
Non - primitive data type

1. Primitive date type
Byte - 1 byte
Sort - 2 byte
Int - 4 byte
Long - 8 byte
Float - 2 byte
Double. - 4 byte
Char. - 1 byte
Boolean - 1 bit

1 bit = 8 bit

Range of primitive data types

Byte - 1 byte - 8 bit
Sort - 2 byte - 16 bit
Int - 4 byte - 32 bit
Long - 8 byte _ 64 bit
Float. - 2 byte - 16 bit
Double. - 4 byte -16 bit
Char. - 1 byte - 8 bit
Boolean - 1 bit- 1 bit

*2. Non - primitive Data types *
String

String values will be inside the " " (double quotation)
String can store any text. Eg.- Names → "John" Sentences → "I love programming" Numbers as text → "12345" Symbols → "@#$%" Addresses → "New York, USA"
String stores the multiple char " ".

Day-3 details of Class and Object

Karthick M — Fri, 30 Jan 2026 14:05:52 +0000

Class

*Class is a java keyword
*Class is a template
*Class is logical entity

*First letter of the class name should be in capital(camel notation)
Eg. SalaryAccount

*also in class name we can use the following special chars $, &, _.

*use the numerical values only in the intermediate and last of the class name

Syntax:
Class BankDetails
{
Code
}

OBJECT

*Object is combination of State and Behaviour
*Object is physical entity
*Object is used to store State and behaviour
Syntax
BankDetails ref = new BankDetails();

*new is a keyword of java
*If we create a object, jvm will allocate a memory in heap memory at runtime