OOP Checklist - Revision history

Admin: /* Java Checklist of Functionality */

2017-06-18T18:33:15Z

Java Checklist of Functionality

← Older revision		Revision as of 18:33, 18 June 2017
Line 15:		Line 15:
	* [[Java/Interfaces]] - related to abstract classes, but not quite the same. Require that certain methods be implemented, but do not do anything further (whereas, virtual classes can actually implement a method.)		* [[Java/Interfaces]] - related to abstract classes, but not quite the same. Require that certain methods be implemented, but do not do anything further (whereas, virtual classes can actually implement a method.)

	* [[Java/Encapsulation]] - Use private/public. Heuristics ~~for~~ private~~/public?~~		* [[Java/Encapsulation]] - Use private/public. Heuristics? Make things as private as possible.

	* [[Java/Iterable]] -Make the tree iterable. Provide an automated way of iterating over each node in the tree.		* [[Java/Iterable]] -Make the tree iterable. Provide an automated way of iterating over each node in the tree.

Admin at 18:03, 18 June 2017

2017-06-18T18:03:33Z

← Older revision		Revision as of 18:03, 18 June 2017
Line 1:		Line 1:
	See [[Checklists]]		See [[Checklists]]

	This page contains a checklist for creating an abstract data ~~type or data container~~.		This page contains a checklist for creating objects, and enhancing their functionality. Geared toward data containers and abstract data types.

	=Java=		=Java=

			==Data Containers==

	More "formal" abstract data types in Java typically conform to the Collections interfaces. These can be quite extensive. On the other hand, less functional data containers can provide one-off solutions, but get in the way of reusability. The following checklist covers functionality/features that data containers should provide, ranging from less complicated to more complicated.		More "formal" abstract data types in Java typically conform to the Collections interfaces. These can be quite extensive. On the other hand, less functional data containers can provide one-off solutions, but get in the way of reusability. The following checklist covers functionality/features that data containers should provide, ranging from less complicated to more complicated.

	==Java ~~Abstract Data Types -~~ Checklist of Functionality==		==Java Checklist of Functionality==

	* [[Java/Abstract Class]] - Data containers should probably make use of abstract classes. This can make code organization (finding which method is implemented in which child or parent class) a pain.		* [[Java/Abstract Class]] - Data containers should probably make use of abstract classes. This can make code organization (finding which method is implemented in which child or parent class) a pain.

	* [[Java/Interfaces]] - related to abstract classes, but not quite the same. Require that certain methods be implemented, but do not do anything further (whereas, virtual classes can actually implement a method.)		* [[Java/Interfaces]] - related to abstract classes, but not quite the same. Require that certain methods be implemented, but do not do anything further (whereas, virtual classes can actually implement a method.)

	* [[Java/Encapsulation]] - Use private/public. Heuristics for private/public?		* [[Java/Encapsulation]] - Use private/public. Heuristics for private/public?

	* [[Java/Iterable]] -Make the tree iterable. Provide an automated way of iterating over each node in the tree.		* [[Java/Iterable]] -Make the tree iterable. Provide an automated way of iterating over each node in the tree.

	* [[Java/Generics]] - Use generic types whenever/wherever possible! (interfaces too.)		* [[Java/Generics]] - Use generic types whenever/wherever possible! (interfaces too.)

			* [[Java/Exceptions]] - Handle your exceptions cleanly.


	So, the ADT checklist boils down to:		So, the ADT checklist boils down to:
	* ~~Abstract Classes and~~ Interfaces		* Abstraction/Interfaces
	* Encapsulation		* Encapsulation
	* Iterables		* Iterables
	* Generics		* Generics
			* Exceptions


	=Python=		=Python=

	==Python ~~Abstract Data Types -~~ Checklist of Functionality==		==Python Checklist of Functionality==

	Many of same principles/checklists hold for Python:		Many of same principles/checklists hold for Python:

Admin: Admin moved page ADT Checklist to OOP Checklist

2017-06-18T18:01:15Z

Admin moved page ADT Checklist to OOP Checklist

← Older revision	Revision as of 18:01, 18 June 2017
(No difference)

Admin at 17:26, 18 June 2017

2017-06-18T17:26:23Z

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

	More "formal" abstract data types in Java typically conform to the Collections interfaces. These can be quite extensive. On the other hand, less functional data containers can provide one-off solutions, but get in the way of reusability. The following checklist covers functionality/features that data containers should provide, ranging from less complicated to more complicated.		More "formal" abstract data types in Java typically conform to the Collections interfaces. These can be quite extensive. On the other hand, less functional data containers can provide one-off solutions, but get in the way of reusability. The following checklist covers functionality/features that data containers should provide, ranging from less complicated to more complicated.

			==Java Abstract Data Types - Checklist of Functionality==

	* [[Java/Abstract Class]] - Data containers should probably make use of abstract classes. This can make code organization (finding which method is implemented in which child or parent class) a pain.		* [[Java/Abstract Class]] - Data containers should probably make use of abstract classes. This can make code organization (finding which method is implemented in which child or parent class) a pain.
Line 22:		Line 24:

	=Python=		=Python=

			==Python Abstract Data Types - Checklist of Functionality==

	Many of same principles/checklists hold for Python:		Many of same principles/checklists hold for Python:

Admin: /* Java */

2017-06-18T17:25:36Z

Java

← Older revision		Revision as of 17:25, 18 June 2017
Line 20:		Line 20:



			=Python=

			Many of same principles/checklists hold for Python:
			* abstract classes and virtual methods
			* encapsulation (underscore for method names - knowing HOW to make things private)
			* iterables
			* generic types (well, okay... maybe not. ctypes?)



			=Flags=

	[[Category:ADT]]		[[Category:ADT]]

			{{CSFlag}}

Admin: Created page with "See Checklists This page contains a checklist for creating an abstract data type or data container. =Java= More "formal" abstract data types in Java typically conform t..."

2017-06-18T17:23:28Z

Created page with "See Checklists This page contains a checklist for creating an abstract data type or data container. =Java= More "formal" abstract data types in Java typically conform t..."

New page

See [[Checklists]]

This page contains a checklist for creating an abstract data type or data container.

=Java=

More "formal" abstract data types in Java typically conform to the Collections interfaces. These can be quite extensive. On the other hand, less functional data containers can provide one-off solutions, but get in the way of reusability. The following checklist covers functionality/features that data containers should provide, ranging from less complicated to more complicated.

* [[Java/Abstract Class]] - Data containers should probably make use of abstract classes. This can make code organization (finding which method is implemented in which child or parent class) a pain.
* [[Java/Interfaces]] - related to abstract classes, but not quite the same. Require that certain methods be implemented, but do not do anything further (whereas, virtual classes can actually implement a method.)
* [[Java/Encapsulation]] - Use private/public. Heuristics for private/public?
* [[Java/Iterable]] -Make the tree iterable. Provide an automated way of iterating over each node in the tree.
* [[Java/Generics]] - Use generic types whenever/wherever possible! (interfaces too.)

So, the ADT checklist boils down to:
* Abstract Classes and Interfaces
* Encapsulation
* Iterables
* Generics

[[Category:ADT]]