Welcome! This site is currently in beta. Get 10% off everything with promo code BETA10.

Blog Post

OOP Concepts in Java

33 min to complete · By Ryan Desmond

Software deals in data. `To effectively utilize data, you need to parse data to make sense of it, analyze data, update data, store data, and so on. So, how do you deal with and make sense of all this data? Object Oriented Programming!

Object Oriented Programming (OOP) allows you to model data – and the methods/functions that act on that data – in an intuitive way. Once you’ve modeled the required data classes and objects the application needs, you can interact with that data in a logical way.

Continue reading about Object Oriented Programming, OOP Concepts, Elements, Languages, Modeling, and more.

OOP concepts in Java, OOP concepts, what is object oriented programming

What is Object Oriented Programming?

Object Oriented Programming is a coding paradigm that organizes code around data, aka “objects”, rather than functions and procedures. OOP simplifies software development by enabling us to model any data that we need and work with that data in a logical way.

OOP uses classes to define the data model and provide simple, reusable blueprints for creating objects. By allowing us to model the world around us in an intuitive way, OOP vastly reduces software complexity, development time, and maintenance.

For instance, if you are building an application that manages a restaurant, you would have classes such as Restaurant, Menu, MenuItem, Beverage, Employee, and Guest. Once you have the classes that map out the application, you can quickly associate, compare, update, collate, and analyze all the data in that model.

You can also map these objects to databases and communicate with other services on the web using these objects in JSON.

Why is OOP Important?

  1. Reduces complexity: OOP promotes data reuse, helping reduce development time and complexity. Using OOP concepts in Java, you can write a functionality once and reuse it everywhere else.
  2. Reduces maintenance time: OOP makes projects modular, allowing you to isolate and solve issues more efficiently. For example, if the bill amount is incorrect, the problem is with the Bill class, and one can go directly there and start debugging.
  3. Widely applicable: OOP can be used to model any scenario imaginable, making it highly useful and applicable in various business use cases.

Object-Oriented Languages

Object Oriented Languages are programming languages with OOP features. There are two main categories of Object Oriented Languages (OOLs):

  1. Class-based OOLs: In these, classes are defined first, and objects are instances of classes. Some examples of these languages are C++, Java, Ruby, Scala, and Eiffel.
  2. Classless OOLs: In these, objects are cloned from their prototypes. Every object can have only one prototype link. Some examples of these languages are Self and Haskel.

Many languages, however, fall outside of these two categories. An example is Javascript, which has some properties of each of the two types.

OOP Elements in Java

Class

A Class is a template – or a blueprint – that defines the form of an object. A class specifies the data and the code that acts on objects within that class. Objects are instances of a class, while data members are instance variables.

Classes, in their purest form, define two major aspects of an object: the data and methods. The data is stored as instance variables of different types. This data is used to describe objects of the said class. The methods describe actions that can be performed on that data.

Instance variables are declared outside of methods and exist as class members. Each instance of a class – as well as each object – gets its own instance variables.

The best way to understand the class/object relationship is to look at an example. In the code below, we created a basic class called Vehicle, which can tell us the number of passengers and fuel capacity:

class Vehicle{
    //declaration of instance variable storing num of passengers
    private int passengers; 
    // method that returns the number of passengers
    public int getPassengers() { 
		return passengers;
    }
	// method “sets” the number of passengers
	public void setPassengers(int numPassengers){
		This.passengers = numPassengers;
	}
}

Now that we have created a class, we can create Objects from this class:

class Example {
    public static void main(String[] args){
        // create a new object of type Vehicle named "myVehicle"
        Vehicle myVehicle = new Vehicle();
        // then we can set the instance variables in the myVehicle object
        myVehicle.setPassengers(5);
        // then we can also access the methods within the myVehicle object
        System.out.println(myVehicle.getPassengers());
    }
}

Source: Javatpoint

Object

Objects are used to store data, act on that data, and interact with other objects. Each time you create an object (aka an instance) of a class, you create an object that contains its own copies of each instance variable found in the class. For example, each instance – or object – of the Vehicle class has its own instance variables, passengers and fuelCap.

class Example {
    public static void main(String[] args){
        // create a new object of type Vehicle named "myVehicle1"
        Vehicle myVehicle1 = new Vehicle();
        // then you can set the instance variables in the myVehicle1 object
        myVehicle1.setPassengers(5)
        Vehicle myVehicle2 = new Vehicle();
        // then you can set the instance variables in the myVehicle2 object
        myVehicle2.setpassengers(11);
        // then you can also access the methods within the myVehicle1 and myVehicle2 objects
        System.out.println(myVehicle1.getPassengers()); //prints 5
        System.out.println(myVehicle2.getPassengers()); //prints 11
    }
}

Now, since each object has its own copies of the instance variables, you can set them to hold distinct values.

All objects have three essential features:

  • State: An object’s state is defined by the object's instance variables and by the values these have. Thus, you can alter the state of an object by changing the values of the instance variables.
  • Behavior: An object’s behavior is defined by its methods. When an object wants to act on another object, it uses that object’s methods. For security reasons, not all of the object’s methods are visible to other objects.
  • Identity: The identity of an object is independent of its instance variables or methods. For example, two vehicles with the same number of passengers and fuel cap are still two different objects.

Source: Javatpoint

OOP Concepts in Java

There are four primary OOP concepts in Java: Encapsulation, Data Abstraction, Polymorphism, and Inheritance.

Encapsulation in Java

Encapsulation in Java is the process of wrapping up variables (data) and the methods (code) that act on that data together as a single unit within a class.

For example, suppose you have two classes – Car and Dog. The Dog class and the Car class are two entirely distinct entities unrelated to each other. Their data (instance variables), and their methods which act on that data are encapsulated within their respective classes. This means all data and methods related to a car will be in the Car class. All data and methods related to a dog will be in the Dog class. You can create as many objects of these classes as you want.

class Car {
    String make;
    String model;
    public void drive(int distance){
        // some action(s) to drive the car
    }
}

Another example depicted below is a Box class, in which we create three instances – or objects – of the Box class.

OOP concepts in Java, OOP concepts, what is object oriented programming

Data Abstraction in Java

Abstraction in Java is the act of hiding unnecessary details and only showing essential information to the user. For example, a driver sees a car as a car, rather than as its individual components.

Abstraction can be achieved with either abstract classes or interfaces.

Abstract Classes

Abstract classes are restricted classes that cannot be used to create objects. The instance variables of an abstract class can be accessed when inherited from another class. Abstract methods are methods present only in abstract classes which do not have a body. The body is provided by a subclass that inherits from the abstract class. If a class has even one abstract method, it is an abstract class.

abstract class Vehicle{
  // Abstract method - the method below does not have a “method body”
  public abstract int numberOfWheels();
  
  // Below is a standard method with a body
  public void start() {
    System.out.println("Starting vehicle.");
  }
}

// Subclass (inherits from Vehicle)
class Car extends Vehicle{
  public int numberOfWheels() {
    // The method body of numberOfWheels() is provided here
    System.out.println("Car has 4 wheels");
    return 4;
  }
}

class AbstractClassDemo {
  public static void main(String[] args) {
    Car myCar = new Car(); // Create a Car object
    Int wheels = myCar.numberOfWheels();
    myCar.start();
  }
}

Interfaces

Interfaces are completely abstract classes that can be used to group related methods. Interfaces do not have any non-abstract methods, while abstract classes can have non-abstract methods.

interface Vehicle{
  public abstract int numberOfWheels();
  public abstract void start();
}

// Class that implements the Vehicle interface
class Car implements Vehicle{
  public int numberOfWheels() {
    System.out.println("Car has 4 wheels");
    return 4;
  }
  public void start() {
    System.out.println("Starting car.");
  }
}

class AbstractClassDemo {
  public static void main(String[] args) {
    Car myCar = new Car(); // Create a Car object
    int wheels = myCar.numberOfWheels();
    myCar.start();
  }
}

Inheritance in Java

Inheritance is when one object acquires many of the properties and behaviors of a parent object.

Inheritance provides code reusability, allowing us to minimize redundant code by organizing shared attributes in parent classes – known as superclasses. OOP languages enable a class to add a superclass when it’s declared. Child classes – aka subclasses – inherit all public and protected variables and methods from their superclasses.

Using a visual example, “Red Apple” and “Green Apple” only need to define what makes them unique from each other. Their shared attributes will reside within the (parent) Apple class. The attributes shared between Apple and Orange will live within the Fruit class.

OOP concepts in Java, OOP concepts, what is object oriented programming

For example, using code:

class Car {
    public String make;
    public String model;
    public void drive(int distance){
        // some action(s) to drive the car
    }
}


class SportsCar extends Car {
    boolean hasRaceTires;
    boolean hasSpoiler;
    public double getZerotoSixtyTime(){
         // do something to determine time from zero to sixty MPH
    }
} 


class CarDemo {
    public static void main(String[] args){
        SportsCar ferrari = new SportsCar();
        //below, we are using the "make" variable, which is defined in Car
        Ferrari.make = "Ferrari";
        //below, we are using the "model" variable, which is defined in Car
        Ferrari.model = "599 XX";
        //below, we are using the "hasSpoiler" variable, which is defined in SportsCar
        Ferrari.hasSpoiler = true;
        //below, we are using the "hasRaceTires" variable, which is defined in SportsCar
        Ferrari.hasRaceTires = true;
        //below we are using the "drive()" method which is defined in Car
        ferrari.drive(20);
        //below, we are using the "getZeroToSixtyTime" method, which is defined in SportsCar
        double time = ferrari.getZeroToSixtyTime();
        //...
    } 
}

An object of the SportsCar class has direct access to all public and protected members of the Car class. The SportsCar class may use the public and protected variables and methods in the Car class as though they are their own, as though they were defined in the SportsCar class. That said, the Car class has no knowledge of the SportsCar class.

Polymorphism in Java

Polymorphism is the ability of an object to take on many forms, thereby allowing a method to perform different actions based on which object the method is called upon.

For example, in the depiction below, we use the steering wheel in the center as an analogy for polymorphism in Java. No matter what car you’re driving, there is a steering wheel. The steering wheel remains constant; however, depending on what type of car you’re driving – a sports car vs. a vintage car vs. a semi-truck – the mechanism behind the wheel and the behavior produced can be quite different.

Using the polymorphism OOP concept in Java, we can replicate a concept to make our code easier, more flexible, and more intuitive.

OOP concepts in Java, OOP concepts, what is object oriented programming

One great example of polymorphism is the System.out.println() method that we all use so frequently. It looks like a single method println() – but how does it work in so many different ways if it's a single method?

For instance, if Java is a strongly typed language, how can a single method take an int, a double, a String, an object, a char, etc., as a parameter? How is this possible? Polymorphism. What looks like a single method println() is actually nine separate methods. Each method takes a different parameter type and has a slightly different behavior to accomplish the goal of printing that value.

public void println(boolean x) {
        //...
    }
    public void println(char x) {
        //..
    }
    }
    public void println(int x) {
        // ...
    }

    // and there are 6 more println() methods

The polymorphism demonstrated by println() results from “overloading”. In this case, the println() method is “overloaded” nine times in the Java source code. This allows us to call this method in nine different ways. That said, to the end-user, it looks like a single method.

Another great example of polymorphism in Java is the concept of “overriding”. In this case, a parent class can define a method, and a child class can override the behavior of the parent class. This is where Inheritance and Polymorphism overlap.

To override a method in a parent class, the child class must declare a method with the same return type, name, and parameters. The method signatures must match exactly. @Override is an optional Java annotation that communicates that this method overrides a method in a parent class.

// parent class Vehicle
class Vehicle {
    int mpg;
    int fuel_capacity;
    String type;

    // parent method start()
    public void start(){
        System.out.println("Vehicle starting...");
        // do steps to start a vehicle
    }
}


// child class Motorcycle
class Motorcycle extends Vehicle {
    Motorcycle(){
        mpg = 30;
        fuel_capacity = 10;
        type = "motorcycle";
    }
    
    // the method below overrides the behavior of the start() method in the Vehicle class
    @Override
    public void start(){
        System.out.println("Motorcycle starting...");
        // do steps to start a motorcycle
    }
}


class OverrideDemo {
    public static void main(String[] args){
        Vehicle vehicle = new Vehicle();
        Vehicle moto = new Motorcycle();
        // now invoke the start() method on the Motorcycle
        // which overrides the start() method in the Vehicle class
        moto.start();
        // now invoke the start() method on the Vehicle object 
        // (which will call the start() method in the Vehicle class)
        vehicle.start();
    }
}

In the example above, the start() method of the Vehicle class is overridden in the Motorcycle class. This makes perfect sense; while most vehicles start similarly, a motorcycle has different steps and actions required to start it.

For instance, most motorcycles have a kick-start. Using the concept of overriding, we can treat a motorcycle as a vehicle like any other, but we can define specific behaviors to the start() method depending on which type of vehicle we’re dealing with.

Object Association: Composition and Aggregation

Now that you understand the core OOP concepts in Java, the next step is to consider how all these objects interact with or relate to one another. In short, we can associate objects with one another, we can create objects that are composed of other objects, and we can aggregate objects that, as a whole, represent a larger concept. Let’s take a look at each below.

Object Association

Object Association is when there is a relationship between objects of two different classes. For example, we can associate a “Student” with a “Car”. But a student is not comprised of a car. And a car is not comprised of a student. They are two unique objects that can be associated. For example:

Student student = new Student(...);
Car car = new Car(...);
System.out.println(student.name + “ drives a “ + car.brand);

In the example above, we are “associating the Student and Car. But they are not codependent. Each can and does exist independently of the other.

Object Composition

Object Composition is what happens when one class is comprised of one or more other classes. Object composition forms a “part-of” relationship between the two classes. For example, a Vehicle class is a composition of the Battery and Engine classes. When the vehicle is destroyed, its components are also destroyed. For example:

public class Vehicle {
    
    Battery battery;
    Engine engine;
 
    public Vehicle(Battery battery, Vehicle vehicle){
        this.battery = battery;
        this.engine = engine;
    }
}

In the example above, the Vehicle class contains both the Battery and Engine classes as instance variables. The Vehicle class is composed of multiple sub-objects. The Vehicle, in this case, much as is the case in the real world, cannot exist without a Battery and an Engine. This is object composition.

The aggregation association between two or more classes is when the classes can exist independently but as a group can be interpreted as a larger concept. The classes have a unidirectional, “has-a” relationship with each other. For example, a Company class is an aggregation of many objects of the Person class (its employees). However, if the company ends, the persons will continue to exist.

Object-Oriented Modeling (OOM)

Now that you understand OOP concepts and Object Association, Object-oriented modeling (OOM) is the first step in actual development when using an object-oriented approach. Here, you model the problem by creating classes corresponding to real-world entities. Only the attributes and behaviors of the object relevant to the current task at hand are retained, and the others are discarded.

For example, to build a restaurant management system, you may need to model different objects such as Restaurant, Menu, MenuItem, Beverage, Employee, and Guest. An employee may have some attributes irrelevant to the restaurant management system, such as their hobbies or least favorite color. These are not included in the instance variables for the Employee class.

Steps in Object-Oriented Modeling

Object-oriented modeling typically has the following steps:

  • Identification of classes
  • Identification of instance variables of the classes
  • Identification of methods of the classes
  • Identification of relationships between classes

Once these elements are identified, you can begin using OOP concepts in Java!

Summary – OOP Concepts in Java

OOP simplifies software development and maintenance by allowing us to model the world around us logically and intuitively. With OOP, you can define the data model and required functionality once and reuse it everywhere, reducing complexity and development time.

OOP organizes code around data, aka “objects”, instead of functions and logic. OOP uses classes as blueprints for creating objects. The four main OOP concepts in Java include:

  1. Encapsulation: The process of wrapping up data and the methods that operate on that data together as a single unit within a class. For example, all data and methods related to a cat will be in the Cat class. All data and methods related to a dog will be in the Dog class.
  2. Data Abstraction: The process of hiding unnecessary details from the user and only showing essential information and, for example, showing a car as a car rather than an axle, wheels, doors, windshield, engine, muffler, radiator, etc.
  3. Inheritance: When one object acquires many of the properties and behaviors of a parent object. For example, a Red Apple class and a Green Apple class both inherit many properties from the Apple class, inheriting many of its properties from the Fruit class.
  4. Polymorphism: Polymorphism is the ability of an object to take on many forms, thereby allowing a method to perform different actions based on which object the method is called upon. For example, the steering wheel in a semi-truck acts quite differently than the steering wheel in a sports car, even though they are both still steering wheels.

Want to learn more?

If you’d like to diver even deeper into OOP concepts in Java and to build OOP projects on your own, click below to check out CodingNomads’ Java Programming Courses and Java Career Track.

READ NEXT: TOP 7 REASONS TO LEARN JAVA