Changes for page Code Example: Data Structure Style vs. Object Style

Summary

• Page properties (1 modified, 0 added, 0 removed)

Details

Page properties

Content

...	...	@@ -1,30 +1,42 @@
1		-asd
	1	+### Use Cases
2	2
3		-```
4		-type Square struct {
5		- length float
6		-}
	3	+This example is intended to demonstrate the extensibility differences between data structures and objects by extending them with
7	7
8		-type Circle struct {
9		- length float
10		-}
	5	+1. an Area() function (extending behavior)
	6	+1. a rectangle type (extending data type)
11	11
12		-func Area(g GeometricObject) float {
13		- switch (g.type()):
14		- case Circle:
15		- return
16		- case Square:
17		- return ...
18		-}
	8	+### Data Structure Style
19	19
20		-func Circumference(g GeometricObject) float {
21		- ...
22		-}
23		-```
	10	+ interface GeometricObject {}
	11	+
	12	+ class Square implements GeometricObject {
	13	+ length float
	14	+ }
	15	+
	16	+ class Circle implements GeometricObject {
	17	+ radius float
	18	+ }
	19	+
	20	+ function Circumference(g GeometricObject) float {
	21	+ switch type(g):
	22	+ case Square:
	23	+ return 4 * g.length
	24	+ case Circle:
	25	+ return 2 * PI * g.radius
	26	+ }
24	24
	28	+1. Adding an Area() function with a very similar anatomy to Circumference() is easy because it only requires adding new code.
	29	+1. Adding a new datatype, Rectangle, is harder because it requires touching existing code, namely any functions like Circumference() or Area() that need to be enabled handle this datatype.
	30	+
	31	+####
	32	+
25	25	#### Object-Oriented Style
26	26
27		- class Square {
	35	+ interface GeometricObject {
	36	+ Circumference() float
	37	+ }
	38	+
	39	+ class Square implements GeometricObject {
28	28	length float
29	29
30	30	constructor(length float) {
...	...	@@ -31,16 +31,12 @@
31	31	this.length = length
32	32	}
33	33
34		- func Area() float {
35		- return this.length * this.length
36		- }
37		-
38	38	func Circumference() float {
39	39	return 4 * this.length
40	40	}
41	41	}
42	42
43		- class Circle {
	51	+ class Circle implements GeometricObject {
44	44	radius float
45	45
46	46	constructor(radius float) {
...	...	@@ -47,11 +47,15 @@
47	47	this.radius = radius
48	48	}
49	49
50		- func Area() float {
51		- return PI * this.radius * this.radius
52		- }
53		-
54	54	func Circumference() float {
55	55	return 2 * PI * this.radius
56	56	}
57	57	}
	62	+
	63	+1. Adding a function Area() to the GeometricObject interface is hard because it requires touching existing code, namely extending all Square and Circle classes with the new function.
	64	+1. Adding a new datatype, Rectangle, is easy because only new code is added, namely a Rectangle class.
	65	+
	66	+### Conclusion
	67	+
	68	+* The lesson here is that data structures are easy to extend with functions and hard to extend with data type, and objects are easy to extend with other objects but hard to extend with functionality.
	69	+* Although the difference between the two styles may seem insignificant in this simplified example, it has serious implications in complex production codebases with multiple data types and behaviors.