12.1 Object-oriented programming

Object-oriented programming (OOP) is a powerful paradigm that organizes code around data and functions. It focuses on creating reusable, modular code through concepts like encapsulation, inheritance, and polymorphism. These principles help developers build flexible and maintainable software systems.

OOP revolves around classes and objects. Classes serve as blueprints, defining attributes and methods, while objects are instances of classes with unique data. This approach allows for better code organization, promotes reusability, and enables the creation of complex systems through relationships between classes.

Fundamentals of object-oriented programming

• Object-oriented programming (OOP) is a programming paradigm based on the concept of objects, which can contain data and code
• OOP focuses on creating reusable code and organizing software around data and functions rather than logic and procedures
• The main principles of OOP include encapsulation, inheritance, and polymorphism, which help create modular, flexible, and maintainable code

Classes vs objects

Top images from around the web for Classes vs objects

• 

  object oriented - UML class diagram notations: Differences between Association, Aggregation and ... View original

  Is this image relevant?

• 

  File:CPT-OOP-objects and classes - attmeth.svg - Wikimedia Commons View original

  Is this image relevant?

• 

  Object-Oriented Programming Concepts View original

  Is this image relevant?

• 

  object oriented - UML class diagram notations: Differences between Association, Aggregation and ... View original

  Is this image relevant?

• 

  File:CPT-OOP-objects and classes - attmeth.svg - Wikimedia Commons View original

  Is this image relevant?

1 of 3

Top images from around the web for Classes vs objects

• 

  object oriented - UML class diagram notations: Differences between Association, Aggregation and ... View original

  Is this image relevant?

• 

  File:CPT-OOP-objects and classes - attmeth.svg - Wikimedia Commons View original

  Is this image relevant?

• 

  Object-Oriented Programming Concepts View original

  Is this image relevant?

• 

  object oriented - UML class diagram notations: Differences between Association, Aggregation and ... View original

  Is this image relevant?

• 

  File:CPT-OOP-objects and classes - attmeth.svg - Wikimedia Commons View original

  Is this image relevant?

1 of 3

• Classes define the structure and behavior of objects and serve as blueprints for creating instances (objects)
• Objects are instances of a class that encapsulate state (attributes) and behavior (methods)
  • Each object has its own unique set of attribute values, but shares the same methods defined in the class
• Example: A

  Person

  class might define attributes like

  name

  and

  age

  , while objects of the

  Person

  class would represent specific individuals with their own names and ages

Encapsulation of data and behavior

• Encapsulation bundles data (attributes) and functions (methods) that operate on that data within a class
• It hides the internal state of an object and provides controlled access through public methods
  • This protects the data from unintended modification and ensures consistency
• Example: A

  BankAccount

  class might have private attributes like

  balance

  and public methods like

  deposit()

  and

  withdraw()

  to manage the account balance safely

Inheritance for code reuse

• Inheritance allows classes to inherit attributes and methods from other classes, promoting code reuse and hierarchical relationships
• A subclass (derived class) inherits the properties of its superclass (base class) and can add or override attributes and methods
  • This enables the creation of specialized classes based on more general ones
• Example: A

  Student

  class might inherit from a

  Person

  class, adding student-specific attributes and methods while retaining the common ones from

  Person

Polymorphism and dynamic dispatch

• Polymorphism allows objects of different classes to be treated as objects of a common superclass
• It enables writing code that can work with objects of multiple types, as long as they share a common interface or base class
• Dynamic dispatch (or dynamic binding) determines which implementation of a method to call based on the actual type of the object at runtime
  • This allows for runtime polymorphism, where the appropriate method is invoked based on the object's class hierarchy
• Example: A

  Shape

  class might define a

  draw()

  method, which is overridden in subclasses like

  Circle

  and

  Rectangle

  to provide specific drawing implementations

Designing classes in OOP

Identifying key attributes and methods

• When designing classes, identify the essential attributes (data) and methods (behavior) that define the objects
• Attributes represent the state of an object and are typically implemented as instance variables
• Methods define the actions or operations that objects can perform and manipulate the object's state
  • They encapsulate the logic and algorithms associated with the class
• Example: For a

  Car

  class, attributes might include

  make

  ,

  model

  , and

  year

  , while methods could be

  start()

  ,

  accelerate()

  , and

  brake()

Constructors for object initialization

• Constructors are special methods used to initialize objects when they are created
• They ensure that objects are properly set up with initial values for their attributes
• Constructors can accept parameters to customize the initialization of objects
  • They can also perform any necessary setup or validation tasks
• Example: A

  Point

  class might have a constructor that accepts

  x

  and

  y

  coordinates to initialize the position of the point object

Access modifiers for encapsulation

• Access modifiers control the visibility and accessibility of class members (attributes and methods)
• Common access modifiers include:

  • public

    : Accessible from anywhere

  • private

    : Accessible only within the same class

  • protected

    : Accessible within the same class and its subclasses
• Proper use of access modifiers helps achieve encapsulation by hiding internal details and providing controlled access through public methods
• Example: In a

  BankAccount

  class, the

  balance

  attribute should be

  private

  to prevent direct modification, while methods like

  getBalance()

  can be

  public

  for controlled access

Static vs instance members

• Static members (attributes and methods) belong to the class itself rather than instances of the class
• They are shared among all instances of the class and can be accessed using the class name
  • Static attributes maintain their values across all instances and can be used for class-level data
  • Static methods can be invoked without creating an instance of the class and are often used for utility functions
• Instance members (attributes and methods) belong to individual instances of the class
  • Each instance has its own copy of instance attributes and can have different values
  • Instance methods operate on the specific instance and can access its attributes
• Example: In a

  MathUtils

  class, a static method

  sqrt()

  can be used to calculate the square root of a number without creating an instance of the class

Relationships between classes

Composition vs aggregation

• Composition and aggregation are types of association relationships between classes
• Composition represents a strong "has-a" relationship, where one object is composed of one or more other objects
  • The composed object is responsible for the creation and lifetime of its parts
  • If the composing object is destroyed, its parts are also destroyed
• Aggregation represents a weaker "has-a" relationship, where one object contains references to other objects
  • The aggregated objects can exist independently of the containing object
  • The lifetime of the aggregated objects is not tied to the lifetime of the containing object
• Example: A

  Car

  class might have a composition relationship with an

  Engine

  class (the car is responsible for creating and destroying the engine) and an aggregation relationship with a

  Driver

  class (the driver can exist independently of the car)

Association and multiplicity

• Association represents a general relationship between classes, indicating that objects of one class are connected to objects of another class
• Multiplicity specifies the number of instances of one class that can be associated with an instance of another class
  • Common multiplicities include one-to-one, one-to-many, and many-to-many
• Associations can be unidirectional (one-way) or bidirectional (two-way) depending on the navigability between the classes
• Example: A

  Student

  class might have a one-to-many association with a

  Course

  class, indicating that a student can be enrolled in multiple courses, but each course has many students

Dependency injection principles

• Dependency injection is a design pattern that allows the dependencies of a class to be provided from external sources rather than being created internally
• It promotes loose coupling by separating the creation and usage of dependencies
• Dependencies can be injected through constructors, setter methods, or interfaces
  • Constructor injection ensures that the required dependencies are provided when an object is created
  • Setter injection allows dependencies to be set after object creation
  • Interface injection uses an interface to define the contract for injecting dependencies
• Example: A

  UserService

  class might have a dependency on a

  UserRepository

  interface for data access, which can be injected through the constructor to allow for flexibility and testability

Abstract classes vs interfaces

• Abstract classes and interfaces are used to define common behavior and contracts for subclasses
• Abstract classes provide a base implementation that subclasses can inherit from and override
  • They can contain both abstract and non-abstract methods
  • Abstract methods are declared without an implementation and must be overridden by subclasses
  • Non-abstract methods can have a default implementation that subclasses can optionally override
• Interfaces define a contract of methods that implementing classes must adhere to
  • They contain only method signatures without any implementation
  • Classes can implement multiple interfaces, allowing for multiple inheritance of behavior
• Example: A

  Shape

  abstract class might define a common

  getArea()

  method, while

  Circle

  and

  Rectangle

  subclasses provide specific implementations; an

  Drawable

  interface might define a

  draw()

  method that classes like

  Shape

  and

  Sprite

  can implement

Inheritance and polymorphism

Extending classes with inheritance

• Inheritance allows classes to inherit attributes and methods from a superclass, forming a hierarchical relationship
• The subclass (derived class) inherits the members of the superclass (base class) and can add new members or override existing ones
  • Inherited members are available in the subclass without the need for redefinition
  • Overridden methods in the subclass provide a specialized implementation that replaces the superclass implementation
• Inheritance promotes code reuse, modularity, and the creation of specialized classes based on more general ones
• Example: A

  Dog

  class can inherit from an

  Animal

  class, inheriting common attributes like

  name

  and

  age

  and methods like

  eat()

  , while adding dog-specific attributes and behaviors

Overriding methods in subclasses

• Method overriding allows subclasses to provide their own implementation of methods inherited from the superclass
• The overridden method in the subclass has the same name, return type, and parameters as the method in the superclass
  • The

    @Override

    annotation is used to indicate that a method is intended to override a superclass method
• Overriding methods allows subclasses to specialize or modify the behavior defined in the superclass
• Example: A

  Rectangle

  class can override the

  getArea()

  method inherited from a

  Shape

  class to provide a rectangle-specific area calculation

Abstract methods and classes

• Abstract methods are declared in a class without an implementation and are intended to be overridden by subclasses
  • They are defined with the

    abstract

    keyword and end with a semicolon (no method body)
• Abstract classes are classes that contain one or more abstract methods and cannot be instantiated directly
  • They are declared with the

    abstract

    keyword before the class declaration
  • Abstract classes can have both abstract and non-abstract methods
  • Subclasses of an abstract class must provide implementations for all inherited abstract methods or be declared as abstract themselves
• Abstract methods and classes are used to define common behavior that subclasses must implement, enforcing a contract for the subclasses
• Example: A

  Vehicle

  abstract class can declare an abstract method

  startEngine()

  , which subclasses like

  Car

  and

  Motorcycle

  must implement

Casting and type checking

• Casting allows objects to be treated as objects of a different type within the same class hierarchy
• Upcasting is the process of casting an object to its superclass type
  • It is always safe because every object is an instance of its superclass
  • Upcasting allows objects to be treated polymorphically based on their superclass type
• Downcasting is the process of casting an object to a subclass type
  • It requires an explicit cast and can be unsafe if the object is not actually an instance of the subclass
  • Downcasting is used when specific subclass functionality needs to be accessed
• Type checking is the process of verifying the actual type of an object at runtime
  • The

    instanceof

    operator is used to check if an object is an instance of a specific class or interface
  • Type checking is often used before downcasting to ensure the cast is safe
• Example: A

  Shape

  variable can be used to store objects of its subclasses like

  Circle

  and

  Rectangle

  (upcasting), and type checking with

  instanceof

  can be used before downcasting to access subclass-specific methods

Virtual methods and dynamic binding

• Virtual methods are methods that can be overridden by subclasses and exhibit dynamic binding
• Dynamic binding (or dynamic dispatch) is the mechanism that determines which implementation of a method to call based on the actual type of the object at runtime
  • It allows polymorphic behavior, where the appropriate overridden method is invoked based on the object's class hierarchy
• In most object-oriented languages, methods are virtual by default, allowing subclasses to override them
• When a virtual method is called on an object, the runtime system determines the actual type of the object and invokes the most specific overridden method in the class hierarchy
• Example: If a

  Shape

  superclass defines a virtual

  draw()

  method and subclasses like

  Circle

  and

  Rectangle

  override it, calling

  draw()

  on a

  Shape

  variable will dynamically invoke the overridden method based on the actual object type

Advanced OOP concepts

Multiple inheritance and mixins

• Multiple inheritance allows a class to inherit from multiple superclasses, combining their attributes and methods
  • It enables a subclass to inherit features from multiple sources
  • However, multiple inheritance can lead to complexity and ambiguity, such as the "diamond problem" when a subclass inherits from two superclasses that have a common ancestor
• Mixins are a way to achieve a form of multiple inheritance by defining reusable classes that can be "mixed in" with other classes
  • Mixins are typically implemented as classes that provide a specific set of methods and attributes
  • They are not intended to be instantiated on their own but are used to enhance the functionality of other classes through inheritance or composition
• Example: A

  Flyable

  mixin can be defined with methods like

  fly()

  and

  land()

  , which can be mixed into classes like

  Bird

  and

  Airplane

  to add flying behavior

Inner classes and nested types

• Inner classes are classes defined within another class, known as the outer class
  • They have access to the members (including private members) of the outer class
  • Inner classes are often used to encapsulate related functionality or to define helper classes that are tightly coupled to the outer class
• Nested types are types (classes, interfaces, or enums) defined within another type
  • They can be static or non-static (inner)
  • Static nested types are associated with the outer class itself and do not have access to instance members of the outer class
  • Non-static nested types (inner classes) are associated with instances of the outer class and have access to both static and instance members of the outer class
• Example: A

  Car

  class can have an inner class

  Engine

  that encapsulates the engine-related functionality and has access to the car's attributes

Anonymous classes and lambdas

• Anonymous classes are inner classes without a name that are defined and instantiated in a single expression
  • They are often used to implement interfaces or extend classes for one-time use
  • Anonymous classes are defined using the

    new

    keyword followed by the interface or superclass name and the class body in curly braces
• Lambdas (lambda expressions) are a concise way to represent anonymous functions
  • They provide a shorthand syntax for defining and using functional interfaces (interfaces with a single abstract method)
  • Lambdas are often used in functional programming paradigms and can be passed as arguments to methods or stored in variables
• Example: An anonymous class can be used to define an on-the-fly implementation of an

  ActionListener

  interface for a button click event; a lambda expression can be used to define a

  Comparator

  for sorting a collection

Reflection and metaprogramming

• Reflection is the ability of a program to examine and modify its own structure and behavior at runtime
  • It allows introspection of classes, interfaces, methods, and attributes
  • Reflection can be used to dynamically create objects, invoke methods, and access or modify fields
• Metaprogramming is the technique of writing programs that manipulate or generate other programs
  • It involves using reflection and other language features to modify or extend the behavior of a program at runtime
  • Metaprogramming can be used for tasks such as code generation, dynamic proxies, and runtime class modification
• Example: Reflection can be used to dynamically load and instantiate classes based on user input or configuration; metaprogramming can be used to generate boilerplate code or implement dynamic proxies for logging or security purposes

Design patterns in OOP

Creational patterns like factories

• Creational design patterns deal with object creation mechanisms, trying to create objects in a suitable manner for the situation
• Factory pattern is a creational pattern that provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created
  • It encapsulates object creation logic and provides a way to create objects without specifying their exact class
  • The factory method can return different subclasses based on input or configuration
• Other creational patterns include Singleton (ensuring a class has only one instance), Builder (separating object construction from its representation), and Prototype (creating new objects by cloning existing ones)
• Example: A

  ShapeFactory

  class can have a factory method

  createShape(type)

  that returns instances of different shape subclasses (

  Circle

  ,

  Rectangle

  , etc.) based on the provided type parameter

Structural patterns like adapters

• Structural design patterns deal with the composition of classes and objects, focusing on simplifying the relationships and interactions between them
• Adapter pattern is a structural pattern that allows incompatible interfaces to work together by converting the interface of one class into another interface that clients expect
  • It acts as a bridge between two incompatible interfaces, allowing them to collaborate
  • The adapter wraps an existing class with a new interface to make it compatible with the client's interface
• Other structural patterns include Decorator (adding behavior to objects dynamically), Facade (providing a simplified interface to a complex system), and Proxy (providing a surrogate or placeholder for another object)
• Example: A

  LegacyPrinter

  class with an incompatible interface can be adapted using a

  PrinterAdapter

  class that implements the expected

  Printer

  interface and delegates the calls to the legacy printer

Behavioral patterns like observers

• Behavioral design patterns deal with communication and interaction between objects, focusing on the assignment of responsibilities and the flow of communication
• Observer pattern is a behavioral pattern that defines a one-to-many dependency between objects, so that when one object changes state, all its dependents are notified and updated automatically
  • It allows objects (observers) to register their interest in another object (subject) and be notified when the subject's state changes
  • The subject maintains a list of observers and notifies them whenever its state changes
• Other behavioral patterns include Command (encapsulating a request as an object