Forwarding (object-oriented programming) - Revision history

79.173.164.66: Improved sentence clarity

2024-04-02T11:06:01Z

Improved sentence clarity

← Previous revision		Revision as of 11:06, 2 April 2024
Line 26:		Line 26:
	}		}
	</syntaxhighlight>		</syntaxhighlight>
	~~under~~ delegation ~~this~~ will output <samp>m2, n1</samp> because <code>n()</code> is evaluated in the context of the original (sending) object, while under forwarding ~~this~~ will output <samp>m2, n2</samp> because <code>n()</code> is evaluated in the context of the receiving object.<ref name="buechiweck"/>		Under delegation, <code>m()</code> will output <samp>m2, n1</samp> because <code>n()</code> is evaluated in the context of the original (sending) object, while under forwarding, it will output <samp>m2, n2</samp> because <code>n()</code> is evaluated in the context of the receiving object.<ref name="buechiweck"/>

	In casual use, forwarding is often referred to as "delegation", or considered a form of delegation, but in careful usage they are clearly distinguished by what <code>self</code> refers to. While delegation is analogous to [[Inheritance (object-oriented programming)\|inheritance]], allowing behavioral reuse (and concretely [[code reuse]]) ''without'' changing evaluation context, forwarding is analogous to [[object composition\|composition]], as execution depends only on the receiving (member) object, not the (original) sending object. In both cases, reuse is dynamic, meaning determined at run time (based on the ''object'' to which use is delegated or forwarded), rather than static, meaning determined at compile/link time (based on the ''class'' which is inherited from). Like inheritance, delegation allows the sending object to modify the original behavior, but is susceptible to problems analogous to the [[fragile base class]]; while forwarding provides stronger encapsulation and avoids these problems; see [[composition over inheritance]].<ref name="buechiweck"/>		In casual use, forwarding is often referred to as "delegation", or considered a form of delegation, but in careful usage they are clearly distinguished by what <code>self</code> refers to. While delegation is analogous to [[Inheritance (object-oriented programming)\|inheritance]], allowing behavioral reuse (and concretely [[code reuse]]) ''without'' changing evaluation context, forwarding is analogous to [[object composition\|composition]], as execution depends only on the receiving (member) object, not the (original) sending object. In both cases, reuse is dynamic, meaning determined at run time (based on the ''object'' to which use is delegated or forwarded), rather than static, meaning determined at compile/link time (based on the ''class'' which is inherited from). Like inheritance, delegation allows the sending object to modify the original behavior, but is susceptible to problems analogous to the [[fragile base class]]; while forwarding provides stronger encapsulation and avoids these problems; see [[composition over inheritance]].<ref name="buechiweck"/>

Frap: /* Simple */ add UML class diagram

2024-02-29T13:23:46Z

Simple: add UML class diagram

← Previous revision		Revision as of 13:23, 29 February 2024
Line 89:		Line 89:

	=== Simple ===		=== Simple ===
			[[File:UML forwarding printer.svg\|right\|UML class diagram that illustrates forwarding.]]

	In this [[Java (programming language)\|Java]] example, the {{Java\|Printer}} [[Class (computer science)\|class]] has a {{Java\|print}} method. This print method, rather than performing the print itself, forwards to an object of class {{Java\|RealPrinter}}. To the outside world it appears that the {{Java\|Printer}} object is doing the print, but the {{Java\|RealPrinter}} object is the one actually doing the work.		In this [[Java (programming language)\|Java]] example, the {{Java\|Printer}} [[Class (computer science)\|class]] has a {{Java\|print}} method. This print method, rather than performing the print itself, forwards to an object of class {{Java\|RealPrinter}}. To the outside world it appears that the {{Java\|Printer}} object is doing the print, but the {{Java\|RealPrinter}} object is the one actually doing the work.

178.49.234.115: /* Delegation */ Placing statements into separate lines.

2021-11-28T05:02:06Z

Delegation: Placing statements into separate lines.

← Previous revision		Revision as of 05:02, 28 November 2021
Line 18:		Line 18:
	// Receiver		// Receiver
	void m() {		void m() {
	print("m2, "); n();		print("m2, ");
			n();
	}		}

Frap: /* Examples */ modern Python 3

2020-11-25T13:32:04Z

Examples: modern Python 3

← Previous revision		Revision as of 13:32, 25 November 2020
Line 53:		Line 53:

	<syntaxhighlight lang="python">		<syntaxhighlight lang="python">
	class A~~(object)~~:		class A:
	def __init__(self, x) -> None:		def __init__(self, x) -> None:
	self.x = x		self.x = x
Line 60:		Line 60:
	print(self.x)		print(self.x)

	class B~~(object)~~:		class B:
	def __init__(self, a) -> None:		def __init__(self, a) -> None:
	self.a = a		self.a = a

WOSlinker: change source to syntaxhighlight

2020-07-25T10:07:40Z

change source to syntaxhighlight

← Previous revision		Revision as of 10:07, 25 July 2020
Line 10:		Line 10:

	For example, given the following code:		For example, given the following code:
	<~~source~~ lang="Java">		<syntaxhighlight lang="Java">
	// Sender		// Sender
	void n() {		void n() {
Line 24:		Line 24:
	print("n2");		print("n2");
	}		}
			</syntaxhighlight>
	</source>
	under delegation this will output <samp>m2, n1</samp> because <code>n()</code> is evaluated in the context of the original (sending) object, while under forwarding this will output <samp>m2, n2</samp> because <code>n()</code> is evaluated in the context of the receiving object.<ref name="buechiweck"/>		under delegation this will output <samp>m2, n1</samp> because <code>n()</code> is evaluated in the context of the original (sending) object, while under forwarding this will output <samp>m2, n2</samp> because <code>n()</code> is evaluated in the context of the receiving object.<ref name="buechiweck"/>

Line 32:		Line 32:
	A simple example of explicit forwarding in Java: an instance of <code>B</code> forwards calls to the <code>foo</code> method of its <code>a</code> field:		A simple example of explicit forwarding in Java: an instance of <code>B</code> forwards calls to the <code>foo</code> method of its <code>a</code> field:

	<~~source~~ lang="Java">		<syntaxhighlight lang="Java">
	class B {		class B {
	A a;		A a;
	T foo() { return a.foo(); }		T foo() { return a.foo(); }
	}		}
			</syntaxhighlight>
	</source>
	Note that when executing <code>a.foo()</code>, the <code>this</code> object is <code>a</code> (a subtype of <code>A</code>), not the original object (an instance of <code>B</code>). Further, <code>a</code> need not be an instance of <code>A</code>: it may be an instance of a subtype. Indeed, <code>A</code> need not even be a class: it may be an interface/[[Protocol (object-oriented programming)\|protocol]].		Note that when executing <code>a.foo()</code>, the <code>this</code> object is <code>a</code> (a subtype of <code>A</code>), not the original object (an instance of <code>B</code>). Further, <code>a</code> need not be an instance of <code>A</code>: it may be an instance of a subtype. Indeed, <code>A</code> need not even be a class: it may be an interface/[[Protocol (object-oriented programming)\|protocol]].

	Contrast with inheritance, in which <code>foo</code> is defined in a superclass <code>A</code> (which must be a class, not an interface), and when called on an instance of a subclass <code>B</code>, it uses the code defined in <code>A</code>, but the <code>this</code> object is still an instance of <code>B</code>:		Contrast with inheritance, in which <code>foo</code> is defined in a superclass <code>A</code> (which must be a class, not an interface), and when called on an instance of a subclass <code>B</code>, it uses the code defined in <code>A</code>, but the <code>this</code> object is still an instance of <code>B</code>:
	<~~source~~ lang="Java">		<syntaxhighlight lang="Java">
	class A {		class A {
	T foo() { /* ... */ };		T foo() { /* ... */ };
Line 48:		Line 48:
	class B extends A {		class B extends A {
	}		}
			</syntaxhighlight>
	</source>

	In this Python example, class <code>B</code> forwards the <code>foo</code> method and the <code>x</code> property to the object in its <code>a</code> field: using these on <code>b</code> (an instance of <code>B</code>) is the same as using them on <code>b.a</code> (the instance of <code>A</code> to which these are forwarded).		In this Python example, class <code>B</code> forwards the <code>foo</code> method and the <code>x</code> property to the object in its <code>a</code> field: using these on <code>b</code> (an instance of <code>B</code>) is the same as using them on <code>b.a</code> (the instance of <code>A</code> to which these are forwarded).

	<~~source~~ lang="python">		<syntaxhighlight lang="python">
	class A(object):		class A(object):
	def __init__(self, x) -> None:		def __init__(self, x) -> None:
Line 85:		Line 85:
	b.x = 17 # b.a.x now has value 17		b.x = 17 # b.a.x now has value 17
	del b.x # Deletes b.a.x.		del b.x # Deletes b.a.x.
			</syntaxhighlight>
	</source>

	=== Simple ===		=== Simple ===
Line 93:		Line 93:
	Forwarding is simply passing a duty off to someone/something else. Here is a simple example:		Forwarding is simply passing a duty off to someone/something else. Here is a simple example:

	<~~source~~ lang="java">		<syntaxhighlight lang="java">
	class RealPrinter { // the "receiver"		class RealPrinter { // the "receiver"
	void print() {		void print() {
Line 114:		Line 114:
	}		}
	}		}
			</syntaxhighlight>
	</source>

	=== Complex ===		=== Complex ===
Line 120:		Line 120:
	The more complex case is a [[Decorator pattern#Java\|Decorator Pattern]] that by using [[interface (Java)\|interfaces]], forwarding can be made more flexible and [[type safety\|typesafe]]. "Flexibility" here means that {{Java\|C}} need not refer to {{Java\|A}} or {{Java\|B}} in any way, as the switching of forwarding is abstracted from {{Java\|C}}. In this example, class {{Java\|C}} can forward to any class that implements an interface {{Java\|I}}. Class {{Java\|C}} has a method to switch to another forwarder. Including the {{Java\|implements}} clauses improves [[type safety]], because each class must implement the methods in the interface. The main tradeoff is more code.		The more complex case is a [[Decorator pattern#Java\|Decorator Pattern]] that by using [[interface (Java)\|interfaces]], forwarding can be made more flexible and [[type safety\|typesafe]]. "Flexibility" here means that {{Java\|C}} need not refer to {{Java\|A}} or {{Java\|B}} in any way, as the switching of forwarding is abstracted from {{Java\|C}}. In this example, class {{Java\|C}} can forward to any class that implements an interface {{Java\|I}}. Class {{Java\|C}} has a method to switch to another forwarder. Including the {{Java\|implements}} clauses improves [[type safety]], because each class must implement the methods in the interface. The main tradeoff is more code.

	<~~source~~ lang=Java>		<syntaxhighlight lang=Java>
	interface I {		interface I {
	void f();		void f();
Line 158:		Line 158:
	}		}
	}		}
			</syntaxhighlight>
	</source>

	==Applications==		==Applications==

Frap: /* Simple */ format code

2019-12-22T21:56:12Z

Simple: format code

← Previous revision		Revision as of 21:56, 22 December 2019
Line 93:		Line 93:
	Forwarding is simply passing a duty off to someone/something else. Here is a simple example:		Forwarding is simply passing a duty off to someone/something else. Here is a simple example:

	<source lang=~~Java~~>		<source lang="java">
	class RealPrinter { // the "receiver"		class RealPrinter { // the "receiver"
	void print() {		void print() {
	System.out.println("Hello world!");		System.out.println("Hello world!");
			}
⚫	}
	}		}

	class Printer { // the "sender"		class Printer { // the "sender"
	RealPrinter p = new RealPrinter(); // create the receiver		RealPrinter p = new RealPrinter(); // create the receiver
	void print() {		void print() {
	p.print(); // calls the receiver		p.print(); // calls the receiver
			}
	}
	}		}
		⚫

	public class Main {		public class Main {
	public static void main(String[] arguments) {		public static void main(String[] arguments) {
	// to the outside world it looks like Printer actually prints.		// to the outside world it looks like Printer actually prints.
	Printer printer = new Printer();		Printer printer = new Printer();
	printer.print();		printer.print();
			}
	}
	}		}
	</source>		</source>

Frap: /* Examples */ type hint

2019-11-30T18:17:17Z

Examples: type hint

← Previous revision		Revision as of 18:17, 30 November 2019
Line 52:		Line 52:
	In this Python example, class <code>B</code> forwards the <code>foo</code> method and the <code>x</code> property to the object in its <code>a</code> field: using these on <code>b</code> (an instance of <code>B</code>) is the same as using them on <code>b.a</code> (the instance of <code>A</code> to which these are forwarded).		In this Python example, class <code>B</code> forwards the <code>foo</code> method and the <code>x</code> property to the object in its <code>a</code> field: using these on <code>b</code> (an instance of <code>B</code>) is the same as using them on <code>b.a</code> (the instance of <code>A</code> to which these are forwarded).

	<source lang="~~Python~~">		<source lang="python">
	class A:		class A(object):
	def __init__(self, x):		def __init__(self, x) -> None:
	self.x = x		self.x = x

Line 60:		Line 60:
	print(self.x)		print(self.x)

	class B:		class B(object):
	def __init__(self, a):		def __init__(self, a) -> None:
	self.a = a		self.a = a

Frap: /* Examples */ 4 space indention for Java

2019-04-24T11:02:02Z

Examples: 4 space indention for Java

← Previous revision		Revision as of 11:02, 24 April 2019
Line 34:		Line 34:
	<source lang="Java">		<source lang="Java">
	class B {		class B {
	A a;		A a;
	T foo() { return a.foo(); }		T foo() { return a.foo(); }
	}		}
	</source>		</source>
Line 43:		Line 43:
	<source lang="Java">		<source lang="Java">
	class A {		class A {
	T foo() { /* ... */ };		T foo() { /* ... */ };
	}		}

Citation bot: Alter: title, isbn. Add: bibcode, title-link, isbn. | You can use this bot yourself. Report bugs here. | rsjaffe; Category:Object-oriented_programming.

2019-02-03T01:28:39Z

Alter: title, isbn. Add: bibcode, title-link, isbn. | You can use this bot yourself. Report bugs here. | rsjaffe; Category:Object-oriented_programming.

← Previous revision		Revision as of 01:28, 3 February 2019
Line 7:		Line 7:
	{{quote		{{quote
	\|The difference between forwarding and delegation is the binding of the self parameter in the wrappee when called through the wrapper. With delegation, the self parameter is bound to the wrapper, with forwarding it is bound to the wrappee. ... Forwarding is a form of automatic message resending; delegation is a form of inheritance with binding of the parent (superclass) at run time, rather than at compile/link time as with 'normal' inheritance.<ref name="buechiweck">{{cite book \|first1=Martin \|last1=Büchi \|first2=Wolfgang \|last2=Weck \|title=ECOOP 2000 — Object-Oriented Programming		\|The difference between forwarding and delegation is the binding of the self parameter in the wrappee when called through the wrapper. With delegation, the self parameter is bound to the wrapper, with forwarding it is bound to the wrappee. ... Forwarding is a form of automatic message resending; delegation is a form of inheritance with binding of the parent (superclass) at run time, rather than at compile/link time as with 'normal' inheritance.<ref name="buechiweck">{{cite book \|first1=Martin \|last1=Büchi \|first2=Wolfgang \|last2=Weck \|title=ECOOP 2000 — Object-Oriented Programming
	\|chapter=Generic Wrappers \|chapter-url=http://www.lirmm.fr/~ducour/Doc-objets/ECOOP/papers/1850/18500201.pdf \|volume=1850 \|series=Lecture Notes in Computer Science \|year=2000 \|doi=10.1007/3-540-45102-1_10 \|pages=[https://books.google.com/books?id=CFtuCQAAQBAJ&pg=PA212&dq=forwarding+vs.+delegation 212–213]}}</ref>}}		\|chapter=Generic Wrappers \|chapter-url=http://www.lirmm.fr/~ducour/Doc-objets/ECOOP/papers/1850/18500201.pdf \|volume=1850 \|series=Lecture Notes in Computer Science \|year=2000 \|doi=10.1007/3-540-45102-1_10 \|pages=[https://books.google.com/books?id=CFtuCQAAQBAJ&pg=PA212&dq=forwarding+vs.+delegation 212–213]\|isbn=978-3-540-67660-7 }}</ref>}}

	For example, given the following code:		For example, given the following code:
Line 167:		Line 167:
	\| authorlink2 = Richard Helm \| first2 = Richard \| last2 = Helm \| authorlink3 = Ralph Johnson (computer scientist) \| first3 = Ralph \| last3 = Johnson \| authorlink4 = John Vlissides \| first4 = John \| last4 = Vlissides		\| authorlink2 = Richard Helm \| first2 = Richard \| last2 = Helm \| authorlink3 = Ralph Johnson (computer scientist) \| first3 = Ralph \| last3 = Johnson \| authorlink4 = John Vlissides \| first4 = John \| last4 = Vlissides
	\| year = 1995		\| year = 1995
	\| title = ~~[[Design Patterns (book)\|~~Design Patterns: Elements of Reusable Object-Oriented Software]]		\| title = Design Patterns: Elements of Reusable Object-Oriented Software
	\| publisher = [[Addison-Wesley]]		\| publisher = [[Addison-Wesley]]
	\| isbn = 0-201-63361-2		\| isbn = 978-0-201-63361-0
			\| title-link = Design Patterns (book)
⚫	}}</ref> Forwarding is used directly in several patterns:
			\| bibcode = 1995dper.book.....G
		⚫	}}</ref> Forwarding is used directly in several patterns:

	* [[Chain-of-responsibility pattern]]		* [[Chain-of-responsibility pattern]]

Nbarth: /* Delegation */ spacing

2018-02-19T02:41:59Z

Delegation: spacing

← Previous revision		Revision as of 02:41, 19 February 2018
Line 6:		Line 6:

	{{quote		{{quote
	\|The difference between forwarding and delegation is the binding of the self parameter in the wrappee when called through the wrapper. With delegation, the self parameter is bound to the wrapper, with forwarding it is bound to the wrappee. ... Forwarding is a form of automatic message resending; delegation is a form of inheritance with binding of the parent (superclass) at run time, rather than at compile/link time as with 'normal' inheritance.		\|The difference between forwarding and delegation is the binding of the self parameter in the wrappee when called through the wrapper. With delegation, the self parameter is bound to the wrapper, with forwarding it is bound to the wrappee. ... Forwarding is a form of automatic message resending; delegation is a form of inheritance with binding of the parent (superclass) at run time, rather than at compile/link time as with 'normal' inheritance.<ref name="buechiweck">{{cite book \|first1=Martin \|last1=Büchi \|first2=Wolfgang \|last2=Weck \|title=ECOOP 2000 — Object-Oriented Programming
	<ref name="buechiweck">{{cite book \|first1=Martin \|last1=Büchi \|first2=Wolfgang \|last2=Weck \|title=ECOOP 2000 — Object-Oriented Programming
	\|chapter=Generic Wrappers \|chapter-url=http://www.lirmm.fr/~ducour/Doc-objets/ECOOP/papers/1850/18500201.pdf \|volume=1850 \|series=Lecture Notes in Computer Science \|year=2000 \|doi=10.1007/3-540-45102-1_10 \|pages=[https://books.google.com/books?id=CFtuCQAAQBAJ&pg=PA212&dq=forwarding+vs.+delegation 212–213]}}</ref>}}		\|chapter=Generic Wrappers \|chapter-url=http://www.lirmm.fr/~ducour/Doc-objets/ECOOP/papers/1850/18500201.pdf \|volume=1850 \|series=Lecture Notes in Computer Science \|year=2000 \|doi=10.1007/3-540-45102-1_10 \|pages=[https://books.google.com/books?id=CFtuCQAAQBAJ&pg=PA212&dq=forwarding+vs.+delegation 212–213]}}</ref>}}