CSC/ECE 517 Fall 2011/ch2 2c ds - Revision history

Ssreepa: /* Introduction */

2011-09-30T23:48:05Z

Introduction

← Older revision		Revision as of 23:48, 30 September 2011
Line 3:		Line 3:
	=Introduction=		=Introduction=

	In object oriented programming Mixins and Interfaces provide neat constructs to implement certain functionality and benefit from code re-usability. Understanding these constructs will benefit any programmer in designing any software with maximum polymorphic behavior and code re-usability.		In object oriented programming languages, Mixins and Interfaces provide neat constructs to implement certain functionality and benefit from code re-usability. Understanding these constructs will benefit any programmer in designing any software with maximum polymorphic behavior and code re-usability.

	With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to because of the problems associated with multiple inheritance<ref>[http://www.artima.com/intv/gosling13.html Inspiration for Interface]</ref>.		With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to because of the problems associated with multiple inheritance<ref>[http://www.artima.com/intv/gosling13.html Inspiration for Interface]</ref>.

Ssreepa: /* Approaches */

2011-09-30T19:51:40Z

Approaches

← Older revision		Revision as of 19:51, 30 September 2011
Line 205:		Line 205:
	end		end

	fs = Frogsaur.new		fs = Frogsaur.new
	fs.talk # -> ~~I can roar like a dinosaur and croak like a frog~~		fs.talk # -> Which talk method to call ??

	When the method talk is called on the Frogsaur object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Frogsaur class is defined the latest and hence “I can roar like a dinosaur and croak like a frog” is printed. If there was no method defined in the class, method from the Dinosaur is printed since it is next in the hierarchy specified by the include statements.		When the method talk is called on the Frogsaur object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Frogsaur class is defined the latest and hence “I can roar like a dinosaur and croak like a frog” is printed. If there was no method defined in the class, method from the Dinosaur is printed since it is next in the hierarchy specified by the include statements.

Ssreepa: /* Interfaces */

2011-09-30T19:44:05Z

Interfaces

← Older revision		Revision as of 19:44, 30 September 2011
Line 28:		Line 28:

	public class Mall implements ParkingLot {		public class Mall implements ParkingLot {
	boolean add(Car car, int slot) {		boolean add(Car car, int slot) { //... Code to add a car into the parking lot... }

	//... Code to add a car into the parking lot...

	}
	boolean remove(Car car){ // do something }		boolean remove(Car car){ // do something }
	boolean findCar(Int number){ // do something }		boolean findCar(Int number){ // do something }

Ssreepa: /* Interfaces */

2011-09-30T19:43:15Z

Interfaces

← Older revision		Revision as of 19:43, 30 September 2011
Line 28:		Line 28:

	public class Mall implements ParkingLot {		public class Mall implements ParkingLot {
	boolean add(Car car, int slot) {		boolean add(Car car, int slot) {

	//... Code to add a car into the parking lot...		//... Code to add a car into the parking lot...

Ssreepa: /* Interfaces */

2011-09-30T19:42:19Z

Interfaces

← Older revision		Revision as of 19:42, 30 September 2011
Line 30:		Line 30:
	boolean add(Car car, int slot) {		boolean add(Car car, int slot) {

	//... Code to add a car into the parking lot...		//... Code to add a car into the parking lot...

	}		}

Ssreepa: /* Interfaces */

2011-09-30T19:41:46Z

Interfaces

← Older revision		Revision as of 19:41, 30 September 2011
Line 27:		Line 27:
	}		}

			public class Mall implements ParkingLot {
			boolean add(Car car, int slot) {

			//... Code to add a car into the parking lot...

			}
			boolean remove(Car car){ // do something }
			boolean findCar(Int number){ // do something }
			int freeSlotsCount(){ // do something }
			int occupiedSlots(){ // do something }
			int parkingType(){ // do something }
			int calculateParkingFee(int hours, int charge, int duration){ // do something }
			int findParkingSlot(){ // do something }
			}

	Interfaces play another important role in the object-oriented programming language. Interfaces are not part of the class hierarchy, although they work in combination with classes. Interfaces provide an alternative for languages like Java that does not allow multiple inheritance .		Interfaces play another important role in the object-oriented programming language. Interfaces are not part of the class hierarchy, although they work in combination with classes. Interfaces provide an alternative for languages like Java that does not allow multiple inheritance .

Ssreepa: /* Drawbacks of Mixins and Interfaces */

2011-09-30T19:33:36Z

Drawbacks of Mixins and Interfaces

← Older revision		Revision as of 19:33, 30 September 2011
Line 227:		Line 227:
	==Drawbacks of Mixins and Interfaces==		==Drawbacks of Mixins and Interfaces==

	The drawbacks of the technique of Mixins are very much debated. Though Mixins provide us with an easy way to write flexible and decoupled code and also help us solve the diamond problem, they pose their own problems. In large programs there could be large number of modules and each module could have loads of methods each performing a certain task.To trace the origin of the methods and to keep in mind the hierarchy is practically impossible. Another issue associated with Mixins pose is silent method overriding.		The drawbacks of the technique of Mixins are very much debated. Though Mixins provide us with an easy way to write flexible and decoupled code and also help us solve the diamond problem, they pose their own problems. In large programs there could be large number of modules and each module could have loads of methods each performing a certain task.To trace the origin of the methods and to keep in mind the hierarchy is practically impossible. Another issue associated with Mixins pose is silent method overriding. Silent method overriding occurs when different modules are included in a class and each module have a method with the same definition. In such a case, the method which gets executed depends upon the way it is included in the class and this is done without any sort of message to the user (silently). In large scale applications this could certainly be an issue considering the number of modules that would be mixed in and it would be difficult to keep track of the hierarchy in which the modules were included.

	Although Java provides polymorphic behavior with the use of interfaces, they sometimes tend to be very slow. The implementation of interfaces are also limited to public methods and constants with no implementation.		Although Java provides polymorphic behavior with the use of interfaces, they sometimes tend to be very slow. The implementation of interfaces are also limited to public methods and constants with no implementation.

Dnyayac: /* Introduction */

2011-09-22T13:08:08Z

Introduction

← Older revision		Revision as of 13:08, 22 September 2011
Line 3:		Line 3:
	=Introduction=		=Introduction=

	Mixins and Interfaces provide neat constructs ~~in object-oriented languages~~ to implement certain functionality and benefit from code ~~reusability~~. Understanding these constructs will benefit any programmer in designing any software with maximum polymorphic behavior and code ~~resuability~~.		In object oriented programming Mixins and Interfaces provide neat constructs to implement certain functionality and benefit from code re-usability. Understanding these constructs will benefit any programmer in designing any software with maximum polymorphic behavior and code re-usability.

	With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to because of the problems associated with multiple inheritance<ref>[http://www.artima.com/intv/gosling13.html Inspiration for Interface]</ref>.		With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to because of the problems associated with multiple inheritance<ref>[http://www.artima.com/intv/gosling13.html Inspiration for Interface]</ref>.

Ssreepa: /* Introduction */

2011-09-22T06:03:32Z

Introduction

← Older revision		Revision as of 06:03, 22 September 2011
Line 5:		Line 5:
	Mixins and Interfaces provide neat constructs in object-oriented languages to implement certain functionality and benefit from code reusability. Understanding these constructs will benefit any programmer in designing any software with maximum polymorphic behavior and code resuability.		Mixins and Interfaces provide neat constructs in object-oriented languages to implement certain functionality and benefit from code reusability. Understanding these constructs will benefit any programmer in designing any software with maximum polymorphic behavior and code resuability.

	With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to because of the problems associated with multiple inheritance.		With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to because of the problems associated with multiple inheritance<ref>[http://www.artima.com/intv/gosling13.html Inspiration for Interface]</ref>.

	While [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] like languages implemented interfaces to allow for [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism],languages like [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] opted not to implement multiple inheritance but to allow the code from one module be added into another class.		While [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] like languages implemented interfaces to allow for [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism],languages like [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] opted not to implement multiple inheritance but to allow the code from one module be added into another class.

Ssreepa: /* Introduction */

2011-09-22T05:59:51Z

Introduction

← Older revision		Revision as of 05:59, 22 September 2011
Line 2:		Line 2:

	=Introduction=		=Introduction=
	With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to .
			Mixins and Interfaces provide neat constructs in object-oriented languages to implement certain functionality and benefit from code reusability. Understanding these constructs will benefit any programmer in designing any software with maximum polymorphic behavior and code resuability.

			With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to because of the problems associated with multiple inheritance.

	While [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] like languages implemented interfaces to allow for [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism],languages like [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] opted not to implement multiple inheritance but to allow the code from one module be added into another class.		While [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] like languages implemented interfaces to allow for [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism],languages like [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] opted not to implement multiple inheritance but to allow the code from one module be added into another class.