DEV Community: Oleksandr

Java: Inheritance, Method Overrides, and Polymorphism.

Oleksandr — Fri, 09 May 2025 10:07:24 +0000

Hey everyone!

In my previous post, I covered encapsulation, getters and setters, access modifiers. Now let's move on to the following fundamental concepts of object-oriented programming: inheritance, method overrides, and polymorphism.

Inheritance

Definitions: A class that is derived from another class is called a subclass (also a derived class, extended class, or child class). The class from which the subclass is derived is called a superclass (also a base class or a parent class).

The idea of inheritance is simple but powerful: When you want to create a new class and there is already a class that includes some of the code that you want, you can derive your new class from the existing class.

A subclass inherits all the members (fields, methods, and nested classes) from its superclass. Constructors are not members, so they are not inherited by subclasses, but the constructor of the superclass can be invoked from the subclass.

Example of Inheritance:

// Super class
class Animal {
    String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + " is eating.");
    }

    public void sleep() {
        System.out.println(name + " is sleeping.");
    }
}

// Subclass
class Dog extends Animal {

    public Dog(String name) {
        super(name); // Calling super class constructor
    }

    public void bark() {
        System.out.println(name + " is barking.");
    }
}

// Entry point
public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog("Rex");

        myDog.eat();     // Inherited from Animal
        myDog.sleep();   // Inherited from Animal
        myDog.bark();    // Method of the Dog class
    }
}

Output:

Rex is eating.
Rex is sleeping.
Rex is barking.

Key Facts About Inheritance in Java

Inheritance creates an “is-a” relationship If Dog extends Animal, then a Dog is an Animal
The extends keyword is used Use extends to create a subclass:

class Dog extends Animal { ... }

A subclass inherits everything except private members
Use super to access parent methods or constructors super() calls the parent constructor. super.methodName() calls a parent class method.
In Java a class can extend only one other class.
Avoid deep inheritance hierarchies Too many levels of inheritance can make code harder to understand and maintain.

Method Overriding

What is Method Overriding?

Method overriding occurs when a subclass provides its own implementation of a method that is already defined in its superclass.

This allows a subclass to define specific behavior while still using the general structure of the superclass.

To override a method:

The method must exist in the superclass.
The method in the subclass must have the same name, return type, and parameters.
Use the @Override annotation (optional but recommended for clarity and compiler checks).

Example of Method Overriding

class Animal {
    public void sound() {
        System.out.println("Animal makes a sound");
    }
}

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

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog(); // Polymorphism in action
        myAnimal.sound(); // Calls overridden method in Dog
    }
}

Output:

Dog barks

Key Points About Method Overriding

The method must have the same signature as the one in the superclass.
The overridden method can have a more specific access modifier (e.g., protected → public).
You can use super.methodName() to call the superclass version of the method from the subclass.
Overriding enables runtime polymorphism.

When Should You Override?

When a subclass needs to customize or specialize a method's behavior. Example: An Animal class with a sound() method, overridden by Dog, Cat, Cow, etc.

Polymorphism

What is Polymorphism?

Polymorphism means “many forms”. In Java, it allows one interface to be used for a general class of actions.

With polymorphism, a parent class reference can point to a child class object, and the correct method is chosen at runtime.

This is a powerful concept because it allows you to write flexible and reusable code.

Example of Polymorphism in Java:

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal1 = new Dog();
        Animal myAnimal2 = new Cat();

        myAnimal1.makeSound(); // Dog barks
        myAnimal2.makeSound(); // Cat meows
    }
}

Output:

Dog barks  
Cat meows

Key Points About Polymorphism

Polymorphism allows methods to behave differently based on the object that’s calling them.
It works with method overriding — the subclass method overrides the parent version.
Enables code generalization: one method can accept many types of objects.
Achieved through inheritance + method overriding.
Only methods are polymorphic — fields are not.

Why Use Polymorphism?

Simplifies code and reduces duplication
Makes your code more extensible and maintainable
Encourages the use of interfaces and abstract classes

Whats next

In the upcoming posts, we’ll explore more advanced and practical concepts in Java:

Abstract Classes & Interfaces
Exception Handling
Enums and Constants

To reinforce what you’ve learned in this post:

Create your own class hierarchy. For example, Animal → Bird, Fish, and Reptile.
Override a method like makeSound() in each subclass with different output.
Try calling overridden methods from the main class using different subclass objects.

This will help you better understand inheritance, method overriding, and polymorphism in action.

Java: Encapsulation, Getters and Setters, Access Modifiers

Oleksandr — Fri, 21 Mar 2025 15:27:07 +0000

Hey everyone!

In my previous post, I covered constructors, return methods, and comments — essential concepts in Java. Today, we’ll continue exploring Object-Oriented Programming (OOP) by learning about encapsulation, getters and setters, access modifiers, and why modifying values directly isn’t a good practice.

Encapsulation in Java

Encapsulation is used to hide the values or state of a structured data object inside a class, preventing unauthorized direct access to them. Instead of allowing values to be changed freely, we use getters and setters to control access and ensure data integrity.

Why use encapsulation?

✅ Keeps data safe by limiting access.
✅ Provides better control over how data is modified.
✅ Makes your code easier to maintain.

Access Modifiers

Access modifiers define the visibility of classes, methods, and variables. Java has four main access modifiers:

public: Accessible from anywhere.
default: Accessible within the same package
protected: Accessible within the same package and by subclasses
private: Accessible only within same class

Example of Encapsulation with Getters and Setters:

class Car {
    // Private fields to ensure data protection
    private String brand;
    private int maxSpeed;

    // Constructor to initialize values
    public Car(String brand, int maxSpeed) {
        this.brand = brand;
        this.maxSpeed = maxSpeed;
    }

    // Getter method for the brand
    public String getBrand() {
        return brand;
    }

    // Setter method for the brand
    public void setBrand(String brand) {
            this.brand = brand;
    }

    // Getter method for maxSpeed
    public int getMaxSpeed() {
        return maxSpeed;
    }

    // Setter method for maxSpeed
    public void setMaxSpeed(int maxSpeed) {
            this.maxSpeed = maxSpeed;
    }

    public void outputValues() {
        System.out.println("Brand: " + brand);
        System.out.println("Max Speed: " + maxSpeed);
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car("BMW", 250);

        // Using getter to display values
        System.out.println("Initial brand: " + car.getBrand());

        // Using setter to update values
        car.setBrand("Audi");
        car.setMaxSpeed(300);

        // Display updated values
        car.outputValues();
    }
}

Output:

Initial brand: BMW
Brand: Audi
Max Speed: 300

Why Avoid Direct Value Modification?

Directly changing field values bypasses important checks and logic that ensure data consistency. Using getters and setters allows you to:

✅ Add validation rules.
✅ Control how values are updated.
✅ Improve code flexibility and scalability.

Summary

✅ Encapsulation protects your data by using private fields.
✅ Getters and setters help control how data is accessed and modified.
✅ Access modifiers define what can be accessed from where.

Whats next

In the next post, we'll explore the topic of inheritance, method overriding, and polymorphism in Java.

To practice, I suggest writing your own class with private fields, using both getters and setters. Try experimenting with access modifiers to understand their behavior better.

Java: Constructors, Return Methods, Comments

Oleksandr — Fri, 21 Feb 2025 17:29:32 +0000

Hey everyone!

In my previous post, I covered Objects, Methods, and Output—key concepts in Java. Today, we’ll continue exploring Object-Oriented Programming (OOP) by diving into сonstructors, methods with return values, comments

Comments in Java

Comments are a way to write notes for yourself or provide explanations for other programmers within your code. They are ignored by the compiler when the code runs, meaning they don’t affect the program’s execution—they are only for humans to read.

What is compiler?

A compiler is a program that translates your Java code into a format that the computer can understand and execute.

Java supports different types of comments:

Single-line comment (starts from //), used for short notes or explanations. Example:

// Next line print car's brand name
System.out.println("Brand name: " + brandName); // Remember about ';'

Multi-line comments(starts from /* and ends with */), used when you need to write longer explanations.

/*
The following line prints the car's model.
Multi-line comments are useful for detailed explanations.
*/
System.out.println("Model: " + model);

Constructors in Java

In simple terms, a constructor in Java is a special method used to create (initialize) objects. It runs automatically when an object of a class is created.

Here are some key points about constructors:

The constructor has the same name as the class
It does not have a return type
It is used to set initial values for object properties(variables)

Example of a constructor:

class Car {
    String brandName;
    String model;
    int maxSpeed;
    double length;
    boolean isEngineWorks;

    // Constructor
    Car() { 
        // Initialize all variables in the constructor
        brandName = "BMW";
        model = "M5";
        maxSpeed = 250;
        length = 4.983;
        isEngineWorks = true;
    }

    void outputValues() {
        System.out.println("Brand name: " + brandName);
        System.out.println("Model: " + model);
        System.out.println("Max Speed: " + maxSpeed);
        System.out.println("Length: " + length);
        System.out.println("Engine Works: " + isEngineWorks);
    }
    public static void main(String[] args) {
        Car car = new Car(); // Calling the constructor when creating an object
        car.outputValues();
    }
}

Output:

Brand name: BMW
Model: M5
Max Speed: 250
Length: 4.983
Engine Works: true

If you do not write any constructor for a class, Java will automatically use a default constructor.
However, the default constructor does not initialize variables - it only creates an object.

Constructors in Java can also accept parameters to initialize variables dynamically.

Example of a constructor with parameters:

class Car {
    String brandName;
    String model;
    int maxSpeed;
    double length;
    boolean isEngineWorks;

    // Constructor with parameters
    Car(String brandName, String model, int maxSpeed, double length, boolean isEngineWorks) {
        this.brandName = brandName;
        this.model = model;
        this.maxSpeed = maxSpeed;
        this.length = length;
        this.isEngineWorks = isEngineWorks;
    }

    void outputValues() {
        System.out.println("Brand name: " + brandName);
        System.out.println("Model: " + model);
        System.out.println("Max Speed: " + maxSpeed);
        System.out.println("Length: " + length);
        System.out.println("Engine Works: " + isEngineWorks);
    }

    public static void main(String[] args) {
        // Passing values to the constructor
        Car car = new Car("BMW","M5",250,4.983,false); 
        car.outputValues();

    }
}

Output:

Brand name: BMW
Model: M5
Max Speed: 250
Length: 4.983
Engine Works: false

Keyword this
In the previous example, you might have noticed the use of this.
The this keyword refers to the current object’s variables.
It helps differentiate between class variables and constructor parameters when they have the same name.

Methods with parameters

Like constructors, methods can also receive parameters that we can use inside them.
Example of a method with parameters:

public class Main {
    public static void main(String[] args) {
        Main main = new Main();
        main.printMessage("Hello");
    }

    // Method with parameters message
    void printMessage(String message) {
        System.out.println(message);
    }
}

Output:

Hello

Method with return type

In Java, a method with a return type is a method that returns a value after execution. The return type specifies the type of data the method will return.
Example of a method with return type:

public class Main {
    public static void main(String[] args) {
        Main main = new Main();
        int a= main.returnInt();
        String b= main.returnString();
        boolean c= main.returnBoolean();
        double d= main.returnDouble();

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }

    int returnInt() {
        return 1;
    }

    String returnString() {
        return "Hello";
    }

    boolean returnBoolean() {
        return true;
    }

    double returnDouble() {
        return 1.0;
    }
}

Output:

1
Hello
true
1.0

You can also use return value for simple output:

public class Main {
    public static void main(String[] args) {
        Main main = new Main();
        System.out.println(main.returnString());
    }

    String returnString() {
        return "Hello";
    }
}

Output:

Hello

Note that a method can also have a void return type if it does not need to return a value.

Keyword `return`

The return keyword specifies which value Java should return as the result of the method execution.

Summary

✅ Constructors help us to initialize objects.
✅ Methods can return values using the return keyword.
✅ Comments make code more understandable.

What's next?

In the next post, we'll discover the topic of encapsulation, Getters and Setters(practical use of encapsulation), access modifiers and why we should not change values directly.

In order to better learn the material, I advise you to write your own class that would contain methods with return types, default and parameterized constructors (try to use them both to create two different objects) and also practice with comments.

Getting Started with Java: Objects, Methods, and Output

Oleksandr — Thu, 20 Feb 2025 17:01:40 +0000

Hey everyone!

In my previous post, I shared my journey and goals as I work towards becoming a Java Developer. Now, it’s time to dive into actual coding!

Java is an object-oriented programming (OOP) language, meaning everything revolves around objects. But why is this important? Think of it like math: you can’t solve logarithms without first understanding basic operations like addition and subtraction. The same applies to Java—before building complex applications, you must grasp the fundamentals.

Today, we’ll cover three core concepts in Java: objects, methods, and fields. We’ll also learn how to display output in the console using System.out.print(). If you're just starting out, this post will give you a solid foundation. And if you already know Java, consider it a refresher

Objects in Java

In Java, we create objects using the class keyword. A class serves as a blueprint for creating objects. Think of it like this:

A Car is a class because it represents a general category.
Specific cars like BMW, Volvo, or Toyota are objects that belong to this class

Every car has properties such as model name, number of seats, max speed, and color. In Java, these properties are called fields (variables).

Declaring Fields (Variables) in Java

Here’s how we define different types of variables in Java:

Integer Numbers (Whole Numbers):
- byte (from -128 to 127)
- short(from -32,768 to 32,767)
- int(from -2,147,483,648 to 2,147,483,647)
- long(from -9 quintillion to +9 quintillion)
Decimal Numbers (Floating-Point Numbers):
- float
- double
Single Character:
- char
Boolean Values (true/false):
- boolean
Text (Strings):
- String (text enclosed in double quotes " ")

Let's create a simple Carclass with some fields:

class Car {
    String brandName = "BMW";
    String model = "M5";
    int maxSpeed = 250;
    double length = 4.983;
    boolean isEngineRunning = false;
}

Understanding Field Declaration

Each field declaration consists of:

A data type (String, int, double, etc.)
A variable name (brandName, model, etc.)
An assignment operator = (used to assign values)
A semicolon ; (required by Java syntax to end a statement)

Rules for Naming Fields in Java

Can contain letters (A-Z, a-z), numbers (0-9), underscores _, and dollar signs $ (though $ is rarely used in practice)
Cannot start with a number (e.g., 3speed ❌)
Cannot contain spaces (e.g., max speed ❌)
Cannot use Java keywords (e.g., int, class, etc.)
Follows camelCase convention (e.g., brandName, isEngineRunning)

How to Output Information in Java

To display information in the console, we use System.out.print() and System.out.println():

System.out.print() → Prints text without moving to a new line.
System.out.println() → Prints text and moves to the next line. Example:

System.out.println("Hello");
System.out.print("World!");

Output:

Hello
World!

We can also print variables:

String brand = "BMW";
System.out.println("Car brand: " + brand);

Output:

Car brand: BMW

The + operator is used to concatenate (join) text and variables.

Methods in Java

Objects don’t just store data—they also perform actions! These actions are defined using methods.

For example, a car can start the engine, accelerate, or brake. In Java, we define these actions as methods inside the class.

Creating a Method

class Car {
    String brandName = "BMW";
    String model = "M5";
    int maxSpeed = 250;
    double length = 4.983;
    boolean isEngineRunning = false;

    void printCarInfo() {
        System.out.println("Brand name: " + brandName);
        System.out.println("Model: " + model);
        System.out.println("Max Speed: " + maxSpeed);
        System.out.println("Length: " + length);
        System.out.println("Engine Running: " + isEngineRunning);
    }
}

To define a method, use the following syntax:

[ReturnType] methodName() {
    // method body
}

The Main Method: The Entry Point

A Java application requires a main method as its entry point. Java starts execution from the main method.


class Car {
    String brandName = "BMW";
    String model = "M5";
    int maxSpeed = 250;
    double length = 4.983;
    boolean isEngineRunning = false;

    public static void main(String[] args) {
        Car car = new Car();
        car.printCarInfo();
    }

    void printCarInfo() {
        System.out.println("Brand name: " + brandName);
        System.out.println("Model: " + model);
        System.out.println("Max Speed: " + maxSpeed);
        System.out.println("Length: " + length);
        System.out.println("Engine Running: " + isEngineRunning);
    }
}

Output:

Brand name: BMW
Model: M5
Max Speed: 250
Length: 4.983
Engine Running: false

Modifying Object Fields with Methods

We can also modify object properties using methods.

class Car {
    String brandName = "BMW";
    String model = "M5";
    int maxSpeed = 250;
    double length = 4.983;
    boolean isEngineRunning = false;

    public static void main(String[] args) {
        Car car = new Car();
        car.printCarInfo();

        car.changeValues();
        car.printCarInfo();
    }

    void printCarInfo() {
        System.out.println("\nBrand name: " + brandName);
        System.out.println("Model: " + model);
        System.out.println("Max Speed: " + maxSpeed);
        System.out.println("Length: " + length);
        System.out.println("Engine Running: " + isEngineRunning);
    }

    void changeValues() {
        brandName = "Mercedes";
        model = "GLE";
        maxSpeed = 230;
        length = 4.926;
        isEngineRunning = true;
    }
}

Output:

Brand name: BMW
Model: M5
Max Speed: 250
Length: 4.983
Engine Running: false

Brand name: Mercedes
Model: GLE
Max Speed: 230
Length: 4.926
Engine Running: true

Summary
Today, we covered:
✅ Objects: The building blocks of Java programs
✅ Fields (Variables): Storing data inside objects
✅ Methods: Defining actions for objects
✅ Printing Output: Using System.out.print() and System.out.println()
✅ The Main Method: The starting point of a Java program

What’s Next?
In the next post, we'll dive deeper into constructors, a special type of method that helps us create objects efficiently!

Final Thoughts
Mastering Java starts with understanding the basics. I hope this post gave you a clear introduction to objects, fields, methods, and printing output in Java. If you have any questions, feel free to ask in the comments!

In order to better learn the material, I advise you to write your own class that would contain the main method, several fields of different types, and methods for output and changing these fields

My Journey to Becoming a Java Developer

Oleksandr — Wed, 19 Feb 2025 18:07:12 +0000

Hello everyone, I’m Oleksandr!
I’m currently a third-year student at a university in Ukraine, but right now, I’m living in Zurich, Switzerland. I’m studying computer science, and my passion for programming started back in high school (around 9th grade). My first steps into the world of coding began with C++, and while I found it fascinating, I hit a roadblock when I encountered arrays. Unfortunately, I gave up on programming for a while after that.

The story doesn’t end there, though. I came back stronger, diving into HTML and CSS. But, once again, I didn’t stick with it long enough to see the bigger picture.

Fast forward to my first year at university, and I discovered Java — my specialization subject. I quickly became the top student in my group. However, when my university switched to online learning, it completely killed my motivation. I found myself playing games instead of studying, and when classes went back offline, I struggled to regain my rhythm.

But this time, I didn’t give up. I reignited my motivation and threw myself back into Java. I started building simple projects and even had some success along the way. But when summer break came, my motivation dropped again, and I lost focus.

Yet, I broke the cycle.

Now, I’m diving into new technologies like Spring Boot, Hibernate, Docker, and more. I’ve completed a few projects, including a social media website and a simple e-commerce site, and now I’m working on a budget tracker. I’m also planning to integrate AI features, which is both challenging and exciting!

Despite my progress, I’ve realized that I still have gaps in my understanding of Java basics and algorithms. So, I’ve decided to start from scratch — reviewing the fundamentals of Java while continuing to develop my projects. This blog will be my way of documenting the journey, sharing my successes, struggles, and everything in between.

What’s next?
In this blog, I’ll share my experiences, lessons learned, and the steps I take to fill in those gaps in my knowledge. I’ll also talk about the projects I’m working on and how I apply the things I learn. Hopefully, my journey will inspire others who are on a similar path!

I’d love for you to follow along as I continue this learning adventure. Feel free to share your thoughts, challenges, or advice — we can support each other on this journey!

DEV Community: Oleksandr

Java: Inheritance, Method Overrides, and Polymorphism.

Inheritance

Key Facts About Inheritance in Java

Method Overriding

What is Method Overriding?

Key Points About Method Overriding

When Should You Override?

Polymorphism

What is Polymorphism?

Key Points About Polymorphism

Why Use Polymorphism?

Whats next

Java: Encapsulation, Getters and Setters, Access Modifiers

Encapsulation in Java

Why use encapsulation?

Access Modifiers

Why Avoid Direct Value Modification?

Summary

Whats next

Java: Constructors, Return Methods, Comments

Comments in Java

What is compiler?

Constructors in Java

Methods with parameters

Method with return type

Keyword return

Summary

What's next?

Getting Started with Java: Objects, Methods, and Output

Objects in Java

Declaring Fields (Variables) in Java

Understanding Field Declaration

Rules for Naming Fields in Java

How to Output Information in Java

Methods in Java

The Main Method: The Entry Point

Modifying Object Fields with Methods

My Journey to Becoming a Java Developer

Keyword `return`