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,42 +8,32 @@
1		-### Use Cases
2		-
3		-This example is intended to demonstrate the extensibility differences between data structures and objects by extending them with
4		-
5		-1. an Area() function (extending behavior)
6		-1. a rectangle type (extending data type)
7		-
8	8	### Data Structure Style
9	9
10		- interface GeometricObject {}
11		-
12		- class Square implements GeometricObject {
	3	+ type Square struct {
13	13	length float
14	14	}
15	15
16		- class Circle implements GeometricObject {
	7	+ type Circle struct {
17	17	radius float
18	18	}
19	19
20		- function Circumference(g GeometricObject) float {
	11	+ func Area(g GeometricObject) float {
21	21	switch type(g):
22	22	case Square:
	14	+ return g.length * g.length
	15	+ case Circle:
	16	+ return PI * g.radius * g.radius
	17	+ }
	18	+
	19	+ func Circumference(g GeometricObject) float {
	20	+ switch type(g):
	21	+ case Square:
23	23	return 4 * g.length
24	24	case Circle:
25	25	return 2 * PI * g.radius
26	26	}
27	27
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		-
33	33	#### Object-Oriented Style
34	34
35		- interface GeometricObject {
36		- Circumference() float
37		- }
38		-
39		- class Square implements GeometricObject {
	29	+ class Square {
40	40	length float
41	41
42	42	constructor(length float) {
...	...	@@ -43,12 +43,16 @@
43	43	this.length = length
44	44	}
45	45
	36	+ func Area() float {
	37	+ return this.length * this.length
	38	+ }
	39	+
46	46	func Circumference() float {
47	47	return 4 * this.length
48	48	}
49	49	}
50	50
51		- class Circle implements GeometricObject {
	45	+ class Circle {
52	52	radius float
53	53
54	54	constructor(radius float) {
...	...	@@ -55,15 +55,11 @@
55	55	this.radius = radius
56	56	}
57	57
	52	+ func Area() float {
	53	+ return PI * this.radius * this.radius
	54	+ }
	55	+
58	58	func Circumference() float {
59	59	return 2 * PI * this.radius
60	60	}
61	61	}
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.