of its a field: class B { A a; T foo() { return a.foo(); } } Note that when executing a.foo(), the this object is a (a subtype of A), not the original object (an instance of B). Further, a need not be an instance of A: it may be an instance of a subtype. Indeed, A need not even be a class: it may be an interface/protocol. Contrast with inheritance, in which foo is defined in a superclass A (which must be a class, not an interface), and when called on an instance of a subclass B, it uses the code defined in A, but the this object is still an instance of B: class A { T foo() { /* ... */ }; } class B extends A { } In this Python example, class B forwards the foo method and the x property to the object in its a field: using these on b (an instance of B) is the same as using them on b.a (the instance of A to which these are forwarded). class A: def __init__(self, x) -> None: self.x = x def foo(self): print(self.x) class B: def __init__(self, a) -> None: self.a = a def foo(self): self.a.foo() @property def x(self): return self.a.x @x.setter def x(self, x): self.a.x = x @x.deleter def x(self): del self.a.x a = A(42) b = B(a) b.foo() # Prints '42'. b.x # Has value '42' b.x = 17 # b.a.x now has value 17 del b.x # Deletes b.a.x. Simple In this Java example, the class has a method. This print method, rather than performing the print itself, forwards to an object of class . To the outside world it appears that the object is doing the print, but the object is the one actually doing the work. Forwarding is simply passing a duty off to someone/something else. Here is a simple example: class RealPrinter { // the "receiver" void print() { System.out.println("Hello world!"); } } class Printer { // the "sender" RealPrinter p = new RealPrinter(); // create the receiver void print() { p.print(); // calls the receiver } } public class Main { public static void main(String[] arguments) { // to the outside world it looks like Printer actually prints. Printer printer = new Printer(); printer.print(); } } Complex The more complex case is a Decorator Pattern that by using interfaces, forwarding can be made more flexible