
- Java - Home
- Java - Overview
- Java - History
- Java - Features
- Java Vs. C++
- JVM - Java Virtual Machine
- Java - JDK vs JRE vs JVM
- Java - Environment Setup
- Java - Hello World Program
- Java - Comments
- Java - Basic Syntax
- Java - Variables
- Java - Data Types
- Java - Type Casting
- Java - Unicode System
- Java - User Input
- Java - Date & Time
Java Operators
- Java - Operators
- Java - Arithmetic Operators
- Java - Assignment Operators
- Java - Relational Operators
- Java - Logical Operators
- Java - Bitwise Operators
- Java Operator Precedence & Associativity
Java Control Statements
- Java - Decision Making
- Java - If Else Statement
- Java - Switch Statement
- Java - Loop Control
- Java - For Loop
- Java - For-Each Loop
- Java - While Loop
- Java - Do While Loop
- Java - Break Statement
- Java - Continue Statement
Object Oriented Programming
- Java - OOPs Concepts
- Java - Object & Classes
- Java - Class Attributes
- Java - Class Methods
- Java - Methods
- Java - Variables Scope
- Java - Constructors
- Java - Access Modifiers
- Java - Inheritance
- Java - Aggregation
- Java - Polymorphism
- Java - Overriding
- Java - Method Overloading
- Java - Dynamic Binding
- Java - Static Binding
- Java - Instance Initializer Block
- Java - Abstraction
- Java - Encapsulation
- Java - Interfaces
- Java - Packages
- Java - Inner Classes
- Java - Static Class
- Java - Anonymous Class
- Java - Singleton Class
- Java - Wrapper Classes
- Java - Enums
- Java - Enum Constructor
- Java - Enum Strings
Java Built-in Classes
Java File Handling
- Java - Files
- Java - Create a File
- Java - Write to File
- Java - Read Files
- Java - Delete Files
- Java - Directories
- Java - I/O Streams
Java Error & Exceptions
- Java - Exceptions
- Java - try-catch Block
- Java - try-with-resources
- Java - Multi-catch Block
- Java - Nested try Block
- Java - Finally Block
- Java - throw Exception
- Java - Exception Propagation
- Java - Built-in Exceptions
- Java - Custom Exception
Java Multithreading
- Java - Multithreading
- Java - Thread Life Cycle
- Java - Creating a Thread
- Java - Starting a Thread
- Java - Joining Threads
- Java - Naming Thread
- Java - Thread Scheduler
- Java - Thread Pools
- Java - Main Thread
- Java - Thread Priority
- Java - Daemon Threads
- Java - Thread Group
- Java - Shutdown Hook
Java Synchronization
- Java - Synchronization
- Java - Block Synchronization
- Java - Static Synchronization
- Java - Inter-thread Communication
- Java - Thread Deadlock
- Java - Interrupting a Thread
- Java - Thread Control
- Java - Reentrant Monitor
Java Networking
- Java - Networking
- Java - Socket Programming
- Java - URL Processing
- Java - URL Class
- Java - URLConnection Class
- Java - HttpURLConnection Class
- Java - Socket Class
- Java - Generics
Java Collections
Java Interfaces
- Java - List Interface
- Java - Queue Interface
- Java - Map Interface
- Java - SortedMap Interface
- Java - Set Interface
- Java - SortedSet Interface
Java Data Structures
Java Collections Algorithms
Advanced Java
- Java - Command-Line Arguments
- Java - Lambda Expressions
- Java - Sending Email
- Java - Applet Basics
- Java - Javadoc Comments
- Java - Autoboxing and Unboxing
- Java - File Mismatch Method
- Java - REPL (JShell)
- Java - Multi-Release Jar Files
- Java - Private Interface Methods
- Java - Inner Class Diamond Operator
- Java - Multiresolution Image API
- Java - Collection Factory Methods
- Java - Module System
- Java - Nashorn JavaScript
- Java - Optional Class
- Java - Method References
- Java - Functional Interfaces
- Java - Default Methods
- Java - Base64 Encode Decode
- Java - Switch Expressions
- Java - Teeing Collectors
- Java - Microbenchmark
- Java - Text Blocks
- Java - Dynamic CDS archive
- Java - Z Garbage Collector (ZGC)
- Java - Null Pointer Exception
- Java - Packaging Tools
- Java - Sealed Classes
- Java - Record Classes
- Java - Hidden Classes
- Java - Pattern Matching
- Java - Compact Number Formatting
- Java - Garbage Collection
- Java - JIT Compiler
Java Miscellaneous
- Java - Recursion
- Java - Regular Expressions
- Java - Serialization
- Java - Strings
- Java - Process API Improvements
- Java - Stream API Improvements
- Java - Enhanced @Deprecated Annotation
- Java - CompletableFuture API Improvements
- Java - Streams
- Java - Datetime Api
- Java 8 - New Features
- Java 9 - New Features
- Java 10 - New Features
- Java 11 - New Features
- Java 12 - New Features
- Java 13 - New Features
- Java 14 - New Features
- Java 15 - New Features
- Java 16 - New Features
Java APIs & Frameworks
Java Class References
- Java - Scanner
- Java - Arrays
- Java - Strings
- Java - Date
- Java - ArrayList
- Java - Vector
- Java - Stack
- Java - PriorityQueue
- Java - LinkedList
- Java - ArrayDeque
- Java - HashMap
- Java - LinkedHashMap
- Java - WeakHashMap
- Java - EnumMap
- Java - TreeMap
- Java - IdentityHashMap
- Java - HashSet
- Java - EnumSet
- Java - LinkedHashSet
- Java - TreeSet
- Java - BitSet
- Java - Dictionary
- Java - Hashtable
- Java - Properties
- Java - Collection
- Java - Array
Java Useful Resources
Java - OOPs (Object-Oriented Programming) Concepts
OOPs (Object-Oriented Programming System)
Object means a real-world entity such as a mobile, book, table, computer, watch, etc. Object-Oriented Programming is a methodology or paradigm to design a program using classes and objects. It simplifies software development and maintenance by providing some concepts.
In this tutorial, we will learn about the concepts of Java (OOPs) object-oriented programming systems.

Java OOPs (Object-Oriented Programming) Concepts
Class
In object-oriented programming, a class is a blueprint from which individual objects are created (or, we can say a class is a data type of an object type). In Java, everything is related to classes and objects. Each class has its methods and attributes that can be accessed and manipulated through the objects.
Examples of Class
If you want to create a class for students. In that case, "Student" will be a class, and student records (like student1, student2, etc) will be objects.
We can also consider that class is a factory (user-defined blueprint) to produce objects.
// create a Student class public class Student { // Declaring attributes String name; int rollNo; String section; // initialize attributes Student(String name, int rollNo, String section){ this.name= name; this.rollNo = rollNo; this.section = section; } // print details public void printDetails() { System.out.println("Student Details:"); System.out.println(this.name+ ", "+", " + this.rollNo + ", " + section); } }
Object
In object-oriented programming, an object is an entity that has two characteristics (states and behavior). Some of the real-world objects are book, mobile, table, computer, etc. An object is a variable of the type class, it is a basic component of an object-oriented programming system. A class has the methods and data members (attributes), these methods and data members are accessed through an object. Thus, an object is an instance of a class.
Example of Objects
Continuing with the example of students, let's create some students as objects and print their details.
// create a Student class public class Student { // Declaring attributes String name; int rollNo; String section; // initialize attributes Student(String name, int rollNo, String section){ this.name= name; this.rollNo = rollNo; this.section = section; } // print details public void printDetails() { System.out.print("Student Details: "); System.out.println(this.name+ ", " + this.rollNo + ", " + section); } public static void main(String[] args) { // create student objects Student student1 = new Student("Robert", 1, "IX Blue"); Student student2 = new Student("Adam", 2, "IX Red"); Student student3 = new Student("Julie", 3, "IX Blue"); // print student details student1.printDetails(); student2.printDetails(); student3.printDetails(); } }
Output
Let us compile and run the above program, this will produce the following result −
Student Details: Robert, 1, IX Blue Student Details: Adam, 2, IX Red Student Details: Julie, 3, IX Blue
Inheritance
In object-oriented programming, inheritance is a process by which we can reuse the functionalities of existing classes to new classes. In the concept of inheritance, there are two terms base (parent) class and derived (child) class. When a class is inherited from another class (base class), it (derived class) obtains all the properties and behaviors of the base class.
Example of Inheritance
Continuing with the example of students, let's make student a derived class of person class. Person class will have a single field name and student class will inherit the same as shown below:
// base class for all students class Person { String name; Person(String name){ this.name = name; } } // create a Student class public class Student extends Person { // Declaring attributes int rollNo; String section; // initialize attributes Student(String name, int rollNo, String section){ super(name); this.rollNo = rollNo; this.section = section; } // print details public void printDetails() { System.out.print("Student Details: "); System.out.println(this.name+ ", " + this.rollNo + ", " + section); } public static void main(String[] args) { // create student objects Student student1 = new Student("Robert", 1, "IX Blue"); Student student2 = new Student("Adam", 2, "IX Red"); Student student3 = new Student("Julie", 3, "IX Blue"); // print student details student1.printDetails(); student2.printDetails(); student3.printDetails(); } }
Output
Let us compile and run the above program, this will produce the following result −
Student Details: Robert, 1, IX Blue Student Details: Adam, 2, IX Red Student Details: Julie, 3, IX Blue
Polymorphism
The term "polymorphism" means "many forms". In object-oriented programming, polymorphism is useful when you want to create multiple forms with the same name of a single entity. To implement polymorphism in Java, we use two concepts method overloading and method overriding.
The method overloading is performed in the same class where we have multiple methods with the same name but different parameters, whereas, the method overriding is performed by using the inheritance where we can have multiple methods with the same name in parent and child classes.
Example of Polymorphism
Continuing with the example of students, let's add another method printDetails() with additional parameter to modify the behavior of the method.
// create a Student class public class Student { // Declaring attributes String name; int rollNo; String section; // initialize attributes Student(String name, int rollNo, String section){ this.name= name; this.rollNo = rollNo; this.section = section; } // print details public void printDetails() { System.out.print("Student Details: "); System.out.println(this.name+ ", " + this.rollNo + ", " + section); } // print details without section if required public void printDetails(boolean hideSection) { System.out.print("Student Details: "); System.out.println(this.name+ ", " + this.rollNo + ", " + (hideSection ? "" : section)); } public static void main(String[] args) { // create student objects Student student1 = new Student("Robert", 1, "IX Blue"); Student student2 = new Student("Adam", 2, "IX Red"); Student student3 = new Student("Julie", 3, "IX Blue"); // print student details student1.printDetails(); student2.printDetails(true); student3.printDetails(false); } }
Output
Let us compile and run the above program, this will produce the following result −
Student Details: Robert, 1, IX Blue Student Details: Adam, 2, Student Details: Julie, 3, IX Blue
Abstraction
In object-oriented programming, an abstraction is a technique of hiding internal details and showing functionalities. The abstract classes and interfaces are used to achieve abstraction in Java.
The real-world example of an abstraction is a Car, the internal details such as the engine, process of starting a car, process of shifting gears, etc. are hidden from the user, and features such as the start button, gears, display, break, etc are given to the user. When we perform any action on these features, the internal process works.
Example of Abstraction
Let's create an Abstract Vehicle class and Car extending the Vehicle class. Vehicle will abstract away internal functionalities.
abstract class Vehicle { public void startEngine() { System.out.println("Engine Started"); } } public class Car extends Vehicle { private String color; public Car(String color) { this.color = color; } public void printDetails() { System.out.println("Car color: " + this.color); } public static void main(String[] args) { Car car = new Car("White"); car.printDetails(); car.startEngine(); } }
Output
Let us compile and run the above program, this will produce the following result −
Car color: White Engine Started
Encapsulation
In an object-oriented approach, encapsulation is a process of binding the data members (attributes) and methods together. The encapsulation restricts direct access to important data. The best example of the encapsulation concept is making a class where the data members are private and methods are public to access through an object. In this case, only methods can access those private data.
Example of Objects
Continuing with the example of students, let's create some students as objects and print their details.
// create a Student class public class Student { // Declaring private attributes private String name; private int rollNo; private String section; // initialize attributes Student(String name, int rollNo, String section){ this.name= name; this.rollNo = rollNo; this.section = section; } // print details public void printDetails() { System.out.print("Student Details: "); System.out.println(this.name+ ", " + this.rollNo + ", " + section); } public static void main(String[] args) { // create student objects Student student1 = new Student("Robert", 1, "IX Blue"); Student student2 = new Student("Adam", 2, "IX Red"); Student student3 = new Student("Julie", 3, "IX Blue"); // print student details student1.printDetails(); student2.printDetails(); student3.printDetails(); } }
Output
Let us compile and run the above program, this will produce the following result −
Student Details: Robert, 1, IX Blue Student Details: Adam, 2, IX Red Student Details: Julie, 3, IX Blue
Advantages of Java OOPs
The following are the advantages of using the OOPs in Java:
- The implementations of OOPs concepts are easier.
- The execution of the OOPs is faster than procedural-oriented programming.
- OOPs provide code reusability so that a programmer can reuse an existing code.
- OOPs help us to keep the important data hidden.