In this tutorial we want to learn about Java OOP for Beginners, Java is one of the most popular programming languages, and the reason is this that Java supports Object Oriented Programming or OOP. OOP is a programming paradigm that allows developers to build complex software systems by organizing code into reusable, modular and easily understandable components called objects. in this article we want to introduce the basics of Java OOP, including its key concepts and terminology.
Classes and Objects
In Java everything is an object and every object belongs to a class. A class is a blueprint or a template that defines the characteristics and behavior of objects of that class. For example, if we were building a program to model a bank account, we might define a class called “BankAccount” that would specify the account number, balance, and various methods for depositing and withdrawing money.
An object, on the other hand, is an instance of a class. Once we have defined a class, we can create as many objects of that class as we need. Each object will have its own unique set of data (known as instance variables) and methods, but all of the objects will share the same set of characteristics and behaviors defined by the class. In our bank account example, we might create multiple objects of the “BankAccount” class, each with its own account number and balance.
Encapsulation is one of the key concepts of OOP, and it refers to the practice of hiding the implementation details of a class from the outside world. in Java we achieve encapsulation by using the access modifiers, because it controls the visibility of a class fields and methods.
There are four access modifiers in Java:
- public: The field or method can be accessed from anywhere, even outside of the class.
- private: The field or method can only be accessed from within the class.
- protected: The field or method can be accessed from within the class, and also from within subclasses and classes in the same package.
- default: If no access modifier is specified, the field or method can be accessed from within the same package.
In general we want to keep the fields of a class private and provide public methods for accessing and modifying those fields. this way we can control how the data is used and ensure that it is always in a valid state.
Inheritance is another important concept in OOP, and it allows us to create new classes based on existing ones. when we have a class and that class inherits from another class, it inherits all of the fields and methods of the parent class. new class is called the subclass and the original class is called the superclass. inheritance allows us to reuse code and avoid duplicating functionality across multiple classes. for example if we want to build a game that had multiple different types of enemies, we might define a superclass called Enemy that would include common methods and fields like health, attack power and movement speed. after that we can create subclasses like Goblin and Orc that would inherit from the Enemy class and add their own unique characteristics and behaviors.
Polymorphism is the ability of an object to take on many forms. in Java we can achieve polymorphism through method overriding and method overloading.
Method overriding occurs when a subclass provides its own implementation of a method that is already defined in the superclass. when we call that method on an object of the subclass, the overridden implementation will be used instead of the one in the superclass.
Method overloading occurs when we define multiple methods with the same name but different parameter lists. When we call the method, Java will choose the appropriate implementation based on the arguments we pass in.