docs/ja-jp/source/declarative.txt

   1 .. index::
   2         single: 宣言型プログラミング; はじめに
   3
   4 ================================
   5 入れ子構造の宣言型プログラミング
   6 ================================
   7
   8 オブジェクト指向による入れ子構造の宣言型プログラミング環境の構築方法を学びます。
   9
  10 * リストへオブジェクトを作成するには
  11 * コンポジションと参照によりオブジェクトとリストを返すには
  12 * オブジェクトのアクセス完了後にコードを実行するには
  13 * オブジェクト指向による宣言型プログラミング
  14
  15 .. index::
  16         pair: 宣言型プログラミング; リストへオブジェクトを作成するには
  17
  18 リストへオブジェクトを作成するには
  19 ====================================
  20
  21 リストの定義時にリストへオブジェクトを作成できます。
  22
  23 Add() 関数、または + 演算子により、必要なときにオブジェクトをリストへ追加できます。
  24
  25 用例:
  26
  27 .. code-block:: ring
  28
  29         alist = [new point, new point, new point]       # # オブジェクトが三つあるリストを作成します。
  30
  31         alist + [1,2,3]                                 # 別の項目をリストへ追加します。
  32
  33         see "Item 4 is a list contains 3 items" + nl
  34         see alist[4]
  35
  36         add(alist , new point)
  37         alist + new point
  38
  39         alist[5] { x = 100 y = 200 z = 300 }
  40         alist[6] { x = 50 y = 150 z = 250 }
  41
  42         see "Object inside item 5" + nl
  43         see alist[5]
  44         see "Object inside item 6" + nl
  45         see alist[6]
  46
  47         class point x y z
  48
  49 実行結果:
  50
  51 .. code-block:: ring
  52
  53         Item 4 is a list contains 3 items
  54         1
  55         2
  56         3
  57         Object inside item 5
  58         x: 100.000000
  59         y: 200.000000
  60         z: 300.000000
  61         Object inside item 6
  62         x: 50.000000
  63         y: 150.000000
  64         z: 250.000000
  65
  66 .. index::
  67         pair: 宣言型プログラミング; 参照によりオブジェクトを返すには
  68
  69 コンポジションと参照によりオブジェクトとリストを返すには
  70 ========================================================
  71
  72 コンポジションの使用とクラス属性のオブジェクトがある場合、オブジェクトの返値は参照で返します。
  73
  74 呼び出し元で代入演算子を使う場合は、オブジェクトのコピーを作成します。
  75
  76 呼出し元で代入演算子を使わない場合は、参照で返されたオブジェクトへ直接アクセスできます。
  77
  78 また、属性がリスト (オブジェクトではありません) でも同じ処理が適用されます。
  79
  80 .. note:: オブジェクト、およびリストは同じ規則で処理します。
  81         関数へ渡すときは、参照渡しになります。
  82         関数から返すときは、参照で返されたオブジェクト属性を除き値返しになります。
  83
  84 用例:
  85
  86 .. code-block:: ring
  87
  88         o1 = new Container
  89         myobj = o1.addobj()     # 別のコピーを代入で作成します。
  90         myobj.x = 100
  91         myobj.y = 200
  92         myobj.z = 300
  93         see o1.aobjs[1]         # コンテナにあるオブジェクトを表示します。
  94         see myobj               # コピーの表示
  95
  96         Class Container
  97                 aObjs = []
  98                 func addobj
  99                         aobjs + new point
 100                         return aobjs[len(aobjs)]        # オブジェクトを参照で返します。
 101
 102         Class point
 103                 x  = 10
 104                 y  = 20
 105                 z  = 30
 106
 107 実行結果:
 108
 109 .. code-block:: ring
 110
 111         x: 10.000000
 112         y: 20.000000
 113         z: 30.000000
 114         x: 100.000000
 115         y: 200.000000
 116         z: 300.000000
 117
 118 用例②:
 119
 120 .. code-block:: ring
 121
 122         func main
 123                 o1 = new screen  {
 124                         content[point()] {
 125                                 x = 100
 126                                 y = 200
 127                                 z = 300
 128                         }
 129                         content[point()] {
 130                                 x = 50
 131                                 y = 150
 132                                 z = 250
 133                         }
 134                 }
 135                 see o1.content[1]
 136                 see o1.content[2]
 137
 138         Class Screen
 139                 content = []
 140                 func point
 141                         content + new point
 142                         return len(content)
 143
 144         Class point
 145                 x  = 10
 146                 y  = 20
 147                 z  = 30
 148
 149 実行結果:
 150
 151 .. code-block:: ring
 152
 153         x: 100.000000
 154         y: 200.000000
 155         z: 300.000000
 156         x: 50.000000
 157         y: 150.000000
 158         z: 250.000000
 159
 160 用例③:
 161
 162 .. code-block:: ring
 163
 164         func main
 165                 o1 = New Screen  {
 166                         point() {               # 参照でオブジェクトへアクセスします。
 167                                 x = 100
 168                                 y = 200
 169                                 z = 300
 170                         }
 171                         point() {               # 参照でオブジェクトへアクセスします。
 172                                 x = 50
 173                                 y = 150
 174                                 z = 250
 175                         }
 176                 }
 177                 see o1.content[1]
 178                 see o1.content[2]
 179
 180         Class Screen
 181                 content = []
 182                 func point
 183                         content + new point
 184                         return content[len(content)]    # オブジェクトを参照で返します。
 185
 186         Class point x=10 y=20 z=30
 187
 188 実行結果:
 189
 190 .. code-block:: ring
 191
 192         x: 100.000000
 193         y: 200.000000
 194         z: 300.000000
 195         x: 50.000000
 196         y: 150.000000
 197         z: 250.000000
 198
 199
 200 .. index::
 201         pair: 宣言型プログラミング; オブジェクトのアクセス完了後にコードを実行するには
 202
 203 オブジェクトのアクセス完了後にコードを実行するには
 204 ==================================================
 205
 206 オブジェクト属性とメソッドを使うには { } でオブジェクトへアクセスします。
 207
 208 オブジェクトに BraceEnd() メソッドがある場合は、オブジェクトのアクセス完了直前に実行します。
 209
 210 用例:
 211
 212 .. code-block:: ring
 213
 214         New Point { See "How are you?" + nl }
 215
 216         Class Point x y z
 217                 func braceend
 218                         see "I'm fine, Thank you!" + nl
 219
 220 実行結果:
 221
 222 .. code-block:: ring
 223
 224         How are you?
 225         I'm fine, Thank you!
 226
 227
 228 .. index::
 229         pair: 宣言型プログラミング; オブジェクト指向による宣言型プログラミング
 230
 231 オブジェクト指向による宣言型プログラミング
 232 ==========================================
 233
 234 この機能でオブジェクト指向による入れ子構造の宣言型プログラミング環境の構築と使用を可能にします。
 235
 236 * { } によるオブジェクト属性、およびメソッドへのアクセス
 237 * BraceEnd() メソッド
 238 * 参照によるオブジェクト返し
 239 * Setter (セッター) / Getter (ゲッター) メソッド (オプション扱い)
 240
 241 用例:
 242
 243 .. code-block:: ring
 244
 245         # 宣言型プログラミング (入れ子構造)
 246
 247         Screen()
 248         {
 249
 250                 point()
 251                 {
 252                         x = 100
 253                         y = 200
 254                         z = 300
 255                 }
 256
 257                 point()
 258                 {
 259                         x = 50
 260                         y = 150
 261                         z = 250
 262                 }
 263         }
 264
 265         # 関数とクラス
 266
 267         Func screen return new screen
 268
 269         Class Screen
 270
 271                 content = []
 272
 273                 func point
 274                         content + new point
 275                         return content[len(content)]
 276
 277                 func braceend
 278                         see "I have " + len(content) + " points!"
 279
 280         Class point
 281
 282                 x=10 y=20 z=30
 283
 284                 func braceend
 285                         see self
 286
 287 実行結果:
 288
 289 .. code-block:: ring
 290
 291         x: 100.000000
 292         y: 200.000000
 293         z: 300.000000
 294         x: 50.000000
 295         y: 150.000000
 296         z: 250.000000
 297         I have 2 points!
 298
 299 .. index::
 300         pair: 宣言型プログラミング; コード品質の向上
 301
 302 コード品質の向上
 303 ================
 304
 305 メソッドで仮引数を使わないときは、メソッド名末尾の () を省略できます。これにより、コード品質の向上になります。
 306 この機能はオブジェクトメソッドとオブジェクト属性との機能に違いがあるため Ring では使えません。
 307 オブジェクト属性へ Getter メソッドを定義するとき、同様の効果をコードの構文で実現できます。
 308 例えば point() メソッドの定義ではなく point 属性値の取得で実行される
 309 getpoint() メソッドを point 属性として定義します。変数名は () を省略できるため、
 310 point() ではなく point と記述します。
 311 getpoint() メソッドはオブジェクトの作成、およびオブジェクトの参照を返します。
 312
 313 用例:
 314
 315 .. code-block:: ring
 316
 317         new Container
 318         {
 319                 Point
 320                 {
 321                         x=10
 322                         y=20
 323                         z=30
 324                 }
 325         }
 326
 327         Class Container
 328                 aObjs = []
 329                 point
 330                 func getpoint
 331                         aObjs + new Point
 332                         return aObjs[len(aObjs)]
 333
 334         Class Point x y z
 335                 func braceend
 336                         see "3D Point" + nl + x + nl + y + nl + z + nl
 337
 338 実行結果:
 339
 340 .. code-block:: ring
 341
 342         3D Point
 343         10
 344         20
 345         30
 346