Cheat Sheet for Java Object-Oriented Programming (OOP)

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.

OOP Concepts Cheat Sheet

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

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!