Java/Generics - Revision history

Admin: Replacing charlesreid1.com:3000 with git.charlesreid1.com

2019-10-09T03:31:45Z

Replacing charlesreid1.com:3000 with git.charlesreid1.com

← Older revision		Revision as of 03:31, 9 October 2019
Line 21:		Line 21:
	This is an example of a Node class found in a linked binary tree class (see [[Binary Trees/LinkedBinTree]] for actual implementation):		This is an example of a Node class found in a linked binary tree class (see [[Binary Trees/LinkedBinTree]] for actual implementation):

	git.charlesreid1.com link: https://charlesreid1.com~~:3000~~/cs/java/src/master/trees/oop-correct-tree/LinkedBinTree.java		git.charlesreid1.com link: https://git.charlesreid1.com/cs/java/src/master/trees/oop-correct-tree/LinkedBinTree.java

	<pre>		<pre>

Admin: /* Example */

2017-06-18T19:12:11Z

Example

Admin: /* Generic Classes */

2017-06-18T18:59:57Z

Generic Classes

← Older revision		Revision as of 18:59, 18 June 2017
Line 13:		Line 13:
	If you use the built-in container types, you also see generic class types. It is the concept that the container can deal with objects of any type, because the container just needs to hold them, or set and get container elements, but never interact with the elements themselves. That's the reason behind the <code>LinkedList<String></code> syntax.		If you use the built-in container types, you also see generic class types. It is the concept that the container can deal with objects of any type, because the container just needs to hold them, or set and get container elements, but never interact with the elements themselves. That's the reason behind the <code>LinkedList<String></code> syntax.

	The important part here is the diamond notation <code><E></code> - the letter that ~~comes after~~ the diamond is arbitrary but it is the keyword indicating the generic type of object that this Node class wraps. Later in the class, the object is referred to using a pointer of generic type E.		The important part here is the diamond notation <code><String></code> - when we define a generic class we deal with a passed parameter of type <code><E></code>, where the letter that goes in the diamond is arbitrary but is the keyword indicating the generic type of object that this Node class wraps. Later in the class, the object is referred to using a pointer of generic type E.

			[[Maps]] and [[Dictionaries]] have keys and values that can each take on different types, but Java implements a similar idea for maps by using a similar idea, defining a <code>Map<K,V></code> that allows the class definition to deal with a generic key/value type.

	===Example===		===Example===

Admin: /* Generic Classes */

2017-06-18T18:57:49Z

Generic Classes

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

	==Generic Classes==		==Generic Classes==

			===Applications===

	One common application of generic classes is when building data structures like linked lists or trees. These objects use node structures to store data under the hood, and these node structures often take the form of objects storing an element of data of arbitrary type, along with pointers.		One common application of generic classes is when building data structures like linked lists or trees. These objects use node structures to store data under the hood, and these node structures often take the form of objects storing an element of data of arbitrary type, along with pointers.

			If you use the built-in container types, you also see generic class types. It is the concept that the container can deal with objects of any type, because the container just needs to hold them, or set and get container elements, but never interact with the elements themselves. That's the reason behind the <code>LinkedList<String></code> syntax.

			The important part here is the diamond notation <code><E></code> - the letter that comes after the diamond is arbitrary but it is the keyword indicating the generic type of object that this Node class wraps. Later in the class, the object is referred to using a pointer of generic type E.

			===Example===

	This is an example of a Node class found in a linked binary tree class (see [[Binary Trees/LinkedBinTree]] for actual implementation):		This is an example of a Node class found in a linked binary tree class (see [[Binary Trees/LinkedBinTree]] for actual implementation):
Line 42:		Line 50:
	}		}
	</pre>		</pre>

	The important part here is the diamond notation <code><E></code> - the letter that comes after the diamond is arbitrary but it is the keyword indicating the generic type of object that this Node class wraps. Later in the class, the object is referred to using a pointer of generic type E.

Admin: Created page with "Can use Java Generics to define classes that wrap generic types. Can also define methods that take generic types of arguments, slightly different syntax. Let's look at each...."

2017-06-18T18:56:04Z

Created page with "Can use Java Generics to define classes that wrap generic types. Can also define methods that take generic types of arguments, slightly different syntax. Let's look at each...."

New page

Can use Java Generics to define classes that wrap generic types.

Can also define methods that take generic types of arguments, slightly different syntax.

Let's look at each.

==Generic Classes==

One common application of generic classes is when building data structures like linked lists or trees. These objects use node structures to store data under the hood, and these node structures often take the form of objects storing an element of data of arbitrary type, along with pointers.

This is an example of a Node class found in a linked binary tree class (see [[Binary Trees/LinkedBinTree]] for actual implementation):

git.charlesreid1.com link: https://charlesreid1.com:3000/cs/java/src/master/trees/oop-correct-tree/LinkedBinTree.java

<pre>
public class LinkedBinaryTree<E> {

protected static class Node<E> {
// No need to expose things.
private E element;
private Node<E> parent; // pointer to parent node
private Node<E> left; // pointer to left child
private Node<E> right; // pointer to right child
// constructor with element and neighbors
public Node(E e, Node<E> above, Node<E> lefty, Node<E> righty) {
element = e;
parent = above;
left = lefty;
right = righty;
}
// get methods - one for each attribute
public E getElement() { return element; }
public Node<E> getParent() { return parent; }
public Node<E> getLeft() { return left; }
public Node<E> getRight() { return right; }
// update methods
public void setElement(E e) { element = e; }
public void setParent(Node<E> up) { parent = up; }
public void setLeft(Node<E> lefty) { left = lefty; }
public void setRight(Node<E> righty) { right = righty; }

}
</pre>

The important part here is the diamond notation <code><E></code> - the letter that comes after the diamond is arbitrary but it is the keyword indicating the generic type of object that this Node class wraps. Later in the class, the object is referred to using a pointer of generic type E.

← Older revision		Revision as of 19:12, 18 June 2017
Line 29:		Line 29:
	// No need to expose things.		// No need to expose things.
	private E element;		private E element;

	private Node<E> parent; // pointer to parent node		private Node<E> parent; // pointer to parent node
	private Node<E> left; // pointer to left child		private Node<E> left; // pointer to left child
	private Node<E> right; // pointer to right child		private Node<E> right; // pointer to right child

	// constructor with element and neighbors		// constructor with element and neighbors
	public Node(E e, Node<E> above, Node<E> lefty, Node<E> righty) {		public Node(E e, Node<E> above, Node<E> lefty, Node<E> righty) {
Line 39:		Line 41:
	right = righty;		right = righty;
	}		}

	// get methods - one for each attribute		// get methods - one for each attribute
	public E getElement() { return element; }		public E getElement() { return element; }

	public Node<E> getParent() { return parent; }		public Node<E> getParent() { return parent; }
	public Node<E> getLeft() { return left; }		public Node<E> getLeft() { return left; }
	public Node<E> getRight() { return right; }		public Node<E> getRight() { return right; }

	// update methods		// update methods
	public void setElement(E e) { element = e; }		public void setElement(E e) { element = e; }

	public void setParent(Node<E> up) { parent = up; }		public void setParent(Node<E> up) { parent = up; }
	public void setLeft(Node<E> lefty) { left = lefty; }		public void setLeft(Node<E> lefty) { left = lefty; }