Java/Interfaces - Revision history

Admin: /* Data Structures Example - Tree */

2017-08-15T22:25:20Z

Data Structures Example - Tree

← Older revision		Revision as of 22:25, 15 August 2017
Line 79:		Line 79:
	==Data Structures Example - Tree==		==Data Structures Example - Tree==

	Let's look at a simple example of an interface for a ~~Tree~~ abstract data type. The interface does not do anything terribly fancy, just describes a size and an isEmpty method, but this enables us to use Tree pointers when we just need to ensure that an object has a size() method.		Let's look at a simple example of an interface for a [[Trees\|tree]] and [[Trees/ADT\|tree abstract data type]]. The interface does not do anything terribly fancy, just describes a size and an isEmpty method, but this enables us to use Tree pointers when we just need to ensure that an object has a size() method.

	The interface:		The interface:

Admin: /* Flies and Telemarketers */

2017-08-15T22:23:43Z

Flies and Telemarketers

← Older revision		Revision as of 22:23, 15 August 2017
Line 66:		Line 66:
	class DiningRoom {		class DiningRoom {

	DiningRoom(Person[] diningPeople, ~~IPest~~[] pests) { ... }		DiningRoom(Person[] diningPeople, Pest[] pests) { ... }

	void ServeDinner() {		void ServeDinner() {
Line 76:		Line 76:
	}		}
	</pre>		</pre>



	==Data Structures Example - Tree==		==Data Structures Example - Tree==

Admin: /* Simple Example */

2017-06-18T20:28:54Z

Simple Example

@@ Line 21: / Line 21: @@
 If we are defining a function in another class that needs the weight of an object, now we don't need to define a wrapper function for each different type (or parent type) of object we might see - PencilMiscellany parent types and AstronomicalObject parent types and etc. - we just need to write an interface that accepts one Noun (interface) object.
-==Simple Example==
+==Toy Examples==
 Let's look at a simple example of an interface for a Tree abstract data type. The interface does not do anything terribly fancy, just describes a size and an isEmpty method, but this enables us to use Tree pointers when we just need to ensure that an object has a size() method.

Admin at 19:29, 18 June 2017

2017-06-18T19:29:11Z

← Older revision		Revision as of 19:29, 18 June 2017
Line 1:		Line 1:
	Interfaces: https://docs.oracle.com/javase/tutorial/java/concepts/interface.html		Interfaces: https://docs.oracle.com/javase/tutorial/java/concepts/interface.html

			Also of interest in Java 8: the line between abstract classes and interfaces just got a little thinner: https://stackoverflow.com/questions/31578427/what-is-the-purpose-of-the-default-keyword-in-java#31578471

			See [[Java/Default keyword]]

	==What are interfaces==		==What are interfaces==

Admin: /* What are interfaces */

2017-06-18T18:18:43Z

What are interfaces

← Older revision		Revision as of 18:18, 18 June 2017
Line 5:		Line 5:
	I like to describe interfaces as inheritance lite - or super polymorphism. They provide some useful guarantees about the way an interface to a class will work, without the restrictive requirements that come with inheritance. A classic example is an interface indicating something can make noise - babies and monster trucks both make noise, but there is not much more they have in common, ontologically.		I like to describe interfaces as inheritance lite - or super polymorphism. They provide some useful guarantees about the way an interface to a class will work, without the restrictive requirements that come with inheritance. A classic example is an interface indicating something can make noise - babies and monster trucks both make noise, but there is not much more they have in common, ontologically.

	An interface requires a class to provide certain methods. A good example of this is for [[~~Tree~~]] data structures (see also [[Data Structures]] and [[Abstract Data Types]]). The abstract implementation of methods that any tree should implement, but that will depend on their concrete implementation, can be defined by an interface, and actually implemented in the class that implements the interface.		An interface requires a class to provide certain methods. A good example of this is for [[Trees]] data structures (see also [[Data Structures]] and [[Abstract Data Types]]). The abstract implementation of methods that any tree should implement, but that will depend on their concrete implementation, can be defined by an interface, and actually implemented in the class that implements the interface.

	The "super polymorphism" part comes from the fact that we can now define a method that takes a parameter that is of the Interface type, if all it needs to do is call the method defined by the interface. Now, we can use one method to implement the one behavior in a whole range of different, otherwise-unrelated objects.		The "super polymorphism" part comes from the fact that we can now define a method that takes a parameter that is of the Interface type, if all it needs to do is call the method defined by the interface. Now, we can use one method to implement the one behavior in a whole range of different, otherwise-unrelated objects.

Admin: /* Simple Example */

2017-06-18T18:16:48Z

Simple Example

@@ Line 30: / Line 30: @@
 </pre>
-The class:
+The abstract class that implements this interface:
 <pre>
@@ Line 50: / Line 50: @@
 	public void setParity(char c){
 		this.parity = c;
+	}
+}

Admin: /* Simple Example */

2017-06-18T18:16:10Z

Simple Example

← Older revision		Revision as of 18:16, 18 June 2017
Line 19:		Line 19:
	==Simple Example==		==Simple Example==

	Let's look at a simple example of an interface for a Tree abstract data type. The interface does not do anything terribly fancy, just describes a size and an isEmpty method,		Let's look at a simple example of an interface for a Tree abstract data type. The interface does not do anything terribly fancy, just describes a size and an isEmpty method, but this enables us to use Tree pointers when we just need to ensure that an object has a size() method.

			The interface:

	<pre>		<pre>
Line 28:		Line 30:
	</pre>		</pre>

	~~but this enables us to use Tree pointers when we just need to ensure that an object has a size() method.~~		The class:

			<pre>
			public abstract class AbstractTree<E> implements Tree {
			int size;
			char parity;

			/** Boolean method definition, required by Tree interface. */
			public boolean isEmpty() {
			return size()==0;
			}

			/** Int method definition, required by Tree interface. */
			public int size() {
			return this.size;
			}

			/** Access method not defined in Tree interface. */
			public void setParity(char c){
			this.parity = c;
			}
			}
			</pre>

	==Flags==		==Flags==

Admin at 18:15, 18 June 2017

2017-06-18T18:15:24Z

@@ Line 1: / Line 1: @@
 Interfaces: https://docs.oracle.com/javase/tutorial/java/concepts/interface.html
-I like to describe interfaces as inheritance lite - they provide some useful guarantees about the way an interface to a class will work, without the restrictive requirements that come with inheritance. A classic example is an interface indicating something can make noise - babies and monster trucks both make noise, but there is not much more they have in common, ontologically.
+==What are interfaces==
 An interface requires a class to provide certain methods. A good example of this is for [[Tree]] data structures (see also [[Data Structures]] and [[Abstract Data Types]]). The abstract implementation of methods that any tree should implement, but that will depend on their concrete implementation, can be defined by an interface, and actually implemented in the class that implements the interface.
 [[Category:Java]]
 [[Category:Interfaces]]
-{{CSFlag}}
+[[Category:OOP]]

Admin at 01:44, 11 June 2017

2017-06-11T01:44:18Z

← Older revision		Revision as of 01:44, 11 June 2017
Line 10:		Line 10:

	[[Category:Java]]		[[Category:Java]]
			[[Category:Interfaces]]
	{{CSFlag}}		{{CSFlag}}

Admin at 01:44, 11 June 2017

2017-06-11T01:44:05Z

← Older revision		Revision as of 01:44, 11 June 2017
Line 10:		Line 10:

	[[Category:Java]]		[[Category:Java]]
			{{CSFlag}}