update principles

Author: jarry

README.md

@@ -0,0 +1,76 @@
+/*
+抽象是一种简化复杂系统的方法，在更高层次上进行建模。抽象包括两个方面，一是过程抽象，二是数据抽象。
+抽象类：Shape是一个抽象类，它包含一个抽象方法calculateArea()。抽象类通过abstract关键字进行声明，不能被实例化。
+抽象类（Abstract Class）和接口（Interface）是不同的机制，用于实现多态性和代码组织。两者都可以用于定义抽象方法，但又有区别。
+抽象类用于表示一种"is-a"关系，而接口用于表示一种"can-do"关系。
+Go没有抽象类，可以使用interface替代。
+Go没有class，可以使用struct替代。
+*/
+package main
+
+import (
+  "fmt"
+  "math"
+)
+
+// 接口：形状
+type Shape interface {
+  // 计算形状的面积
+  calculateArea() float64
+}
+
+// 结构体：圆形
+type Circle struct {
+  radius float64 // 圆的半径
+}
+
+// 实现接口方法：计算圆的面积
+func (c Circle) calculateArea() float64 {
+  return math.Pi * c.radius * c.radius
+}
+
+// 结构体：矩形
+type Rectangle struct {
+  width  float64 // 矩形的宽度
+  height float64 // 矩形的高度
+}
+
+// 实现接口方法：计算矩形的面积
+func (r Rectangle) calculateArea() float64 {
+  return r.width * r.height
+}
+
+// 结构体：三角形
+type Triangle struct {
+  base   float64 // 三角形的底边长
+  height float64 // 三角形的高
+}
+
+// 实现接口方法：计算三角形的面积
+func (t Triangle) calculateArea() float64 {
+  return 0.5 * t.base * t.height
+}
+
+func main() {
+  // 创建圆形对象并计算面积
+  circle := Circle{radius: 5}
+  circleArea := circle.calculateArea()
+  fmt.Println("圆形面积:", circleArea) // 输出：圆形面积: 78.53981633974483
+
+  // 创建矩形对象并计算面积
+  rectangle := Rectangle{width: 4, height: 6}
+  rectangleArea := rectangle.calculateArea()
+  fmt.Println("矩形面积:", rectangleArea) // 输出：矩形面积: 24
+
+  // 创建三角形对象并计算面积
+  triangle := Triangle{base: 3, height: 4}
+  triangleArea := triangle.calculateArea()
+  fmt.Println("三角形面积:", triangleArea) // 输出：三角形面积: 6
+}
+
+/*
+jarry@jarrys-MacBook-Pro abstraction % go run AbstractionExample.go
+圆形面积: 78.53981633974483
+矩形面积: 24
+三角形面积: 6
+*/

oop-principles/README.md renamed to design-principles/README.md

@@ -76,8 +76,8 @@ public static void main(String[] args) {
     double circleArea = circle.calculateArea();
     System.out.println("圆形面积: " + circleArea); // 输出：Circle Area: 78.53981633974483
 
-    // 创建矩形对象并计算面积
-    Rectangle rectangle = new Rectangle(4, 6);
+    // 创建矩形对象并计算面积，这里也可以使用抽象类声明
+    Shape rectangle = new Rectangle(4, 6);
     double rectangleArea = rectangle.calculateArea();
     System.out.println("矩形面积: " + rectangleArea); // 输出：Rectangle Area: 24.0
 

oop-principles/composite-reuse/README.md renamed to design-principles/composite-reuse/README.md

@@ -0,0 +1,73 @@
+/*
+抽象是一种简化复杂系统的方法，在更高层次上进行建模。抽象包括两个方面，一是过程抽象，二是数据抽象。
+抽象类：Shape是一个抽象类，它包含一个抽象方法calculateArea()。抽象类通过abstract关键字进行声明，不能被实例化。
+抽象类（Abstract Class）和接口（Interface）是不同的机制，用于实现多态性和代码组织。两者都可以用于定义抽象方法，但又有区别。
+抽象类用于表示一种"is-a"关系，而接口用于表示一种"can-do"关系。
+JavaScript没有抽象类，声明对象也没有类型，使用了普通类和继承来模拟抽象类的概念。
+抽象类的作用和意义在于提供了一种抽象的、模板化的设计方式，通过定义抽象方法和具体实现，规范了子类的行为，普通类可以替代抽象类，但它们并不完全等价。
+*/
+
+// 类：形状，可看作是抽象类
+class Shape {
+  // 计算形状的面积，子类实现
+  calculateArea() {
+    throw new Error('Method "calculateArea" must be implemented');
+  }
+}
+
+// 子类：圆形
+class Circle extends Shape {
+  constructor(radius) {
+    super();
+    this.radius = radius; // 圆的半径
+  }
+
+  // 实现抽象方法：计算圆的面积
+  calculateArea() {
+    return Math.PI * this.radius ** 2;
+  }
+}
+
+// 子类：矩形
+class Rectangle extends Shape {
+  constructor(width, height) {
+    super();
+    this.width = width; // 矩形的宽度
+    this.height = height; // 矩形的高度
+  }
+
+  // 实现抽象方法：计算矩形的面积
+  calculateArea() {
+    return this.width * this.height;
+  }
+}
+
+// 子类：三角形
+class Triangle extends Shape {
+  constructor(base, height) {
+    super();
+    this.base = base; // 三角形的底边长
+    this.height = height; // 三角形的高
+  }
+
+  // 实现抽象方法：计算三角形的面积
+  calculateArea() {
+    return 0.5 * this.base * this.height;
+  }
+}
+
+// 测试验证
+// 创建圆形对象并计算面积
+const circle = new Circle(5);
+const circleArea = circle.calculateArea();
+console.log("圆形面积:", circleArea); // 输出：圆形面积: 78.53981633974483
+
+// 创建矩形对象并计算面积
+const rectangle = new Rectangle(4, 6);
+const rectangleArea = rectangle.calculateArea();
+console.log("矩形面积:", rectangleArea); // 输出：矩形面积: 24
+
+// 创建三角形对象并计算面积
+const triangle = new Triangle(3, 4);
+const triangleArea = triangle.calculateArea();
+console.log("三角形面积:", triangleArea); // 输出：三角形面积: 6

oop-principles/composite-reuse/java/README.md renamed to design-principles/composite-reuse/java/README.md

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+'''
+抽象是一种简化复杂系统的方法，在更高层次上进行建模。抽象包括两个方面，一是过程抽象，二是数据抽象。
+抽象类：Shape是一个抽象类，它包含一个抽象方法calculateArea()。抽象类通过abstract关键字进行声明，不能被实例化。
+抽象类（Abstract Class）和接口（Interface）是不同的机制，用于实现多态性和代码组织。两者都可以用于定义抽象方法，但又有区别。
+抽象类用于表示一种"is-a"关系，而接口用于表示一种"can-do"关系。
+Python没有抽象类，但由于抽象方法。Python也无需父类声明子类。
+'''
+from abc import ABC, abstractmethod
+import math
+
+# 抽象类：形状
+class Shape(ABC):
+    # 抽象方法：计算形状的面积。由子类具体实现
+    @abstractmethod
+    def calculate_area(self):
+        pass
+
+# 子类：圆形
+class Circle(Shape):
+    def __init__(self, radius):
+        self.radius = radius  # 圆的半径
+
+    # 实现抽象方法：计算圆的面积
+    def calculate_area(self):
+        return math.pi * self.radius ** 2
+
+# 子类：矩形
+class Rectangle(Shape):
+    def __init__(self, width, height):
+        self.width = width  # 矩形的宽度
+        self.height = height  # 矩形的高度
+
+    # 实现抽象方法：计算矩形的面积
+    def calculate_area(self):
+        return self.width * self.height
+
+# 子类：三角形
+class Triangle(Shape):
+    def __init__(self, base, height):
+        self.base = base  # 三角形的底边长
+        self.height = height  # 三角形的高
+
+    # 实现抽象方法：计算三角形的面积
+    def calculate_area(self):
+        return 0.5 * self.base * self.height
+
+# 测试验证
+if __name__ == "__main__":
+    # 创建圆形对象并计算面积
+    circle = Circle(5)
+    circle_area = circle.calculate_area()
+    print("圆形面积:", circle_area)  # 输出：圆形面积: 78.53981633974483
+
+    # 创建矩形对象并计算面积
+    rectangle = Rectangle(4, 6)
+    rectangle_area = rectangle.calculate_area()
+    print("矩形面积:", rectangle_area)  # 输出：矩形面积: 24
+
+    # 创建三角形对象并计算面积
+    triangle = Triangle(3, 4)
+    triangle_area = triangle.calculate_area()
+    print("三角形面积:", triangle_area)  # 输出：三角形面积: 6.0
+
+'''
+jarry@jarrys-MacBook-Pro abstraction % python -V
+Python 3.8.2
+jarry@jarrys-MacBook-Pro abstraction % python AbstractionExample.py
+圆形面积: 78.53981633974483
+矩形面积: 24
+三角形面积: 6.0
+'''