Java Object-Oriented Programming (OOP) Cheat Sheet

Introduction

Object-Oriented Programming (OOP) is a programming paradigm that uses "objects" to design applications and computer programs. It allows for modeling real-world entities and their interactions, making it easier to manage and scale software projects. This cheat sheet covers all fundamental and advanced OOP concepts in Java.

Java OOP Concepts Cheat Sheet

Here's a handy cheat sheet of the most commonly used OOP concepts in Java, along with real-world examples:

Concept	Description	Real-World Example
Object	An instance of a class that contains state and behavior.	A specific car (e.g., a red BMW) is an object of the Car class.
Class	A blueprint for creating objects, defining their state and behavior.	The Car class defines properties like color, model, and methods like drive() and brake().
Abstraction	Hiding complex implementation details and showing only the necessary features of an object.	A TV remote provides buttons for users to interact with, hiding the complex electronics inside.
Encapsulation	Bundling the data (variables) and code (methods) that operates on the data into a single unit or class.	A capsule of medicine contains a mix of ingredients encapsulated in a pill; users can't access them individually.
Inheritance	A mechanism where a new class inherits properties and behaviors from an existing class.	A Sedan class inherits from the Car class, gaining its properties and behaviors while adding specific features.
Polymorphism	The ability of a single function or method to operate in different ways based on the object it is acting upon.	A driver can operate different types of vehicles (car, bike, truck) using the same driving method.
Composition	A design principle where one class is composed of one or more objects from other classes.	A computer is composed of a CPU, RAM, and hard drive, each being a separate class.
Aggregation	A form of association with a "has-a" relationship but with independent lifecycles.	A library has a collection of books, but books can exist without the library.
Association	A relationship between two classes that allows one class to use the functionalities of another class.	A teacher and a student have an association where a teacher teaches a student.
Cohesion	The degree to which the elements of a module/class belong together.	A well-defined class with a single responsibility, such as a Date class handling date-related operations.
Coupling	The degree to which one class is dependent on another class.	High coupling is like a tightly connected group of friends who can't function independently.
Delegation	A design pattern where an object hands off a task to a helper object.	A manager delegates tasks to team members, who perform the actual work.

Explanation of OOP Concepts with Examples

Object

• Description: An instance of a class.
• Example:

  class Car {
      String model;
      int year;
  }
  
  public class Main {
      public static void main(String[] args) {
          Car car = new Car(); // Creating an object of Car
          car.model = "Toyota";
          car.year = 2020;
      }
  }
  

• Explanation: The Car class is used to create an object car with specific attributes (model and year).

Class

• Description: A blueprint for creating objects.
• Example:

  class Car {
      String model;
      int year;
  
      void displayInfo() {
          System.out.println("Model: " + model + ", Year: " + year);
      }
  }
  

• Explanation: The Car class defines attributes and methods for Car objects.

Abstraction

• Description: Hiding complex implementation details and showing only the essential features.
• Example:

  abstract class Animal {
      abstract void makeSound();
  }
  
  class Dog extends Animal {
      void makeSound() {
          System.out.println("Bark");
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Animal myDog = new Dog();
          myDog.makeSound(); // Output: Bark
      }
  }
  

• Explanation: The Animal class is abstract and hides the implementation details of makeSound method, which is provided by the Dog class.

Encapsulation

• Description: Wrapping data (variables) and code (methods) together as a single unit.
• Example:

  class Person {
      private String name;
      private int age;
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public int getAge() {
          return age;
      }
  
      public void setAge(int age) {
          this.age = age;
      }
  }
  

• Explanation: The Person class encapsulates the name and age fields and provides public methods to access and update them.

Inheritance

• Description: A mechanism to create a new class using properties and behaviors of an existing class.
• Example:

  class Animal {
      void eat() {
          System.out.println("This animal eats food");
      }
  }
  
  class Dog extends Animal {
      void bark() {
          System.out.println("This dog barks");
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Dog dog = new Dog();
          dog.eat(); // Output: This animal eats food
          dog.bark(); // Output: This dog barks
      }
  }
  

• Explanation: The Dog class inherits the eat method from the Animal class and adds its own bark method.

Polymorphism

• Description: The ability to present the same interface for different data types.
• Example:

  class Animal {
      void makeSound() {
          System.out.println("Some sound");
      }
  }
  
  class Dog extends Animal {
      void makeSound() {
          System.out.println("Bark");
      }
  }
  
  class Cat extends Animal {
      void makeSound() {
          System.out.println("Meow");
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Animal myDog = new Dog();
          Animal myCat = new Cat();
  
          myDog.makeSound(); // Output: Bark
          myCat.makeSound(); // Output: Meow
      }
  }
  

• Explanation: The makeSound method is overridden in Dog and Cat classes. The myDog and myCat objects call their respective overridden methods.

Composition

• Description: A design principle where a class is composed of one or more objects from other classes.
• Example:

  class Engine {
      void start() {
          System.out.println("Engine starts");
      }
  }
  
  class Car {
      private Engine engine;
  
      Car() {
          engine = new Engine();
      }
  
      void startCar() {
          engine.start();
          System.out.println("Car starts");
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Car car = new Car();
          car.startCar(); // Output: Engine starts, Car starts
      }
  }
  

• Explanation: The Car class is composed of an Engine object. When startCar is called, it uses the Engine object to start the engine first.

Aggregation

• Description: A form of association with a whole-part relationship but without ownership.
• Example:

  class Department {
      private String name;
  
      Department(String name) {
          this.name = name;
      }
  
      String getName() {
          return name;
      }
  }
  
  class University {
      private String name;
      private List<Department> departments;
  
      University(String name) {
          this.name = name;
          departments = new ArrayList<>();
      }
  
      void addDepartment(Department department) {
          departments.add(department);
      }
  
      void showDepartments() {
          for (Department dept : departments) {
              System.out.println(dept.getName());
          }
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          University university = new University("My University");
          Department cs = new Department("Computer Science");
          Department math = new Department("Mathematics");
  
          university.addDepartment(cs);
          university.addDepartment(math);
  
          university.showDepartments(); // Output: Computer Science, Mathematics
      }
  }
  

• Explanation: The University class aggregates Department objects. The departments exist independently of the university.

Association

• Description: A relationship between two classes.
• Example:

  class Author {
      private String name;
  
      Author(String name) {
          this.name = name;
      }
  
      String getName() {
          return name;
      }
  }
  
  class Book {
      private String title;
      private Author author;
  
      Book(String title, Author author) {
          this.title = title;
          this.author = author;
      }
  
      void showDetails() {
          System.out.println("Book: " + title + ", Author: " + author.getName());
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Author author = new Author("J.K. Rowling");
          Book book = new Book("Harry Potter", author);
  
          book.showDetails(); // Output: Book: Harry Potter, Author: J.K. Rowling
      }
  }
  

• Explanation: The Book class is associated with the Author class through the author field.

Cohesion

• Description: The degree to which elements of a module belong together.
• Example:

  class Library {
      private List<Book> books;
  
      Library() {
          books = new ArrayList<>();
      }
  
      void addBook(Book book) {
          books.add(book);
      }
  
      List<Book> getBooks() {
          return books;
      }
  }
  

• Explanation: The Library class has high cohesion as it only deals with managing Book objects.

Coupling

• Description: The degree of direct knowledge that one module has of another.
• Example:

  class Printer {
      void print(String text) {
          System.out.println(text);
      }
  }
  
  class Document {
      private Printer printer;
  
      Document(Printer printer) {
          this.printer = printer;
      }
  
      void printDocument() {
          printer.print("This is a document.");
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Printer printer = new Printer();
          Document document = new Document(printer);
          document.printDocument(); // Output: This is a document.
      }
  }
  

• Explanation: The Document class is tightly coupled with the Printer class, as it relies directly on the Printer class to perform its function.

Delegation

• Description: A design pattern where an object passes a task to a helper object.
• Example:

  class Printer {
      void print(String text) {
          System.out.println(text);
      }
  }
  
  class Document {
      private Printer printer;
  
      Document(Printer printer) {
          this.printer = printer;
      }
  
      void printDocument(String text) {
          printer.print(text);
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Printer printer = new Printer();
          Document document = new Document(printer);
          document.printDocument("Hello, World!"); // Output: Hello, World!
      }
  }
  

• Explanation: The Document class delegates the printing task to the Printer class.

Conclusion

Understanding and applying OOP concepts is crucial for designing robust, maintainable, and scalable software. This cheat sheet provides a quick reference to the key OOP concepts in Java, complete with real-world examples and code snippets. By leveraging these concepts, you can write clean, efficient, and reusable code. Keep this guide handy as you work with Java OOP to enhance your development skills. Happy coding!