Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-28T00:40:03Z

Jwpaul: /* How would you classify it */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-28T00:38:58Z

Jwpaul: /* Suggestion of where to use pure fabrication */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-25T13:43:07Z

Jwpaul: /* Suggestion of where to use pure fabrication */

File:PureFab.gif

2008-07-25T13:41:08Z

Jwpaul:

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-25T13:40:54Z

Jwpaul: /* Suggestion of where to use pure fabrication */

File:Purefab.GIF

2008-07-25T13:38:48Z

Jwpaul:

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-25T13:35:43Z

Jwpaul: /* Suggestion of where to use pure fabrication */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-25T13:35:18Z

Jwpaul: /* Suggestion of where to use pure fabrication */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-25T13:31:51Z

Jwpaul: /* Suggestion of where to use pure fabrication */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-25T13:30:49Z

Jwpaul: /* Suggestion of where to use pure fabrication */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-25T13:29:29Z

Jwpaul: /* Suggestion of where to use pure fabrication */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-25T13:19:03Z

Jwpaul: /* Suggestion of where to use pure fabrication */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-25T13:13:06Z

Jwpaul: /* External links */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-25T13:12:52Z

Jwpaul: /* External links */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-25T13:12:09Z

Jwpaul: /* examples of where to use pure fabrication */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-25T12:45:17Z

Jwpaul: /* Conclusion */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-25T12:35:42Z

Jwpaul: /* examples of code sequences that would be awkward */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-25T12:26:29Z

Jwpaul: /* External links */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-25T12:22:09Z

Jwpaul: /* See Also */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-25T12:22:02Z

Jwpaul: /* External links */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-25T12:21:42Z

Jwpaul: /* See Also */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-25T12:19:37Z

Jwpaul: /* How would you classify it */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-25T12:18:31Z

Jwpaul: /* Conclusion */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-25T12:16:29Z

Jwpaul: /* Conclusion */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-23T10:03:34Z

Jwpaul: /* How would you classify it */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-23T09:48:24Z

Jwpaul: /* How would you classify it */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-23T09:46:27Z

Jwpaul: /* Conclusion */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-23T09:44:34Z

Jwpaul: /* Conclusion */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-23T09:41:05Z

Jwpaul: /* Conclusion */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-23T09:39:59Z

Jwpaul: /* External links */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-23T09:36:52Z

Jwpaul: /* Conclusion */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-23T09:28:56Z

Jwpaul: /* Conclusion */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-23T09:27:40Z

Jwpaul: /* examples of code sequences that would be awkward */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-23T09:19:29Z

Jwpaul: /* Comparisons of */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-23T09:15:04Z

Jwpaul: /* Introduction */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-23T09:07:58Z

Jwpaul: /* Introduction */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-23T02:02:12Z

Jwpaul: /* External links */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-23T01:59:58Z

Jwpaul: /* External links */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-23T01:56:16Z

Jwpaul: /* External links */

CSC/ECE 517 Summer 2008/wiki3 Assignment

2008-07-23T01:51:39Z

Jwpaul:

#[[CSC/ECE_517_Summer_2008/wiki3_1_th | RDB/OO Patterns]]
#[[CSC/ECE_517_Summer_2008/wiki3_1_PF | Pure Fabrication]]
----
[[CSC/ECE 517 Summer 2008]]

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-23T01:50:44Z

Jwpaul: /* External links */

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-23T01:49:53Z

Jwpaul:

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-23T01:49:26Z

Jwpaul:

==Pure fabrication==

Sometimes it is a good idea to introduce into a
system an object that has no counterpart in the real world. This is
called the pure fabrication pattern. Find examples of pure
fabrication, and weave them into a narrative that can teach
programmers when it is helpful and when it is not helpful to fabricate
objects.
== Introduction ==
One of the beloved features of '''[http://www.ruby-lang.org/en/ Ruby]''' is the block based '''[http://en.wikipedia.org/wiki/Iterator Iterator]'''. A Ruby Iterator is simply a method that loops over the contents of an object without exposing its underlying representation.
The verb 'iterate' means "do the same thing many times' so 'iterator' means "one which does the same thing many times". It can also be considered as an object that behaves like a ''[http://www.faqs.org/docs/learnc/x658.html generic pointer]''. The iterator usually references to one particular element in the object collection and then modifies itself so that it points to the next element. '''[http://en.wikipedia.org/wiki/Generator_%28computer_science%29 Generators]''' are a similar feature in '''[http://www.python.org/ Python]'''. The name came as it is the entity which generate iterators. It allows you to write a function that can return a result and pause, resuming in the same place the next time you call the function. The generator feature in Ruby can be implemented by adding a library class called Generator or external iterator. In python the generator is a feature and part of the language.

===Problem Definition===
Ruby, like Java, has iterators to facilitate doing operations on each member of a set. Python has generators as well. Describe how generators differ from iterators, and find examples of code sequences using generators that would be awkward with iterators.

== Iterator ==
The word "iterator" means different things in different contexts and programming languages, but it's always got something to do with visiting each one of a set of objects, where "object" doesn't necessarily mean "class instance": Just take "object" to mean "some instance of some data type, somewhere". Iterators may provide additional features and may behave in a different way depending on the languages.

===Implementing Iterator===
Most of the ''[http://en.wikipedia.org/wiki/Object-oriented_programming OOP]'' languages provide ways to make iterations easy, for example some languages provide class for controlling iteration, etc. But Ruby allows the definition of control structures directly. In terms of Ruby, such user-defined control structures are called iterators.

====Iterator in Ruby====
Iterator in Ruby is simply a method that invokes a block of code. The power is in the code block between the do and end keywords or {...}. Meaning, we can put as much, or little, code in there as needed. And each item being iterated over is passed into the block as a parameter between the pipes. Examples of different iterators are given below.

=====Using Each [http://www.math.hokudai.ac.jp/~gotoken/ruby/ruby-uguide/uguide09.html]=====

a = [ 1, 2, 3 ]
a.each { |x| print x }
==>123
#The internal implementation of the Array.each method could be defined internally like this:
# def each
# for i in 0...size
# yield(self[i])
# end
# end

x is the local variable in which each value of a is stored. And, each is probably the simplest iterator which yield successive elements of its collection.The above two line code is translated into C.

#include<stdio.h>
main()
{
int s[3]={1,2,3};
int i=0;
while(i<3)
{
printf("%d",s[i]);
i++;
}
}
==>123

The advantage of the block-passing style is that generators are a lot more built-in to the language. For example, the below two codes are equivalent and in neither of those cases is an array instantiated with all members of the range (X..Y):
1.upto(100000).each {|x| puts x}

for i in 1..100000
puts i
end

=====Using Find [http://www.nickpeters.net/2008/01/09/ruby-iterators/]=====

a = [ 10,20,30 ]
a.find { |n| n % 5 == 0 }
==>10
The find iterator method in ruby will compare each element using some comparison operator (<, >, ==, etc.) and based on the boolean result (true or false), it will return the first matching value.

=====Using Collect [http://www.nickpeters.net/2008/01/09/ruby-iterators/]=====

a = [ 1, 2, 3, 4, 5 ]
b = a.collect { |n| n + 1 }
==>[2, 3, 4, 5, 6]
Another common iterator is the collect that returns an array of elements that is taken from the corresponding collections.
Iterator can return derived values and not only limited to accessing the data stored in arrays and hashes.

====Iterator in Python====
Python also supports iteration over containers. It is implicitly used in the for statement, in ''[http://en.wikipedia.org/wiki/List_comprehension list comprehensions]'', and in ''[http://en.wikipedia.org/wiki/Python_syntax_and_semantics#Generator_expressions generator expressions]''. An iteration protocol is defined so that iteration is possible over different objects. Most of the container objects can be looped over using for statement. Example of a typical implicit iteration over a sequence is given below [http://docs.python.org/tut/node11.html#SECTION0011900000000000000000].
for element in [1, 2, 3]:
print element

The actual internal implementation is that the for statement calls iter() on the container object. The function returns an iterator object that defines the method next(). The method next() then returns the next item one at a time. When there are no more elements, next() raises a StopIteration exception which tells the for loop to terminate.
Iterators can also be defined explicitly. An example using explicit iterators is given below [http://en.wikipedia.org/wiki/Iterator#Python]

it = iter(sequence)
while True:
try:
value = it.next()
except StopIteration:
break
print value

Python defines several iterator objects to support iteration over general and specific sequence types, dictionaries, and other more specialized forms. The iterator object just have to implement __iter()__ and next(). Ruby iterator has an advantage over Python as it supports code blocks as objects where as Python can use only the for loop for iteration.

===Uses===
# The main use of iterator is it hides the internal details from the user when manipulating with the objects.
# Iterator is trivially more cleaner and elegant which makes it more easy to maintain compared to the accessing of elements based on ''[http://en.wikipedia.org/wiki/Index_%28information_technology%29 indexing]''.
# Iterators follow a consistent way of iterating through all kinds of data structures, as a result it becomes more readable and reusable.
# Using Iterators, inserting of a new element into the container object is easy even after the iterator has advanced beyond the first element. On the other hand, it is more difficult when using indexing as it requires changing of index numbers.

== Generators ==
A generator looks like a function but behaves like an iterator. Both Ruby and Python support generators. As mentioned in the introduction, Ruby has a Generator library and Python has generator as a fundamental part of the language. As being a language feature it is more robust and syntactically more concise and cleaner. On the other hand, using a library class helps to learn a language more easily and more elegant with the less number of features.

=== Generators in Python===
Generators are a simple and powerful tool for creating iterators. They are written like regular functions and called only once. It then returns an iterator which is the actual iterator with _iter()_ and next() methods. Generator doesn't have to worry about the iterator protocol (__iter()__,.next()..), it just works. Yield statement is used whenever they want to return data. Each time next() is called, the generator resumes where it left-off (it remembers all the data values and which statement was last executed). The generator function does NOT run to completion when it's first called - instead, it only runs until it has a value available to return, at which point it yields that value back and suspends operation until called again to resume.
This is described with an example below [http://www.builderau.com.au/program/python/soa/Lazy-list-builders-Generators-in-Python/0,2000064084,339279708,00.htm].
>>> def generator1():
... yield "first"
... yield "second"
... yield "third"
>>> gen = generator1()
>>> gen
>>> #No output was produced.
>>> gen.next()
'first' #Function starts executing here.
>>> gen.next()
'second'
>>> gen.next()
'third'
>>> gen.next()
Traceback (most recent call last):
File "", line 1, in ?
StopIteration

First, a generator called generator1 is defined which will yield three values, the strings "first", "second" and "third". When we create a new generator object (gen) it begins the function. Each time you call the generator's next method, it continues the function until the next yield. When the generator reaches the end of the block, or reaches a return statement, it throws a StopIteration exception.
A generator is a one time operation. So, the generated data is iterated only once but one can call the generated function again if needed. In this way, ''[http://en.wikipedia.org/wiki/Lazy_evaluation Lazy evaluation]'' can be achieved which increases the performance by eliminating unnecessary calculation of values that are never used.
Generator can be more powerful as Python has now included the ability to return the data the generator. For example :
x= yield y
From the perspective of the caller of the generator, this statement returns control back to the caller, just as before. From the perspective of the generator, when the execution comes back into the generator, a value will come with it. In this case, the generator saves it into the variable x. The value comes when the caller calls a function called send() to pass a value back into the generator. The function send() behaves just like the function next(), except that it passes a value. This is explained with an example below.

class MyStuff:
def __init__(self):
self.a = [2,4,6,8,10,12]
def iterate(self):
i = 0
while i < len(self.a):
val = yield self.a[i]
if val == None:
i += 1
else:
if val < 0:
val = 0
if val >= len(self.a):
val = len(self.a) -1
i = val
Here, send() is used to let the caller of the generator reposition the index in the array. Value received is checked whether it is within the bounds of the array, else the closest boundary is set. The value generator received is tested and stored in 'val'.If val is None, that means the generator received no value (the calling code used next(), or perhaps send(None)).

=== Generators in Ruby===
Some of the reason's why Generator library comes into play where external iterators are implemented are mentioned below.
*The internal iterator in Ruby would fail if the iterator is required to pass through a method that needs access on each of the values returned by that iterator.
*Iterators cannot iterate over more than one collection at a time, they cannot be paused or stopped in the middle.
*They can only implement a single traversal strategy.
Example with the library to iterate over a block is given below [http://www.ruby-doc.org/docs/ProgrammingRuby/].

require 'generator'
gen = Generator.new do |result|
result.yield " Start"
3.times { |i| result.yield i}
result.yield "done"
end
while gen.next?
print gen.next,"--"
end
==> Start--0--1--2--done--

==An example to print the successive elements from 10 to 20 in ruby and python ==
===Using generator in Python===

def countfrom(n):
while True:
yield n
n += 1
for i in countfrom(10):
if i <= 20:
print i
else:
break
==>10,11,12,13,14,15,16,17,18,19,20

===Using iterators in Ruby===

(10..20).each { |i| print i,"," }
==>10,11,12,13,14,15,16,17,18,19,20
This above example shows how iterators in Ruby are not very elegant.

===Using generator in Ruby===
require 'generator'
gen = Generator.new(10..20)
while gen.next?
print gen.next, ", "
end
==>10,11,12,13,14,15,16,17,18,19,20
With Ruby generators the code flows similar to Python.

==Comparisons of Ruby generators and Python generators ==

Python was intended to be a highly readable language.Ruby can be a highly readable language with the use of external iterators. Ruby's internal iterators aren't always the best solution. Adding the generator or external iterators function helps get over the difficulty of writing the code and helps with the readability. This sort of makes Ruby like a highly readable language like Python. Ruby's code however runs slower than many compiled languages and other major scripting languages such as Python.

===examples of code sequences that would be awkward ===

==See Also==
* '''[http://www.ruby-lang.org/en/ Ruby]'''
==External links==
*[http://www.ruby-doc.org/docs/ProgrammingRuby/ Programming Ruby The Pragmatic Programmer's Guide]

[[CSC/ECE 517 Summer 2008/wiki1 Assignment|Back to the assignment page]]

CSC/ECE 517 Summer 2008/wiki3 1 PF

2008-07-23T01:42:03Z

Jwpaul:

CSC/ECE 517 Summer 2008/wiki2 8 Inh-Del

2008-07-09T01:35:31Z

Jwpaul: /* Inheritance vs Delegation */

=Inheritance vs Delegation=

[http://en.wikipedia.org/wiki/Inheritance_(programming) Inheritance] and [http://en.wikipedia.org/wiki/Delegation_(programming) delegation] plays a very important role in object-oriented languages. Both of the techniques facilitates the reuse of code that exist in another class. This WIKI will cite examples that show cases where inheritance is better, and cases where delegation is better. I also characterize the situations in which you should employ one or the other.

== Inheritance ==
In [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming OOP], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] is a way to form new classes (instances of which are called objects) using classes that have already been defined. The new classes, known as derived or classes, take over (or inherit) attributes and behavior of the pre-existing classes, which are referred to as base classes (or ancestor classes). It is intended to help reuse existing code with little or no modification.

The top most class is called as the parent class, base class or a superclass.The classes derived from the parent class are known as child classes or [http://www.jguru.com/faq/view.jsp?EID=27916 subclasses].The lower classes of the hierarchy inherit from the upper class. Classes get more specialized as you move toward the bottom of the hierarchy.The subclasses have more functionality than superclass because of this feature and create their own new functionality.

The most common reason of using inheritance is to reuse existing classes or objects. Inheritance represent the is-a relationship between classes. For example, A mallard IS-A duck and IS-A mammal and therefore can be extended with inheritance from the base class of duck.

===Example of Inheritance===
public class Car{
public int gear;
public int speed;
public Car(int speed_of_car, int gear_of_car) {
gear = speed_of_car;
speed = gear_of_car;
}
public void setGear(int new_gear) {
gear = new_gear;
}
public void speedUp(int increment_of_speed) {
speed += increment_of_speed;
}
}

public class Bmw extends Car {
public int seat_height;
public Toyota(int speed_of_car, int new_gear , int new_seat_height) {
super( speed_of_car, new_gear);
seat_height = new_seat_height;
}
public void set_height(int height) {
seat_height= height;
}
}

In this example Car is a base class where as Bmw is a derived class. Bmw has all the properties of Car (gear, speed) but it has its own functionality adjusting the height of seat.
All the cars can be derived from the base class Car which has the common functionality gear and speed and each derived class can add their own fuctionality.So all the common code in the base class and specific code in the child class.

== Delegation==
A technique, which provides the functionality of implementation of a particular interface to a field or expression is called delegation. Delegation passes a duty off to someone else.
It can be define in terms of objects ,where one object forwards certain function calls to another object which is called its delegate. Some languages do not support direct delegation and some do not provide the feature of [http://en.wikipedia.org/wiki/Polymorphism_(computer_science)dynamic polymorphism].

Delegation is a very powerful reuse technique. The most important feature of delegation is its run time flexibility. The delegates can be changed at run time where other processes like inheritance is normally created at compile time.

To be more specific [http://http://en.wikipedia.org/wiki/Delegation_pattern delegation pattern]
is where an object outwardly expresses certain behavior but in reality delegates responsibility for implementing that behavior to an associated object in an Inversion of Responsibility. The delegation pattern is the fundamental abstraction that underpins [http://en.wikipedia.org/wiki/Composition composition] (also referred to as aggregation), [http://en.wikipedia.org/wiki/Mixin mixins] and [http://en.wikipedia.org/wiki/Aspect aspects].

===Example of Delegation===
public interface Car{
public int gear;
public int speed;
public void setGear(int new_gear) {
gear = new_gear;
}
public void speedUp(int increment_of_speed) {
speed += increment_of_speed;
}
}

public class Bmw implements Car {
public int seat_height;
public void setGear(int new_gear) {
gear = new_gear;
}
public void speedUp(int increment_of_speed) {
speed += increment_of_speed;
}
public void set_height(int height) {
seat_height= height;
}
}

In the delegation, child class does not inherit all the properties of base class by default.All the methods that are defined in the base class should be necessarily defined in the child class and child class can add its own functionality.[http://java.sun.com/docs/books/tutorial/java/IandI/subclasses.html Inheritance Ex]

==Where to use Delegation and Inheritance==

Inheritance can not be used everywhere even if satisfies the reuse, is-a relationship and public interface.[http://oreilly.com/catalog/hfdesignpat/chapter/ch03.pdf DesignPatterns]
Ex[http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=4072925 :-]

class Duck{
swim();
quack();
color();
}
class MallradDuck extends Duck{
display();
}
class RubberDuck extends Duck{
display();
}
class RedHeadDuck extends Duck{
display();
}

In the following example all three type of ducks inherit all the properties of a duck. But the rubber duck can neither swim nor quack. So at this point because of the inheritance property
rubber duck inherits the swim() and quack() method. It proves that inheritance should not be used and this is where a method like delegation would be a better solution. RubberDuck has a color just like the mallardDuck and RedHeadDuck. so MallardDuck and RedHeadDuck are perfect to use inheritance on.

Using delegation to satisfy the following case:-
interface Swim{
swim();
{
interface Quack{
quack();
{
interface Color{
color();
{
class MallardDuck implements Swim implements Quack ,Color{
swim();
quack();
color();
}
class RedHeadDuck implements Swim implements Quack ,Color{
swim();
quack();
color();
}
class RubberDuck implements Color{
color();
}

In this example there is somewhat more code but it satisfies the functionality of the different types of ducks. The mallardDuck and the RedHeadDuck has the functionality of swim, quack and color whereas, rubberDuck has only color it can neither swim nor quack. Here through delegation some additional properties of a particular duck can also be added without affection the existing code. The functionality of fly in RedHeadDuck can be added without touching the other type of ducks.

interface Fly{
fly();
{
class RedHeadDuck implements Swim implements Quack implements Color implements Fly{
swim();
quack();
color();
fly();
}

==Listed differences between Inheritance and Delegation==

* Delegation is [http://www.jguru.com/faq/view.jsp?EID=27916 dynamic] in nature whereas Inheritance is [http://en.wikipedia.org/wiki/Inheritance_(computer_science) static] in nature. Since the delegation is dynamic, the [http://en.wikipedia.org/wiki/Delegation_(programming) run] time code can be changed in delegation. Inheritance is defined at compile time.

* Inheritance is faster than delegation because it is created at compile time whereas, delegation is created at run time.

*Inheritance is based on a [http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=40729 is-a] relationship among classes, delegation has the property of [http://en.wikipedia.org/wiki/Has-a has-a] relation.
*Delegation helps in finding bugs easily as compared to inheritance because delegation limit the scope of a possible logical error to a given subset of methods. In delegation code is more simple to explain, more easy to parse. In inheritance lots of functionality are associated with one object causes difficulty in finding bug.

* Inheritance breaks [http://en.csharp-online.net/Classes,_Structs,_and_Objects%E2%80%94Delegation_and_Composition_vs._Inheritance encapsulation], whereas Delegation preserves encapsulation, .

* By implementing delegation, all the methods laid out in the [http://www.learn-programming.za.net/programming_java_learn08.html interface] will be implemented where as in inheritance [http://en.wikipedia.org/wiki/Inheritance_(computer_science) derived] class inherit all the behavior of the base classes by default.

==Conclusion==
Inheritance actually creates something from something else, where delegation is actually using something to create something else. So delegation is a situation where you’re not really building new code from old code your using other code to build new. You can use inheritance where what your building IS-A of something else but if what your building has something of something else and only that part it may be better to use delegation.

Delegation is gaining some popularity in code were it can be implement as a better method. Although inheritance is probably the most widely used way in Object Orientated design to use existing code as tools or patterns to create new code with out reinventing the wheel.

==See Also==

* '''[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation]'''
* '''[http://en.wikipedia.org/wiki/Inheritance_(programming) Inheritance]'''

==External links and references==
*[http://www.jguru.com/faq/view.jsp?EID=27916 Introduction]
*[http://beautifulcode.oreillynet.com/2007/11/preferring_inheritance_to_dele.php Beautiful Code]
*[http://groovy.codehaus.org/Replace+Inheritance+with+Delegation Replace Inheritance with Delegation]
*[http://www.perlmonks.org/index.pl?node_id=278375 Inheritance vs Delegation: pros and cons]
*[http://articles.techrepublic.com.com/5100-10878_11-5031837.html Avoid Java Delegation]
*[http://en.csharp-online.net/Classes,_Structs,_and_Objects%E2%80%94Delegation_and_Composition_vs._Inheritance Delegation and Composition vs. Inheritance]
*[http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=4072925 Sun Delegation vs. Inheritance quick question]
*[http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=4072925 Inheritance vs delegation]
*[http://msdn.microsoft.com/en-us/library/ms973861.aspx inheritance and interfaces]
*[http://www.amazon.com/Object-Oriented-Design-Using-Java-Skrien/dp/0072974168 Object-Oriented Design Using Java, Dale Skrien, 2007]
[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Summer_2008/wiki2_Assignment Back to assignment page]

CSC/ECE 517 Summer 2008/wiki2 8 Inh-Del

2008-07-07T23:44:52Z

Jwpaul: /* External links and references */

=Inheritance vs Delegation=

[http://en.wikipedia.org/wiki/Inheritance_(programming) Inheritance] and [http://en.wikipedia.org/wiki/Delegation_(programming) delegation] plays a very important role in object-oriented languages.Both of the techniques facilitates the reuse of code that exist in another class. This WIKI will cite examples that show cases where inheritance is better, and cases where delegation is better. I also characterizes the situations in which you should employ one or the other.

== Inheritance ==
In [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming OOP], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] is a way to form new classes (instances of which are called objects) using classes that have already been defined. The new classes, known as derived or classes, take over (or inherit) attributes and behavior of the pre-existing classes, which are referred to as base classes (or ancestor classes). It is intended to help reuse existing code with little or no modification.

The top most class is called as the parent class, base class or a superclass.The classes derived from the parent class are known as child classes or [http://www.jguru.com/faq/view.jsp?EID=27916 subclasses].The lower classes of the hierarchy inherite from the upper class. Classes get more specialized as you move toward the bottom of the hierarchy.The subclasses have more functionality than superclass because of this feature and create their own new functionality.

The most common reason of using inheritance is to reuse existing classes or objects. Inheritance represent the is-a relationship between classes. For example, A mallard IS-A duck and IS-A mammal and therefore can be extended with inheritance from the base class of duck.

===Example of Inheritance===
public class Car{
public int gear;
public int speed;
public Car(int speed_of_car, int gear_of_car) {
gear = speed_of_car;
speed = gear_of_car;
}
public void setGear(int new_gear) {
gear = new_gear;
}
public void speedUp(int increment_of_speed) {
speed += increment_of_speed;
}
}

public class Bmw extends Car {
public int seat_height;
public Toyota(int speed_of_car, int new_gear , int new_seat_height) {
super( speed_of_car, new_gear);
seat_height = new_seat_height;
}
public void set_height(int height) {
seat_height= height;
}
}

In this example Car is a base class where as Bmw is a derived class. Bmw has all the properties of Car (gear, speed) but it has its own functionality adjusting the height of seat.
All the cars can be derived from the base class Car which has the common functionality gear and speed and each derived class can add their own fuctionality.So all the common code in the base class and specific code in the child class.

== Delegation==
A technique, which provides the functionality of implementation of a particular interface to a field or expression is called delegation. Delegation passes a duty off to someone else.
It can be define in terms of objects ,where one object forwards certain function calls to another object which is called its delegate. Some languages do not support direct delegation and some do not provide the feature of [http://en.wikipedia.org/wiki/Polymorphism_(computer_science)dynamic polymorphism].

Delegation is a very powerful reuse technique. The most important feature of delegation is its run time flexibility. The delegates can be changed at run time where other processes like inheritance is normally created at compile time.

To be more specific [http://http://en.wikipedia.org/wiki/Delegation_pattern delegation pattern]
is where an object outwardly expresses certain behavior but in reality delegates responsibility for implementing that behavior to an associated object in an Inversion of Responsibility. The delegation pattern is the fundamental abstraction that underpins [http://en.wikipedia.org/wiki/Composition composition] (also referred to as aggregation), [http://en.wikipedia.org/wiki/Mixin mixins] and [http://en.wikipedia.org/wiki/Aspect aspects].

===Example of Delegation===
public interface Car{
public int gear;
public int speed;
public void setGear(int new_gear) {
gear = new_gear;
}
public void speedUp(int increment_of_speed) {
speed += increment_of_speed;
}
}

public class Bmw implements Car {
public int seat_height;
public void setGear(int new_gear) {
gear = new_gear;
}
public void speedUp(int increment_of_speed) {
speed += increment_of_speed;
}
public void set_height(int height) {
seat_height= height;
}
}

In the delegation, child class does not inherit all the properties of base class by default.All the methods that are defined in the base class should be necessarily defined in the child class and child class can add its own functionality.[http://java.sun.com/docs/books/tutorial/java/IandI/subclasses.html Inheritance Ex]

==Where to use Delegation and Inheritance==

Inheritance can not be used everywhere even if satisfies the reuse, is-a relationship and public interface.[http://oreilly.com/catalog/hfdesignpat/chapter/ch03.pdf DesignPatterns]
Ex[http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=4072925 :-]

class Duck{
swim();
quack();
color();
}
class MallradDuck extends Duck{
display();
}
class RubberDuck extends Duck{
display();
}
class RedHeadDuck extends Duck{
display();
}

In the following example all three type of ducks inherit all the properties of a duck. But the rubber duck can neither swim nor quack. So at this point because of the inheritance property
rubber duck inherits the swim() and quack() method. It proves that inheritance should not be used and this is where a method like delegation would be a better solution. RubberDuck has a color just like the mallardDuck and RedHeadDuck. so MallardDuck and RedHeadDuck are perfect to use inheritance on.

Using delegation to satisfy the following case:-
interface Swim{
swim();
{
interface Quack{
quack();
{
interface Color{
color();
{
class MallardDuck implements Swim implements Quack ,Color{
swim();
quack();
color();
}
class RedHeadDuck implements Swim implements Quack ,Color{
swim();
quack();
color();
}
class RubberDuck implements Color{
color();
}

In this example there is somewhat more code but it satisfies the functionality of the different types of ducks. The mallardDuck and the RedHeadDuck has the functionality of swim, quack and color whereas, rubberDuck has only color it can neither swim nor quack. Here through delegation some additional properties of a particular duck can also be added without affection the existing code. The functionality of fly in RedHeadDuck can be added without touching the other type of ducks.

interface Fly{
fly();
{
class RedHeadDuck implements Swim implements Quack implements Color implements Fly{
swim();
quack();
color();
fly();
}

==Listed differences between Inheritance and Delegation==

* Delegation is [http://www.jguru.com/faq/view.jsp?EID=27916 dynamic] in nature whereas Inheritance is [http://en.wikipedia.org/wiki/Inheritance_(computer_science) static] in nature. Since the delegation is dynamic, the [http://en.wikipedia.org/wiki/Delegation_(programming) run] time code can be changed in delegation. Inheritance is defined at compile time.

* Inheritance is faster than delegation because it is created at compile time whereas, delegation is created at run time.

*Inheritance is based on a [http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=40729 is-a] relationship among classes, delegation has the property of [http://en.wikipedia.org/wiki/Has-a has-a] relation.
*Delegation helps in finding bugs easily as compared to inheritance because delegation limit the scope of a possible logical error to a given subset of methods. In delegation code is more simple to explain, more easy to parse. In inheritance lots of functionality are associated with one object causes difficulty in finding bug.

* Inheritance breaks [http://en.csharp-online.net/Classes,_Structs,_and_Objects%E2%80%94Delegation_and_Composition_vs._Inheritance encapsulation], whereas Delegation preserves encapsulation, .

* By implementing delegation, all the methods laid out in the [http://www.learn-programming.za.net/programming_java_learn08.html interface] will be implemented where as in inheritance [http://en.wikipedia.org/wiki/Inheritance_(computer_science) derived] class inherit all the behavior of the base classes by default.

==Conclusion==
Inheritance actually creates something from something else, where delegation is actually using something to create something else. So delegation is a situation where you’re not really building new code from old code your using other code to build new. You can use inheritance where what your building IS-A of something else but if what your building has something of something else and only that part it may be better to use delegation.

Delegation is gaining some popularity in code were it can be implement as a better method. Although inheritance is probably the most widely used way in Object Orientated design to use existing code as tools or patterns to create new code with out reinventing the wheel.

==See Also==

* '''[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation]'''
* '''[http://en.wikipedia.org/wiki/Inheritance_(programming) Inheritance]'''

==External links and references==
*[http://www.jguru.com/faq/view.jsp?EID=27916 Introduction]
*[http://beautifulcode.oreillynet.com/2007/11/preferring_inheritance_to_dele.php Beautiful Code]
*[http://groovy.codehaus.org/Replace+Inheritance+with+Delegation Replace Inheritance with Delegation]
*[http://www.perlmonks.org/index.pl?node_id=278375 Inheritance vs Delegation: pros and cons]
*[http://articles.techrepublic.com.com/5100-10878_11-5031837.html Avoid Java Delegation]
*[http://en.csharp-online.net/Classes,_Structs,_and_Objects%E2%80%94Delegation_and_Composition_vs._Inheritance Delegation and Composition vs. Inheritance]
*[http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=4072925 Sun Delegation vs. Inheritance quick question]
*[http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=4072925 Inheritance vs delegation]
*[http://msdn.microsoft.com/en-us/library/ms973861.aspx inheritance and interfaces]
*[http://www.amazon.com/Object-Oriented-Design-Using-Java-Skrien/dp/0072974168 Object-Oriented Design Using Java, Dale Skrien, 2007]
[http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Summer_2008/wiki2_Assignment Back to assignment page]

CSC/ECE 517 Summer 2008/wiki2 8 Inh-Del

2008-07-07T23:44:06Z

Jwpaul:

=Inheritance vs Delegation=

[http://en.wikipedia.org/wiki/Inheritance_(programming) Inheritance] and [http://en.wikipedia.org/wiki/Delegation_(programming) delegation] plays a very important role in object-oriented languages.Both of the techniques facilitates the reuse of code that exist in another class. This WIKI will cite examples that show cases where inheritance is better, and cases where delegation is better. I also characterizes the situations in which you should employ one or the other.

== Inheritance ==
In [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming OOP], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] is a way to form new classes (instances of which are called objects) using classes that have already been defined. The new classes, known as derived or classes, take over (or inherit) attributes and behavior of the pre-existing classes, which are referred to as base classes (or ancestor classes). It is intended to help reuse existing code with little or no modification.

The top most class is called as the parent class, base class or a superclass.The classes derived from the parent class are known as child classes or [http://www.jguru.com/faq/view.jsp?EID=27916 subclasses].The lower classes of the hierarchy inherite from the upper class. Classes get more specialized as you move toward the bottom of the hierarchy.The subclasses have more functionality than superclass because of this feature and create their own new functionality.

The most common reason of using inheritance is to reuse existing classes or objects. Inheritance represent the is-a relationship between classes. For example, A mallard IS-A duck and IS-A mammal and therefore can be extended with inheritance from the base class of duck.

===Example of Inheritance===
public class Car{
public int gear;
public int speed;
public Car(int speed_of_car, int gear_of_car) {
gear = speed_of_car;
speed = gear_of_car;
}
public void setGear(int new_gear) {
gear = new_gear;
}
public void speedUp(int increment_of_speed) {
speed += increment_of_speed;
}
}

public class Bmw extends Car {
public int seat_height;
public Toyota(int speed_of_car, int new_gear , int new_seat_height) {
super( speed_of_car, new_gear);
seat_height = new_seat_height;
}
public void set_height(int height) {
seat_height= height;
}
}

In this example Car is a base class where as Bmw is a derived class. Bmw has all the properties of Car (gear, speed) but it has its own functionality adjusting the height of seat.
All the cars can be derived from the base class Car which has the common functionality gear and speed and each derived class can add their own fuctionality.So all the common code in the base class and specific code in the child class.

== Delegation==
A technique, which provides the functionality of implementation of a particular interface to a field or expression is called delegation. Delegation passes a duty off to someone else.
It can be define in terms of objects ,where one object forwards certain function calls to another object which is called its delegate. Some languages do not support direct delegation and some do not provide the feature of [http://en.wikipedia.org/wiki/Polymorphism_(computer_science)dynamic polymorphism].

Delegation is a very powerful reuse technique. The most important feature of delegation is its run time flexibility. The delegates can be changed at run time where other processes like inheritance is normally created at compile time.

To be more specific [http://http://en.wikipedia.org/wiki/Delegation_pattern delegation pattern]
is where an object outwardly expresses certain behavior but in reality delegates responsibility for implementing that behavior to an associated object in an Inversion of Responsibility. The delegation pattern is the fundamental abstraction that underpins [http://en.wikipedia.org/wiki/Composition composition] (also referred to as aggregation), [http://en.wikipedia.org/wiki/Mixin mixins] and [http://en.wikipedia.org/wiki/Aspect aspects].

===Example of Delegation===
public interface Car{
public int gear;
public int speed;
public void setGear(int new_gear) {
gear = new_gear;
}
public void speedUp(int increment_of_speed) {
speed += increment_of_speed;
}
}

public class Bmw implements Car {
public int seat_height;
public void setGear(int new_gear) {
gear = new_gear;
}
public void speedUp(int increment_of_speed) {
speed += increment_of_speed;
}
public void set_height(int height) {
seat_height= height;
}
}

In the delegation, child class does not inherit all the properties of base class by default.All the methods that are defined in the base class should be necessarily defined in the child class and child class can add its own functionality.[http://java.sun.com/docs/books/tutorial/java/IandI/subclasses.html Inheritance Ex]

==Where to use Delegation and Inheritance==

Inheritance can not be used everywhere even if satisfies the reuse, is-a relationship and public interface.[http://oreilly.com/catalog/hfdesignpat/chapter/ch03.pdf DesignPatterns]
Ex[http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=4072925 :-]

class Duck{
swim();
quack();
color();
}
class MallradDuck extends Duck{
display();
}
class RubberDuck extends Duck{
display();
}
class RedHeadDuck extends Duck{
display();
}

In the following example all three type of ducks inherit all the properties of a duck. But the rubber duck can neither swim nor quack. So at this point because of the inheritance property
rubber duck inherits the swim() and quack() method. It proves that inheritance should not be used and this is where a method like delegation would be a better solution. RubberDuck has a color just like the mallardDuck and RedHeadDuck. so MallardDuck and RedHeadDuck are perfect to use inheritance on.

Using delegation to satisfy the following case:-
interface Swim{
swim();
{
interface Quack{
quack();
{
interface Color{
color();
{
class MallardDuck implements Swim implements Quack ,Color{
swim();
quack();
color();
}
class RedHeadDuck implements Swim implements Quack ,Color{
swim();
quack();
color();
}
class RubberDuck implements Color{
color();
}

In this example there is somewhat more code but it satisfies the functionality of the different types of ducks. The mallardDuck and the RedHeadDuck has the functionality of swim, quack and color whereas, rubberDuck has only color it can neither swim nor quack. Here through delegation some additional properties of a particular duck can also be added without affection the existing code. The functionality of fly in RedHeadDuck can be added without touching the other type of ducks.

interface Fly{
fly();
{
class RedHeadDuck implements Swim implements Quack implements Color implements Fly{
swim();
quack();
color();
fly();
}

==Listed differences between Inheritance and Delegation==

* Delegation is [http://www.jguru.com/faq/view.jsp?EID=27916 dynamic] in nature whereas Inheritance is [http://en.wikipedia.org/wiki/Inheritance_(computer_science) static] in nature. Since the delegation is dynamic, the [http://en.wikipedia.org/wiki/Delegation_(programming) run] time code can be changed in delegation. Inheritance is defined at compile time.

* Inheritance is faster than delegation because it is created at compile time whereas, delegation is created at run time.

*Inheritance is based on a [http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=40729 is-a] relationship among classes, delegation has the property of [http://en.wikipedia.org/wiki/Has-a has-a] relation.
*Delegation helps in finding bugs easily as compared to inheritance because delegation limit the scope of a possible logical error to a given subset of methods. In delegation code is more simple to explain, more easy to parse. In inheritance lots of functionality are associated with one object causes difficulty in finding bug.

* Inheritance breaks [http://en.csharp-online.net/Classes,_Structs,_and_Objects%E2%80%94Delegation_and_Composition_vs._Inheritance encapsulation], whereas Delegation preserves encapsulation, .

* By implementing delegation, all the methods laid out in the [http://www.learn-programming.za.net/programming_java_learn08.html interface] will be implemented where as in inheritance [http://en.wikipedia.org/wiki/Inheritance_(computer_science) derived] class inherit all the behavior of the base classes by default.

==Conclusion==
Inheritance actually creates something from something else, where delegation is actually using something to create something else. So delegation is a situation where you’re not really building new code from old code your using other code to build new. You can use inheritance where what your building IS-A of something else but if what your building has something of something else and only that part it may be better to use delegation.

Delegation is gaining some popularity in code were it can be implement as a better method. Although inheritance is probably the most widely used way in Object Orientated design to use existing code as tools or patterns to create new code with out reinventing the wheel.

==See Also==

* '''[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation]'''
* '''[http://en.wikipedia.org/wiki/Inheritance_(programming) Inheritance]'''

==External links and references==
*[http://www.jguru.com/faq/view.jsp?EID=27916 Introduction]
*[http://beautifulcode.oreillynet.com/2007/11/preferring_inheritance_to_dele.php Beautiful Code]
*[http://groovy.codehaus.org/Replace+Inheritance+with+Delegation Replace Inheritance with Delegation]
*[http://www.perlmonks.org/index.pl?node_id=278375 Inheritance vs Delegation: pros and cons]
*[http://articles.techrepublic.com.com/5100-10878_11-5031837.html Avoid Java Delegation]
*[http://en.csharp-online.net/Classes,_Structs,_and_Objects%E2%80%94Delegation_and_Composition_vs._Inheritance Delegation and Composition vs. Inheritance]
*[http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=4072925 Sun Delegation vs. Inheritance quick question]
*[http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=4072925 Inheritance vs delegation]
*[http://msdn.microsoft.com/en-us/library/ms973861.aspx inheritance and interfaces]
*[http://www.amazon.com/Object-Oriented-Design-Using-Java-Skrien/dp/0072974168 Object-Oriented Design Using Java, Dale Skrien, 2007]
{http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Summer_2008/wiki2_Assignment Back to assignment page]

CSC/ECE 517 Summer 2008/wiki2 8 Inh-Del

2008-07-01T12:46:48Z

Jwpaul: /* Example of Inheritance */

=Inheritance vs Delagation=

[http://en.wikipedia.org/wiki/Inheritance_(programming) Inheritance] and [http://en.wikipedia.org/wiki/Delegation_(programming) delegation] plays a very important role in object-oriented languages.Both of the techniques facilitates the reuse of code that exist in another class. This WIKI will cite examples that show cases where inheritance is better, and cases where delegation is better. I also characterizes the situations in which you should employ one or the other.

== Inheritance ==
In [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming OOP], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] is a way to form new classes (instances of which are called objects) using classes that have already been defined. The new classes, known as derived or classes, take over (or inherit) attributes and behavior of the pre-existing classes, which are referred to as base classes (or ancestor classes). It is intended to help reuse existing code with little or no modification.

The top most class is called as the parent class, base class or a superclass.The classes derived from the parent class are known as child classes or [http://www.jguru.com/faq/view.jsp?EID=27916 subclasses].The lower classes of the hierarchy inherite from the upper class. Classes get more specialized as you move toward the bottom of the hierarchy.The subclasses have more functionality than superclass because of this feature and create their own new functionality.

The most common reason of using inheritance is to reuse existing classes or objects. Inheritance represent the is-a relationship between classes. For example, A mallard IS-A duck and IS-A mammal and therefore can be extended with inheritance from the base class of duck.

===Example of Inheritance===
public class Car{
public int gear;
public int speed;
public Car(int speed_of_car, int gear_of_car) {
gear = speed_of_car;
speed = gear_of_car;
}
public void setGear(int new_gear) {
gear = new_gear;
}
public void speedUp(int increment_of_speed) {
speed += increment_of_speed;
}
}

public class Bmw extends Car {
public int seat_height;
public Toyota(int speed_of_car, int new_gear , int new_seat_height) {
super( speed_of_car, new_gear);
seat_height = new_seat_height;
}
public void set_height(int height) {
seat_height= height;
}
}

In this example Car is a base class where as Bmw is a derived class. Bmw has all the properties of Car (gear, speed) but it has its own functionality adjusting the height of seat.
All the cars can be derived from the base class Car which has the common functionality gear and speed and each derived class can add their own fuctionality.So all the common code in the base class and specific code in the child class.

== Delegation==
A technique, which provides the functionality of implementation of a particular interface to a field or expression is called delegation. Delegation passes a duty off to someone else.
It can be define in terms of objects ,where one object forwards certain function calls to another object which is called its delegate. Some languages do not support direct delegation and some do not provide the feature of [http://en.wikipedia.org/wiki/Polymorphism_(computer_science)dynamic polymorphism].

Delegation is a very powerful reuse technique. The most important feature of delegation is its run time flexibility. The delegates can be changed at run time where other processes like inheritance is normally created at compile time.

To be more specifif [http://http://en.wikipedia.org/wiki/Delegation_pattern delegation pattern]
is where an object outwardly expresses certain behavior but in reality delegates responsibility for implementing that behavior to an associated object in an Inversion of Responsibility. The delegation pattern is the fundamental abstraction that underpins [http://en.wikipedia.org/wiki/Composition composition] (also referred to as aggregation), [http://en.wikipedia.org/wiki/Mixin mixins] and [http://en.wikipedia.org/wiki/Aspect aspects].

===Example of Delegation===
public interface Car{
public int gear;
public int speed;
public void setGear(int new_gear) {
gear = new_gear;
}
public void speedUp(int increment_of_speed) {
speed += increment_of_speed;
}
}

public class Bmw implementation Car {
public int seat_height;
public void setGear(int new_gear) {
gear = new_gear;
}
public void speedUp(int increment_of_speed) {
speed += increment_of_speed;
}
public void set_height(int height) {
seat_height= height;
}
}

In the delegation, child class does not inherit all the properties of base class by default.All the methods that are defined in the base class should be necessarily defined in the child class and child class can add its own functionality.[http://java.sun.com/docs/books/tutorial/java/IandI/subclasses.html Inheritance Ex]

==Where to use Delegation and Inheritance==

Inheritance can not be used everywhere even if satisfies the reuse, is-a relationship and public interface.[http://oreilly.com/catalog/hfdesignpat/chapter/ch03.pdf DesignPatterns]
Ex[http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=4072925 :-]

class Duck{
swim();
quack();
color();
}
class MallradDuck extends Duck{
display();
}
class RubberDuck extends Duck{
display();
}
class RedHeadDuck extends Duck{
display();
}

In the following example all three type of ducks inherit all the properties of a duck. But the rubber duck can neither swim nor quack. So at this point because of the inheritance property
rubber duck inherits the swim() and quack() method. It proves that inheritance should not be used and this is where a method like delegation would be a better solution. RubberDuck has a color just like the mallardDuck and RedHeadDuck. so MallardDuck and RedHeadDuck are perfect to use inheritance on.

Using delegation to satisfy the following case:-
interface Swim{
swim();
{
interface Quack{
quack();
{
interface Color{
color();
{
class MallardDuck implements Swim implements Quack implements Color{
swim();
quack();
color();
}
class RedHeadDuck implements Swim implements Quack implements Color{
swim();
quack();
color();
}
class RubberDuck implements Color{
color();
}

In this example there is somewhat more code but it satisfies the functionality of the different types of ducks. The mallardDuck and the RedHeadDuck has the functionality of swim, quack and color whereas, rubberDuck has only color it can neither swim nor quack. Here through delegation some additional properties of a particular duck can also be added without affection the existing code. The functionality of fly in RedHeadDuck can be added without touching the other type of ducks.

interface Fly{
fly();
{
class RedHeadDuck implements Swim implements Quack implements Color implements Fly{
swim();
quack();
color();
fly();
}

==Listed differences between Inheritance and Delegation==

* Delegation is [http://www.jguru.com/faq/view.jsp?EID=27916 dynamic] in nature whereas Inheritance is [http://en.wikipedia.org/wiki/Inheritance_(computer_science) static] in nature. Since the delegation is dynamic, the [http://en.wikipedia.org/wiki/Delegation_(programming) run] time code can be changed in delegation. Inheritance is defined at compile time.

* Inheritance is faster than delegation because it is created at compile time whereas, delegation is created at run time.

*Inheritance is based on a [http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=40729 is-a] relationship among classes, delegation has the property of [http://en.wikipedia.org/wiki/Has-a has-a] relation.
*Delegation helps in finding bugs easily as compared to inheritance because delegation limit the scope of a possible logical error to a given subset of methods. In delegation code is more simple to explain, more easy to parse. In inheritance lots of functionality are associated with one object causes difficulty in finding bug.

* Inheritance breaks [http://en.csharp-online.net/Classes,_Structs,_and_Objects%E2%80%94Delegation_and_Composition_vs._Inheritance encapsulation], whereas Delegation preserves encapsulation, .

* By implementing delegation, all the methods laid out in the [http://www.learn-programming.za.net/programming_java_learn08.html interface] will be implemented where as in inheritance [http://en.wikipedia.org/wiki/Inheritance_(computer_science) derived] class inherit all the behavior of the base classes by default.

==Conclusion==
Inheritance actually creates something from something else, where delegation is actually using something to create something else. So delegation is a situation where you’re not really building new code from old code your using other code to build new. You can use inheritance where what your building IS-A of something else but if what your building has something of something else and only that part it may be better to use delegation.

Delegation is gaining some popularity in code were it can be implement as a better method. Although inheritance is probably the most widely used way in Object Orientated design to use existing code as tools or patterns to create new code with out reinventing the wheel.

==See Also==

* '''[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation]'''
* '''[http://en.wikipedia.org/wiki/Inheritance_(programming) Inheritance]'''

==External links and references==
*[http://www.jguru.com/faq/view.jsp?EID=27916 Introduction]
*[http://beautifulcode.oreillynet.com/2007/11/preferring_inheritance_to_dele.php Beautiful Code]
*[http://groovy.codehaus.org/Replace+Inheritance+with+Delegation Replace Inheritance with Delegation]
*[http://www.perlmonks.org/index.pl?node_id=278375 Inheritance vs Delegation: pros and cons]
*[http://articles.techrepublic.com.com/5100-10878_11-5031837.html Avoid Java Delegation]
*[http://en.csharp-online.net/Classes,_Structs,_and_Objects%E2%80%94Delegation_and_Composition_vs._Inheritance Delegation and Composition vs. Inheritance]
*[http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=4072925 Sun Delegation vs. Inheritance quick question]
*[http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=4072925 Inheritance vs delegation]
*[http://msdn.microsoft.com/en-us/library/ms973861.aspx inheritance and interfaces]
*[http://www.amazon.com/Object-Oriented-Design-Using-Java-Skrien/dp/0072974168 Object-Oriented Design Using Java, Dale Skrien, 2007]

CSC/ECE 517 Summer 2008/wiki2 8 Inh-Del

2008-07-01T12:42:46Z

Jwpaul: /* Where to use Delegation and Inheritance */

=Inheritance vs Delagation=

[http://en.wikipedia.org/wiki/Inheritance_(programming) Inheritance] and [http://en.wikipedia.org/wiki/Delegation_(programming) delegation] plays a very important role in object-oriented languages.Both of the techniques facilitates the reuse of code that exist in another class. This WIKI will cite examples that show cases where inheritance is better, and cases where delegation is better. I also characterizes the situations in which you should employ one or the other.

== Inheritance ==
In [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming OOP], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] is a way to form new classes (instances of which are called objects) using classes that have already been defined. The new classes, known as derived or classes, take over (or inherit) attributes and behavior of the pre-existing classes, which are referred to as base classes (or ancestor classes). It is intended to help reuse existing code with little or no modification.

The top most class is called as the parent class, base class or a superclass.The classes derived from the parent class are known as child classes or [http://www.jguru.com/faq/view.jsp?EID=27916 subclasses].The lower classes of the hierarchy inherite from the upper class. Classes get more specialized as you move toward the bottom of the hierarchy.The subclasses have more functionality than superclass because of this feature and create their own new functionality.

The most common reason of using inheritance is to reuse existing classes or objects. Inheritance represent the is-a relationship between classes. For example, A mallard IS-A duck and IS-A mammal and therefore can be extended with inheritance from the base class of duck.

===Example of Inheritance===
public class Car{
public int gear;
public int speed;
public Car(int speed_of_car, int gear_of_car) {
gear = speed_of_car;
speed = gear_of_car;
}
public void setGear(int new_gear) {
gear = new_gear;
}
public void speedUp(int increment_of_speed) {
speed += increment_of_speed;
}
}

public class Bmw extends Car {
public int seat_height;
public Toyota(int speed_of_car, int new_gear , int new_seat_height) {
super( speed_of_car, new_gear);
seat_height = new_seat_height;
}
public void set_height(int height) {
seat_height= height;
}
}

In this example Car is a base class where as Bmv is a derived class.Bmv has all the properties of Car (gear, speed) but it has its own functionality adjusting the height of seat.
All the cars can be derived from the base class Car which has the common functionality gear and speed and each derived class can add their own fuctionality.So all the common code in the base class and specific code in the child class.

== Delegation==
A technique, which provides the functionality of implementation of a particular interface to a field or expression is called delegation. Delegation passes a duty off to someone else.
It can be define in terms of objects ,where one object forwards certain function calls to another object which is called its delegate. Some languages do not support direct delegation and some do not provide the feature of [http://en.wikipedia.org/wiki/Polymorphism_(computer_science)dynamic polymorphism].

Delegation is a very powerful reuse technique. The most important feature of delegation is its run time flexibility. The delegates can be changed at run time where other processes like inheritance is normally created at compile time.

To be more specifif [http://http://en.wikipedia.org/wiki/Delegation_pattern delegation pattern]
is where an object outwardly expresses certain behavior but in reality delegates responsibility for implementing that behavior to an associated object in an Inversion of Responsibility. The delegation pattern is the fundamental abstraction that underpins [http://en.wikipedia.org/wiki/Composition composition] (also referred to as aggregation), [http://en.wikipedia.org/wiki/Mixin mixins] and [http://en.wikipedia.org/wiki/Aspect aspects].

===Example of Delegation===
public interface Car{
public int gear;
public int speed;
public void setGear(int new_gear) {
gear = new_gear;
}
public void speedUp(int increment_of_speed) {
speed += increment_of_speed;
}
}

public class Bmw implementation Car {
public int seat_height;
public void setGear(int new_gear) {
gear = new_gear;
}
public void speedUp(int increment_of_speed) {
speed += increment_of_speed;
}
public void set_height(int height) {
seat_height= height;
}
}

In the delegation, child class does not inherit all the properties of base class by default.All the methods that are defined in the base class should be necessarily defined in the child class and child class can add its own functionality.[http://java.sun.com/docs/books/tutorial/java/IandI/subclasses.html Inheritance Ex]

==Where to use Delegation and Inheritance==

Inheritance can not be used everywhere even if satisfies the reuse, is-a relationship and public interface.[http://oreilly.com/catalog/hfdesignpat/chapter/ch03.pdf DesignPatterns]
Ex[http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=4072925 :-]

class Duck{
swim();
quack();
color();
}
class MallradDuck extends Duck{
display();
}
class RubberDuck extends Duck{
display();
}
class RedHeadDuck extends Duck{
display();
}

In the following example all three type of ducks inherit all the properties of a duck. But the rubber duck can neither swim nor quack. So at this point because of the inheritance property
rubber duck inherits the swim() and quack() method. It proves that inheritance should not be used and this is where a method like delegation would be a better solution. RubberDuck has a color just like the mallardDuck and RedHeadDuck. so MallardDuck and RedHeadDuck are perfect to use inheritance on.

Using delegation to satisfy the following case:-
interface Swim{
swim();
{
interface Quack{
quack();
{
interface Color{
color();
{
class MallardDuck implements Swim implements Quack implements Color{
swim();
quack();
color();
}
class RedHeadDuck implements Swim implements Quack implements Color{
swim();
quack();
color();
}
class RubberDuck implements Color{
color();
}

In this example there is somewhat more code but it satisfies the functionality of the different types of ducks. The mallardDuck and the RedHeadDuck has the functionality of swim, quack and color whereas, rubberDuck has only color it can neither swim nor quack. Here through delegation some additional properties of a particular duck can also be added without affection the existing code. The functionality of fly in RedHeadDuck can be added without touching the other type of ducks.

interface Fly{
fly();
{
class RedHeadDuck implements Swim implements Quack implements Color implements Fly{
swim();
quack();
color();
fly();
}

==Listed differences between Inheritance and Delegation==

* Delegation is [http://www.jguru.com/faq/view.jsp?EID=27916 dynamic] in nature whereas Inheritance is [http://en.wikipedia.org/wiki/Inheritance_(computer_science) static] in nature. Since the delegation is dynamic, the [http://en.wikipedia.org/wiki/Delegation_(programming) run] time code can be changed in delegation. Inheritance is defined at compile time.

* Inheritance is faster than delegation because it is created at compile time whereas, delegation is created at run time.

*Inheritance is based on a [http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=40729 is-a] relationship among classes, delegation has the property of [http://en.wikipedia.org/wiki/Has-a has-a] relation.
*Delegation helps in finding bugs easily as compared to inheritance because delegation limit the scope of a possible logical error to a given subset of methods. In delegation code is more simple to explain, more easy to parse. In inheritance lots of functionality are associated with one object causes difficulty in finding bug.

* Inheritance breaks [http://en.csharp-online.net/Classes,_Structs,_and_Objects%E2%80%94Delegation_and_Composition_vs._Inheritance encapsulation], whereas Delegation preserves encapsulation, .

* By implementing delegation, all the methods laid out in the [http://www.learn-programming.za.net/programming_java_learn08.html interface] will be implemented where as in inheritance [http://en.wikipedia.org/wiki/Inheritance_(computer_science) derived] class inherit all the behavior of the base classes by default.

==Conclusion==
Inheritance actually creates something from something else, where delegation is actually using something to create something else. So delegation is a situation where you’re not really building new code from old code your using other code to build new. You can use inheritance where what your building IS-A of something else but if what your building has something of something else and only that part it may be better to use delegation.

Delegation is gaining some popularity in code were it can be implement as a better method. Although inheritance is probably the most widely used way in Object Orientated design to use existing code as tools or patterns to create new code with out reinventing the wheel.

==See Also==

* '''[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation]'''
* '''[http://en.wikipedia.org/wiki/Inheritance_(programming) Inheritance]'''

==External links and references==
*[http://www.jguru.com/faq/view.jsp?EID=27916 Introduction]
*[http://beautifulcode.oreillynet.com/2007/11/preferring_inheritance_to_dele.php Beautiful Code]
*[http://groovy.codehaus.org/Replace+Inheritance+with+Delegation Replace Inheritance with Delegation]
*[http://www.perlmonks.org/index.pl?node_id=278375 Inheritance vs Delegation: pros and cons]
*[http://articles.techrepublic.com.com/5100-10878_11-5031837.html Avoid Java Delegation]
*[http://en.csharp-online.net/Classes,_Structs,_and_Objects%E2%80%94Delegation_and_Composition_vs._Inheritance Delegation and Composition vs. Inheritance]
*[http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=4072925 Sun Delegation vs. Inheritance quick question]
*[http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=4072925 Inheritance vs delegation]
*[http://msdn.microsoft.com/en-us/library/ms973861.aspx inheritance and interfaces]
*[http://www.amazon.com/Object-Oriented-Design-Using-Java-Skrien/dp/0072974168 Object-Oriented Design Using Java, Dale Skrien, 2007]

CSC/ECE 517 Summer 2008/wiki2 8 Inh-Del

2008-07-01T12:40:56Z

Jwpaul: /* Listed differences between Inheritance and Delegation */

=Inheritance vs Delagation=

[http://en.wikipedia.org/wiki/Inheritance_(programming) Inheritance] and [http://en.wikipedia.org/wiki/Delegation_(programming) delegation] plays a very important role in object-oriented languages.Both of the techniques facilitates the reuse of code that exist in another class. This WIKI will cite examples that show cases where inheritance is better, and cases where delegation is better. I also characterizes the situations in which you should employ one or the other.

== Inheritance ==
In [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming OOP], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) inheritance] is a way to form new classes (instances of which are called objects) using classes that have already been defined. The new classes, known as derived or classes, take over (or inherit) attributes and behavior of the pre-existing classes, which are referred to as base classes (or ancestor classes). It is intended to help reuse existing code with little or no modification.

The top most class is called as the parent class, base class or a superclass.The classes derived from the parent class are known as child classes or [http://www.jguru.com/faq/view.jsp?EID=27916 subclasses].The lower classes of the hierarchy inherite from the upper class. Classes get more specialized as you move toward the bottom of the hierarchy.The subclasses have more functionality than superclass because of this feature and create their own new functionality.

The most common reason of using inheritance is to reuse existing classes or objects. Inheritance represent the is-a relationship between classes. For example, A mallard IS-A duck and IS-A mammal and therefore can be extended with inheritance from the base class of duck.

===Example of Inheritance===
public class Car{
public int gear;
public int speed;
public Car(int speed_of_car, int gear_of_car) {
gear = speed_of_car;
speed = gear_of_car;
}
public void setGear(int new_gear) {
gear = new_gear;
}
public void speedUp(int increment_of_speed) {
speed += increment_of_speed;
}
}

public class Bmw extends Car {
public int seat_height;
public Toyota(int speed_of_car, int new_gear , int new_seat_height) {
super( speed_of_car, new_gear);
seat_height = new_seat_height;
}
public void set_height(int height) {
seat_height= height;
}
}

In this example Car is a base class where as Bmv is a derived class.Bmv has all the properties of Car (gear, speed) but it has its own functionality adjusting the height of seat.
All the cars can be derived from the base class Car which has the common functionality gear and speed and each derived class can add their own fuctionality.So all the common code in the base class and specific code in the child class.

== Delegation==
A technique, which provides the functionality of implementation of a particular interface to a field or expression is called delegation. Delegation passes a duty off to someone else.
It can be define in terms of objects ,where one object forwards certain function calls to another object which is called its delegate. Some languages do not support direct delegation and some do not provide the feature of [http://en.wikipedia.org/wiki/Polymorphism_(computer_science)dynamic polymorphism].

Delegation is a very powerful reuse technique. The most important feature of delegation is its run time flexibility. The delegates can be changed at run time where other processes like inheritance is normally created at compile time.

To be more specifif [http://http://en.wikipedia.org/wiki/Delegation_pattern delegation pattern]
is where an object outwardly expresses certain behavior but in reality delegates responsibility for implementing that behavior to an associated object in an Inversion of Responsibility. The delegation pattern is the fundamental abstraction that underpins [http://en.wikipedia.org/wiki/Composition composition] (also referred to as aggregation), [http://en.wikipedia.org/wiki/Mixin mixins] and [http://en.wikipedia.org/wiki/Aspect aspects].

===Example of Delegation===
public interface Car{
public int gear;
public int speed;
public void setGear(int new_gear) {
gear = new_gear;
}
public void speedUp(int increment_of_speed) {
speed += increment_of_speed;
}
}

public class Bmw implementation Car {
public int seat_height;
public void setGear(int new_gear) {
gear = new_gear;
}
public void speedUp(int increment_of_speed) {
speed += increment_of_speed;
}
public void set_height(int height) {
seat_height= height;
}
}

In the delegation, child class does not inherit all the properties of base class by default.All the methods that are defined in the base class should be necessarily defined in the child class and child class can add its own functionality.[http://java.sun.com/docs/books/tutorial/java/IandI/subclasses.html Inheritance Ex]

==Where to use Delegation and Inheritance==

Inheritance can not be used everywhere even if satisfies the reuse, is-a relationship and public interface.[http://oreilly.com/catalog/hfdesignpat/chapter/ch03.pdf DesignPatterns]
Ex[http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=4072925 :-]

class Duck{
swim();
quack();
color();
}
class MallradDuck extends Duck{
display();
}
class RubberDuck extends Duck{
display();
}
class RedHeadDuck extends Duck{
display();
}

In the following example all three type of ducks inherit all the properties of a duck. But the rubber duck can neither swim nor quack. So at this point because of the inheritance property
rubber duck inherits the swim() and quack() method. It proves that inheritance should not be used and this is were a method like delegation would be a better solution. RubberDuck has a color just like the mallardDuck and RedHeadDuck. so MallardDuck and RedHeadDuck are perfect to use inheritance on.

Using delegation to satisfy the following case:-
interface Swim{
swim();
{
interface Quack{
quack();
{
interface Color{
color();
{
class MallardDuck implements Swim implements Quack implements Color{
swim();
quack();
color();
}
class RedHeadDuck implements Swim implements Quack implements Color{
swim();
quack();
color();
}
class RubberDuck implements Color{
color();
}

In this example there is somewhat more code but it satisfies the functionality of the different types of ducks. The mallardDuck and the RedHeadDuck has the functionality of swim, quack and color whereas, rubberDuck has only color it can neither swim nor quack. Here through delegation some additional properties of a particular duck can also be added without affection the existing code. The functionality of fly in RedHeadDuck can be added without touching the other type of ducks.

interface Fly{
fly();
{
class RedHeadDuck implements Swim implements Quack implements Color implements Fly{
swim();
quack();
color();
fly();
}

==Listed differences between Inheritance and Delegation==

* Delegation is [http://www.jguru.com/faq/view.jsp?EID=27916 dynamic] in nature whereas Inheritance is [http://en.wikipedia.org/wiki/Inheritance_(computer_science) static] in nature. Since the delegation is dynamic, the [http://en.wikipedia.org/wiki/Delegation_(programming) run] time code can be changed in delegation. Inheritance is defined at compile time.

* Inheritance is faster than delegation because it is created at compile time whereas, delegation is created at run time.

*Inheritance is based on a [http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=40729 is-a] relationship among classes, delegation has the property of [http://en.wikipedia.org/wiki/Has-a has-a] relation.
*Delegation helps in finding bugs easily as compared to inheritance because delegation limit the scope of a possible logical error to a given subset of methods. In delegation code is more simple to explain, more easy to parse. In inheritance lots of functionality are associated with one object causes difficulty in finding bug.

* Inheritance breaks [http://en.csharp-online.net/Classes,_Structs,_and_Objects%E2%80%94Delegation_and_Composition_vs._Inheritance encapsulation], whereas Delegation preserves encapsulation, .

* By implementing delegation, all the methods laid out in the [http://www.learn-programming.za.net/programming_java_learn08.html interface] will be implemented where as in inheritance [http://en.wikipedia.org/wiki/Inheritance_(computer_science) derived] class inherit all the behavior of the base classes by default.

==Conclusion==
Inheritance actually creates something from something else, where delegation is actually using something to create something else. So delegation is a situation where you’re not really building new code from old code your using other code to build new. You can use inheritance where what your building IS-A of something else but if what your building has something of something else and only that part it may be better to use delegation.

Delegation is gaining some popularity in code were it can be implement as a better method. Although inheritance is probably the most widely used way in Object Orientated design to use existing code as tools or patterns to create new code with out reinventing the wheel.

==See Also==

* '''[http://en.wikipedia.org/wiki/Delegation_(programming) Delegation]'''
* '''[http://en.wikipedia.org/wiki/Inheritance_(programming) Inheritance]'''

==External links and references==
*[http://www.jguru.com/faq/view.jsp?EID=27916 Introduction]
*[http://beautifulcode.oreillynet.com/2007/11/preferring_inheritance_to_dele.php Beautiful Code]
*[http://groovy.codehaus.org/Replace+Inheritance+with+Delegation Replace Inheritance with Delegation]
*[http://www.perlmonks.org/index.pl?node_id=278375 Inheritance vs Delegation: pros and cons]
*[http://articles.techrepublic.com.com/5100-10878_11-5031837.html Avoid Java Delegation]
*[http://en.csharp-online.net/Classes,_Structs,_and_Objects%E2%80%94Delegation_and_Composition_vs._Inheritance Delegation and Composition vs. Inheritance]
*[http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=4072925 Sun Delegation vs. Inheritance quick question]
*[http://forum.java.sun.com/thread.jspa?threadID=702260&messageID=4072925 Inheritance vs delegation]
*[http://msdn.microsoft.com/en-us/library/ms973861.aspx inheritance and interfaces]
*[http://www.amazon.com/Object-Oriented-Design-Using-Java-Skrien/dp/0072974168 Object-Oriented Design Using Java, Dale Skrien, 2007]