Pascal for Java users/de: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1		-	\
2	1		Zurück zu den [[Additional information/de\|Zusätzlichen Informationen]].\
3		-	\
	2	+
4	3		=Übersetzen von gemeinsamen Programm-Teilen= Die verlinkte englischsprachige Seite zeigt, wie gemeinsame Probleme in verschiedenen Programmiersprachen, einschließlich Java und FreePascal / Object Pascal gelöst werden können.\
5	4		[Rosetta Code](http://rosettacode.org/wiki/Category:Pascal)
6	5
7	6		# Übersetzen von Java-Operatoren
8	7
9	8		## Arithmetische Operatoren
10	9
11	10		\| Java \| Pascal \| Kommentare \|
12	11		\|------\|--------\|-----------------------------------\|
13	12		\| + \| + \| Addition \|
14	13		\| - \| - \| Subtraktion \|
15	14		\| * \| * \| Multiplikation \|
16	15		\| / \| / \| Gleitkommadivision \|
17	16		\| % \| Mod \| Modulo (Division ohne Rest) \|
18	17		\| ++ \| Inc \| inkrementieren (Hochzählen) \|
19	18		\| -- \| Dec \| dekrementieren (Herunterzählen) \|
20	19
21	20		## Relationale Operatoren
22	21
23	22		\| Java \| Pascal \| Kommentare \|
24	23		\|-------\|--------\|------------------\|
25	24		\| == \| = \| gleich \|
26	25		\| != \| \<\> \| ungleich \|
27	26		\| \< \| \< \| kleiner \|
28	27		\| \<= \| \<= \| kleiner gleich \|
29	28		\| \> \| \> \| grösser \|
30	29		\| \>= \| \>= \| grösser gleich \|
31	30
32	31		## Logische Operatoren
33	32
34		-	~~<table>~~
35	33		<thead>
36		-	~~<tr>~~
37		-	~~<th>Java</th>~~
38		-	~~<th>Pascal</th>~~
39		-	~~<th>Kommentare</th>~~
40		-	~~</tr>~~
	34	+
41	35		</thead>
42	36		<tbody>
43		-	~~<tr>~~
44		-	~~<td> !</td>~~
45		-	~~<td> Not</td>~~
46		-	~~<td> Negation (Den Wahrheitswert in sein Gegenteil ändern)</td>~~
47		-	~~</tr>~~
48		-	~~<tr>~~
49		-	~~<td> &&</td>~~
50		-	~~<td> And</td>~~
51		-	~~<td> logisches UND mit Kurzschlussauswertung<br />~~
	37	+
52	38		In Free Pascal ist dies die Standard-Compilereinstellung</td>
53		-	~~</tr>~~
54		-	~~<tr>~~
55		-	~~<td> <nowiki></td>~~
56		-	~~<td></td>~~
57		-	~~<td> Or</td>~~
58		-	~~</tr>~~
59		-	~~<tr>~~
60		-	~~<td> &</td>~~
61		-	~~<td> And</td>~~
62		-	~~<td> logisches UND mit Komplettauswertung<br />~~
	39	+
63	40		In Free Pascal ist dies die Compilerdirektive {$B ON}</td>
64		-	~~</tr>~~
65		-	~~<tr>~~
66		-	~~<td> \|</td>~~
67		-	~~<td> Or</td>~~
68		-	~~<td> logisches ODER mit Komplettauswertung In Free Pascal ist dies die Compilerdirektive {$B ON}</td>~~
69		-	~~</tr>~~
70		-	~~<tr>~~
71		-	~~<td> ^</td>~~
72		-	~~<td> Xor</td>~~
73		-	~~<td> exclusives ODER</td>~~
74		-	~~</tr>~~
	41	+
75	42		</tbody>
76		-	~~</table>~~
77	43
78	44		## Bit Operatoren
79	45
80	46		\| Java \| Pascal \| Kommentare \|
81	47		\|----\|----\|----\|
82	48		\| ~ \| Not \| Einerkomplement \|
83	49		\| & \| And \| bitweises UND \|
84	50		\| \\| \| Or \| bitweises inclusives ODER \|
85	51		\| ^ \| Xor \| bitweises exclusives ODER \|
86	52		\| \>\> \| Shr \| bitweises Rechtsschieben mit Vorzeichen \|
87	53		\| \>\>\> \| ist in Free Pascal nicht vorhanden \| bitweises Rechtsschieben ohne Vorzeichen \|
88	54		\| \<\< \| Shl \| bitweises Linksschieben \|
89	55
90	56		## Zuweisungs Operatoren
91	57
92	58		Hinweis: C-artige Operatoren werden in Free Pascal über die Kommandozeilenoption -Sc ermöglicht. C-artige Operatoren werden in Lazarus über die Projekteinstellungen ermöglicht.\
93	59		{\\| class="wikitable" ! Java !! Pascal !! Kommentare \\|- \\| = \\| := \\| Einfache Zuweisung \\|- \\| += \\| += \\| Additionszuweisung \\|- \\| -= \\| -= \\| Subtraktionszuweisung \\|- \\| = \\| = \\| Multiplikationszuweisung \\|- \\| /= \\| /= \\| Divisionszuweisung \\|- \\| %= \\| ist in Free Pascal nicht vorhanden \\| Modulo Zuweisung \\|- \\| &= \\| ist in Free Pascal nicht vorhanden \\| UND Zuweisung \\|- \\| \\|= \\| ist in Free Pascal nicht vorhanden \\| ODER Zuweisung \\|- \\| ^= \\| ist in Free Pascal nicht vorhanden \\| Exclusive ODER Zuweisung \\|- \\| \>\>= \\| ist in Free Pascal nicht vorhanden \\| Rechtsschiebe Zuweisung \\|- \\| \>\>\>= \\| ist in Free Pascal nicht vorhanden \\| Rechtsschiebe Zuweisung mit Nullexpansion \\|- \\| \<\<= \\| ist in Free Pascal nicht vorhanden \\| Linksschiebe Zuweisung \\|}
94	60
95	61		## Sonstige Operatoren
96	62
97	63		\| Java \| Pascal \| \|
98	64		\|------\|--------\|--------------------\|
99	65		\| & \| @ \| Adresse von ... \|
100	66		\| * \| ^ \| Zeiger / Pointer \|
101	67
102	68		## Ternärer Operator
103	69
104		-	\
105	70		{\\| class="wikitable" ! Java !! Pascal !! Kommentare \\|- \\| ? \\| ist in Free Pascal nicht vorhanden \\| Erlaubt die verkürzte Schreibweise von If-Else Verzweigungen und gibt einen Wert zurück\
106	71		Verwendung:\
107		-	~~Ergebnisfeld = Bedingung <b>?</b> Wahrfall : Falschfall\~~
	72	+	Ergebnisfeld = Bedingung ? Wahrfall : Falschfall\
108	73		\
109	74		Beispiel:\
110	75		Für ein Maximum in Java:\
111	76		max = ( a \> b ) ? a : b;\
112	77		\
113	78		Dies entspricht in Pascal folgendem if-else-Konstrukt:\
114	79		if a \> b Then\
115	80		max := a\
116	81		else\
117	82		max := b;\
118	83		\\|}
119	84
120	85		# Übersetzen von Java Kommentarzeichen
121	86
122	87		\| Java \| Pascal \| Kommentare \|
123	88		\|-------\|--------\|---------------------------\|
124	89		\| /* \| { \| Anfang eines Kommentars \|
125	90		\| /* \| (* \| Anfang eines Kommentars \|
126	91		\| */ \| } \| Ende eines Kommentars \|
127	92		\| / \| ) \| Ende eines Kommentars \|
128	93		\| // \| // \| Kommentarzeile \|
129	94
130	95		# Übersetzen von Java Anweisungsblöcken
131	96
132	97		\| Java \| Pascal \| Kommentare \|
133	98		\|------\|---------\|-------------------------------------------\|
134	99		\| { \| Begin \| Anfang eines Anweisungsblocks \|
135	100		\| } \| End \| Ende / Abschluss eines Anweisungsblocks \|
136	101
137	102		# Übersetzen von Java Schleifentypen
138	103
139	104		\| Java \| Pascal \| Kommentare \|
140	105		\|----\|----\|----\|
141	106		\| for( ...; ...; ...++) \| For ... To ... Do \| Kopfgesteuerte Schleife, die hochgezählt wird \|
142	107		\| for(...; ...; ...--) \| For ... Downto ... Do \| Kopfgesteuerte Schleife, die heruntergezählt wird \|
143	108		\| for (Datentyp ...: Array) // For Each Schleife \| For ... in \| Kopfgesteuerte Schleife, für das Durchsuchen von Mengen \|
144	109		\| while (...) \| While ... Do \| Kopfgesteuerte Schleife \|
145	110		\| do ... while(...) \| Repeat ... Until \| Fussgesteuerte Schleife \|
146	111		\| do ... while!(...) \| Repeat ... Until ... Not \| Fussgesteuerte Schleife mit Nichtung des Ergebnisses des Ausdrucks \|
147	112
148	113		# Übersetzen von Java Verzweigungen / Bedingungen
149	114
150	115		\| Java \| Pascal \| Kommentare \|
151	116		\|----\|----\|----\|
152	117		\| if(...) \| If ... Then \| If-Bedingung \|
153	118		\| if(...) ... else \| If ... Then ... Else \| If-Bedingung mit Sonstzweig \|
154	119		\| switch(...) case ...: ...break; \| Case ... Of ...: ... End; \| Case-Bedingung \|
155	120		\| switch(...) case ...: ... break; default ...; \| Case ... Of ...: ... Else ... End; \| Case-Bedingung mit Sonst-Zweig \|
156	121
157	122		# Übersetzen von Java Verzweigungen- / Schleifenabbrüchen
158	123
159	124		\| Java \| Pascal \| Kommentare \|
160	125		\|----\|----\|----\|
161	126		\| break \| Break \| Die break-Anweisung ermöglicht es, vorzeitig eine Schleife (oder ein switch-case-Konstrukt) zu verlassen \|
162	127		\| continue \| Continue \| Die continue-Anweisung ermöglicht es, den aktuellen Schleifendurchlauf zu beenden \|
163	128
164	129		# Übersetzen von Java Prozeduren und Funktionen
165	130
166	131		\| Java \| Pascal \| Kommentare \|
167	132		\|----\|----\|----\|
168	133		\| void Prozedurname(...) \| Procedure Prozedurname(...) \| Unterprogramm (Prozedur) ohne Rückgabewert \|
169	134		\| datentyp Funktionsname(...) \| Function Funktionsname(...): Datentyp \| Unterprogramm (Funktion) mit Rückgabewert \|
170	135		\| return \| FunctionName := ... \| Diese Pascal-Schreibweise ist überholt (deprecated) \|
171	136		\| return \| Result := ... \| Einer Funktion Ihren Rückgabewert zuweisen \|
172	137
173	138		# Übersetzen von Java Dateiheadern
174	139
175	140		\| Java \| Pascal \| Kommentare \|
176	141		\|----\|----\|----\|
177	142		\| package ...; \| Unit ...; \| Einbinden der Pascal Unit bzw. des Java Packages \|
178	143		\| import ...; \| Uses ...; \| Bindet Bibliotheken und Klassen ein \|
179	144		\| public static void main(String\[...\] args) {...} \| Program ProgramName; Begin ... End. \| Hauptprogramm \|
180	145
181	146		# Übersetzen von Java Datentypen
182	147
183	148		\| Java Datentyp \| Pascal Datentyp \| Speichergrösse in Bits \| Range \|
184	149		\|----\|----\|----\|----\|
185	150		\| byte \| Shortint \| 8-Bit \| -128 .. 127 \|
186	151		\| short \| SmallInt \| 16-Bit \| -32768 .. 32767 \|
187	152		\| int \| LongInt \| 32-Bit \| -2147483648..2147483647 \|
188	153		\| long \| Int64 \| 64-Bit \| -9 223 372 036 854 775 808 .. 9 223 372 036 854 775 807 \|
189	154		\| float \| Single \| 32-Bit \| 1.5E-45 .. 3.4E+38 \|
190	155		\| double \| Double \| 64-Bit \| 5.0E-324 .. 1.7E+308 \|
191	156		\| boolean \| Boolean \| 8-Bit \| False bzw. True \|
192	157		\| char \| WideChar \| 16-Bit \| 2 Bytes codieren ein sichtbares Zeichen \|
193	158		\| String \| WideString \| 0-Bit bis ∞ \| Zeichenkette \|
194	159
195	160		# Übersetzen von Java Aufzählungen (Enumerationen)
196	161
197		-	~~<table>~~
198	162		<thead>
199		-	~~<tr>~~
200		-	~~<th>Java</th>~~
201		-	~~<th>Pascal</th>~~
202		-	~~<th>Kommentare</th>~~
203		-	~~</tr>~~
	163	+
204	164		</thead>
205	165		<tbody>
206		-	~~<tr>~~
207		-	~~<td> enum TheEnum = {MINVALUE, MAXVALUE}</td>~~
208		-	~~<td> TheEnum = (MINVALUE, MAXVALUE)</td>~~
209		-	~~<td> Die Konstante MINVALUE enthält den Wert 0<br />~~
	166	+
210	167		Die Konstante MAXVALUE enthält den Wert 1</td>
211		-	~~</tr>~~
	168	+
212	169		</tbody>
213		-	~~</table>~~
214	170
215	171		# Übersetzen von Java Arrays
216	172
217	173		\| Java \| Pascal \| Kommentare \|
218	174		\|----\|----\|----\|
219	175		\| Datentyp\[\] arrayName = new Datentyp\[...\]; \| Datentyp: Array\[...\] Of Datentyp; \| \|
220	176		\| Datentyp arrayVar\[...\] = new Datentyp\[...\]; \| Datentyp: Array\[...\] Of Datentyp; \| \|
221	177
222	178		# Übersetzen der Java Objektorientierung
223	179
224		-	~~<table>~~
225	180		<thead>
226		-	~~<tr>~~
227		-	~~<th>Java</th>~~
228		-	~~<th>Pascal</th>~~
229		-	~~<th>Kommentare</th>~~
230		-	~~</tr>~~
	181	+
231	182		</thead>
232	183		<tbody>
233		-	~~<tr>~~
234		-	~~<td> class Klassenname{...}</td>~~
235		-	~~<td> Klassenname = Class ... End;</td>~~
236		-	~~<td> Leitet eine Klassendeklaration ein Schreibweise für Free Pascal und Delphi</td>~~
237		-	~~</tr>~~
238		-	~~<tr>~~
239		-	~~<td> class Klassenname{...}</td>~~
240		-	~~<td> Klassenname = Object ... End;</td>~~
241		-	~~<td> Leitet eine Klassendeklaration ein Schreibweise für Free Pascal und Turbo Pascal</td>~~
242		-	~~</tr>~~
243		-	~~<tr>~~
244		-	~~<td> class Klassenname<T> {...}</td>~~
245		-	~~<td> Generic Klassenname = Class<T> ... End;</td>~~
246		-	~~<td> Leitet eine Klassendeklaration ein Generische Klassen werden erst ab Free Pascal 2.2.2 unterstützt</td>~~
247		-	~~</tr>~~
248		-	~~<tr>~~
249		-	~~<td> Klassenname(...)</td>~~
250		-	~~<td> Constructor Klassenname.Konstruktorname(...);</td>~~
251		-	~~<td> In Java ist der Name des Konstructors der Klassenname<br />~~
	184	+
252	185		In Free Pascal ist der Name des Konstruktors Create</td>
253		-	~~</tr>~~
254		-	~~<tr>~~
255		-	~~<td> abstract</td>~~
256		-	~~<td> Abstract</td>~~
257		-	~~<td> Kennzeichnet eine abstrakte Klasse oder eine abstrakte Methode, d. h. die Klasse oder Methode wird nicht implementiert.</td>~~
258		-	~~</tr>~~
259		-	~~<tr>~~
260		-	~~<td> implements</td>~~
261		-	~~<td> SomeClass = Class(SomeInterface)</td>~~
262		-	~~<td> Implementiert ein Interface</td>~~
263		-	~~</tr>~~
264		-	~~<tr>~~
265		-	~~<td> extends</td>~~
266		-	~~<td> SubClass = Class(BaseClass)</td>~~
267		-	~~<td> Bezeichnet die Klasse von der geerbt wird</td>~~
268		-	~~</tr>~~
269		-	~~<tr>~~
270		-	~~<td> final</td>~~
271		-	~~<td> Final</td>~~
272		-	~~<td> Verhindert das nachträgliche Ändern oder Überschreiben von virtuellen Methoden</td>~~
273		-	~~</tr>~~
274		-	~~<tr>~~
275		-	~~<td> interface</td>~~
276		-	~~<td> TheInterface = Interface</td>~~
277		-	~~<td> Deklariert die Schnittstelle einer Klasse</td>~~
278		-	~~</tr>~~
279		-	~~<tr>~~
280		-	~~<td> new Class()</td>~~
281		-	~~<td> InstanzVariable := Klassenname.Create</td>~~
282		-	~~<td> Initialisierung von Referenz-Datentypen</td>~~
283		-	~~</tr>~~
284		-	~~<tr>~~
285		-	~~<td> private</td>~~
286		-	~~<td> Private</td>~~
287		-	~~<td> </td>~~
288		-	~~</tr>~~
289		-	~~<tr>~~
290		-	~~<td> protected</td>~~
291		-	~~<td> Protected</td>~~
292		-	~~<td> </td>~~
293		-	~~</tr>~~
294		-	~~<tr>~~
295		-	~~<td> public</td>~~
296		-	~~<td> Public</td>~~
297		-	~~<td> </td>~~
298		-	~~</tr>~~
299		-	~~<tr>~~
300		-	~~<td> static</td>~~
301		-	~~<td> Static</td>~~
302		-	~~<td> </td>~~
303		-	~~</tr>~~
304		-	~~<tr>~~
305		-	~~<td> static</td>~~
306		-	~~<td> Class Function</td>~~
307		-	~~<td> </td>~~
308		-	~~</tr>~~
309		-	~~<tr>~~
310		-	~~<td> static</td>~~
311		-	~~<td> Class Procedure</td>~~
312		-	~~<td> </td>~~
313		-	~~</tr>~~
314		-	~~<tr>~~
315		-	~~<td> super</td>~~
316		-	~~<td> Inherited</td>~~
317		-	~~<td> Ruft den Elternkonstruktor auf</td>~~
318		-	~~</tr>~~
319		-	~~<tr>~~
320		-	~~<td> this</td>~~
321		-	~~<td> Self</td>~~
322		-	~~<td> Bezeichnet die Klasse "in der man sich gerade befindet" (Selbstreferenz)</td>~~
323		-	~~</tr>~~
324		-	~~<tr>~~
325		-	~~<td> transient</td>~~
326		-	~~<td> </td>~~
327		-	~~<td> Die Variable soll bei der Speicherung von Objekten (Serialisierung) nicht gespeichert werden.</td>~~
328		-	~~</tr>~~
329		-	~~<tr>~~
330		-	~~<td></td>~~
331		-	~~<td></td>~~
332		-	~~<td></td>~~
333		-	~~</tr>~~
	186	+
334	187		</tbody>
335		-	~~</table>~~
336	188
337	189		## Freigabe eines Objektes
338	190
339		-	~~<table>~~
340	191		<thead>
341		-	~~<tr>~~
342		-	~~<th>Java</th>~~
343		-	~~<th>Pascal</th>~~
344		-	~~<th>Kommentare</th>~~
345		-	~~</tr>~~
	192	+
346	193		</thead>
347	194		<tbody>
348		-	~~<tr>~~
349		-	~~<td> null</td>~~
350		-	~~<td> Nil</td>~~
351		-	~~<td> Gibt die Referenz auf ein Objekt frei. Mehr ist in Java nicht nötig, den Rest erledigt in Java der Garbage-Collektor.<br />~~
	195	+
352	196		In Pascal führt der Aufruf FreeAndNil(...) zum selben Ergebnis.</td>
353		-	~~</tr>~~
	197	+
354	198		</tbody>
355		-	~~</table>~~
356	199
357	200		## Klassenbestimmung
358	201
359	202		\| Java \| Pascal \| Kommentare \|
360	203		\|--------------\|--------\|----------------------------------------------------\|
361	204		\| instanceof \| Is \| Bestimmt die Klassenzugehörigkeit eines Objektes \|
362	205
363	206		## Werfen von Exceptions
364	207
365	208		\| Java \| Pascal \| Kommentare \|
366	209		\|----\|----\|----\|
367	210		\| throw \| Raise \| Wirft eine Exception \|
368	211		\| throws \| ist in Free Pascal nicht vorhanden \| Gibt im Methodenkopf einer Klasse oder Methode an, welche Ausnahme(n) von der Klasse bzw. Methode ausgelöst werden kann. \|
369	212
370	213		## Fangen von Exceptions
371	214
372	215		\| Java \| Pascal \| Kommentare \|
373	216		\|----\|----\|----\|
374	217		\| try { ... } catch { ... } \| Try Begin ... End Except Begin ... End \| Fehlerbehandlung mit einem Try-Block \|
375	218		\| try { ... } catch { ... } finally { ... } \| begin ... try try ... except ... end; finally ... end; ... end; \| Fehlerbehandlung mit einem Block für Abschlussarbeiten \|
376	219
377	220		## Threadprogrammierung
378	221
379		-	~~<table>~~
380	222		<thead>
381		-	~~<tr>~~
382		-	~~<th>Java</th>~~
383		-	~~<th>Pascal</th>~~
384		-	~~<th>Kommentare</th>~~
385		-	~~</tr>~~
	223	+
386	224		</thead>
387	225		<tbody>
388		-	~~<tr>~~
389		-	~~<td> synchronized</td>~~
390		-	~~<td> Synchronize(@...)</td>~~
391		-	~~<td> Dient der Synchronisation mit dem Hauptthread.</td>~~
392		-	~~</tr>~~
393		-	~~<tr>~~
394		-	~~<td> volatile</td>~~
395		-	~~<td> </td>~~
396		-	~~<td> Variablen, die dem Datenaustasch mit anderen Threads dienen, werden in Java mit volatile deklariert.<br />~~
	226	+
397	227		In Free Pascal sind alle global definierten Variablen volatile.</td>
398		-	~~</tr>~~
	228	+
399	229		</tbody>
400		-	~~</table>~~
401	230
402	231		# Aufruf von Fremdfunktionen (z. B. aus Dll's)
403	232
404	233		\| Java \| Pascal \| Kommentare \|
405	234		\|----------\|-----------\|-----------------------------------------\|
406	235		\| native \| StdCall \| Pascal / FPC Standardaufrufkonvention \|
407	236		\| native \| CDecl \| C Standardaufrufkonvention \|
408	237
409		-	\
410		-	\
411	238		--Olaf 14:28, 24 March 2013 (UTC)
412	239
413	240		---
414	241		From the Free Pascal wiki, page "Pascal for Java users/de", as it stood on 2014-01-12 after a change by Olaf, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).
415	242		Category: Code/de
416	243		Category: Deutsch

Back to history