Java/Abstract Class - Revision history

Admin: /* Abstract Abstract Class: Implements No Methods */

2017-06-18T19:49:23Z

Abstract Abstract Class: Implements No Methods

← Older revision		Revision as of 19:49, 18 June 2017
Line 89:		Line 89:
	* num_children		* num_children
	* is_leaf		* is_leaf


	<pre>		<pre>
Line 100:		Line 99:
	abstract int length();		abstract int length();
	abstract boolean isEmpty();		abstract boolean isEmpty();
	abstract ~~Iterable~~<E> ~~iter~~();		abstract Iterator<E> iterator();
	}		}
	</pre>		</pre>

Admin at 19:35, 18 June 2017

2017-06-18T19:35:07Z

@@ Line 2: / Line 2: @@
 As such, it can declare fields and implement methods.
 Here, we declare an abstract class called AbstractTree. This takes a generic type <E>, and it does not define any constructors. It does define a few methods, some of which pass along <E> when passing method parameters.
@@ Line 78: / Line 80: @@
 [[Category:OOP]]
-[[Category:Java]]
+[[Category:Data Structures]]

Admin at 17:53, 18 June 2017

2017-06-18T17:53:57Z

← Older revision		Revision as of 17:53, 18 June 2017
Line 6:		Line 6:

	<pre>		<pre>
			// The abstract tree:
	public abstract class AbstractTree<E> {		public abstract class AbstractTree<E> {
	int size;		int size;
Line 32:		Line 33:

	<pre>		<pre>
			// A nice little exception
	class Empty extends IllegalStateException {}		class Empty extends IllegalStateException {}

			// The concrete tree:
	public class ConcreteTree<E> extends AbstractTree<E> {		public class ConcreteTree<E> extends AbstractTree<E> {

Admin at 17:50, 18 June 2017

2017-06-18T17:50:29Z

← Older revision		Revision as of 17:50, 18 June 2017
Line 65:		Line 65:
	}		}
	</pre>		</pre>

			As a result, when we run this class and its driver (at the bottom of the class), we see:

			<pre>
			$ javac ConcreteTree.java && java ConcreteTree
			Size: 5
			Parity: x
			</pre>


			[[Category:OOP]]
			[[Category:Java]]

Admin: Created page with "An abstract tree in Java is a class that is not intended to be implemented itself, but is nonetheless a full-on Java class. As such, it can declare fields and implement metho..."

2017-06-18T17:49:23Z

Created page with "An abstract tree in Java is a class that is not intended to be implemented itself, but is nonetheless a full-on Java class. As such, it can declare fields and implement metho..."

New page

An abstract tree in Java is a class that is not intended to be implemented itself, but is nonetheless a full-on Java class.

As such, it can declare fields and implement methods.

Here, we declare an abstract class called AbstractTree. This takes a generic type <E>, and it does not define any constructors. It does define a few methods, some of which pass along <E> when passing method parameters.

<pre>
public abstract class AbstractTree<E> {
int size;
char parity; // just a made-up doohickeythingamajig

/** Boolean method definition. */
public boolean isEmpty() {
return size()==0;
}

/** Int method definition. */
public int size() {
return this.size;
}

/** Some kind of access method. */
public void setParity(char c){
this.parity = c;
}
}
</pre>

Now if we take a look at the concrete class, we have a class that implements two additional methods, and calls these two new methods. The ConcreteTree class defines them, but they access fields and methods defined in the parent class, AbstractTree.

Note that the concrete implementation is actually dealing with data, and so has the responsibility of implementing the Empty exception.

<pre>
class Empty extends IllegalStateException {}

public class ConcreteTree<E> extends AbstractTree<E> {

public ConcreteTree(int n) {
this.size = n;
this.setParity('x');
}

/** Print "parity" of this thing (whatever that is). */
public void printParity() {
if(isEmpty()) {
throw new Empty();
}
System.out.println("Parity: "+this.parity);
}

/** Print size of this thing. */
public void printSize() {
if(isEmpty()) {
throw new Empty();
} else {
System.out.println("Size: "+this.size);
}
}

public static void main(String[] args) {
ConcreteTree<String> c = new ConcreteTree<String>(5);
c.printSize();
c.printParity();
}
}
</pre>