Ring/课程/使用嵌套结构的声明式编程
< Ring
在本章中，我们将学习如何在面向对象的基础上使用嵌套结构构建声明式编程的世界。
我们将学习关于
- 在列表中创建对象
- 组合和通过引用返回对象和列表
- 在对象访问结束时执行代码
- 面向对象的顶部声明式编程
我们可以在列表定义期间在列表中创建对象。我们也可以使用 Add() 函数或 + 运算符随时将对象添加到列表中。
示例
alist = [new point, new point, new point] # create list contains three objects
alist + [1,2,3] # add another item to the list
see "Item 4 is a list contains 3 items" + nl
see alist[4]
add(alist , new point)
alist + new point
alist[5] { x = 100 y = 200 z = 300 }
alist[6] { x = 50 y = 150 z = 250 }
see "Object inside item 5" + nl
see alist[5]
see "Object inside item 6" + nl
see alist[6]
class point x y z输出
Item 4 is a list contains 3 items
1
2
3
Object inside item 5
x: 100.000000
y: 200.000000
z: 300.000000
Object inside item 6
x: 50.000000
y: 150.000000
z: 250.000000当我们使用组合并将对象作为类属性之一时，当我们返回该对象时，它将通过引用返回。
如果被调用者使用了赋值运算符，则会创建对象的另一个副本。
调用者可以避免使用赋值运算符，并直接使用返回的引用访问该对象。
如果属性是列表（而不是对象），则也会执行相同操作。
.. 注意:: 对象和列表使用相同的规则处理。当您将它们传递给函数时，它们是通过引用传递的，当您将它们从函数中返回时，它们是通过值返回的，除非它是对象属性，在这种情况下会执行通过引用返回。
示例
o1 = new Container
myobj = o1.addobj() # the assignment will create another copy
myobj.x = 100
myobj.y = 200
myobj.z = 300
see o1.aobjs[1] # print the object inside the container
see myobj # print the copy
Class Container
aObjs = []
func addobj
aobjs + new point
return aobjs[len(aobjs)] # return object by reference
Class point
x = 10
y = 20
z = 30输出
x: 10.000000
y: 20.000000
z: 30.000000
x: 100.000000
y: 200.000000
z: 300.000000示例(2)
func main
o1 = new screen {
content[point()] {
x = 100
y = 200
z = 300
}
content[point()] {
x = 50
y = 150
z = 250
}
}
see o1.content[1]
see o1.content[2]
Class Screen
content = []
func point
content + new point
return len(content)
Class point
x = 10
y = 20
z = 30输出
x: 100.000000
y: 200.000000
z: 300.000000
x: 50.000000
y: 150.000000
z: 250.000000示例(3)
func main
o1 = New Screen {
point() { # access the object using reference
x = 100
y = 200
z = 300
}
point() { # access the object using reference
x = 50
y = 150
z = 250
}
}
see o1.content[1]
see o1.content[2]
Class Screen
content = []
func point
content + new point
return content[len(content)] # return the object by reference
Class point x=10 y=20 z=30输出
x: 100.000000
y: 200.000000
z: 300.000000
x: 50.000000
y: 150.000000
z: 250.000000我们可以使用 { } 访问对象，以使用对象属性和方法。
如果对象包含名为 BraceEnd() 的方法，则该方法将在对象访问结束之前执行。
示例
New Point { See "How are you?" + nl }
Class Point x y z
func braceend
see "I'm fine, Thank you!" + nl输出
How are you?
I'm fine, Thank you!接下来的功能使我们能够在面向对象的基础上使用嵌套结构构建和使用声明式编程环境
- 使用 {} 访问对象属性和方法
- BraceEnd() 方法
- 通过引用返回对象
- Setter/Getter 方法（可选）
示例
# Declartive Programming (Nested Structures)
Screen()
{
point()
{
x = 100
y = 200
z = 300
}
point()
{
x = 50
y = 150
z = 250
}
}
# Functions and Classes
Func screen return new screen
Class Screen
content = []
func point
content + new point
return content[len(content)]
func braceend
see "I have " + len(content) + " points!"
Class point
x=10 y=20 z=30
func braceend
see self输出
x: 100.000000
y: 200.000000
z: 300.000000
x: 50.000000
y: 150.000000
z: 250.000000
I have 2 points!当我们可以避免在方法名称后面编写 () 时，我们可以获得更好的结果和更漂亮的代码，因为这些方法不接受参数。此功能没有由 Ring 语言直接提供，因为对象方法和对象属性之间存在差异。当我们为对象属性定义一个 getter 方法时，我们可以对代码的语法获得类似的效果。例如，而不是定义 point() 方法，我们将定义 point 属性，然后定义 getpoint() 方法，该方法将在您尝试获取 point 属性的值时执行。由于我们直接编写变量名，不带 ()，因此我们可以编写 point 而不是 point()，而 getpoint() 方法将为我们创建对象并返回对象引用。
示例
new Container
{
Point
{
x=10
y=20
z=30
}
}
Class Container
aObjs = []
point
func getpoint
aObjs + new Point
return aObjs[len(aObjs)]
Class Point x y z
func braceend
see "3D Point" + nl + x + nl + y + nl + z + nl输出
3D Point
10
20
30