added japanese translation of java external object.
[scilab.git] / scilab / modules / external_objects_java / help / ja_JP / 02-getting-started.xml
1 <?xml version="1.0" encoding="UTF-8"?>
2
3 <!--
4 *
5 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
6 * Copyright (C) 2013 - S/E - Sylvestre Ledru
7 * Copyright (C) 2012 - CNES - Simon Billemont
8 *
9 * This file must be used under the terms of the CeCILL.
10 * This source file is licensed as described in the file COPYING, which
11 * you should have received as part of this distribution.  The terms
12 * are also available at
13 * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
14 *
15 *
16 -->
17
18 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" version="5.0-subset Scilab" xml:lang="ja" xml:id="jims-getting-started-2">
19     
20     <refnamediv>
21         
22         <refname>入門 - 第2ステップ</refname>
23         
24         <refpurpose>Java Scilab バインディングを使用するには?</refpurpose>
25         
26     </refnamediv>
27     
28     <refsection>
29         
30         <title>説明</title>
31         
32         <para>
33             
34             このチュートリアルは, 
35             
36             <link linkend="jims-getting-started">第1ステップ</link>の続きです.
37             
38         </para>
39         
40     </refsection>
41     
42     <refsection>
43         
44         <title>例 3: Scilabvで Java オブジェクトを使用する</title>
45         
46         <para>
47             
48             この例では,より高度に抽象化された一連のJavaオブジェクトを
49             
50             定義します. 次に, Javaスクリプト言語の一種としてScilabを使用して
51             
52             これらのオブジェクトに様々な操作を行います.
53             
54             以下の様なJavaの広範な機能を紹介します; 
55             
56             staticメソッド (Factory construct), Enums, 簡単なポリモーフィズム, 
57             
58             メンバ/メソッドのスコープ.
59         </para>
60         
61         <para>
62             
63             この広範な機能は,簡単な家を記述する7つの簡単なクラスにより示されます;
64             
65         </para>
66         
67         <programlisting role="java"><![CDATA[
68 // House.java という名前で保存
69 package com.foo;
70
71 import java.util.Arrays;
72 import java.util.LinkendList;
73 import java.util.List;
74
75 public class House {
76
77         private Color                   color;
78         private Door                    door;
79         private List<IWindow>   windows = new LinkendList<IWindow>();
80
81         public House(Color color, Door door, IWindow... windows) {
82                 this.color = color;
83                 this.door = door;
84                 this.windows.addAll(Arrays.asList(windows));
85         }
86
87         public void repaint() {
88                 swapDoorHouseColor();
89         }
90
91         private void swapDoorHouseColor() {
92                 Color doorColor = door.getColor();
93                 door.repaint(color);
94                 color = doorColor;
95         }
96
97         public void addWindow(IWindow window) {
98                 windows.add(window);
99         }
100
101         public void replaceDoor(Door newDoor) {
102                 this.door = newDoor;
103         }
104
105         @Override
106         public String toString() {
107                 return String.format(
108                                 "This is a house painted in %s, has a %s door, and %d windows",
109                                 color.getDescr(), door.getColor().getDescr(), windows.size());
110         }
111 }
112       ]]></programlisting>
113         
114         <programlisting role="java"><![CDATA[
115 package com.foo;
116
117 public class HouseFactory {
118
119         public static House basicHouse() {
120                 Door door = new Door(Color.WHITE);
121                 IWindow window = new RectangularWindow(2, 0.8);
122                 return new House(Color.WHITE, door, window);
123         }
124
125         public static House flashyHouse() {
126                 Door door = new Door(Color.random());
127                 IWindow window = new CircularWindow(1.2);
128                 return new House(Color.random(), door, window);
129         }
130 }
131       ]]></programlisting>
132         
133         <programlisting role="java"><![CDATA[
134
135 package com.foo;
136
137 import java.util.Random;
138
139 public enum Color {
140
141         BLACK("black"), BLUE("blue"), BROWN("brown"), GREEN("green"),
142         ORANGE("orange"), RED("red"), WHITE("white"), YELLOW("yellow");
143
144         public String   descr;
145
146         private Color(String s) {
147                 descr = s;
148         }
149
150         public String getDescr() {
151                 return descr;
152         }
153
154         public static Color random() {
155                 Color[] allColors = values();
156                 return allColors[new Random().nextInt(values().length)];
157         }
158 }      ]]></programlisting>
159         
160         <programlisting role="java"><![CDATA[
161
162 package com.foo;
163
164 public class Door {
165
166         private Color   color;
167
168         public Door(Color color) {
169                 this.color = color;
170         }
171
172         public Color getColor() {
173                 return color;
174         }
175
176         public void repaint(Color newColor) {
177                 color = newColor;
178         }
179 }
180       ]]></programlisting>
181         
182         <programlisting role="java"><![CDATA[
183 package com.foo;
184
185 public interface IWindow {
186
187         double getWindowArea();
188
189 }
190       ]]></programlisting>
191         
192         <programlisting role="java"><![CDATA[
193 package com.foo;
194
195 public class RectangularWindow implements IWindow {
196
197         double  length;
198         double  width;
199
200         public RectangularWindow(double length, double width) {
201                 this.length = length;
202                 this.width = width;
203         }
204
205         public double getWindowArea() {
206                 return length * width;
207         }
208 }
209       ]]></programlisting>
210         
211         <programlisting role="java"><![CDATA[
212 package com.foo;
213
214 public class CircularWindow implements IWindow {
215
216         double  radius;
217
218         public CircularWindow(double radius) {
219                 this.radius = radius;
220         }
221
222         public double getWindowArea() {
223                 return Math.PI * radius * radius;
224         }
225 }
226       ]]></programlisting>
227         
228         
229         
230         <programlisting role="example"><![CDATA[
231 // この例はScilabディストリビューションに含まれます.
232 directory=SCI+"/modules/external_objects_java/examples/com/foo/"
233 // これらを全てコンパイルします
234 jcompile(ls(directory + "/*.java"))
235       ]]></programlisting>
236         
237         <para>
238             
239             まず, 基本となるfactory houseを構築しましょう.
240             
241             このため, HouseFactory をインポートし, 静的メソッドbasicHouse()
242             
243             を呼び出す必要があります.
244             
245         </para>
246         
247         <screen>
248             
249             -->jimport("com.foo.HouseFactory")
250             
251             
252             
253             -->house = HouseFactory.basicHouse()
254             
255             house  =
256             
257             
258             
259             This is a house painted in white, has a white door, and 1 windows
260             
261             
262             
263         </screen>
264         
265         <para>
266             
267             これは, 静的メソッドをJavaと同様にコールできることを示します.
268             
269             これは, "jinvoke(HouseFactory, 'basicHouse')"  と等価であることも
270             
271             頭に入れておいてください.
272             
273             
274             
275             オブジェクトのメッセージも以下のように交換できます:
276             
277             <screen>
278                 
279                 com.foo.House@ae8022
280                 
281                 To
282                 
283                 This is a house painted in white, has a white door, and 1 windows
284                 
285             </screen>
286             
287             これは, Houseクラスが標準で \cmd[toString] メソッドを有するためです. この <literal>toString</literal>は,この表現を生成する際に使用されます. <link linkend="jgetclassname">jgetclassname</link> を呼び出すことにより, この場合も Houseオブジェクトの実際の型(クラス)を取得できます.
288             
289             <screen>
290                 
291                 -->jgetclassname(house)
292                 
293                 ans  =
294                 
295                 
296                 
297                 com.foo.House
298                 
299             </screen>
300             
301             
302             
303             更に興味深いのは,HouseをScilabに直接インポートせずに,家の説明が入手できたことです!
304             
305             家が構築されたので,この家に別の窓を追加してみましょう. このため, 新しい窓を作成し,   <literal>addWindow(IWindow)</literal>関数により家に追加します. <literal>IWindow</literal>は窓に関する抽象化された説明で, 直接インスタンス化することはできません. しかし, 構築時に以下の2種類の実装が利用可能です; <literal>RectangularWindow</literal> および <literal>CircularWindow</literal>. この家は, factory で <literal>RectangularWindow</literal> を1つ付けているため, 新たに<literal>CircularWindow</literal>を作成してみましょう.
306             
307         </para>
308         
309         <screen>
310             
311             -->jimport("com.foo.IWindow")
312             
313             
314             
315             -->IWindow.new()
316             
317             !--error 999
318             
319             Method invocation: An error occurred: Exception when calling Java method : No such constructor in the class com.foo.IWindow.
320             
321             
322             
323             -->jimport("com.foo.CircularWindow")
324             
325             
326             
327             --> newWindow = CircularWindow.new(0.5)
328             
329             newWindow  =
330             
331             
332             
333             com.foo.CircularWindow@3e389405
334             
335             
336             
337             -->house.addWindow(newWindow);
338             
339             
340             
341             -->house
342             
343             house  =
344             
345             
346             
347             This is a house painted in white, has a white door, and 2 windows
348             
349             
350             
351         </screen>
352         
353         <para>
354             
355             新しい窓が作成され, リファレンスが変数 "newWindow" に保存されました.次に, この窓が変数をラップすることを必要とせずに家に追加されました.これは通常予想される動作です.最後に, 家が2つの窓を有することを表示します.
356             
357         </para>
358         
359         <para>
360             
361             しかし, ドアが気に入らないため, ドアを変更してみましょう. ドアを作成するには, ドアの色を選ぶ必要があります. Color はJava Enum クラス型です. 前記と同様に, まず変数をインポートし,新規インスタンスを作成した後, 家のドアを交換します.
362             
363         </para>
364         
365         <screen>
366             
367             -->jimport("com.foo.Color")
368             
369             
370             
371             -->jimport("com.foo.Door")
372             
373             
374             
375             -->newDoor = Door.new(Color.RED)
376             
377             newDoor  =
378             
379             
380             
381             com.foo.Door@54a5f709
382             
383             
384             
385             -->house.replaceDoor(newDoor);
386             
387             
388             
389             -->house
390             
391             house  =
392             
393             
394             
395             This is a house painted in white, has a red door, and 2 windows
396             
397         </screen>
398         
399         <para>
400             
401             Enum型の使用はクラスと同様に簡単です! これらのメソッドとメンバは同じ方針に基づいています:
402             
403         </para>
404         
405         <screen>
406             
407             -->c = Color.random()
408             
409             c  =
410             
411             
412             
413             BLACK
414             
415             
416             
417             -->c = Color.random()
418             
419             c  =
420             
421             
422             
423             BLUE
424             
425             
426             
427             -->c.getDescr()
428             
429             ans  =
430             
431             
432             
433             blue
434             
435         </screen>
436         
437         <para>
438             
439             家に保持される窓のリストは<literal>IWindow</literal>型
440             
441             です. これにより, リストに追加できるのは通常は窓のみです.
442             
443             これを確かめるため, Scilabで<literal>Door</literal>を
444             
445             追加するとどうなるかを見てみましょう.
446             
447         </para>
448         
449         <screen>
450             
451             -->house.addWindow(newDoor);
452             
453             !--error 999
454             
455             Method invocation: An error occurred: Exception when calling Java method : No method addWindow in the class com.foo.House or bad arguments type.
456             
457         </screen>
458         
459         <para>
460             
461             Java Reflectionを使用した場合と同様, JVM セキュリティ機構が,Javaポリモーフィズム規則に反することを防止するべく監視しています.
462             
463         </para>
464         
465         <screen>
466             
467             -->c.descr
468             
469             ans  =
470             
471             
472             
473             blue
474             
475             
476             
477             -->house.door
478             
479             !--error 999
480             
481             %_EObj_e: An error occurred: Exception when calling Java method : Invalid field door
482             
483             
484             
485             -->house.repaint();
486             
487             
488             
489             -->house
490             
491             house  =
492             
493             
494             
495             This is a house painted in red, has a white door, and 2 windows
496             
497             
498             
499             -->house.swapDoorHouseColor()
500             
501             !--error 999
502             
503             %_EObj_e: An error occurred: Exception when calling Java method : Invalid field swapDoorHouseColor
504             
505         </screen>
506         
507         <para>
508             
509             結論として, JIMSパッケージは Java JNIインターフェイスをScilab上で隠蔽する役割を担っており, これにより,非常に簡単にかつ透過的にScilabでJavaライブラリを使用することが可能です.全ての通常のJVM機能が存在し,Scilab構文は明確で直感的に使用できます.
510             
511         </para>
512         
513         <para>
514             
515             ここまでで, ScilabとJavaライブラリを連携させ,
516             
517             Javaの全機能をScilabスクリプト環境で利用する
518             
519             方法を理解できたはずです.
520             
521         </para>
522         
523     </refsection>
524     
525     <refsection>
526         
527         <title>履歴</title>
528         
529         <revhistory>
530             
531             <revision>
532                 
533                 <revnumber>5.5.0</revnumber>
534                 
535                 <revremark>
536                     
537                     関数が導入されました. 'JIMS'モジュールに基づきます.
538                     
539                     JIMSモジュールとの動作上の主な違いは,
540                     
541                     <link linkend="jautoUnwrap">jautoUnwrap</link>がデフォルトで
542                     
543                     有効になっていることです.
544                     
545                 </revremark>
546                 
547             </revision>
548             
549         </revhistory>
550         
551     </refsection>
552     
553 </refentry>
554
555
556