‫ﻤﻥ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺔ ﺇﻟﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ‬

‫‪From pseudo code to program code‬‬

‫ﻤﻘﺩﻤﺔ‬
‫ﺒﻌﺩ ﻭﻀﻊ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺔ ﺃﻭ ﺨﻁﻭﺍﺕ ﺤل ﻤﺴﺄﻟﺔ ﺒﻭﺍﺴﻁﺔ ﺍﻟﺤﺎﺴﻭﺏ ﻭﺍﻟﺘﻌﺒﻴﺭ ﻋﻨﻬﺎ ﺒﻠﻐﺔ‬
‫ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺎﺕ ‪ ،pseudo code‬ﻻ ﺒﺩ ﻤﻥ ﻨﻘل ﻫﺫﻩ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺔ ﺇﻟﻰ ﺒﺭﻨﺎﻤﺞ ﺤﺎﺴﻭﺒﻲ ﺃﻱ ﺍﻻﻨﺘﻘﺎل‬
‫ﺇﻟﻰ ﻟﻐﺔ ﺒﺭﻤﺠﺔ ﻓﻌﻠﻴﺔ ﻴﻔﻬﻤﻬﺎ ﺍﻟﺤﺎﺴﻭﺏ‪ ،‬ﻟﻴﻜﻭﻥ ﺒﺈﻤﻜﺎﻨﻨﺎ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﺤل ﻭﺍﺨﺘﺒﺎﺭﻩ ﻓﻌﻠﻴﹸﺎ‪،‬‬
‫ﻭﺍﻟﺤﺼﻭل ﻋﻠﻰ ﺍﻟﻭﻅﺎﺌﻑ ﺍﻟﻤﻁﻠﻭﺒﺔ‪.‬‬
‫ﻟﻘﺩ ﻋﺭﻓﻨﺎ‪ ،‬ﻓﻲ ﺘﻌﺭﻴﻔﻨﺎ ﻟﻸﺴﺱ ﺍﻟﻌﺎﻤﺔ ﻟﻌﻤل ﺍﻟﺤﺎﺴﻭﺏ‪ ،‬ﺃﻨﻪ ﻴﻤﻜﻥ ﺍﻟﺘﻤﻴﻴﺯ ﺒﻴﻥ ﺜﻼﺙ ﻤﺴﺘﻭﻴﺎﺕ ﻤﻥ‬
‫ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ‪ :‬ﻟﻐﺎﺕ ﺍﻵﻟﺔ‪ ،‬ﻟﻐﺎﺕ ﺍﻟﻤﺠﻤ‪‬ﻊ‪ ،‬ﻭﻤﺎ ﻫﻭ ﻏﻴﺭ ﺫﻟﻙ ﻨﺴﻤﻴﻪ ﻟﻐﺎﺕ ﻋﺎﻟﻴﺔ ﺍﻟﻤﺴﺘﻭﻯ‪.‬‬
‫ﻭﺒﺎﻟﻁﺒﻊ ﺴﻴﻜﻭﻥ ﺍﺴﺘﺨﺩﺍﻤﻨﺎ‪ ،‬ﻓﻲ ﺘﺭﻤﻴﺯ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺔ ﻟﻠﻠﻐﺎﺕ ﻋﺎﻟﻴﺔ ﺍﻟﻤﺴﺘﻭﻯ‪ ،‬ﻭﻤﻨﻬﺎ ﺘﺤﺩﻴﺩﹰﺍ ﺍﻟﻠﻐﺎﺕ‬
‫ﺍﻟﻤﻬﻴﻜﻠﺔ‪ .‬ﻭ ﻨﻌﻠﻡ ﺃﻨﻪ ﺒﺎﻹﻤﻜﺎﻥ ﺍﻻﻨﺘﻘﺎل ﺁﻟﻴﹸﺎ ﻤﻥ ﺒﺭﻨﺎﻤﺞ ﺒﻠﻐﺔ ﺒﺭﻤﺠﺔ ﻋﺎﻟﻴﺔ ﺍﻟﻤﺴﺘﻭﻯ ﺇﻟﻰ ﺒﺭﻨﺎﻤﺞ‬
‫ﺘﻨﻔﻴﺫﻱ )ﻟﻐﺔ ﺁﻟﺔ( ﻋﺒﺭ ﺍﺴﺘﺨﺩﺍﻡ ﺒﺭﻨﺎﻤﺞ ﺨﺎﺹ ﺴﻤﻴﻨﺎﻩ ﻤﺘﺭﺠﻡ ‪.compiler‬‬
‫ﻴﺘﺤﻘﻕ ﺍﻟﻤﺘﺭﺠﻡ ﻤﻥ ﻗﻭﺍﻋﺩ ﺍﻟﻠﻐﺔ ﻓﻲ ﻨﺹ ﺒﺭﻨﺎﻤﺠﻨﺎ ﻗﺒل ﺘﻭﻟﻴﺩ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﺘﻨﻔﻴﺫﻱ‪.‬‬
‫ﺴﻨﺭﻯ ﻓﻴﻤﺎ ﻴﻠﻲ ﺍﻟﻤﻘﺎﺒل ﻟﻠﻐﺔ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺎﺕ ﻓﻲ ﻟﻐﺎﺕ ﺒﺭﻤﺠﺔ ﻤﺴﺘﺨﺩﻤﺔ ﻭﻤﻨﺘﺸﺭﺓ ﻋﻠﻰ ﻨﻁﺎﻕ‬
‫ﻭﺍﺴﻊ‪ .‬ﺴﻨﺘﺒﻴﻥ ﺃﻥ ﺍﻟﺒﻨﻰ ﺍﻷﺴﺎﺴﻴﺔ )ﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺎﺕ ﺍﻟﺨﻤﺱ ﺍﻟﻘﺎﻋﺩﻴﺔ ﺍﻟﻤﺫﻜﻭﺭﺓ ﺁﻨﻔﺎ( ﺴﺘﺠﺩ‬
‫ﻤﻜﺎﻓﺌﺎ ﻤﺒﺎﺸﺭﺍ ﺃﻭ ﺸﺒﻪ ﻤﺒﺎﺸﺭ ﺒﻠﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻌﺎﻟﻴﺔ ﺍﻟﻤﺴﺘﻭﻯ‪.‬‬
‫ﺍﻨﻅﺭ ﻓﻲ ﺍﻟﺠﺩﺍﻭل ﺍﻟﺘﺎﻟﻴﺔ‪ ،‬ﻟﻘﺩ ﻗﻤﻨﺎ ﺒﻭﻀﻊ ﺍﻟﺘﻘﺎﺒل ﻓﻴﻬﺎ‪ ،‬ﻟﺤل ﻤﺴﺄﻟﺔ ﺇﻴﺠﺎﺩ ﺠـﺫﻭﺭ ﻤﻌﺎﺩﻟـﺔ ﻤـﻥ‬
‫ﺍﻟﺩﺭﺠﺔ ﺍﻟﺜﺎﻨﻴﺔ‪ ،‬ﺒﻴﻥ ﻟﻐﺔ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺎﺕ ﻭﻟﻐﺎ ﺕ ﺍﻟﺒﺭﻤﺠﺔ‪ Pascal, C :‬ﻭ ‪.Basic, Fortran 90‬‬
‫ﻭﻨﻌﺭﺽ ﺃﺨﻴﺭﹰﺍ ﺍﻟﺘﻘﺎﺒل ﻤﻊ ﻟﻐﺔ ‪ Java‬ﺍﻟﺘﻲ ﺴﺘﻜﻭﻥ ﺃﺩﺍﺘﻨﺎ ﺍﻟﺒﺭﻤﺠﻴﺔ ﻓﻲ ﻫﺫﻩ ﺍﻟﻤﺎﺩﺓ‪.‬‬

‫‪C Code‬‬ ‫‪Pascal Code‬‬ ‫‪Pseudo Code‬‬

‫ﻟﻐﺔ اﻟﺨﻮارزﻣﻴﺎت‬
‫>‪#include <stdio.h‬‬ ‫;‪program resol‬‬
‫>‪#include <math.h‬‬
‫{ ) (‪int main‬‬
‫‪// solution of second degree equation‬‬ ‫} ‪{ solution of second degree equation‬‬
‫*‪/‬‬ ‫*(‬
‫‪a.x.x + b.x + c = 0‬‬ ‫‪a.x.x + b.x + c = 0‬‬ ‫}ﺣﻞ اﻟﻤﻌﺎدﻟﺔ ‪{a.x2 + b.x + c = 0‬‬
‫‪*/‬‬ ‫)*‬
‫‪var‬‬
‫;‪float a, b, c, delta, x0, x1, x2‬‬ ‫;‪a,b,c,delta,x0,x1,x2: real‬‬
‫‪begin‬‬
‫;)" ‪printf("Input A:‬‬ ‫;)‪Write('Input A: '); readln(a‬‬
‫;)‪scanf ("%f",&a‬‬ ‫;)‪write('Input B: '); readln(b‬‬ ‫اﻗﺮأ ‪a, b, c‬‬
‫;)" ‪printf("Input B:‬‬ ‫;)‪write('Input C: '); readln(c‬‬
‫;)‪scanf ("%f",&b‬‬

‫‪1‬‬
 printf("Input C: ");
scanf ("%f",&c);
Delta = b*b - a * 4 * c; Delta := b*b - 4*a*c; delta ← b2 - 4*b*c

if (delta > 0) { if (delta > 0) then ‫( ﻧﻔﱢﺬ‬delta > 0 ) ‫إذا‬

begin
x1 = (-b -sqrt(delta)) /(2*a); x1:= (-b-sqrt(delta))/ (2*a); x1 ← (-b-sqr(delta))/(2*a)
x2 = (b - sqrt(delta)) / (2*a); x2 := (-b+sqrt(delta))/(2*a); x2 ← (- b+sqr(delta))/(2*a)
printf("x1=%f x2=%f\n", x1, x2); writeln('x1= ',x1,' x2= ',x2); ”x1=”, x1,” x2=”, x2 ‫اآﺘﺐ‬
} end;
if (delta == 0) { if (delta = 0) then ‫( ﻧﻔﱢﺬ‬delta = 0 ) ‫إذا‬
begin
x0 = -b /(2*a); x0:=-b/(2*a); x0 ← -b /(2*a)
printf("x0=%f\n",x0); writeln('x0= ',x0); ”x0=”, x0 ‫اآﺘﺐ‬
} end;
if (delta < 0) if (delta < 0) then ‫( ﻧﻔﱢﺬ‬delta < 0 ) ‫إذا‬
printf("no real solution \n"); writeln(' no real solution '); ” no real solution” ‫اآﺘﺐ‬

} End.

Visual BASIC Code Fortran 90 Code Pseudo Code

‫ﻟﻐﺔ اﻟﺨﻮارزﻣﻴﺎت‬
program resol
REM solution of second degree equation * solution of second degree equation
‘ *
‘ a.x.x + b.x + c = 0 * a.x.x + b.x + c = 0
{a.x2 + b.x + c = 0 ‫}ﺣﻞ اﻟﻤﻌﺎدﻟﺔ‬
‘ *
real a,b,c,delta,x0,x1,x2
a = InputBox("input A ") read(*,'Input A') a
b = InputBox("input B") read(*,' Input A') b a, b, c ‫اﻗﺮأ‬
c = InputBox("input C") read(*,'Input A') c

Delta = b^2-4*a*c delta = b**2 – 4*a*c delta ← b2 - 4*b*c

if delta > 0 then if (delta > 0) then ‫( ﻧﻔﱢﺬ‬delta > 0 ) ‫إذا‬

x1=(-b-sqr(delta))/ (2*a) x1=(-b-sqrt(delta))/ (2*a) x1 ← (-b-sqr(delta))/(2*a)
x2=(-b+sqr(delta))/(2*a) x2=(-b+sqrt(delta))/(2*a) x2 ← (-b+sqr(delta))/(2*a)
MsgBox "x1= " & x1 & " x2= " & x2 write(*,*) 'x1= ',x1,' x2= ',x2 ”x1=”, x1,” x2=”, x2 ‫اآﺘﺐ‬
Endif endif
if delta = 0 then if (delta = = 0) then ‫( ﻧﻔﱢﺬ‬delta = 0 ) ‫إذا‬
x0 = -b/(2*a) x0=-b/(2*a) x0 ← -b /(2*a)
MsgBox "x0= " & x0 write(*,*) 'x0= ',x0 ”x0=”, x0 ‫اآﺘﺐ‬
Endif endif
If delta < 0 Then if (delta < 0) ; ‫( ﻧﻔﱢﺬ‬delta < 0 ) ‫إذا‬
MsgBox "no real solution" write(*,*) ' no real solution ' ” no real solution” ‫اآﺘﺐ‬
EndIf
End End

Java Code Pseudo Code

‫ﻟﻐﺔ اﻟﺨﻮارزﻣﻴﺎت‬
import javax.swing.JOptionPane;
class Solution2degree {

2
public static void main( String[] arg ) {
// solution of second degree equation
/*
a.x.x + b.x + c = 0
{a.x2 + b.x + c = 0 ‫}ﺣﻞ اﻟﻤﻌﺎدﻟﺔ‬
*/
float a; String Sa;
float b; String Sb;
float c; String Sc;
float delta, x1, x2, x0;

Sa = JOptionPane.showInputDialog(" Input A : ");

a = Float.parseFloat(Sa);
Sb = JOptionPane.showInputDialog(" Input B : ");
a, b, c ‫اﻗﺮأ‬
b = Float.parseFloat(Sb);
Sc = JOptionPane.showInputDialog(" Input C : ");
c = Float.parseFloat(Sc);

delta = b*b - 4*a*c delta ← b2 - 4*b*c

if ( delta > 0) { ‫( ﻧﻔﱢﺬ‬delta > 0 ) ‫إذا‬

x1 = ( -b - (float) Math.sqrt( delta ) ) / (2*a) ;
x1 ← (-b-sqr(delta))/(2*a)
x2 = ( -b + (float) Math.sqrt( delta ) ) / (2*a) ;
x2 ← (-b+sqr(delta))/(2*a)
System.out.println(" x1= "+ x1 + " x2= "+x2 );
”x1=”, x1,” x2=”, x2 ‫اآﺘﺐ‬
}

if ( delta == 0) { ‫( ﻧﻔﱢﺬ‬delta = 0 ) ‫إذا‬

x0 = -b / (2*a) ; x0 ← -b /(2*a)
System.out.println(" x0= "+ x0 ); ”x0=”, x0 ‫اآﺘﺐ‬
}

if ( delta < 0) ‫( ﻧﻔﱢﺬ‬delta < 0 ) ‫إذا‬

System.out.println(" no real solution " ); ” no real solution” ‫اآﺘﺐ‬

}
}

program frame ‫ ﺑﺪاﻳﺔ )ﺗﺮوﻳﺴﺔ( وﻧﻬﺎﻳﺔ‬: ‫ﺗﺄﻃﻴﺮ اﻟﺒﺮﻧﺎﻣﺞ‬

comments ‫ﺗﻌﻠﻴﻖ‬
variables declaration ‫اﻟﺘﺼﺮﻳﺢ ﻋﻦ اﻟﻤﺘﺤﻮﻻت‬
input instructions ‫اﻟﺠﺰء اﻟﻤﺘﻀﻤﻦ ﻟﺘﻌﻠﻴﻤﺎت إدﺧﺎل اﻟﻤﻌﻄﻴﺎت‬
instructions ‫ﺟﺰء اﻟﺘﻌﻠﻴﻤﺎت اﻟﺘﻨﻔﻴﺬﻳﺔ‬

pseudo code ‫ﻟﻐﺔ اﻟﺨﻮارزﻣﻴﺎت‬

.‫ﺇﻥ ﺘﻨﻔﻴﺫ ﺃﻱ ﻤﻥ ﻫﺫﻩ ﺍﻟﺒﺭﺍﻤﺞ ﺴﻴﻌﻁﻲ ﺠﺫﻭﺭ ﻤﻌﺎﺩﻟﺔ ﺍﻟﺩﺭﺠﺔ ﺍﻟﺜﺎﻨﻴﺔ ﺍﻟﺤﻘﻴﻘﻴﺔ‬
‫ﺴﻴﺘﺒﻴﻥ ﻟﻙ‬ Java ‫ ﻋﻨﺩﻤﺎ ﺘﻨﺘﻬﻲ ﻤﻥ ﻗﺭﺍﺀﺓ ﻫﺫﺍ ﺍﻟﻔﺼل ﺍﻟﺫﻱ ﻴﺘﻀﻤﻥ ﻟﻤﺤﺔ ﻋﺎﻤﺔ ﻋﻥ ﻟﻐﺔ‬،‫ﻭﺍﻵﻥ‬
‫ ﻓﻬﻲ ﺃﺩﺍﺓ ﺒﺭﻤﺠﻴﺔ ﺘﻀﻌﻙ ﻤﻨﺫ ﺍﻵﻥ ﻋﻠﻰ ﻗﻭﺍﻋﺩ‬.‫ﻟﻤﺎﺫﺍ ﺍﺨﺘﺭﻨﺎ ﻟﻙ ﻫﺫﻩ ﺍﻟﻠﻐﺔ ﺍﻟﺤﺩﻴﺜﺔ ﺍﻟﺭﺍﺌﻌﺔ‬
.‫ﻼ‬
‫ ﻭﻟﻜﻨﻙ ﺴﺘﺘﻠﻤﺱ ﻤﺯﺍﻴﺎﻫﺎ ﺃﻜﺜﺭ ﻓﻲ ﻤﺭﺍﺤل ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﺘﻘﺩﻤﺔ ﻤﺴﺘﻘﺒ ﹰ‬،‫ﻫﻨﺩﺴﺔ ﺒﺭﻤﺠﻴﺔ ﺠﻴﺩﺓ‬

3
 ‫‪pseudo‬‬ ‫ﺴﻴﺴﺘﺭﻋﻲ ﺍﻨﺘﺒﺎﻫﻙ ﺍﻟﺘﻘﺎﺒل ﺸﺒﻪ ﺍﻟﻜﺎﻤل ﻟﻠﻌﺩﻴﺩ ﻤﻥ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﻓﻲ ﻟﻐﺔ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺎﺕ‬
‫ﻤﻊ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻔﻌﻠﻴﺔ‪ ،‬ﻟﺘﻘﻭل ﺒﻌﺩ ﺫﻟﻙ‪ ،‬ﻜل ﻤﺎ ﺫﻜﺭﻨﺎﻩ ﺤﻭل ﻟﻐﺔ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺎﺕ ﻤﺎ ﻫﻭ‬ ‫‪code‬‬

‫ﺇﻻ ﺘﺭﺠﻤﺔ ﻟﻠﻌﺭﺒﻴﺔ ﻤﻥ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻔﻌﻠﻴﺔ‪ .‬وﻳﻤﻜﻦ أن ﺗﻄﺮح اﻟﺴﺆال اﻟﺘﺎﻟﻲ‪:‬‬
‫ﻟﻤﺎﺫﺍ ﻻ ﻨﺴﺘﺨﺩﻡ ﺍﻟﻤﺼﻁﻠﺤﺎﺕ ﺍﻹﻨﻜﻠﻴﺯﻴﺔ‪ ،‬ﺒل ﻟﻤﺎﺫﺍ ﻻ ﻨﻌﺒﺭ ﻤﺒﺎﺸﺭ ﹰﺓ ﻋﻥ ﺤﻠﻨﺎ ﺃﻭ ﺨﻭﺍﺭﺯﻤﻴﺘﻨﺎ‬
‫ﺒﻠﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻔﻌﻠﻴﺔ ﺍﻟﺘﻲ ﻨﺴﺘﺨﺩﻤﻬﺎ؟‬
‫ﻴﻔﻜﺭ ﺍﻹﻨﺴﺎﻥ ﺒﻠﻐﺔ‪ ،‬ﻭﻫﻲ ﻏﺎﻟﺒﹰﺎ ﻟﻐﺘﻪ ﺍﻟﻁﺒﻴﻌﻴﺔ ﺃﻭ ﺍﻟﻠﻐﺔ ﺍﻷﻡ‪ ،‬ﻟﺫﻟﻙ ﻜﺎﻨﺕ ﻟﻐﺔ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺎﺕ‬
‫ﺍﻟﻤﻘﺩﻤﺔ ﻟﻙ ﻫﻨﺎ ﺒﺎﻟﻌﺭﺒﻴﺔ‪ ،‬ﻟﺘﻜﻭﻥ ﺃﻗﺭﺏ ﻤﺎ ﻴﻤﻜﻥ ﻟﻤﺎ ﺘﻌﺒﺭ ﻋﻨﻪ ﻋﻨﺩﻤﺎ ﺘﺸﺭﺡ ﺤل ﺍﻟﻤﺴﺄﻟﺔ‪ .‬ﻭﻟﻭ‬
‫ﻜﺎﻥ ﺒﺎﻹﻤﻜﺎﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺃﺴﻤﺎﺀ ﺍﻟﻤﺘﺤﻭﻻﺕ ﺒﺎﻟﻠﻐﺔ ﺍﻟﻌﺭﺒﻴﺔ ﺴﻬل ﺍﻟﻨﻘل ﺇﻟﻰ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻔﻌﻠﻴﺔ‬
‫ﻟﻜﻨﺎ ﺍﺴﺘﺨﺩﻤﻨﺎﻩ‪ ،‬ﻓﺭﺒﻤﺎ ﻴﺴﻬل ﻋﻠﻴﻙ ﺍﻟﺘﻌﺒﻴﺭ ﺃﻜﺜﺭ‪ .‬ﺇﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﺼﻁﻠﺤﺎﺕ ﺍﻹﻨﻜﻠﻴﺯﻴﺔ‪ ،‬ﺇﻥ ﻜﺎﻥ‬
‫ﻤﺭﻴﺤﹰﺎ ﻟﻙ ﺃﻜﺜﺭ ﻓﻲ ﺍﻟﺘﻌﺒﻴﺭ ﻋﻥ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺔ‪ ،‬ﻭﺭﺒﻤﺎ ﻴﻐﺩﻭ ﻜﺫﻟﻙ ﺒﻌﺩ ﺍﺴﺘﺨﺩﺍﻤﻙ ﺍﻟﻤﻜﺜﻑ ﻟﻠﻐﺔ‬
‫ﺒﺭﻤﺠﺔ ﻓﻌﻠﻴﺔ‪ ،‬ﻓﻼ ﻀﻴﺭ ﻓﻲ ﺫﻟﻙ‪ .‬ﻭﻟﻜﻥ ﺍﻋﻠﻡ ﺃﻥ ﻜﺘﺏ ﺍﻟﺒﺭﻤﺠﺔ ﺒﺎﻟﻠﻐﺔ ﺍﻹﻨﻜﻠﻴﺯﻴﺔ ﺘﺴﺘﺨﺩﻡ‬
‫ﻫﻭ ﺃﻥ ﻴﻜﻭﻥ‬ ‫‪pseudo code‬‬ ‫ﺃﻴﻀﺎ ُ‪ ،‬ﺇﺫ ﺃﻥ ﺍﻟﻬﺩﻑ ﻤﻥ ﻟﻐﺔ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺎﺕ‬ ‫‪pseudo code‬‬

‫ﺍﻟﻤﺴﻭﺩﺓ ﻟﺤﻠﻙ ﺒﺤﻴﺙ ﺘﺴﺘﻁﻴﻊ ﺃﻥ ﺘﻌﻜﺱ ﺃﻓﻜﺎﺭﻙ ﻟﻠﺤل ﺒﺴﻬﻭﻟﺔ ﻭﻴﺴﺭ‪ ،‬ﺃﻱ ﺃﻥ ﻤﺎ ﺘﻔﻜﺭ ﺒﻪ ﺘﻜﺘﺒﻪ‬
‫ﺒﻬﺎ ﻤﺒﺎﺸﺭﺓﹰ‪ ،‬ﺒﺤﻴﺙ ﻻ ﺘﻌﻴﻘﻙ ﻗﻭﺍﻋﺩ ﺼﺎﺭﻤﺔ ﺃﻭ ﻤﺼﻁﻠﺤﺎﺕ ﺨﺎﺼﺔ‪ .‬ﻭﻟﻜﻥ ﺭﺃﻴﺕ ﺃﻨﻨﺎ ﻭﻀﻌﻨﺎ‬
‫ﺒﻌﺽ ﺍﻷﻁﺭ ﻭﺍﻟﻬﻴﻜﻠﺔ ﻓﻲ ﻫﺫﻩ ﺍﻟﻠﻐﺔ ﻟﺘﻜﻭﻥ ﺴﻬﻠﺔ ﺍﻟﻨﻘل ﺇﻟﻰ ﺍﻟﻤﺒﻴﻀﺔ ﻭﻫﻲ ﻫﻨﺎ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ‬
‫ﺍﻟﻔﻌﻠﻴﺔ‪ ،‬ﻓﻬﻨﺎ ﺍﻟﻘﻭﺍﻋﺩ ﺼﺎﺭﻤﺔ ﻭﺩﻗﻴﻘﺔ ﻻ ﺘﺤﺘﻤل ﺃﻱ ﻫﻔﻭﺓ ﺃﻭ ﺨﻁﺄ ﻜﻤﺎ ﺴﺘﻠﻤﺱ ﺒﻴﺩﻙ ﺫﻟﻙ‪.‬‬
‫ﻭﺍﻵﻥ‪ ،‬ﺁﻥ ﺍﻷﻭﺍﻥ‪ ،‬ﻓﻨﺤﻥ ﻤﺘﻠﻬﻔﻭﻥ ﻟﻨﻌﺭﻑ ﻋﻥ ﻜﺜﺏ ﻟﻐﺔ ﺒﺭﻤﺠﺔ ﻓﻌﻠﻴﺔ‪ ،‬ﻨﻔﻜﻙ ﻗﻭﺍﻋﺩﻫﺎ ﻭﻨﻌﺭﻑ‬
‫ﺍﺴﺘﺨﺩﺍﻤﻬﺎ ﻟﻨﺨﺘﺒﺭ ﻓﻌﻠﻴﹰﺎ ﺒﻴﺩﻴﻨﺎ ﺨﻭﺍﺭﺯﻤﻴﺎﺕ ﺤﻠﻨﺎ؟‬
‫ﻋﺒﺭ ﻤﺤﺭﺭ ﺍﻟﻨﺼﻭﺹ )ﺍﻟﺫﻱ ﻴﺄﺘﻲ‬ ‫‪Java‬‬ ‫ﻴﻤﻜﻨﻙ ﺃﻥ ﺘﺒﺩﺃ ﻤﻥ ﺍﻵﻥ‪ ،‬ﺒﺈﺩﺨﺎل ﺍﻟﻨﺹ ﺍﻟﺒﺭﻤﺠﻲ ﺒﻠﻐﺔ‬
‫ﻤﺭﺍﻓﻘﹰﺎ ﻟﻠﻤﺘﺭﺠﻡ ﺍﻟﺫﻱ ﺴﺘﺴﺨﺩﻤﻪ(‪ ،‬ﻭﺍﻟﺫﻱ ﺴﺘﹸﺸﺭﺡ ﻟﻙ ﻁﺭﻴﻘﺔ ﺍﺴﺘﺴﺨﺩﺍﻤﻪ ﻤﻥ ِﻗﺒ‪‬ل ﻤﺩﺭﺱ ﺍﻟﻌﻤﻠﻲ‪.‬‬
‫ﺃﺩﺨل ﺍﻟﻨﺹ ﺒﺤﺫﺍﻓﻴﺭﻩ‪ ،‬ﻭﺩﻗﻕ ﺠﻤﻴﻊ ﺍﻷﺨﻁﺎﺀ ﺍﻹﻤﻼﺌﻴﺔ‪ ،‬ﺜﻡ ﺍﻁﻠﺏ ﺍﻟﺘﺭﺠﻤﺔ ‪ ،‬ﻓﻲ ﺤﺎل ﺃﻱ ﺃﺨﻁﺎﺀ‬
‫ﻓﻲ ﺃﻱ ﺴﻁﺭ ﺴﻴﺸﻴﺭ ﺍﻟﻤﺘﺭﺠﻡ ﺇﻟﻰ ﺫﻟﻙ‪ ،‬ﺼﺤﺢ ﺴﻁﺭﺍﻟﺨﻁﺄ ﺜﻡ ﺃﻋﺩ ﻤﻥ ﺠﺩﻴﺩ‪ ،‬ﺇﻟﻰ ﺃﻥ ﻴﻘﻭل‬
‫ﺍﻟﻤﺘﺭﺠﻡ ﻟﻙ ﺃﻥ ﻋﻤﻠﻴﺔ ﺍﻟﺘﺭﺠﻤﺔ ﺠﺭﺕ ﺒﻨﺠﺎﺡ‪ .‬ﻫﺫﻩ ﺍﻟﻌﻤﻠﻴﺔ ﺍﻟﺸﺎﻗﺔ ﻨﺴﺒﻴﹸﺎ ﻓﻲ ﺍﻟﺒﺩﺍﻴﺔ ﻻ ﺒﺩ ﻤﻨﻬﺎ‪،‬‬
‫ﻫل ﺘﺘﺫﻜﺭ ﺘﻌﻠﻤﻙ ﻷﻭل ﻟﻐﺔ ﺃﺠﻨﺒﻴﺔ‪ ،‬ﺘﺨﻁﺊ ﺜﻡ ﺘﺼﺤ‪‬ﺢ‪ .‬ﺒﻌﺽ ﺍﻟﻤﺴﺎﻋﺩﺓ‪ ،‬ﺴﻴﻘﺩﻤﻬﺎ ﻟﻙ ﻤﺩﺭﺱ‬
‫ﺍﻟﻌﻤﻠﻲ ﻓﻲ ﺍﻟﺒﺩﺍﻴﺔ‪ ،‬ﻭﻟﻜﻥ ﺍﻋﻠﻡ ﺃﻥ ﺍﻷﻤﺭ ﻴﺘﻁﻠﺏ ﻤﻨﻙ ﺠﻬﺩﹰﺍ ﻫﺎﻤﹰﺎ ﻟﺘﺘﺂﻟﻑ ﻤﻊ ﻟﻐﺔ ﺠﺩﻴﺩﺓ‪.‬‬
‫ﻭﻟﺘﺤﻘﻴﻕ ﺫﻟﻙ ﻴﻤﻜﻨﻙ ﺃﻥ ﺘﺒﺩﺃ ﺒﺎﻀﻐﻁ ﻋﻠﻰ ﺍﻟﺯﺭ ﺍﻟﻤﻭﺠﻭﺩ ﺃﻤﺎﻤﻙ ﻟﺘﺭﻯ ﺘﻨﻔﻴﺫ ﺒﺭﻨﺎﻤﺞ إﻳﺠﺎد ﺟﺬور‬
‫‪x.x -3x -10 = 0‬‬ ‫ﻣﻌﺎدﻟﺔ اﻟﺪرﺟﺔ اﻟﺜﺎﻧﻴﺔ ﻟﻠﻤﻌﺎﺩﻟﺔ ﺍﻟﺘﺎﻟﻴﺔ‬

‫‪4‬‬
 ‫ﻗﻭﺍﻋﺩ ﻋﺎﻤﺔ ﻓﻲ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ‬ ‫‪-1‬‬
‫ﺍﻟﻜﻠﻤﺎﺕ ﺍﻟﻤﻔﺘﺎﺤﻴﺔ )ﺍﻟﻤﺤﺠﻭﺯﺓ( ﻟﻠﻠﻐﺔ‬
‫ﻭﻨﺴﻤﻴﻬﺎ ﺃﻴﻀﹰﺎ ﺍﻟﻜﻠﻤﺎﺕ ﺍﻟﻤﺤﺠﻭﺯﺓ ﻟﻠﻐﺔ ‪،reserved word‬‬ ‫‪keywords‬‬ ‫ﻟﻜل ﻟﻐﺔ ﺒﺭﻤﺠﺔ ﻜﻠﻤﺎﺕ ﻤﻔﺘﺎﺤﻴﺔ‬
‫ﻭﻤﻨﻬﺎ ﺒﺸﻜل ﺃﺴﺎﺴﻲ ﺍﻟﻜﻠﻤﺎﺕ ﺍﻟﺘﻲ ﺘﻜﺭﺴﻬﺎ ﺍﻟﻠﻐﺔ ﻟﺒﻨﺎﺀ ﺸﻜﻠﻬﺎ ﺍﻟﻘﻭﺍﻋﺩﻱ ‪.‬‬
‫ﻓﻲ ﺍﻷﻤﺜﻠﺔ ﺍﻟﻤﺫﻜﻭﺭﺓ ﺒﻠﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺃﺸﺭﻨﺎ ﺇﻟﻰ ﻫﺫﻩ ﺍﻟﻜﻠﻤﺎﺕ ﺒﺎﻟﻠﻭﻥ ﺍﻟﻐﺎﻤﻕ‪.‬‬
‫ﻫﻲ ﻜﻠﻤﺔ ﻤﻔﺘﺎﺤﻴﺔ ﻓﻲ ﻜل ﺍﻟﻠﻐﺎﺕ ﺍﻟﻤﺫﻜﻭﺭﺓ‪.‬‬ ‫‪if‬‬ ‫ﺃﻤﺜﻠﺔ‪ :‬ﻜﻠﻤﺔ‬
‫ﹸﺘﻤّﻴﺯ ﺒﻌﺽ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﻭﻤﻨﻬﺎ ‪ C‬ﻭ ‪ Java‬ﺒﻴﻥ ﺍﻟﺤﺭﻭﻑ ﺍﻟﻜﺒﻴﺭﺓ ﻭﺍﻟﺼﻐﻴﺭﺓ‪.‬‬
‫‪Java‬‬ ‫‪،‬‬ ‫‪C‬‬ ‫ﻓﻲ‬
‫ﻜﻜﻠﻤﺔ ﻤﻔﺘﺎﺤﻴﺔ‪.‬‬ ‫‪if‬‬ ‫ﻋﻭﻀﹰﺎ ﻋﻥ‬ ‫‪If‬‬ ‫ﻻ ﻴﻤﻜﻥ ﻜﺘﺎﺒﺔ‬
‫ﺠﻤﻴﻊ ﺍﻟﻜﻠﻤﺎﺕ ﺍﻟﻤﺤﺠﻭﺯﺓ ﻟﻠﻐﺔ ﺘﻜﺘﺏ ﺒﺄﺤﺭﻑ ﺼﻐﻴﺭﺓ‪.‬‬ ‫‪Java‬‬ ‫‪،‬‬ ‫‪C‬‬ ‫ﻤﻼﺤﻅﺔ‪ :‬ﻓﻲ‬
‫ﻜﺄﺴﻤﺎﺀ ﻤﺘﺤﻭﻻﺕ ﻓﻨﺤﻥ ﻨﻘﺼﺩ ﻤﺘﺤﻭﻟﻴﻥ ﻤﺨﺘﻠﻔﻴﻥ‬ ‫‪A‬‬ ‫ﻭ‬ ‫‪a‬‬ ‫ﺇﺫﺍ ﺍﺴﺘﺨﺩﻤﻨﺎ‬
‫‪ Fortran‬ﻭ‪Pascal‬‬ ‫ﻭ‬ ‫‪Basic‬‬ ‫ﻓﻲ‬
‫)ﻻ ﺘﻤﻴﻴﺯ ﺒﻴﻥ ﺤﺎﻻﺕ ﺍﻟﺤﺭﻭﻑ(‬
‫ﻜﻜﻠﻤﺔ ﻤﻔﺘﺎﺤﻴﺔ‪.‬‬ ‫‪if‬‬ ‫ﻋﻭﻀﹰﺎ ﻋﻥ‬ ‫‪iF‬‬ ‫ﺃﻭ‬ ‫‪IF‬‬ ‫ﺃﻭ‬ ‫‪If‬‬ ‫ﻴﻤﻜﻥ ﻜﺘﺎﺒﺔ‬
‫ﻜﺄﺴﻤﺎﺀ ﻤﺘﺤﻭﻻﺕ ﻓﻨﺤﻥ ﻨﻘﺼﺩ ﻨﻔﺱ ﺍﻟﻤﺘﺤﻭل‬ ‫‪A‬‬ ‫ﻭ‬ ‫‪a‬‬ ‫ﺇﺫﺍ ﺍﺴﺘﺨﺩﻤﻨﺎ‬

‫ﺍﻨﺘﺒﻪ ﺠﻴﺩﹰﺍ ﻟﻸﺨﻁﺎﺀ ﺍﻹﻤﻼﺌﻴﺔ ﻓﻲ ﺍﻟﻜﻠﻤﺎﺕ )ﺴﻭﺍﺀ ﺍﻟﻜﻠﻤﺎﺕ ﺍﻟﻤﺤﺠﻭﺯﺓ ﺃﻭ ﺃﺴﻤﺎﺀ ﺍﻟﻤﺘﺤﻭﻻﺕ(‬
‫ﻓﻬﻲ ﻤﺼﺩﺭ ﺍﻷﺨﻁﺎﺀ ﺍﻷﻭل ﺍﻟﺫﻱ ﻴﺼﺭﺥ ﺍﻟﻤﺘﺭﺠﻡ ﻓﻲ ﻭﺠﻬﻙ ﺒﺴﺒﺒﻪ‪ .‬ﻨﻘﻭل ﺼﺭﺍﺥ ﻷﻨﻪ ﻏﺎﻟﺒ ﹰﺎ ﻻ‬
‫ﻴﻌﻁﻴﻙ ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﺩﺍﻟﺔ ﺃﻥ ﻫﻨﺎﻙ ﺨﻁ ًﺄ ﺇﻤﻼﺌﻴ ﹰﺎ‪.‬‬

‫ﺤﺩﻭﺩ ﺍﻟﺘﻌﻠﻴﻤﺔ‬
‫ ﻟﻜل ﺘﻌﻠﻴﻤﺔ ﻨﻬﺎﻴﺔ‪.‬‬
‫ﻨﻬﺎﻴﺔ ﺍﻟﺘﻌﻠﻴﻤﺔ ﻫﻲ ﻨﻬﺎﻴﺔ ﺍﻟﺴﻁﺭ‬ ‫‪:Fortran‬‬ ‫ﻭ‬ ‫‪Basic‬‬ ‫ﻓﻲ‬
‫;‬ ‫ﻨﻬﺎﻴﺔ ﺍﻟﺘﻌﻠﻴﻤﺔ ﻫﻲ ﺍﻟﻔﺎﺼﻠﺔ ﺍﻟﻤﻨﻘﻭﻁﺔ‬ ‫‪:Pascal‬‬ ‫ﻭ‬ ‫‪Java‬‬ ‫‪،‬‬ ‫‪C‬‬ ‫ﻓﻲ‬
‫ﺘﹸﺤﺩﱠﺩ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﻤﻬﻴﻜﻠﺔ )ﺴﻨﺴﻤﻴﻬﺎ ﺃﻴﻀﹰﺎ ﻜﺘﻠﺔ ﺘﻌﻠﻴﻤﺎﺕ ‪ (instruction block‬ﺒﺤﻴﺙ ﺘﺘﻀﺢ‬ ‫‬

‫ﺒﺩﺍﻴﺘﻬﺎ ﻭﻨﻬﺎﻴﺘﻬﺎ‪.‬‬
‫‪end‬‬ ‫ﺍﻟﻨﻬﺎﻴﺔ‪:‬‬ ‫‪begin‬‬ ‫ﻓﻲ ‪ :Pascal‬ﺍﻟﺒﺩﺍﻴﺔ‪:‬‬
‫}‬ ‫ﺍﻟﻨﻬﺎﻴﺔ‪:‬‬ ‫{‬ ‫‪ :Java ،‬ﺍﻟﺒﺩﺍﻴﺔ‪:‬‬ ‫‪C‬‬ ‫ﻓﻲ‬
‫ﻓﻲ ‪:Fortran 90 ،Basic‬‬
‫‪if‬‬ ‫ﺍﻟﺒﺩﺍﻴﺔ‪ :‬ﻫﻲ ﺴﻁﺭ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻲ ﺘﺴﺘﺨﺩﻡ ﻜﺘﻠﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ‪ .‬ﻤﺜﺎل‪:‬‬
‫‪endif‬‬ ‫ﺍﻟﻨﻬﺎﻴﺔ‪ :‬ﻜﻠﻤﺔ ﺨﺎﺼﺔ ﺒﺎﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﻲ ﺘﺴﺘﺨﺩﻡ ﻜﺘﻠﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ‪ .‬ﻤﺜﺎل‪:‬‬

‫‪5‬‬
 ‫ﻋﻨﺩﻤﺎ ﺘﻜﻭﻥ ﻤﺠﻤﻭﻋﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﻤﻬﻴﻜﻠﺔ )ﻜﺘﻠﺔ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﻤﺭﺘﺒﻁﺔ ﺒﺘﻨﻔﻴﺫ ﺘﻌﻠﻴﻤﺔ( ﻤﻜﻭﻨ ﹰﺔ ﻤﻥ‬
‫ﺘﻌﻠﻴﻤﺔ ﻭﺤﻴﺩﺓ ﻴﻤﻜﻥ ﺍﻻﺴﺘﻐﻨﺎﺀ ﻋﻥ ﺘﺤﺩﻴﺩ ﺍﻟﺒﺩﺍﻴﺔ ﻭﺍﻟﻨﻬﺎﻴﺔ‪.‬‬

‫ﺍﻟﺘﺼﺭﻴﺢ ﻋﻥ ﺍﻟﻤﺘﺤﻭﻻﺕ‬
‫ﻓﻲ ﻤﻌﻅﻡ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﻻ ﺒﺩ ﻤﻥ ﺍﻟﺘﺼﺭﻴﺢ ﻋﻥ ﺍﻟﻤﺘﺤﻭﻻﺕ ﻗﺒل ﺃﻱ ﺍﺴﺘﺨﺩﺍﻡ ﻟﻬﺎ‪ ،‬ﻭﻏﺎﻟﺒﹰﺎ ﻴﻜﻭﻥ‬
‫ﺍﻟﺘﺼﺭﻴﺢ ﻓﻲ ﺃﻭل ﺍﻟﺒﺭﻨﺎﻤﺞ‪.‬‬
‫ﻭﻨﻤﻁﻪ ‪.type‬‬ ‫‪identifier‬‬ ‫ﻴﺠﺭﻱ ﺍﻟﺘﺼﺭﻴﺢ ﺒﺫﻜﺭ ﺍﺴﻡ ﺍﻟﻤﺘﺤﻭل‬
‫ﻤﺜﺎل‪:‬‬
‫ﻫﻭ ﺍﺴﻡ ﻤﺘﺤﻭل )ﺨﺎﻨﺔ ﺫﺍﻜﺭﺓ( ﻤﻥ ﻨﻤﻁ ﻋﺩﺩ ﺤﻘﻴﻘﻲ‪.‬‬ ‫‪a‬‬ ‫ﻟﻠﺘﺼﺭﻴﺢ ﺒﺄﻥ‬
‫‪Real a; :pascal‬‬ ‫ﻓﻲ‬
‫‪float a; :C‬‬ ‫ﻭ‬ ‫‪java‬‬ ‫ﻓﻲ‬

‫ﻗﻭﺍﻋﺩ ﺘﺴﻤﻴﺔ ﺍﻟﻤﺘﺤﻭﻻﺕ‬

‫‪ ،‬ﻜﻤﺎ ﻴﻤﻜﻥ ﺍﺴﺘﺨﺩﺍﻡ‬ ‫‪0,1,2,..9‬‬ ‫ﻴﺒﺩﺃ ﺍﺴﻡ ﺍﻟﻤﺘﺤﻭل ﺒﺤﺭﻑ ﺃﺒﺠﺩﻱ‪ ،‬ﻭﻴﻤﻜﻥ ﺃﻥ ﻴﺘﻀﻤﻥ ﺍﻷﺭﻗﺎﻡ‪:‬‬ ‫•‬

‫ﻋﻼﻤﺔ ﺍﻟﻭﺼل ‪) ،_،‬ﻟﻴﺱ ﺭﻤﺯ ﺇﺸﺎﺭﺓ ﺍﻟﻁﺭﺡ ‪.(-‬‬

‫ﻴﺠﺏ ﻋﺩﻡ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻜﻠﻤﺎﺕ ﺍﻟﻤﻔﺘﺎﺤﻴﺔ ﻟﻠﻐﺔ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ ﻜﺎﺴﻡ ﻟﻤﺘﺤﻭل )ﺃﻟﻡ ﻨﺴﻤﻴﻬﺎ ﻜﻠﻤﺎﺕ‬ ‫•‬

‫ﻤﺤﺠﻭﺯﺓ ﻟﻠﻠﻐﺔ(‬

‫ﺠﺎﻓﺎ<<‬ ‫ﻟﻠﻐﺔ‬ ‫‪keywords‬‬ ‫>> ﺍﻨﻅﺭ ﺠﺩﻭل ﺍﻟﻜﻠﻤﺎﺕ ﺍﻟﻤﻔﺘﺎﺤﻴﺔ‬

‫ﺃﻤﺜﻠﺔ‪:‬‬
‫‪a, b, c, x1, x0, delta, realRoot, real_root‬‬
‫‪1x, x-y, x(y, ..., if‬‬ ‫ﺃﺴﻤﺎﺀ ﻤﺘﺤﻭﻻﺕ ﻏﻴﺭ ﺼﺤﻴﺤﺔ‪:‬‬
‫ﻟﻤﺎﺫﺍ؟‬
‫ﺍﻨﺘﺒﻪ‪ :‬ﹸﺘﻤ‪‬ﻴﺯ ﺒﻌﺽ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﻭﻤﻨﻬﺎ ‪ C‬ﻭ ‪ Java‬ﺒﻴﻥ ﺍﻟﺤﺭﻭﻑ ﺍﻟﻜﺒﻴﺭﺓ ﻭﺍﻟﺼﻐﻴﺭﺓ‪.‬‬

‫ﻤﻔﺭﺩﺍﺕ ﺍﻟﻠﻐﺔ‬
‫ﺇﻀﺎﻓ ﹰﺔ ﺇﻟﻰ ﺍﻟﻜﻠﻤﺎﺕ ﺍﻟﻤﻔﺘﺎﺤﻴﺔ‪ ،‬ﺘﺴﺘﺨﺩﻡ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﺍﻟﺭﻤﻭﺯ‪ :‬ﻤﺜل ﺭﻤﻭﺯ ﺍﻟﻌﻤﻠﻴﺎﺕ )‬
‫ﻤﻨﻬﺎ ﺍﻟﺤﺴﺎﺒﻴﺔ ‪ ،(+, -, *, /‬ﻭﺭﻤﻭﺯ ﺫﺍﺕ ﻭﻅﺎﺌﻑ ﺨﺎﺼﺔ ) ﻓﻲ ﻤﻌﻅﻡ ﺍﻟﻠﻐﺎﺕ‪ = :‬ﻤﺨﺼﺼﺔ‬
‫ﻟﻺﺴﻨﺎﺩ ﻟﻤﺘﺤﻭل‪ ; ،‬ﻟﻨﻬﺎﻴﺔ ﺍﻟﺘﻌﻠﻴﻤﺔ‪........(..‬‬
‫ﻭﺒﺎﻟﻁﺒﻊ ﻴﺴﺘﺨﺩﻡ ﺍﻟﻔﺭﺍﻍ ﻟﻠﻔﺼل ﺒﻴﻥ ﺍﻟﻜﻠﻤﺎﺕ ﻓﻲ ﺍﻟﻠﻐﺔ )ﺍﻟﻜﻠﻤﺎﺕ ﺍﻟﻤﻔﺘﺎﺤﻴﺔ ﻭﺃﺴﻤﺎﺀ ﺍﻟﻤﺘﺤﻭﻻﺕ‪،‬‬
‫ﻼ(‪.‬‬
‫ﻭﺃﺴﻤﺎﺀ ﺍﻷﻨﻤﺎﻁ ﻤﺜ ﹰ‬
‫ﻭﺍﻟﻘﺎﻋﺩﺓ ﺍﻟﻌﺎﻤﺔ ﺃﻨﻪ ﻓﻲ ﺍﻟﻤﻜﺎﻥ ﺍﻟﺫﻱ ﻴﻭﻀﻊ ﻓﻴﻪ ﻓﺭﺍﻍ‪ ،‬ﻴﻤﻜﻨﻙ ﻭﻀﻊ ﺍﻟﻌﺩﺩ ﺍﻟﺫﻱ ﺘﺭﻴﺩ ﻤﻥ‬

‫‪6‬‬
 ‫ﻤﺜل ﺃﻱ ﻓﺭﺍﻍ ﺃﻭ ﻤﺠﻤﻭﻋﺔ ﻓﺭﺍﻏﺎﺕ‪.‬‬ ‫‪tab‬‬ ‫ﺍﻟﻔﺭﺍﻏﺎﺕ‪ ،‬ﻭﺘﻘﺒل ﻤﻌﻅﻡ ﺍﻟﻤﺘﺭﺠﻤﺎﺕ ﻋﻼﻤﺔ ﺍﻟﺠﺩﻭﻟﺔ‬
‫ﻭﺍﻟﻘﺎﻋﺩﺓ ﻨﻔﺴﻬﺎ ﺘﻨﻁﺒﻕ ﻋﻠﻰ ﻨﻬﺎﻴﺔ ﺍﻟﺴﻁﺭ‪ ،‬ﻓﻔﻲ ﺍﻟﻤﻜﺎﻥ ﺍﻟﺫﻱ ﺘﻭﻀﻊ ﻓﻴﻪ ﻨﻬﺎﻴﺔ ﻟﻠﺴﻁﺭ ﻴﻤﻜﻨﻙ‬
‫ﺇﻀﺎﻓﺔ ﺍﻟﻌﺩﺩ ﺍﻟﺫﻱ ﺘﺭﻴﺩ ﻤﻥ ﺍﻷﺴﻁﺭ ﺍﻟﻔﺎﺭﻏﺔ‪.‬‬
‫ﻨﺴﺘﻔﻴﺩ ﻤﻥ ﻋﺩﻡ ﺘﻘﻴﻴﺩ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﻟﻨﺎ ﺒﻌﺩﺩ ﻤﺤﺩﺩ ﻤﻥ ﺍﻟﻔﺭﺍﻏﺎﺕ ﻭﺍﻷﺴﻁﺭ ﺍﻟﻔﺎﺭﻏﺔ‪ ،‬ﻟﻭﻀﻊ‬
‫ﺍﻟﺘﻨﺴﻴﻕ ﺍﻟﺫﻱ ﻨﺭﻴﺩ ﻟﺒﺭﺍﻤﺠﻨﺎ‪ ،‬ﻟﺯﻴﺎﺩﺓ ﻭﻀﻭﺡ ﻗﺭﺍﺀﺓ ﺍﻟﻨﺹ ﺍﻟﺒﺭﻤﺠﻲ‪ ،‬ﻭﺨﺼﻭﺼﹰﺎ ﻤﺎ ﻴﺘﻌﻠﻕ‬
‫ﺒﺈﻅﻬﺎﺭ ﺍﻟﺒﻨﻴﺔ ﺍﻟﻤﻬﻴﻜﻠﺔ ﻟﻠﺘﻌﻠﻴﻤﺎﺕ ﻭﻁﺭﻴﻘﺔ ﺘﺩﺍﺨﻠﻬﺎ‪ ،‬ﺤﻴﺙ ﻨﻀﻊ ﺍﻟﻔﺭﺍﻏﺎﺕ ﻟﺘﺤﺩﻴﺩ ﺍﻟﻤﺤﺎﺫﺍﺓ‬
‫ﻼ ﺒﻴﻥ ﺍﻟﺨﻁﻭﺍﺕ ﺍﻟﺭﺌﻴﺴﺔ ﺍﻟﻤﻜﻭﻨﺔ ﻟﺤﻠﻨﺎ‬
‫ﺍﻟﻤﻨﺎﺴﺒﺔ‪ .‬ﻜﻤﺎ ﻴﻤﻜﻨﻨﺎ ﻭﻀﻊ ﺃﺴﻁﺭﹰﺍ ﻓﺎﺭﻏﺔ ﺘﺸﻜل ﻓﻭﺍﺼ ﹰ‬
‫)ﻟﺒﺭﻨﺎﻤﺠﻨﺎ(‪.‬‬

‫ﺍﻟﺘﻌﺒﻴﺭ ﻋﻥ ﺍﻟﻘﻴﻡ ﺍﻟﺜﺎﺒﺘﺔ ﻓﻲ ﺍﻟﻠﻐﺔ‬

‫‪ .‬ﻭﺇﺴﻨﺎﺩ‬ ‫‪150‬‬ ‫ﻼ ﻨﻜﺘﺏ ﺍﻟﻌﺩﺩ ﺍﻟﺼﺤﻴﺢ‬
‫ﻨﺴﺘﺨﺩﻡ ﻓﻲ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻷﻋﺩﺍﺩ ﺒﺸﻜل ﻁﺒﻴﻌﻲ‪ ،‬ﻓﻤﺜ ﹰ‬
‫;‪i = 150‬‬ ‫ﺇﻟﻰ ﺍﻟﻤﺘﺤﻭل ‪ ،i‬ﻜﺘﺒﻨﺎﻩ ﺒﺸﻜل ﻁﺒﻴﻌﻲ‪:‬‬ ‫‪150‬‬ ‫ﺍﻟﻌﺩﺩ‬
‫ﻫﻭ ﻤﺘﺤﻭل‪ ،‬ﻭﺒﺎﻟﺘﺎﻟﻲ ﻟﻪ ﻨﻤﻁ ﻤﻌﻴﻥ‪ ،‬ﻭﻟﻴﻜﻥ ﻫﻨﺎ ﻫﻭ ﻨﻤﻁ ﻋﺩﺩ ﺼﺤﻴﺢ‪ .‬ﻓﻨﻘﻭل ﻓﻲ ﻟﻐﺎﺕ‬ ‫‪i‬‬ ‫ﻭﻟﻜﻥ‬
‫ﻤﻥ ﻨﻤﻁ ﻋﺩﺩ ﺼﺤﻴﺢ‪.‬‬ ‫‪constant‬‬ ‫ﻫﻭ ﺜﺎﺒﺕ‬ ‫‪150‬‬ ‫ﺍﻟﺒﺭﻤﺠﺔ ﺃﻥ‬
‫ﻓﻬﺫﻩ‬ ‫‪150. 150.0, 15E1, 1.5E2‬‬ ‫ﻭﺫﻜﺭﻨﺎ ﺒﺸﻜل ﻁﺒﻴﻌﻲ ﺃﻥ ﺍﻷﻋﺩﺍﺩ ﺍﻟﺤﻘﻴﻘﻴﺔ ﻴﻤﻜﻥ ﻜﺘﺎﺒﺘﻬﺎ‪:‬‬
‫ﺃﺸﻜﺎل ﻤﻥ ﺍﻟﺘﻌﺒﻴﺭ ﻋﻥ ﺍﻟﻘﻴﻡ ﺍﻟﺜﺎﺒﺘﺔ ﺍﻟﺘﻲ ﻨﺘﻌﺎﻤل ﻤﻌﻬﺎ ﻋﻨﺩﻤﺎ ﻨﺘﻌﺎﻤل ﻤﻊ ﺍﻟﻤﺘﺤﻭﻻﺕ ﻭﺍﻟﺘﻌﺎﺒﻴﺭ‬
‫ﺍﻟﺤﺴﺎﺒﻴﺔ ﺍﻟﻌﺩﺩﻴﺔ ﺍﻟﺤﻘﻴﻘﻴﺔ‪.‬‬
‫ﺘﺘﻴﺢ ﻋﺩﺓ ﺃﻨﻭﺍﻉ ﻟﻸﻨﻤﺎﻁ ﺍﻟﻌﺩﺩﻴﺔ ﺍﻟﺼﺤﻴﺤﺔ ﻤﻨﻬﺎ ﻭﺍﻟﺤﻘﻴﻘﻴﺔ‪ ،‬ﻟﺫﻟﻙ‬ ‫‪C, Java‬‬ ‫ﺇﻥ ﺒﻌﺽ ﺍﻟﻠﻐﺎﺕ ﻤﺜل‬
‫ﻴﻤﻜﻥ ﺃﻥ ﻨﺤﺩﺩ ﺒﺩﻗﺔ ﺍﻟﻨﻤﻁ ﺍﻟﻌﺩﺩﻱ ﻟﻠﺜﺎﺒﺕ‪ ،‬ﻋﻥ ﻁﺭﻴﻕ ﺇﻀﺎﻓﺔ ﺤﺭﻑ ﻓﻲ ﺁﺨﺭ ﺍﻟﺜﺎﺒﺕ‪.‬‬
‫ﺃﻤﺜﻠﺔ‪:‬‬
‫‪float‬‬ ‫ﻷﺸﻴﺭ ﺃﻥ ﺍﻟﺜﺎﺒﺕ ﻫﻭ ﻤﻥ ﺍﻟﻨﻤﻁ ﺍﻟﻌﺩﺩﻱ ﺍﻟﺤﻘﻴﻘﻲ‬ ‫‪150.0f‬‬

‫‪double‬‬ ‫ﻷﺸﻴﺭ ﺃﻥ ﺍﻟﺜﺎﺒﺕ ﻫﻭ ﻤﻥ ﺍﻟﻨﻤﻁ ﺍﻟﻌﺩﺩﻱ ﺍﻟﺤﻘﻴﻘﻲ‬ ‫‪150.0d‬‬

‫‪long‬‬ ‫ﻷﺸﻴﺭ ﺃﻥ ﺍﻟﺜﺎﺒﺕ ﻫﻭ ﻤﻥ ﺍﻟﻨﻤﻁ ﺍﻟﻌﺩﺩﻱ ﺍﻟﺼﺤﻴﺢ‬ ‫‪150l‬‬

‫‪comments‬‬ ‫ﺍﻟﺘﻌﻠﻴﻘﺎﺕ‬
‫ﺘﺘﻴﺢ ﺠﻤﻴﻊ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺇﻤﻜﺎﻥ ﻭﻀﻊ ﺘﻌﻠﻴﻕ ﻓﻲ ﺍﻟﻨﺹ ﺍﻟﺒﺭﻤﺠﻲ‪ ،‬ﻭﻫﻭ ﻋﺒﺎﺭﺓ ﻋﻥ ﻨﺹ ﻴﻀﻌﻪ‬
‫ﺍﻟﻤﺒﺭﻤﺞ ﻟﻴ‪‬ﻌﻠﱢﻕ ﻋﻠﻰ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺸﺎﺭﺤﹰﺎ ﻭﻤﻭﻀﺤ ﹰﺎ‪ .‬ﻫﺫﺍ ﺍﻟﻨﺹ ﺍﻟﺘﻌﻠﻴﻕ ﻴﺘﺠﺎﻫﻠﻪ ﺍﻟﺤﺎﺴﻭﺏ‬
‫)ﺍﻟﻤﺘﺭﺠﻡ(‪ ،‬ﻴﻤﻜﻨﻙ ﺃﻥ ﺘﻜﺘﺏ ﺒﻪ ﻤﺎ ﺘﺸﺎﺀ‪ ،‬ﻟﻜﻥ ﺍﻟﺘﻌﻠﻴﻘﺎﺕ ﻤﻔﻴﺩﺓ ﺠﺩﹰﺍ ﻟﻔﻬﻡ ﺍﻟﻨﺹ ﺍﻟﺒﺭﻤﺠﻲ ﻋﻨﺩ‬
‫ﻤﺭﺍﺠﻌﺘﻪ ﻤﻥ ﻗﺒل ﺍﻟﻤﺒﺭﻤﺞ ﻨﻔﺴﻪ ﺃﻭ ﻤﻥ ﻗﺒل ﺍﻵﺨﺭﻴﻥ‪.‬‬
‫‪:‬‬ ‫‪ C‬ﻭ‪Java‬‬ ‫ﻓﻲ‬
‫ﻴﺄﺨﺫ ﺍﻟﺘﻌﻠﻴﻕ ﺃﺤﺩ ﺸﻜﻠﻴﻥ‪:‬‬

‫‪7‬‬
 ‫ﺘﺠﻌل ﺍﻟﻨﺹ ﺍﻟﺒﺭﻤﺠﻲ ﺍﺒﺘﺩﺍ ‪‬ﺀ ﻤﻨﻬﺎ ﺤﺘﻰ ﻨﻬﺎﻴﺔ ﺍﻟﺴﻁﺭ ﺘﻌﻠﻴﻘ ﹰﺎ‬ ‫‪//‬‬

‫ﻨﻬﺎﻴﺔ ﺍﻟﺘﻌﻠﻴﻕ‪.‬‬ ‫‪*/‬‬ ‫ﺒﺩﺍﻴﺔ ﺍﻟﺘﻌﻠﻴﻕ‪،‬‬ ‫*‪/‬‬

‫ﺃﻤﺜﻠﺔ‪:‬‬
‫‪// solution of second degree equation‬‬

‫‪a = b = c = 0; // variables initialisation‬‬

‫*‪/‬‬
‫‪a.x.x + b.x + c = 0‬‬
‫‪*/‬‬
‫ﻤﻼﺤﻅﺔ ﻫﺎﻤﺔ‪:‬‬
‫ﻴﻤﻜﻨﻨﺎ ﺍﻻﺴﺘﻔﺎﺩﺓ ﻤﻥ ﺇﻤﻜﺎﻨﻴﺔ ﺍﻟﺘﻌﻠﻴﻕ ﻜﺜﻴﺭﹸﺍ ﺃﺜﻨﺎﺀ ﺍﺨﺘﺒﺎﺭﻨﺎ ﻭﻤﻼﺤﻘﺘﻨﺎ ﻟﺘﻌﻠﻴﻤﺎﺕ ﺒﺭﻨﺎﻤﺠﻨﺎ‪ ،‬ﻭﺫﻟﻙ‬
‫ﺒﺘﺤﻴﻴﺩ ﺒﻌﺽ ﺍﻟﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺒﺭﻤﺠﻴﺔ ﻭﺍﻻﺨﺘﺒﺎﺭ ﺒﺩﻭﻨﻬﺎ ﺃﻭ ﺒﺒﺩﻴل ﻋﻨﻪ ﻭﺫﻟﻙ"ﺒﺘﻌﻠﻴﻘﻬﺎ" ﺜﻡ ﺇﻋﺎﺩﺘﻬﺎ‬
‫ﺒﺤﺫﻑ ﺍﻟﺘﻌﻠﻴﻕ‪.‬‬
‫ﻤﺜﺎل‪:‬‬
‫; ‪a = (x+y)/b‬‬
‫ﻭ ﺃﻥ ﺃﺒﻘﻰ ﻤﺘﺫﻜﺭﹰﺍ ﻟﻠﺘﻌﻠﻴﻤﺔ ﺍﻷﺼﻠﻴﺔ‪.‬‬ ‫;‪a = x+y/b‬‬ ‫ﺃﺭﻴﺩ ﺃﻥ ﺃﺠﺭﺏ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺒﺩﻴﻠﺔ‬
‫ﺃﺠﻌل ﺍﻟﻨﺹ ﺍﻟﺒﺭﻤﺠﻲ ﻋﻠﻰ ﺍﻟﻨﺤﻭ ﺍﻟﺘﺎﻟﻲ ﻭﺃﺨﺘﺒﺭﻩ‪:‬‬
‫; ‪// a = (x+y)/b‬‬
‫;‪a = x+y/b‬‬
‫ﺃﻨﻤﺎﻁ ﺍﻟﻤﺘﺤﻭﻻﺕ‬
‫ﺘﺘﻴﺢ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﻋﺩﺓ ﺃﻨﻤﺎﻁ ﻤﻥ ﺍﻟﻤﻌﻁﻴﺎﺕ‪ .‬ﻨﻤﻴﺯ ﻓﻴﻬﺎ ﺒﻴﻥ‪:‬‬
‫ﺍﻷﻨﻤﺎﻁ ﺍﻟﺒﺴﻴﻁﺔ‪ :‬ﻭﺘﺘﻀﻤﻥ ﺍﻷﻨﻤﺎﻁ ﺍﻟﻌﺩﺩﻴﺔ ﻭﺍﻟﺤﺭﻓﻴﺔ ﻭﺍﻟﻤﻨﻁﻘﻴﺔ‪.‬‬
‫ﺍﻷﻨﻤﺎﻁ ﺍﻟﻤﺭﻜﺒﺔ‪ :‬ﻭﺘﺘﻀﻤﻥ ﺒﺸﻜل ﺃﺴﺎﺴﻲ ﺍﻟﺴﻼﺴل ﺍﻟﺤﺭﻓﻴﺔ ﻭﺍﻟﺠﺩﺍﻭل )ﺃﻭ ﺍﻟﻤﺼﻔﻭﻓﺎﺕ(‪،‬‬
‫ﻭﺍﻟﺘﺴﺠﻴﻼﺕ‪ ،‬ﻭﺍﻟﺼﻔﻭﻑ ﻓﻲ ﺍﻟﻠﻐﺎﺕ ﻏﺭﻀﻴﺔ ﺍﻟﺘﻭﺠﻪ‪.‬‬

‫ﺃﻨﻤﺎﻁ ﺍﻟﻤﺘﺤﻭﻻﺕ‪ ،‬ﺍﻷﻨﻤﺎﻁ ﺍﻟﻌﺩﺩﻴﺔ‬

‫ﺒﺎﻟﻁﺒﻊ‪ ،‬ﺘﻘﺩﻡ ﺠﻤﻴﻊ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﻟﻨﺎ ﺃﻨﻤﺎﻁﹰﺎ ﻋﺩﺩﻴﺔ‪ ،‬ﻭﻟﻜﻨﻬﺎ ﺘﺨﺘﻠﻑ ﻜﺜﻴﺭﹰﺍ ﻋﻥ ﺒﻌﻀﻬﺎ ﻓﻲ‬
‫ﺃﺼﻨﺎﻑ ﻫﺫﻩ ﺍﻷﻨﻤﺎﻁ ﺍﻟﺘﻲ ﺘﺘﻴﺤﻬﺎ‪ .‬ﻨﻤﻴﺯ ﺒﻴﻥ ﺍﻷﻨﻤﺎﻁ ﺍﻟﻌﺩﺩﻴﺔ ﻨﻤﻁﻴﻥ‪:‬‬
‫ﻨﻤﻁ ﻋﺩﺩ ﺼﺤﻴﺢ‬ ‫•‬

‫ﻨﻤﻁ ﻋﺩﺩ ﺤﻘﻴﻘﻲ‬ ‫•‬

‫ﻟﻜﻥ ﺘﺫﻜﺭ ﺃﻨﻨﺎ ﺍﻵﻥ ﺃﻤﺎﻡ ﺍﻷﻋﺩﺍﺩ ﻓﻲ ﺍﻟﺤﺎﺴﻭﺏ ﻭﻟﻴﺱ ﺍﻷﻋﺩﺍﺩ ﻓﻲ ﺍﻟﺭﻴﺎﻀﻴﺎﺕ ﺤﻴﺙ ﻨﻘﻭل ﻓﻲ‬
‫ﺍﻷﻋﺩﺍﺩ ﺍﻟﺼﺤﻴﺤﺔ ‪ :‬ﻨﺎﻗﺹ ﻻﻨﻬﺎﻴﺔ ﺇﻟﻰ ﺯﺍﺌﺩ ﻻﻨﻬﺎﻴﺔ‪ ،‬ﻭ ﻨﻘﻭل ﻓﻲ ﺍﻷﻋﺩﺍﺩ ﺍﻟﺤﻘﻴﻘﻴﺔ‪ :‬ﻋﺩﺩ ﺤﻘﻴﻘﻲ‬
‫ﻏﻴﺭ ﻤﻨﺘﻬﻲ ) ﻟﻪ ﻋﺩﺩ ﻏﻴﺭ ﻤﻨﺘﻪ ﻤﻥ ﺍﻷﺭﻗﺎﻡ ﺒﻌﺩ ﺍﻟﻔﺎﺼﻠﺔ ﻜﺎﻟﻌﺩﺩ ‪ .(PI‬ﻟﺫﻟﻙ ﺘﺨﺘﻠﻑ ﺍﻷﻨﻤﺎﻁ‬
‫ﺍﻟﻌﺩﺩﻴﺔ ﺍﻟﺘﻲ ﺘﺘﻴﺤﻬﺎ ﻜل ﻟﻐﺔ‪ ،‬ﻭﺃﻨﻭﺍﻉ ﻫﺫﻩ ﺍﻷﻨﻤﺎﻁ ﻓﻲ ﺍﻟﻠﻐﺔ ﺘﺒﻌﹰﺎ ﻟﻠﺤﺠﻡ )ﺃﻭ ﻟﻌﺩﺩ ﺨﺎﻨﺎﺕ ﺍﻟﺫﺍﻜﺭﺓ(‬

‫‪8‬‬
 ‫ﺍﻟﺘﻲ ﻴ‪‬ﻜﺭ‪‬ﺱ ﻟﻜل ﻨﻤﻁ‪.‬‬

‫ﺃﻤﺜﻠﺔ‬
‫‪:Pascal‬‬
‫‪real‬‬ ‫ﻭ ﻨﻤﻁ ﺤﻘﻴﻘﻲ ﻭﺤﻴﺩ‬ ‫‪integer‬‬ ‫ﻨﻤﻁ ﺼﺤﻴﺢ ﻭﺤﻴﺩ‬
‫ﺍﻟﺤﺠﻡ‪ :‬ﻏﻴﺭ ﻤﺤﺩﺩ ﻭﻴﺘﺭﻙ ﻟﻤﺘﺭﺠﻡ ﺍﻟﻠﻐﺔ‪.‬‬
‫‪:C‬‬
‫‪ .‬ﻭﻟﻜﻥ ﺘﺘﻴﺢ ﺠﻤﻴﻊ ﺍﻷﻨﻭﺍﻉ ﺍﻟﺘﻲ ﺘﺭﻴﺩﻫﺎ‪ .‬ﺤﺴﺏ‬ ‫‪int‬‬ ‫ﺍﻷﻨﻤﺎﻁ ﺍﻟﺼﺤﻴﺤﺔ ﻜﻠﻬﺎ ﺘﻤﻠﻙ ﺍﺴﻡ ﺍﻟﻨﻤﻁ‬
‫ﺍﻟﻜﻠﻤﺔ )ﺍﻟﻨﻤﻁ( ﻜﻤﺎ ﻴﻠﻲ‪:‬‬
‫‪ :‬ﻋﺩﺩ ﺼﺤﻴﺢ ﺼﻐﻴﺭ‪.‬‬ ‫‪short‬‬

‫‪ :‬ﻋﺩﺩ ﺼﺤﻴﺢ ﻜﺒﻴﺭ‪.‬‬ ‫‪long‬‬

‫‪ :‬ﻋﺩﺩ ﺼﺤﻴﺢ ﻤﻭﺠﺏ‪.‬‬ ‫‪unsigned‬‬

‫ﺍﻷﻨﻤﺎﻁ ﺍﻟﺤﻘﻴﻘﻴﺔ‪:‬‬
‫‪ :‬ﻋﺩﺩ ﺤﻘﻴﻘﻲ ﻤﺤﺩﻭﺩ ﺍﻟﺩﻗﺔ‪.‬‬ ‫‪float‬‬

‫‪ :‬ﻋﺩﺩ ﺤﻘﻴﻘﻲ ﺫﻭ ﺩﻗﺔ ﻜﺒﻴﺭﺓ‪.‬‬ ‫‪double‬‬

‫ﺍﻟﺤﺠﻡ‪ :‬ﻏﻴﺭ ﻤﺤﺩﺩ ﻭﻴﺘﺭﻙ ﻟﻤﺘﺭﺠﻡ ﺍﻟﻠﻐﺔ‪.‬‬ ‫‪C‬‬ ‫ﻓﻲ ﻟﻐﺔ‬

‫‪:Fortran‬‬
‫ﺘﺘﻴﺢ ﺃﻨﻤﺎﻁ ﻤﺨﺘﻠﻔﺔ ﻟﻸﻋﺩﺍﺩ ﺍﻟﺼﺤﻴﺤﺔ ﻭ ﺍﻟﺤﻘﻴﻘﻴﺔ ‪ ،‬ﺒل ﺘﺘﻴﺢ ﺃﻴﻀﹰﺎ ﻨﻤﻁ ﺍﻷﻋﺩﺍﺩ ﺍﻟﻌﻘﺩﻴﺔ‬
‫‪.COMLEX‬‬
‫‪:Java‬‬
‫‪byte, short, int, long‬‬ ‫ﺍﻷﻨﻤﺎﻁ ﺍﻟﺼﺤﻴﺤﺔ‪:‬‬
‫‪float, double‬‬ ‫ﺍﻷﻨﻤﺎﻁ ﺍﻟﺤﻘﻴﻘﻴﺔ‪:‬‬
‫ﺍﻟﺤﺠﻡ‪ :‬ﻤﺤﺩﺩ ﺒﺸﻜل ﻗﻴﺎﺴﻲ ﻓﻲ ﻟﻐﺔ ‪ .Java‬ﻭﻫﻨﺎ ﺃﺤﺩ ﺍﻻﻤﺘﻴﺎﺯﺍﺕ ﺍﻟﺭﺍﺌﻌﺔ ﻟﻬﺫﻩ ﺍﻟﻠﻐﺔ ﺍﻟﺤﺩﻴﺜﺔ‪.‬‬
‫>> ﺍﻨﻅﺭ ﺠﺩﻭل ﺍﻷﻨﻤﺎﻁ ﺍﻟﺒﺴﻴﻁﺔ ﻓﻲ ‪<<Java‬‬
‫‪Primitive type‬‬ ‫‪Size‬‬ ‫‪Minimum‬‬ ‫‪Maximum‬‬
‫‪boolean‬‬ ‫‪1-bit‬‬ ‫‪-‬‬ ‫‪-‬‬
‫‪16‬‬
‫‪char‬‬ ‫‪16-bit‬‬ ‫‪Unicode0‬‬ ‫‪Unicode 2 -1‬‬
‫‪byte‬‬ ‫‪8-bit‬‬ ‫‪-128‬‬ ‫‪+127‬‬
‫‪short‬‬ ‫‪16-bit‬‬ ‫‪-215‬‬ ‫‪+215-1‬‬
‫‪int‬‬ ‫‪32-bit‬‬ ‫‪-231‬‬ ‫‪+231-1‬‬
‫‪long‬‬ ‫‪64-bit‬‬ ‫‪-263‬‬ ‫‪+263-1‬‬
‫‪float‬‬ ‫‪32-bit‬‬ ‫‪IEEE 754‬‬ ‫‪IEEE 754‬‬
‫‪double‬‬ ‫‪64-bit‬‬ ‫‪IEEE 754‬‬ ‫‪IEEE 754‬‬
‫‪Java‬‬ ‫ﺠﺩﻭل ﺍﻷﻨﻤﺎﻁ ﺍﻟﺒﺴﻴﻁﺔ ) ‪ (primitive types‬ﻓﻲ‬

‫‪9‬‬
 ‫ﺃﻨﻤﺎﻁ ﺍﻟﻤﺘﺤﻭﻻﺕ‪ ،‬ﻨﻤﻁ ﺍﻷﻋﺩﺍﺩ ﺍﻟﺤﻘﻴﻘﻴﺔ‬
‫ﺍﺴﺘﺨﺩﻤﻨﺎ ﺘﺴﻤﻴﺔ ﻨﻤﻁ ﺍﻷﻋﺩﺍﺩ ﺍﻟﺤﻘﻴﻘﺔ ﻜﺘﺭﺠﻤﺔ ﺤﺭﻓﻴﺔ ﻤﻥ ﺍﻻﻨﻜﻠﻴﺯﻴﺔ ‪ ،Real‬ﻭ ﺘﺴﺘﺨﺩﻡ ﺍﻟﻜﻠﻤﺔ‬
‫ﺃﻴﻀﹰﺎ ﻟﺘﻌﻨﻲ ﺍﻟﺘﻤﺜﻴل ﻟﻸﻋﺩﺍﺩ ﺍﻟﺤﻘﻴﻘﻴﺔ ﺒﺎﻟﻔﺎﺼﻠﺔ ﺍﻟﻌﺎﺌﻤﺔ‪:‬‬ ‫‪float‬‬

‫= ‪.0.0025 = 0.025 x 10-1‬‬ ‫‪0.25 x 10-2= 0.25E-2‬‬

‫ﻭﻟﻜﻥ ﻜﻤﺎ ﺫﻜﺭﻨﺎ ﺃﻥ ﻫﺫﺍ ﺍﻟﻨﻤﻁ ﻻ ﻴﻤﺜل ﺒﻁﺒﻴﻌﺔ ﺍﻟﺤﺎل ﺍﻟﻌﺩﺩ ﺍﻟﺤﻘﻴﻘﻲ ﺒﺎﻟﻤﻔﻬﻭﻡ ﺍﻟﺭﻴﺎﻀﻲ ﺍﻟﺩﻗﻴﻕ‪،‬‬
‫ﻷﻥ ﺍﻟﻌﺩﺩ ﺍﻟﺤﻘﻴﻘﻲ ﻗﺩ ﻴﻜﻭﻥ ﻏﻴﺭ ﻤﻨﺘﻬﻲ ﺍﻟﺩﻗﺔ ﺒﻤﻌﻨﻰ ﺃﻥ ﻋﺩﺩ ﺍﻷﺭﻗﺎﻡ ﺍﻟﺘﺎﻟﻴﺔ ﻟﻠﻔﺎﺼﻠﺔ ﻏﻴﺭ ﻤﻨﺘﻪ‪.‬‬
‫= ‪ 3.1415926.....‬ﻭﺍﻟﻌﺩﺩ ‪.1/3 = 0.33333333....‬‬ ‫‪PI‬‬ ‫ﻤﺜﺎل‪ :‬ﺍﻟﻌﺩﺩ‬
‫ﺃﻱ ﺘﻤﺜﻴل ﻓﻲ ﺍﻟﺤﺎﺴﻭﺏ ﻫﻭ ﺘﻤﺜﻴل ﻤﻨﺘﻪ‪ ,‬ﻓﺤﺴﺏ ﻁﺭﻴﻘﺔ ﺘﻤﺜﻴل ﺍﻟﻨﻤﻁ ﺍﻟﺤﻘﻴﻘﻲ ﺘﺨﺘﻠﻑ ﺍﻟﺩﻗﺔ‬
‫ﺃﻭ ﻋﺩﺩ ﺍﻷﺭﻗﺎﻡ ﺍﻟﺘﻲ ﻴﺴﺘﻁﻴﻊ ﺍﻟﺤﺎﺴﻭﺏ ﺨﺯﻨﻬﺎ ﺒﻌﺩ ﺍﻟﻔﺎﺼﻠﺔ‪.‬‬ ‫‪precision‬‬

‫ﻭﻫﺫﺍ ﻤﺎ ﻴﻘﻭﺩﻨﺎ ﺇﻟﻰ ﺍﻟﻨﺘﻴﺠﺔ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬

‫ﺍﻟﻤﺴﺎﻭﺍﺓ ﺍﻟﺭﻴﺎﻀﻴﺔ ﻓﻲ ﺤﺎﻟﺔ ﺍﻟﺘﻌﺎﺒﻴﺭ ﺍﻟﺤﺴﺎﺒﻴﺔ ﺍﻟﺤﻘﻴﻘﻴﺔ ﻗﺩ ﺘﺨﺘﻠﻑ ﻋﻥ ﺍﻟﻤﺴﺎﻭﺍﺓ ﺍﻟﺤﺎﺴﻭﺒﻴﺔ‪.‬‬
‫‪3‬‬ ‫= )‪* (1/3‬‬ ‫‪1‬‬ ‫ﺭﻴﺎﻀﻴﹰﺎ‬
‫ﺇﺫﺍ ﻜﺎﻥ ﺘﻤﺜﻴل ﺍﻟﻌﺩﺩ ﺤﺎﺴﻭﺒﻴ ﹰﺎ‬ ‫‪3‬‬ ‫= )‪* (1/3‬‬ ‫‪3‬‬ ‫≠ ‪* 0.333333 = 0.999999‬‬ ‫‪1‬‬ ‫ﺒﻴﻨﻤﺎ ﺤﺎﺴﻭﺒﻴﺎ‪:‬‬
‫ﻴﺴﻤﺢ ﺒﺴﺕ ﺨﺎﻨﺎﺕ ﻋﺸﺭﻴﺔ ﺒﻌﺩ ﺍﻟﻔﺎﺼﻠﺔ ﻓﻘﻁ‪.‬‬
‫ﻭﺒﺎﻟﺘﺎﻟﻲ ﻴﺠﺏ ﺍﻻﻨﺘﺒﺎﻩ ﺇﻟﻰ ﺘﺠﻨﺏ ﺍﺴﺘﺨﺩﺍﻡ ﻤﻘﺎﺭﻨﺔ ﺍﻟﻤﺴﺎﻭﺍﺓ ﻓﻲ ﺤﺎﻟﺔ ﺍﻷﻋﺩﺍﺩ ﺍﻟﺤﻘﻴﻘﻴﺔ‬
‫ﻭﺍﻻﺴﺘﻌﺎﻀﺔ ﺒﻤﻘﺎﺭﻨﺔ ﺍﻟﺘﻘﺭﻴﺏ ﺍﻟﺫﻱ ﻨﺭﻴﺩﻩ ﻓﻲ ﻤﺴﺄﻟﺘﻨﺎ‪.‬‬
‫ﻫﺫﻩ ﺍﻟﻤﻼﺤﻅﺔ ﻫﺎﻤﺔ ﻋﻠﻰ ﺼﻌﻴﺩ ﺍﻟﺘﻘﺭﻴﺒﺎﺕ ﺍﻟﺤﺴﺎﺒﻴﺔ ﺍﻟﻤﺭﺍﻓﻘﺔ ﻟﻠﺤﺴﺎﺏ ﺍﻟﻌﺩﺩﻱ ﺍﻟﺤﺎﺴﻭﺒﻲ‪ ،‬ﻭﻟﻜﻨﻬﺎ‬
‫ﺘﻌﻨﻴﻨﺎ ﻫﻨﺎ ﻷﻥ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻤﺴﺎﻭﺍﺓ ﺒﻴﻥ ﺍﻷﻋﺩﺍﺩ ﺍﻟﺤﻘﻴﻘﻴﺔ ﻗﺩ ﻴﻜﻭﻥ ﻤﺼﺩﺭ ﻷﺨﻁﺎﺀ ﺒﺭﻤﺠﻴﺔ ﺼﻌﺒﺔ‬
‫ﺍﻻﻜﺘﺸﺎﻑ ﻜﺎﻟﺩﺨﻭل ﻓﻲ ﺤﻠﻘﺔ ﻻﻨﻬﺎﺌﻴﺔ ﻨﺘﻴﺠﺔ ﺍﺴﺘﺨﺩﺍﻤﻪ ﻓﻲ ﺸﺭﻁ ﺍﻟﺘﻜﺭﺍﺭ‪ ،‬ﺃﻭ ﻋﺩﻡ ﺘﻨﻔﻴﺫ ﺃﻱ ﻤﻥ‬
‫ﻜﺘﻠﺔ ﺘﻌﻠﻴﻤﺎﺕ ﻓﻲ ﺘﻌﻠﻴﻤﺔ ﺸﺭﻁﻴﺔ‪.‬‬
‫ﺕ ﻤِﺜﻠﹶﻪ"‬
‫ﻭﺍﻨﻁﻼﻗﹰﺎ ﻤﻥ ﺍﻟﻤﺜل ﺍﻟﻘﺎﺌل‪" :‬ﻻ ﺘﹶﻨ ِﻪ ﻋﻥ ﺃﻤ ٍﺭ ﻭﺘﺄ ِ‬
‫ﻓﺈﻥ ﺍﻟﺒﺭﺍﻤﺞ ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺘﻌﻠﻴﻤﻲ ﺍﻟﻤﻌﺭﻭﺽ ﻟﺤل ﻤﻌﺎﺩﻟﺔ ﻤﻥ ﺍﻟﺩﺭﺠﺔ ﺍﻟﺜﺎﻨﻴﺔ‪ ،‬ﺘﺘﻀﻤﻥ ﺍﺨﺘﺒﺎﺭ‬
‫! ﻓﻬل ﻫﺫﻩ ﺍﻟﺒﺭﺍﻤﺞ ﺨﺎﻁﺌﺔ؟‬ ‫)‪if (delta == 0‬‬ ‫‪Java‬‬ ‫ﻴﺴﺎﻭﻱ ﺍﻟﺼﻔﺭ! ﻓﻲ‬ ‫‪delta‬‬ ‫ﺍﻟﻤﺴﺎﻭﺍﺓ!‬
‫ﺒﺎﻟﻁﺒﻊ ﻻ‪ .‬ﺇﻨﻪ ﻤﺜﺎل ﺘﻌﻠﻴﻤﻲ ﺃﻭﻻﹰ‪ ،‬ﻴﻨﻘل ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺔ ﺍﻟﻤﺄﻟﻭﻓﺔ ﺍﻟﺘﻲ ﻨﻌﺭﻓﻬﺎ ﺭﻴﺎﻀﻴ ﹰﺎ ﻜﻤﺎ ﻫﻲ ﺇﻟﻰ‬
‫ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﺴﺘﺨﺩﻤﺔ‪ .‬ﻭ ﻴﻤﻜﻨﻙ ﺍﺨﺘﺒﺎﺭﻩ ﻋﻠﻰ ﺍﻟﻜﺜﻴﺭ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻭﻴﻌﻤل ﻤﻌﻬﺎ ﺒﺸﻜل‬
‫ﺼﺤﻴﺢ‪ .‬ﻭﻟﻜﻨﻪ ﻟﻴﺱ ﺼﺤﻴﺢ ﺒﺎﻟﻤﻁﻠﻕ! ﻓﻬﻭ ﻻ ﻴﻌﻁﻲ ﺍﻟﻨﺘﻴﺠﺔ ﺍﻟﺼﺤﻴﺤﺔ ﻓﻲ ﺤﺎﻟﺔ ﺃﻋﺩﺍﺩ ﺤﻘﻴﻘﻴﺔ‬
‫‪.‬‬ ‫‪1./3‬‬ ‫ﻏﻴﺭ ﻤﻨﺘﻬﻴﺔ‪ .‬ﻤﺜل ﺤﺎﻟﺔ ﺠﺫﺭ ﻤﻀﺎﻋﻑ‬
‫ﺘﻌﻤﺩﻨﺎ ﺇﺒﻘﺎﺀ ﺍﻟﻤﺜﺎل ﻜﻤﺎ ﻫﻭ ﻟﺴﺒﺒﻴﻥ‪:‬‬
‫ﻜﺜﻴﺭﹰﺍ ﻤﺎ ﻴ‪‬ﻌﻁﻰ ﻜﺒﺭﻨﺎﻤﺞ ﺘﻌﻠﻴﻤﻲ‪ ،‬ﻓﺎﻟﺨﻭﺍﺭﺯﻤﻴﺔ ﻓﻴﻪ ﺴﻬﻠﺔ ﻭﻤﺄﻟﻭﻓﺔ‪ ،‬ﻭﺍﻟﺘﻁﺒﻴﻕ ﺍﻟﺤﺴﺎﺒﻲ ﺍﻟﺫﻱ ﻴﻘﺩﻤﻪ‬ ‫•‬

‫ﺍﻟﺒﺭﻨﺎﻤﺞ ﻤﻔﻴﺩ‪.‬‬

‫‪10‬‬
‫ﺃﺭﺩﻨﺎ ﺃﻥ ﻨﻠﻔﺕ ﺍﻟﻨﻅﺭ ﻤﻨﺫ ﺍﻟﺒﺩﺍﻴﺔ‪ ،‬ﻭﻫﺫﺍ ﺭﺒﻤﺎ ﻻ ﺘﺸﺩﺩ ﻋﻠﻴﻪ ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﻜﺘﺏ ﺘﻌﻠﻴﻡ ﺍﻟﺒﺭﻤﺠﺔ ﻟﻠﻤﺒﺘﺩﺌﻴﻥ‬ ‫•‬

‫ﻜﺜﻴﺭﺍﹰ‪ ،‬ﺃﻨﻪ ﻴﺠﺏ ﺍﻻﻨﺘﺒﺎﻩ ﻜﺜﻴﺭﹰﺍ ﻋﻨﺩﻤﺎ ﻴﺘﻌﻠﻕ ﺍﻷﻤﺭ ﺒﺎﻟﺤﺴﺎﺒﺎﺕ ﺍﻟﻌﺩﺩﻴﺔ ﻓﻲ ﺍﻟﺤﺎﺴﻭﺏ‪ .‬ﻭﺍﻻﻨﺘﻘﺎل ﻤﻥ‬
‫ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺔ ﺇﻟﻰ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ ﻟﻴﺱ ﻤﺒﺎﺸﺭﹰﺍ ﺒل ﻴﺤﺘﺎﺝ ﺇﻟﻰ ﺘﺩﻗﻴﻕ‪ .‬ﺇﻟﻴﻙ ﻤﺜﺎل ﺁﺨﺭ ﻋﻥ ﻫﺫﺍ‪ ،‬ﻓﻲ ﻟﻐﺔ‬
‫‪0.25‬‬ ‫ﺘﺴﺎﻭﻱ‬ ‫‪1./4‬‬ ‫ﺘﺴﺎﻭﻱ ﺍﻟﺼﻔﺭ ﻷﻨﻬﺎ ﺘﻌﺘﺒﺭ ﻗﺴﻤﺔ ﻀﻤﻥ ﺍﻷﻋﺩﺍﺩ ﺍﻟﺼﺤﻴﺤﺔ‪ ،‬ﺒﻴﻨﻤﺎ‬ ‫‪1/4 :C‬‬ ‫ﻭ‬ ‫‪Java‬‬

‫ﻷﻨﻬﺎ ﺘﻌﺘﺒﺭ ﻗﺴﻤﺔ ﺤﻘﻴﻘﻴﺔ!‬

‫ﺴﻨﻁﻠﺏ ﻤﻨﻙ ﺒﺎﻟﺘﻤﺎﺭﻴﻥ ﻭﻀﻊ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﺼﺤﻴﺢ ﺒﺎﻟﻤﻁﻠﻕ‪ ،‬ﻋﻨﺩﻤﺎ ﻨﻁﻠﺏ ﻤﻨﻙ ﺍﻟﺤل ﺍﻟﻌﺎﻡ ﻟﺤل‬
‫ﻤﻌﺎﺩﻟﺔ ﺍﻟﺩﺭﺠﺔ ﺍﻟﺜﺎﻨﻴﺔ ﻭﻜﺘﺎﺒﺔ ﺍﻟﺠﺫﻭﺭ ﺍﻟﻌﻘﺩﻴﺔ ﺃﻴﻀﹰﺎ‪.‬‬
‫ﺇﺫﺍ ﻜﻨﺎ ﻓﻲ ﻤﺴﺄﻟﺘﻨﺎ ﻨﻌﺘﺒﺭ ﺃﻥ ﻋﺩﺩﻴﻥ )ﻤﻥ ﻨﻤﻁ ﺤﻘﻴﻘﻲ( ﻤﺘﺴﺎﻭﻴﺎﻥ ﺇﺫﺍ ﻜﺎﻥ ﺍﻟﻔﺭﻕ ﺒﻴﻨﻬﻤﺎ ﻤﻥ ﻤﺭﺘﺒﺔ‬
‫ﺼﻐﻴﺭﺓ ﻭﻟﺘﻜﻥ ‪ 0.000001‬ﻋﻨﺩﻫﺎ‪:‬‬
‫‪B‬‬ ‫ﻴﺴﺎﻭﻱ‬ ‫‪A‬‬ ‫ﺒﺩﻻ ﻤﻥ ﺍﻟﻜﺘﺎﺒﺔ ﺍﻟﺒﺭﻤﺠﻴﺔ )ﻓﻲ ﺍﻟﺸﺭﻁ ﻤﺜﻼ( ‪:‬‬
‫ﻨﻜﺘﺏ‪ |A-B | < 0.000001 :‬ﺃﻱ ﺍﻟﻘﻴﻤﺔ ﺍﻟﻤﻁﻠﻘﺔ ﻟﻠﻔﺭﻕ ﺒﻴﻨﻬﻤﺎ ﺼﻐﻴﺭ ﺠﺩﹰﺍ ﺒﺤﻴﺙ ﻨﻌﺘﺒﺭﻫﻤﺎ‬
‫ﻤﺘﺴﺎﻭﻴﺎﻥ ﻓﻲ ﻤﺴﺄﻟﺘﻨﺎ‪.‬‬
‫ﻼ ‪ 10-5‬ﺘﻜﺘﺏ ﻓﻲ ﻤﻌﻅﻡ ﻟﻐﺎﺕ‬
‫ﻨﻨﻭﻩ ﻫﻨﺎ ﺇﻟﻰ ﺇﻤﻜﺎﻨﻴﺔ ﻜﺘﺎﺒﺔ ﺍﻷﻋﺩﺍﺩ ﺍﻟﺤﻘﻴﻘﻴﺔ ﺒﺎﻟﺸﻜل ﺍﻷﺴﻲ‪ :‬ﻤﺜ ﹰ‬
‫ﺍﻟﺒﺭﻤﺠﺔ ﺒﺎﻟﺸﻜل ‪.1.0E-5‬‬

‫ﺍﻟﻌﻤﻠﻴﺎﺕ ﻭﺍﻟﺘﻭﺍﺒﻊ ﺍﻟﺤﺴﺎﺒﻴﺔ‬

‫ﺘﺘﻴﺢ ﻟﻨﺎ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺇﺠﺭﺍﺀ ﺍﻟﻌﻤﻠﻴﺎﺕ ﺍﻟﺤﺴﺎﺒﻴﺔ ﺍﻷﺴﺎﺴﻴﺔ ﻤﻥ ﺠﻤﻊ ﻭﻁﺭﺡ ﻭﻀﺭﺏ ﻭﻗﺴﻤﺔ‬
‫‪Basic‬‬ ‫ﻭ‬ ‫‪Fortran‬‬ ‫ﻼ ﺘﺘﻴﺢ ﻜل ﻤﻥ ﻟﻐﺔ‬
‫)‪ (/,*,-،+‬ﺇﻀﺎﻓﺔ ﺇﻟﻰ ﻋﻤﻠﻴﺎﺕ ﺃﺨﺭﻯ ﺘﺒﻌﹸﺎ ﻟﻠﻐﺔ‪ .‬ﻓﻤﺜ ﹰ‬
‫ﻋﻤﻠﻴﺔ ﺍﻟﺭﻓﻊ ﺇﻟﻰ ﺃﻱ ﻗﻭﻯ ﻜﻌﻤﻠﻴﺔ ﺃﺴﺎﺴﻴﺔ ) ‪ b**2‬ﻭ ‪ ،(b^2‬ﻋﻠﻰ ﺤﻴﻥ ﻻ ﺘﺘﻴﺤﻬﺎ ‪،Pascal‬‬
‫(‪ .‬ﺇﻥ ﺍﻟﻠﻐﺎﺕ ﺘﺨﺘﻠﻑ ﺃﻴﻀﹰﺎ ﺒﺎﻟﺘﻭﺍﺒﻊ ﺍﻟﺤﺴﺎﺒﻴﺔ‬ ‫)‪pow(b,n‬‬ ‫ﻜﺘﺎﺒﻊ ﺠﺎﻫﺯ )ﺍﻟﺘﺎﺒﻊ‬ ‫‪Java‬‬ ‫ﻭﺘﺘﻴﺤﻬﺎ‬
‫ﺍﻟﺠﺎﻫﺯﺓ ﺍﻟﻤﺘﺎﺤﺔ )ﺘﺴﻤﻰ ﺃﻴﻀﺎ ﺍﻟﺘﻭﺍﺒﻊ ﺍﻟﺴﺎﺒﻘﺔ ﺍﻟﺘﻌﺭﻴﻑ ‪.(Predefined functions‬‬
‫ﻓﻲ ‪:Java‬‬
‫‪ ،‬ﻭﻨﺴﺘﺨﺩﻡ ﺍﻟﺘﻭﺍﺒﻊ ﺍﻟﺤﺴﺎﺒﻴﺔ ﺍﻟﻤﺘﺎﺤﺔ‬ ‫‪Math‬‬ ‫ﺍﻟﺘﻭﺍﺒﻊ ﺍﻟﺭﻴﺎﻀﻴﺔ ﻤﺘﺎﺤﺔ ﻋﺒﺭ ﺍﻟﺼﻑ ﺍﻟﺒﺭﻤﺠﻲ‬
‫)‪Math.function(...‬‬ ‫ﺒﺎﻟﺸﻜل‪:‬‬
‫ﻤﺜﺎل‪:‬‬
‫ﺘﺎﺒﻊ ﺍﻟﺠﻴﺏ‪.‬‬ ‫) ‪Math.sin( x‬‬

‫ﺘﺎﺒﻊ ﺍﻟﺭﻓﻊ ﻟﻘﻭﺓ‪.‬‬ ‫) ‪Math.pow( x, n‬‬

‫ﺍﻷﻭﻟﻭﻴﺎﺕ ﺒﻴﻥ ﺍﻟﻌﻤﻠﻴﺎﺕ ﺍﻟﺤﺴﺎﺒﻴﺔ‬

‫ﻨﻘﺼﺩ ﺒﺎﻷﻭﻟﻭﻴﺎﺕ ﺒﻴﻥ ﺍﻟﻌﻤﻠﻴﺎﺕ ﺘﺤﺩﻴﺩ ﺍﻟﻌﻤﻠﻴﺎﺕ ﺍﻟﺤﺴﺎﺒﻴﺔ ﺍﻟﺘﻲ ﺘﻨﻔﺫ ﺃﻭﻻ ﻓﻲ ﺤﺎل ﻋﺩﻡ ﻭﺠﻭﺩ‬
‫ﺃﻗﻭﺍﺱ ﺒﻴﻥ ﺍﻟﻌﻤﻠﻴﺎﺕ‪.‬‬

‫‪11‬‬
 ‫ﻻ ﻭﺇﻻ ﺘﻨﻔﺫ‬
‫ﺍﻟﻘﺎﻋﺩﺓ ﺍﻟﻌﺎﻤﺔ‪ :‬ﺇﺫﺍ ﻜﺎﻥ ﻫﻨﺎﻙ ﺃﻗﻭﺍﺱ ﺘﺤﺴﺏ ﺍﻟﺘﻌﺎﺒﻴﺭ ﺍﻟﺘﻲ ﺘﺘﻀﻤﻨﻬﺎ ﺍﻷﻗﻭﺍﺱ ﺃﻭ ﹰ‬
‫ﺍﻟﻌﻤﻠﻴﺎﺕ ﺍﻟﺤﺴﺎﺒﻴﺔ ﻤﻥ ﺍﻟﻴﺴﺎﺭ ﺇﻟﻰ ﺍﻟﻴﻤﻴﻥ ﺒﺄﺨﺫ ﺍﻷﻭﻟﻭﻴﺎﺕ ﺍﻟﺘﺎﻟﻴﺔ ﺒﻌﻴﻥ ﺍﻻﻋﺘﺒﺎﺭ‪.‬‬
‫ﺍﻷﻭﻟﻭﻴﺔ ﺍﻟﻌﻠﻴﺎ ﻟﻠﻀﺭﺏ ﻭﺍﻟﻘﺴﻤﺔ ﻭﻜﻼﻫﻤﺎ ﻤﺘﺴﺎﻭﻴﺎﻥ ﻓﻲ ﺍﻷﻭﻟﻭﻴﺔ‪.‬‬
‫ﺍﻷﻭﻟﻭﻴﺔ ﺍﻟﺩﻨﻴﺎ ﻟﻠﺠﻤﻊ ﻭﺍﻟﻁﺭﺡ ﻭﻜﻼﻫﻤﺎ ﻤﺘﺴﺎﻭﻴﺎﻥ ﻓﻲ ﺍﻷﻭﻟﻭﻴﺔ‪.‬‬
‫ﻨﻨﺼﺢ ﺒﻭﻀﻊ ﺍﻷﻗﻭﺍﺱ ﻋﻨﺩ ﺍﻟﺘﺭﺩﺩ ﺃﻤﺎﻡ ﻤﻌﺭﻓﺔ ﺍﻷﻭﻟﻭﻴﺎﺕ‪ ،‬ﻭﻟﻜﻥ ﺫﻟﻙ ﻗﺩ ﻴﻌﻘﱢﺩ ﺍﻟﺘﻌﺒﻴﺭ ﺃﺤﻴﺎﻨﹰﺎ ﻤﻥ‬
‫ﺸﻜل ﺍﻟﺘﻌﺒﻴﺭ ﺒﻜﺜﺭﺓ ﺍﻷﻗﻭﺍﺱ ﻭﺯﻴﺎﺩﺓ ﺘﺩﺍﺨﻼﺘﻬﺎ‪ .‬ﻟﺫﻟﻙ ﻻ ﺒ ﱠﺩ ﻤﻥ ﺍﻟﻌﻭﺩﺓ ﺇﻟﻰ ﻗﻭﺍﻋﺩ ﺍﻷﻭﻟﻭﻴﺔ ﺒﻴﻥ‬
‫ﺍﻟﻌﻤﻠﻴﺎﺕ ﻭﺨﺼﻭﺼﹰﺎ ﻓﻲ ﻟﻐﺔ ‪ C‬ﻭ ‪ Java‬ﺍﻟﻠﺘﻴﻥ ﺘﻤﻠﻜﺎﻥ ﻤﻥ ﺍﻟﻌﻤﻠﻴﺎﺕ ﻋﺩﺩﹰﺍ ﺃﻜﺒﺭ ﻭﻤﺘﻨﻭﻉ ﻤﻥ‬
‫ﻤﻌﻅﻡ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﻤﺘﺩﺍﻭﻟﺔ‪ .‬ﻭﻨﻌﻭﺩ ﻟﻠﺘﻨﻭﻴﻪ ﺃﻥ ﻟﻐﺔ ‪ C‬ﻭ ‪ Java‬ﻤﺘﺸﺎﺒﻬﺘﺎﻥ ﺒل ﻤﺘﻁﺎﺒﻘﺘﺎﻥ ﻓﻲ‬
‫ﻤﻌﻅﻡ ﻤﺎ ﻴﺘﻌﻠﻕ ﺒﺎﻟﻌﻤﻠﻴﺎﺕ ﻭ ﺍﻟﺘﻌﺎﺒﻴﺭ‪.‬‬
‫ﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﻘﺭﺍﺀﺓ ﻭﺍﻟﻜﺘﺎﺒﺔ )ﺍﻟﺩﺨل ﻭﺍﻟﺨﺭﺝ( ﻓﻲ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ‬
‫ﻭﺇﻥ ﻜﺎﻨﺕ ﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﻘﺭﺍﺀﺓ ﻭﺍﻟﻜﺘﺎﺒﺔ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻲ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺘﺅﺩﻱ ﺍﻟﻬﺩﻑ ﺍﻷﺴﺎﺴﻲ ﺍﻟﺫﻱ‬
‫ﻋﺭﻓﻨﺎﻩ ﻓﻲ ﻟﻐﺔ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺎﺕ‪،‬ﻭﻫﻭ ﺍﻟﺤﺼﻭل ﻋﻠﻰ ﻤﻌﻁﻴﺎﺕ ﻤﻥ ﻤﺴﺘﺨﺩﻡ ﻭ ﺇﻅﻬﺎﺭ ﺍﻟﻨﺘﺎﺌﺞ ﻟﻪ‪ ،‬ﺇﻻ‬
‫ﺃﻥ ﻁﺭﻴﻘﺔ ﺘﺤﻘﻴﻕ ﺫﻟﻙ ﺘﺨﺘﻠﻑ ﻜﺜﻴﺭﺍﹰ‪ ،‬ﻭﻫﻨﺎﻙ ﺘﻔﺼﻴﻼﺕ ﻜﺜﻴﺭﺓ ﻓﻲ ﺃﻴﺔ ﻟﻐﺔ ﺒﺭﻤﺠﺔ ﺘﺴﺘﺨﺩﻤﻬﺎ‪،‬‬
‫ﻴﻤﻜﻨﻙ ﺘﺭﻙ ﻫﺫﻩ ﺍﻟﺘﻔﺎﺼﻴل ﻟﺘﺘﻌﻠﻤﻬﺎ ﻓﻴﻤﺎ ﺒﻌﺩ‪ .‬ﺇﻥ ﺍﻟﻬﺩﻑ ﻓﻲ ﻫﺫﻩ ﺍﻟﻤﺭﺤﻠﺔ ﻫﻭ ﺍﻟﺘﻤﻜﻥ ﻤﻥ ﺍﺨﺘﺒﺎﺭ‬
‫ﺨﻭﺍﺭﺯﻤﻴﺘﻨﺎ ﻭﺤﻠﻭﻟﻨﺎ ﺒﻠﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ‪ ،‬ﻭﻟﻴﺱ ﺇﻋﻁﺎﺀ ﺒﺭﻨﺎﻤﺞ ﺭﺍﺌﻊ ﺍﻟﺘﻔﺎﻋل ﻭ ﺍﻟﺘﺨﺎﻁﺒﻴﺔ ﻤﻥ ﺴﻬﻭﻟﺔ‬
‫ﺍﻻﺴﺘﺨﺩﺍﻡ ﻭﺠﻤﺎل ﺍﻹﻅﻬﺎﺭ‪.‬‬
‫‪.‬‬ ‫‪Java‬‬ ‫ﻭﺒﺎﻟﺘﺎﻟﻲ ﺴﻨﺸﺭﺡ ﻫﻨﺎ ﻓﻘﻁ ﻤﺎ ﻴﺨﺹ ﻟﻐﺔ ﺍﻟﺒﺭﻤﺠﺔ‬

‫‪Java‬‬ ‫ﺘﻌﻠﻴﻤﺎﺕ ﺍﻟﺨﺭﺝ ﻓﻲ‬ ‫‪-2‬‬

‫ﺍﻹﻅﻬﺎﺭ ﻋﻠﻰ ﻭﺤﺩﺓ ﺍﻟﺨﺭﺝ ﺍﻟﻘﻴﺎﺴﻴﺔ )ﺍﻟﺸﺎﺸﺔ ﺍﻟﺴﻭﺩﺍﺀ "ﺤﺭﻓﻴﺔ"(‬
‫ﺍﻜﺘﺏ “‪" black screen‬‬
‫;) " ‪System.out.println( " black screen‬‬
‫ﻋﻠﻰ ﺍﻟﺸﺎﺸﺔ‪:‬‬
‫‪black screen‬‬
‫ﻤﺜﺎل ‪2‬‬
‫‪"x0=", x0‬‬ ‫ﺍﻜﺘﺏ‬
‫;) ‪System.out.println( "x0=" + x0‬‬
‫ﻋﻠﻰ ﺍﻟﺸﺎﺸﺔ‪:‬‬
‫‪x0= 5.0‬‬
‫ﻤﺜﺎل ‪3‬‬
‫‪"x1=", x1, "x2="+x2‬‬ ‫ﺍﻜﺘﺏ‬
‫;) ‪System.out.println( " x1=" + x1 + " x2=" + x2‬‬
‫ﻋﻠﻰ ﺍﻟﺸﺎﺸﺔ‪:‬‬
‫‪x1= -2.0 x2= 5.0‬‬

‫‪12‬‬
 ‫‪:‬‬ ‫‪println‬‬ ‫ﻴﻭﺠﺩ ﺘﺸﺎﺒﻪ ﻅﺎﻫﺭﻱ ﺒﻴﻥ ﺘﻌﻠﻴﻤﺔ ﺍﻟﻜﺘﺎﺒﺔ ﻓﻲ ﻟﻐﺔ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺎﺕ ﻭ ﺍﻟﺘﻌﻠﻴﻤﺔ‬
‫ﻴﺤل ﻤﻜﺎﻨﻬﺎ ﺇﺸﺎﺭﺓ ‪.+‬‬ ‫‪,‬‬ ‫ﺍﻟﻔﺎﺼﻠﺔ‬
‫‪”x0=”, x0‬‬ ‫ﺍﻜﺘﺏ‬

‫;) ‪System.out.println( "x0=" + x0‬‬

‫ﻟﻴﺴﺕ‬ ‫‪+‬‬ ‫ﻲ ﺃﻥ ﺃﻨﺒﻬﻙ ﺃﻥ‬

‫ﻫﺫﺍ ﺤﺴﻥ‪ ،‬ﻭﻴﺴﻬل ﻋﻠﻴﻨﺎ ﺍﻻﻨﺘﻘﺎل ﺇﻟﻰ ﺘﻌﻠﻴﻤﺔ ﺍﻟﻜﺘﺎﺒﺔ ﻓﻲ ﺍﻟﻠﻐﺔ‪ .‬ﻭﻟﻜﻥ ﻋﻠ ّ‬
‫ﻫﻲ ﻨﺹ ﺃﻱ‬ ‫‪String‬‬ ‫ﺒﻬﺫﻩ ﺍﻟﺒﺭﺍﺀﺓ‪ ،‬ﻓﻬﻲ ﻋﻤﻠﻴﺔ ﻟﻀﻡ ﺴﻠﺴﻠﺘﻴﻥ ﺤﺭﻓﻴﺘﻴﻥ ) ﺍﻟﺴﻠﺴﻠﺔ ﺍﻟﺤﺭﻓﻴﺔ‬
‫"(؛‬ ‫"‬ ‫ﻤﺠﻤﻭﻋﺔ ﺤﺭﻭﻑ ﺘﺤﺎﻁ ﺒﻴﻥ ﺭﻤﺯﻱ ﺇﺸﺎﺭﺓ ﺘﻨﺼﻴﺹ‬

‫‪+‬‬ ‫ﻤﺜﺎل‪ :‬ﻤﺜﺎل ﻋﻠﻰ ﻋﻤﻠﻴﺔ ﻀﻡ ﺴﻠﺴﻠﺘﻴﻥ ﺤﺭﻓﻴﺘﻴﻥ ﺒﺎﺴﺘﺨﺩﺍﻡ‬

‫"! ‪" Java input is difficult‬‬ ‫ﺘﻌﻁﻲ ﺍﻟﺴﻠﺴﻠﺔ ﺍﻟﺤﺭﻓﻴﺔ‪:‬‬ ‫"! ‪" Java input" + " is difficult‬‬

‫‪"x0=" + x0‬‬ ‫ﻭﻟﻜﻥ ﻤﺎﺫﺍ ﻋﻥ ﻀﻡ ﻋﺩﺩ ﺃﻭ ﻤﺘﺤﻭل )ﺃﻭ ﺘﻌﺒﻴﺭ( ﺇﻟﻰ ﺴﻠﺴﻠﺔ ﺤﺭﻓﻴﺔ‪:‬‬
‫ﺘﻤﺜﻴل ﻨﺼﻲ‪ ،‬ﺇﻥ ﻟﻠﻤﺘﺤﻭل ﻤﻥ ﺃﻱ ﻨﻤﻁ ﺇﻅﻬﺎﺭ ﻤﻌﻴﻥ ﻜﺴﻠﺴﻠﺔ‬ ‫‪Java‬‬ ‫ﻓﻲ ﺍﻟﺤﻘﻴﻘﺔ ﻟﻜل ﺸﻲﺀ ﻓﻲ‬
‫ﻀﻤﻨﻴﹰﺎ ﺒﻀﻡ ﻫﺫﻩ ﺍﻟﺴﻠﺴﻠﺔ ﺍﻟﻤﻤﺜﻠﺔ ﻟﻠﻤﺘﺤﻭل ﻋﻨﺩﻤﺎ ﻴﺠﺭﻱ "ﺠﻤﻌﻬﺎ" ﺃﻭ ﻀﻤﻬﺎ‬ ‫‪Java‬‬ ‫ﺤﺭﻓﻴﺔ‪ ،‬ﺘﻘﻭﻡ‬
‫ﺇﻟﻰ ﺴﻠﺴﻠﺔ ﺤﺭﻓﻴﺔ ﻓﻌﻠﻴﺔ ﺒﺎﻟﻌﻤﻠﻴﺔ ‪.+‬‬
‫ﺃﻱ ﺃﻥ‪:‬‬
‫ﻓﻲ ﺤﺎل ﻜﺎﻨﺕ ﻗﻴﻤﺔ ﺍﻟﻤﺘﺤﻭل ﻤﻥ ﻨﻤﻁ ﺤﻘﻴﻘﻲ ﻫﻲ ﺍﻟﻘﻴﻤﺔ‬ ‫"‪"x0= " +"5.0‬‬ ‫ﺘﻜﺎﻓﺊ‬ ‫‪"x0= " + x0‬‬

‫‪x0= 5.0‬‬ ‫ﻭﻫﻲ ﻤﺎ ﻴﻅﻬﺭ ﻋﻠﻰ ﺍﻟﺸﺎﺸﺔ‪:‬‬ ‫"‪"x0= 5.0‬‬ ‫‪ .5‬ﻭﻨﺘﻴﺠﺔ ﺍﻟﻀﻡ ﻫﻲ ﺍﻟﺴﻠﺴﻠﺔ ﺍﻟﺤﺭﻓﻴﺔ‪:‬‬
‫ﺘﻅﻬﺭ ﺴﻠﺴﻠﺘﻬﺎ ﺍﻟﺤﺭﻓﻴﺔ ﻋﻠﻰ ﺍﻟﺩﺨل ﺍﻟﻨﻅﺎﻤﻲ ﻭﻴﻨﺘﻘل ﺇﻟﻰ‬ ‫‪System.out.println‬‬ ‫ﺇﻥ ﺍﻟﺘﻌﻠﻴﻤﺔ‬
‫‪System.out.print‬‬ ‫ﺍﻹﻅﻬﺎﺭ ﺇﻟﻰ ﺴﻁﺭ ﺠﺩﻴﺩ‪ ،‬ﻭﺇﺫﺍ ﺃﺭﺩﻨﺎ ﺒﻘﺎﺀ ﺍﻹﻅﻬﺎﺭ ﻋﻠﻰ ﻨﻔﺱ ﺍﻟﺴﻁﺭ ﻨﺴﺘﺨﺩﻡ‬
‫ﻻ ﻋﻨﻬﺎ‪.‬‬
‫ﺒﺩ ﹰ‬

‫ﺍﻹﻅﻬﺎﺭ ﻋﻠﻰ ﺼﻨﺩﻭﻕ ﺤﻭﺍﺭ )ﺸﺎﺸﺔ ﻨﻭﺍﻓﺫ "ﺒﻴﺎﻨﻴﺔ"(‪:‬‬

‫"‪" graphical screen‬‬ ‫ﺍﻜﺘﺏ‬

‫ﺘﻌﻠﻴﻤﺔ ﺍﻹﻅﻬﺎﺭ‪:‬‬
‫;) "‪JOptionPane.showMessageDialog(null, " graphical screen‬‬

‫‪13‬‬
‫ﺘﻘﻭﻡ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺒﺎﻹﻅﻬﺎﺭ ﻋﻠﻰ ﺼﻨﺩﻭﻕ ﺤﻭﺍﺭ ﻓﻲ ﻨﻅﺎﻡ ﻨﻭﺍﻓﺫ )ﻨﻅﺎﻡ ﺒﻴﺎﻨﻲ ﺫﻭ ﻭﺍﺠﻬﺎﺕ ﺘﻔﺎﻋﻠﻴﺔ‬
‫ﻤﻊ ﺍﻟﻤﺴﺘﺨﺩﻡ ‪.(GUI: Graphical User Interface‬‬
‫‪ ،‬ﺃﻱ ﺇﻅﻬﺎﺭ ﺴﻠﺴﻠﺔ‬ ‫‪println‬‬ ‫ﺘﻌﻤل ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﻭﻓﻕ ﻨﻔﺱ ﺍﻟﻘﺎﻋﺩﺓ ﺍﻟﺘﻲ ﺫﻜﺭﻨﺎﻫﺎ ﻓﻲ ﺘﻌﻠﻴﻤﺔ‬
‫ﺤﺭﻓﻴﺔ‪ ،‬ﻨﺎﺘﺠﺔ ﻋﻥ ﻀﻡ ﺴﻼﺴل ﺤﺭﻓﻴﺔ ﻭﻤﺘﺤﻭﻻﺕ‪ .‬ﻓﻜل ﻤﺎ ﻫﻭ ﻤﻭﺠﻭﺩ ﻓﻲ ﺍﻟﻠﻭﻥ ﺍﻷﺨﻀﺭ ﻓﻲ‬
‫‪ ،‬ﻴﻤﻜﻥ ﻭﻀﻌﻪ ﻤﻜﺎﻥ ﺍﻟﻠﻭﻥ ﺍﻷﺨﻀﺭ ﻓﻲ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ‪.‬‬ ‫‪println‬‬ ‫ﺘﻌﻠﻴﻤﺔ‬
‫ﺘﻨﺒﻴﻪ )ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻭﻅﺎﺌﻑ ﻤﻥ ﺍﻟﺤﺯﻡ ﺍﻟﺒﺭﻤﺠﻴﺔ ﺍﻟﻘﻴﺎﺴﻴﺔ( ‪:‬‬
‫ﺃﻥ ﻫﺫﺍ ﺍﻟﺘﺎﺒﻊ ﻤﻭﺠﻭﺩ ﻤﻊ ﻏﺭﺽ ﺒﺭﻤﺠﻲ ﻴﻨﺘﻤﻲ ﺇﻟﻰ ﺤﺯﻤﺔ ﺒﺭﻤﺠﻴﺔ ﻗﻴﺎﺴﻴﺔ ﻤﻠﺤﻘﺔ ﺒﺎﻟﻠﻐﺔ‪ ،‬ﻟﺫﻟﻙ‬
‫ﻻﺒﺩ ﻤﻥ ﺍﻹﺸﺎﺭﺓ ﺇﻟﻰ ﺫﻟﻙ ﺼﺭﺍﺤ ﹶﺔ ﻓﻲ ﺃﻭل ﻋﺒﺎﺭﺓ ﻓﻲ ﺍﻟﻨﺹ ﺍﻟﺒﺭﻤﺠﻲ‪:‬‬
‫;‪import javax.swing.JOptionPane‬‬
‫)ﺍﺴﺘﻭﺭﺩ ﻟﻨﺎ ﻤﺎ ﻴﻠﻲ‪ ،(:‬ﺴﻨﺴﺘﺨﺩﻤﻬﺎ ﻋﻤﻭﻤﺎﹰ‪،‬‬ ‫‪import‬‬ ‫ﻫﺫﻩ ﺍﻟﻌﺒﺎﺭﺓ ﺍﻟﺘﻲ ﺘﺒﺩﺃ ﺒﺎﻟﻜﻠﻤﺔ ﺍﻟﻤﻔﺘﺎﺤﻴﺔ‬
‫ﻜﻠﻤﺎ ﺃﺭﺩﻨﺎ ﺍﺴﺘﺨﺩﺍﻡ ﻭﻅﺎﺌﻑ ﻤﺴﺒﻘﺔ ﺍﻟﺘﻌﺭﻴﻑ ﻤﻭﺠﻭﺩﺓ ﻓﻲ ﺍﻟﺤﺯﻡ ﺍﻟﺒﺭﻤﺠﻴﺔ ﺍﻟﻘﻴﺎﺴﻴﺔ ﺍﻟﻜﺜﻴﺭﺓ‬
‫ﻭﺍﻟﻐﻨﻴﺔ ﺍﻟﺘﻲ ﺘﺘﻴﺤﻬﺎ ‪.Java‬‬
‫ﻓﻲ ﺃﻭل ﺍﻟﻨﺹ ﺍﻟﺒﺭﻤﺠﻲ‪ ،‬ﻟﺘﹸﻌﻠﻡ ﺍﻟﻤﺘﺭﺠﻡ ﺃﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻴﺤﺘﻭﻱ‬ ‫‪import‬‬ ‫ﺘﻭﻀﻊ ﻋﺒﺎﺭﺓ ﺍﻻﺴﺘﻴﺭﺍﺩ‬
‫ﻋﻠﻰ ﻭﻅﺎﺌﻑ ﻏﻴﺭ ﻤﻌﺭﻓﺔ ﻓﻲ ﺍﻟﻨﺹ ﺍﻟﺒﺭﻤﺠﻲ‪ ،‬ﻴﻤﻜﻨﻪ ﺍﻟﻌﺜﻭﺭ ﻋﻠﻴﻬﺎ ﺃﻭ ﺍﺴﺘﻴﺭﺍﺩﻫﺎ ﻤﻥ ﺤﻴﺙ‬
‫ﺘﻌﺭﻓﻬﺎ ﻟﻪ ﻋﺒﺎﺭﺓ ‪.import‬‬

‫‪Java‬‬ ‫ﺘﻌﻠﻴﻤﺎﺕ ﺍﻹﺩﺨﺎل ﻓﻲ‬ ‫‪-3‬‬

‫ﻗﺩ ﺘﺴﺘﻐﺭﺏ ﻴﺎ ﺼﺩﻴﻘﻲ ﺃﻨﻲ ﺒﺩﺃﺕ ﻟﻙ‪ ،‬ﺒﺎﻟﺤﺩﻴﺙ ﻋﻥ ﺍﻟﺨﺭﺝ ﻗﺒل ﺍﻟﺩﺨل‪ ،‬ﻭﺍﻵﻥ ﺃﻴﻀﹰﺎ ﺴﺄﺤﺩﺜﻙ‬
‫ﻋﻥ ﺍﻟﺩﺨل ﺍﻟﺘﻔﺎﻋﻠﻲ ﺍﻟﺒﻴﺎﻨﻲ ﻗﺒل ﺍﻟﺩﺨل ﺍﻟﻨﻅﺎﻤﻲ ﺃﻱ ﺍﻟﺩﺨل ﺍﻟﻤﺄﻟﻭﻑ ﻤﻊ ﺍﻟﺸﺎﺸﺔ ﺍﻟﺴﻭﺩﺍﺀ‪ .‬ﺇﻨﻨﺎ‬
‫ﻨﺘﺩﺭﺝ ﻤﻌﹰﺎ ﻭﻓﻕ ﺼﻌﻭﺒﺔ ﺍﻟﻤﻭﻀﻭﻉ‪.‬‬
‫ﺍﻋﻠﻡ ﻴﺎ ﺼﺩﻴﻘﻲ‪ :‬ﺃﻥ ﻟﻜل ﺸﻲﺀ ﺜﻤﻥ ﻤﻌﻴﻥ!‬
‫ﻜﻠﻐﺔ ﺒﺭﻤﺠﺔ‪ ،‬ﻭﺴﺘﻘﺩﺭﻫﺎ ﻤﺴﺘﻘﺒﻼﹰ‪ ،‬ﻜﺄﺩﺍﺓ ﻫﻨﺩﺴﺔ ﺒﺭﻤﺠﻴﺔ‬ ‫‪Java‬‬ ‫ﺇﻥ ﺍﻟﻤﺯﺍﻴﺎ ﺍﻟﺭﺍﺌﻌﺔ ﺍﻟﺘﻲ ﺘﻘﺩﻤﻬﺎ‬
‫ﺠﻴﺩﺓ‪ ،‬ﻟﻴﺴﺕ ﺒﻼ ﺜﻤﻥ‪ .‬ﻭﻟﻜﻥ ﺍﻟﻁﺭﻴﻕ ﺇﻟﻰ ﺍﻟﻬﺩﻑ ﺍﻟﻌﻅﻴﻡ ﻟﻴﺴﺕ ﺩﺍﺌﻤﹰﺎ ﻤﻔﺭﻭﺸ ﹰﺔ ﺒﺎﻟﻭﺭﻭﺩ‪ .‬ﻓﻔﻲ‬
‫ﺍﻟﻭﻗﺕ ﺍﻟﺫﻱ ﻨﺠﺩ ﻓﻴﻪ ﺘﻌﻠﻴﻤﺎﺕ ﺩﺨل ﻭﺨﺭﺝ ﺴﻬﻠﺔ ﻭﻤﺒﺎﺸﺭﺓ ﻓﻲ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ‪ ،‬ﺴﻨﺒﺫل‬
‫ﻫﻨﺎ ﺠﻬﺩﹰﺍ ﺃﻜﺒﺭ‪ .‬ﺇﻨﻪ ﺍﻻﻨﺘﻅﺎﻡ ﻓﻲ ﻫﺫﻩ ﺍﻟﻠﻐﺔ ﻭﻋﻤﻭﻤﻴﺘﻬﺎ ﻫﻭ ﻨﺴﺒﻴﹰﺎ ﻭﺭﺍﺀ ﺒﻌﺽ ﺍﻟﺼﻌﻭﺒﺎﺕ ﻫﻨﺎ‪.‬‬

‫‪Java‬‬ ‫ﺍﻟﻤﺒﺩﺃ ﺍﻷﺴﺎﺴﻲ ﻟﻠﺩﺨل ﺍﻟﺒﺴﻴﻁ ﻓﻲ‬

‫ﺒﺤﻴﺙ ﺘﺤﻘﻕ ﻟﻨﺎ ﻤﺒﺎﺸﺭﺓ ً ﺍﻟﺩﺨل ﺇﻟﻰ ﻤﺘﺤﻭﻻﺕ ﻤﻥ ﺍﻷﻨﻤﺎﻁ‬ ‫‪Java‬‬ ‫ﻻ ﻴﻭﺠﺩ ﻭﻅﻴﻔﺔ ﺠﺎﻫﺯﺓ ﻓﻲ‬
‫ﺍﻟﻌﺩﺩﻴﺔ‪.‬‬
‫‪String‬‬ ‫ﻭﻟﻜﻥ ﻴﻭﺠﺩ ﻭﻅﺎﺌﻑ ﺠﺎﻫﺯﺓ ﺘﺴﻤﺢ ﻟﻨﺎ ﺒﺈﺩﺨﺎل ﺴﻠﺴﻠﺔ ﺤﺭﻭﻑ ﺇﻟﻰ ﻤﺘﺤﻭل )ﻤﻥ ﻨﻤﻁ‬
‫ﺴﻠﺴﻠﺔ ﺤﺭﻓﻴﺔ(‪.‬‬

‫‪14‬‬
 ‫ﻭﻴﻭﺠﺩ ﺒﻌﺩﻫﺎ ﺍﻟﻭﻅﺎﺌﻑ ﺍﻟﻼﺯﻤﺔ ﻟﻠﺘﺤﻭﻴل ﻤﻥ ﺴﻠﺴﻠﺔ ﺤﺭﻓﻴﺔ ﺇﻟﻰ ﺍﻟﻨﻤﻁ ﺍﻟﻌﺩﺩﻱ‪.‬‬
‫ﻭﻟﻭﻀﻭﺡ ﻋﻤﻠﻴﺔ ﺍﻹﺩﺨﺎل ﻭﺫﻟﻙ ﺒﺎﻻﻨﺘﻘﺎل ﻤﻥ ﺴﻠﺴﻠﺔ ﺤﺭﻓﻴﺔ ﺇﻟﻰ ﻤﺘﺤﻭل ﻋﺩﺩﻱ‪ ،‬ﺴﻨﻌﺭﻑ ﻟﻜل‬
‫ﻻ ﺴﻠﺴﻠﺔ ﺤﺭﻓﻴﺔ‪ ،‬ﺴﻴﺨﺘﺯﻥ ﺍﻟﺤﺭﻭﻑ ﺍﻟﺘﻲ ﻨﺩﺨﻠﻬﺎ‬
‫ﻤﺘﺤﻭل ﻋﺩﺩﻱ ﻨﺭﻴﺩ ﺇﺩﺨﺎل ﻗﻴﻤﺔ ﺇﻟﻴﻪ‪ ،‬ﻤﺘﺤﻭ ﹰ‬
‫ﻤﻌﺒﺭﺓ ﻋﻥ ﻫﺫﻩ ﺍﻟﻘﻴﻤﺔ‪.‬‬

‫ﻤﺜﺎل‪:‬‬
‫ﻤﻥ ﺍﻟﻨﻤﻁ ﺍﻟﺤﻘﻴﻘﻲ ‪ ،float‬ﺴﺄﻋﺭﻑ ﻤﺒﺎﺸﺭ ﹰﺓ‬ ‫‪a‬‬ ‫ﺇﺫﺍ ﻜﻨﺕ ﺃﺭﻴﺩ ﺇﺩﺨﺎل ﻗﻴﻤﺔ ﺇﻟﻰ ﺍﻟﻤﺘﺤﻭل ﺍﻟﻌﺩﺩﻱ‬
‫ﺴﺄﺴﻤﻴﻪ ‪.Sa‬‬ ‫‪String‬‬ ‫ﻻ ﻤﻥ ﺴﻠﺴﻠﺔ ﺤﺭﻓﻴﺔ‬
‫ﺇﻟﻰ ﺠﺎﻨﺒﻪ ﻤﺘﺤﻭ ﹰ‬
‫;‪float a; String a‬‬ ‫ﻭﺴﻴﻜﻭﻥ ﻟﺩﻱ ﻓﻲ ﻗﺴﻡ ﺍﻟﺘﺼﺭﻴﺢ ﻋﻥ ﺍﻟﻤﺘﺤﻭﻻﺕ‪:‬‬

‫ﺍﻹﺩﺨﺎل ﻤﻥ ﺼﻨﺩﻭﻕ ﺤﻭﺍﺭ )ﻤﻥ ﺸﺎﺸﺔ ﻨﻭﺍﻓﺫ "ﺒﻴﺎﻨﻴﺔ"(‪:‬‬

‫)‪ a‬ﻤﺘﺤﻭل ﻋﺩﺩﻱ ﻤﻥ ﻨﻤﻁ ‪(float‬‬ ‫‪a‬‬ ‫ﺇﻗﺭﺃ‬

‫;‪float a; String Sa‬‬

‫;)" ‪Sa = JOptionPane.showInputDialog(" Input A :‬‬
‫;) ‪a = Float.parseFloat( Sa‬‬

‫ﺇﺫﻥ‪ ،‬ﻨﻨﻔﱢﺫ ﺘﻌﻠﻴﻤﺔ ﺇﺩﺨﺎل ﻗﻴﻤﺔ ﻤﻥ ﻨﻤﻁ ﻋﺩﺩﻱ )ﻓﻲ ﻟﻐﺔ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺎﺕ( ﺒﺘﻌﻠﻴﻤﺘﻴﻥ ﻓﻲ ‪:Java‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻷﻭﻟﻰ‪:‬‬
‫ﻭﻨﺤﺼل ﻓﻴﻬﺎ ﻤﻥ ﺍﻟﺩﺨل ﻋﻠﻰ ﺴﻠﺴﻠﺔ ﺤﺭﻓﻴﺔ ﺘﻤﺜل ﺸﻜل ﻜﺘﺎﺒﺔ ﺍﻟﻌﺩﺩ )ﺍﻷﺭﻗﺎﻡ‪ ،‬ﺍﻹﺸﺎﺭﺓ‪،‬‬
‫ﺍﻟﻔﺎﺼﻠﺔ(‪.‬‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺜﺎﻨﻴﺔ‪:‬‬
‫ﻨﺤﻭل ﻓﻴﻬﺎ ﺍﻟﺴﻠﺴﻠﺔ ﺍﻟﺤﺭﻓﻴﺔ ﺇﻟﻰ ﺍﻟﻨﻤﻁ ﺍﻟﻌﺩﺩﻱ ﺍﻟﺫﻱ ﻨﺭﻴﺩ‪ ،‬ﻭ ﻫﺫﻩ ﺍﻟﺘﻌﻠﻴﻤﺔ ﻫﻲ ﺘﻌﺒﻴﺭ ﻴﻁﻠﺏ ﺘﺎﺒﻊ‬
‫ﺇﻟﻰ ﺍﻟﻤﺘﺤﻭل ﺍﻟﻌﺩﺩﻱ ﺍﻟﺤﻘﻴﻘﻲ‬ ‫‪Sa‬‬ ‫ﻟﻴﺤﻭ‪‬ل )ﻟﻴﻌﺭﺏ ‪ (parse‬ﺍﻟﺴﻠﺴﻠﺔ ﺍﻟﺤﺭﻓﻴﺔ‬ ‫) ‪parseFloat( Sa‬‬

‫‪ .a‬ﺃﻨﺕ ﺘﻌﻠﻡ ﺃﻥ ﺍﻟﻤﺘﺤﻭل ﻤﻥ ﺍﻟﻨﻤﻁ ﺍﻟﻌﺩﺩﻱ ﻴﻤﱠﺜل ﻓﻲ ﺍﻟﺤﺎﺴﻭﺏ ﺒﺎﻟﻨﻅﺎﻡ ﺍﻟﺜﻨﺎﺌﻲ ﺒﻁﺭﻴﻘﺔ ﺨﺎﺼﺔ‪،‬‬
‫ﻭ ﻟﻴﺴﺕ ﺃﺒﺩﹰﺍ ﻋﺒﺎﺭﺓ ﻋﻥ ﺘﻤﺜﻴل ﻟﻤﺘﺘﺎﻟﻴﺔ )ﻟﺴﻠﺴﻠﺔ( ﺍﻟﺤﺭﻭﻑ )ﻟﻸﺭﻗﺎﻡ( ﺍﻟﺘﻲ ﻨﻜﺘﺏ ﻓﻴﻬﺎ ﺍﻟﻌﺩﺩ‪.‬‬
‫)ﺘﺒﺩﺃ ﺒﺤﺭﻑ ﻜﺒﻴﺭ( ﺘﺸﻴﺭ ﺇﻟﻰ ﻤﺎﻨﺴﻤﻴﻪ ﻨﻤﻁ ﻤﻐﻠﱟﻑ )‪ (Wrapper Type‬ﻟﻠﻨﻤﻁ ﺍﻟﺒﺴﻴﻁ‬ ‫‪Float‬‬ ‫ﺍﻟﻜﻠﻤﺔ‬

‫ﻨﻤﻁ ﻤﻐﻠﱢﻑ‪.‬‬ ‫‪Java‬‬ ‫‪ ،float‬ﻭﻟﻜل ﻨﻤﻁ ﺒﺴﻴﻁ ﻓﻲ‬

‫‪15‬‬
 ‫>> ﺍﻨﻅﺭ ﺠﺩﻭل ﺍﻷﻨﻤﺎﻁ ﺍﻟﻤﻐﻠﱢﻔﺔ<<‬
‫‪Primitive type‬‬ ‫‪Size‬‬ ‫‪Minimum‬‬ ‫‪Maximum‬‬ ‫‪Wrapper type‬‬
‫‪boolean‬‬ ‫‪1-bit‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪Boolean‬‬
‫‪16‬‬
‫‪char‬‬ ‫‪16-‬‬ ‫‪Unicode 0‬‬ ‫‪Unicode 2 -‬‬ ‫‪Character‬‬
‫‪bit‬‬ ‫‪1‬‬
‫‪byte‬‬ ‫‪8-bit‬‬ ‫‪-128‬‬ ‫‪+127‬‬ ‫‪Byte‬‬
‫‪short‬‬ ‫‪16-‬‬ ‫‪-215‬‬ ‫‪+215-1‬‬ ‫‪Short‬‬
‫‪bit‬‬
‫‪int‬‬ ‫‪32-‬‬ ‫‪-231‬‬ ‫‪+231-1‬‬ ‫‪Integer‬‬
‫‪bit‬‬
‫‪long‬‬ ‫‪64-‬‬ ‫‪-263‬‬ ‫‪+263-1‬‬ ‫‪Long‬‬
‫‪bit‬‬
‫‪float‬‬ ‫‪32-‬‬ ‫‪IEEE 754‬‬ ‫‪IEEE 754‬‬ ‫‪Float‬‬
‫‪bit‬‬
‫‪double‬‬ ‫‪64-‬‬ ‫‪IEEE 754‬‬ ‫‪IEEE 754‬‬ ‫‪Double‬‬
‫‪bit‬‬
‫‪void‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪-‬‬ ‫‪Void‬‬

‫‪Java‬‬ ‫( ﻟﻸﻨﻤﺎﻁ ﺍﻟﺒﺴﻴﻁﺔ ﻓﻲ‬ ‫)‪Wrapper type‬‬ ‫ﺠﺩﻭل ﺍﻷﻨﻤﺎﻁ ﺍﻟﻤﻐﻠﱢﻔﺔ‬

‫ﻭﻜﻤﺎ ﻓﻌﻠﻨﺎ ﻟﻠﺘﺤﻭﻴل ﺇﻟﻰ ﺍﻟﻨﻤﻁ ﺍﻟﺤﻘﻴﻘﻲ‪ ،‬ﻨﻔﻌل ﻤﻊ ﺍﻷﻨﻤﺎﻁ ﺍﻷﺨﺭﻯ‪ ،‬ﺒﺎﺴﺘﺨﺩﺍﻡ ﺍﻟﻨﻤﻁ ﺍﻟﻤﻐﻠﱢﻑ‬
‫ﺍﻟﻤﻭﺍﻓﻕ‪:‬‬
‫;‪int i; String Si‬‬

‫;) ‪i = Integer.parseInteger( Si‬‬

‫ﺍﻹﻅﻬﺎﺭ ﻋﻠﻰ ﻭﺤﺩﺓ ﺍﻟﺨﺭﺝ ﺍﻟﻘﻴﺎﺴﻴﺔ )ﺍﻟﺸﺎﺸﺔ ﺍﻟﺴﻭﺩﺍﺀ "ﺤﺭﻓﻴﺔ"(‬

‫ﻴﻨﻁﺒﻕ ﻨﻔﺱ ﺍﻟﻤﺒﺩﺃ ﻓﻲ ﻫﺫﻩ ﺍﻟﺤﺎﻟﺔ )ﺍﻟﻘﺭﺍﺀﺓ ﺇﻟﻰ ﺴﻠﺴﻠﺔ ﺤﺭﻓﻴﺔ‪ ،‬ﺜﻡ ﺍﻟﺘﺤﻭﻴل ﺇﻟﻰ ﺍﻟﻨﻤﻁ ﺍﻟﻌﺩﺩﻱ(‪.‬‬
‫ﻭﻟﻜﻥ ﻗﺭﺍﺀﺓ ﺍﻟﺩﺨل ﻜﺴﻠﺴﻠﺔ ﺤﺭﻓﻴﺔ ﻤﻥ ﺍﻟﺩﺨل ﺍﻟﻨﻅﺎﻤﻲ ) ﺍﻹﺩﺨﺎل ﻤﻥ ﻟﻭﺤﺔ ﺍﻟﻤﻔﺎﺘﻴﺢ ﻤﻊ ﺸﺎﺸﺔ‬
‫ﺤﺭﻓﻴﺔ‪-‬ﺴﻭﺩﺍﺀ ﻓﻘﻁ‪ ،‬ﻜﻤﺎ ﻫﻭ ﺍﻟﺤﺎل ﻓﻲ ﻤﻌﻅﻡ ﻟﻐﺎﺕ ﺍﻟﺒﺭﻤﺠﺔ ﺍﻟﺘﻘﻠﻴﺩﻴﺔ( ﻴﺴﺘﺩﻋﻲ ﺇﻀﺎﻓﺎﺕ‬
‫ﻤﺯﻋﺠﺔ ﺇﻟﻰ ﺒﺭﻨﺎﻤﺠﻨﺎ‪.‬‬
‫ﻴﺠﺏ ﻭﻀﻊ ﺍﻟﺘﻐﻴﻴﺭﺍﺕ ﺍﻟﺘﺎﻟﻴﺔ ﻓﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ‪:‬‬

‫;‪import java.io.IOException‬‬

‫{ ‪class Solution2degreeI‬‬

‫‪public static void main(String‬‬

‫‪args[ ]) throws IOException‬‬
‫{‬

‫;)‪DataInputStream input = new DataInputStream( System.in‬‬

‫;‪float a; String Sa‬‬

‫‪16‬‬
 ‫;)(‪Sa=input.readLine‬‬

‫;)‪a=Float.parseFloat(Sa‬‬

‫ﻟﻤﻌﺎﻟﺠﺔ ﺃﻱ ﺤﺎﻻﺕ ﺍﺴﺘﺜﻨﺎﺌﻴﺔ‬ ‫‪Java‬‬ ‫ﺇﻥ ﺍﻟﺘﻐﻴﻴﺭﺍﺕ‪ ،‬ﺍﻟﻤﻭﺠﻭﺩﺓ ﻗﺒل ﺠﺴﻡ ﺍﻟﺒﺭﻨﺎﻤﺞ‪ ،‬ﺘﻔﺭﻀﻬﺎ‬
‫‪ ،‬ﻗﺩ ﻴﺤﺩﺙ‬ ‫‪Java‬‬ ‫ﻋ ‪‬ﺭﻑ‬
‫‪ ،exception‬ﻭﻻ ﺩﺍﻋﻲ ﻟﻤﻌﺭﻓﺔ ﺘﻔﺎﺼﻴل ﺫﻟﻙ ﺍﻵﻥ‪ .‬ﻓﻲ ﺤﺎﻟﺔ ﺍﻟﺩﺨل‪ ،‬ﻓﻲ ‪‬‬
‫ﻻ ﺒﺩ ﻤﻥ ﺍﻹﺸﺎﺭﺓ ﺇﻟﻴﻪ ﺼﺭﺍﺤ ﹰﺔ ﻓﻲ ﺍﻟﻨﺹ ﺍﻟﺒﺭﻤﺠﻲ‪ ،‬ﻭﻫﺫﺍ ﻤﺎ ﻓﻌﻠﻨﺎﻩ‬ ‫‪IOException‬‬ ‫ﺍﺴﺘﺜﻨﺎﺀ ﻫﻭ‬
‫ﻫﻨﺎ‪.‬‬

‫ﺇﻥ ﺍﻟﺘﻌﺭﻴﻑ ﺍﻟﺼﺭﻴﺢ ﻟﻠﺩﺨل ﺍﻟﻨﻅﺎﻤﻲ ﻻﺒﺩ ﺃﻥ ﻴﻜﻭﻥ ﻋﺒﺭ ﺍﻟﺘﺼﺭﻴﺢ ﻋﻥ ﺸﻲﺀ‪/‬ﻏﺭﺽ ﺨﺎﺹ‬
‫‪ ،‬ﻴﺠﺭﻱ ﺫﻟﻙ ﺒﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺼﺭﻴﺢ‬ ‫‪Java‬‬ ‫ﻓﻴﺤﺎﻟﺘﻨﺎ( ﻨﻌﺭّﻓﻪ ﻤﻥ ﺇﻁﺎﺭ ﻋﺎﻡ ﻟﻠﺩﺨل ﻓﻲ‬ ‫‪input‬‬ ‫)ﺍﻟﻤﺘﺤﻭل‬
‫ﺍﻟﻤﺭﻜﺒﺔ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬

‫;)‪DataInputStream input = new DataInputStream( System.in‬‬

‫ﺒﻌﺩ ﻭﻀﻊ ﺍﻟﺘﻐﻴﻴﺭﺍﺕ ﺍﻟﺴﺎﺒﻘﺔ ﻴﺼﺒﺢ ﺍﻷﻤﺭ ﻤﺒﺎﺸﺭﹰﺍ‪:‬‬

‫ﺍﻟﺘﻌﻠﻴﻤﺔ;)(‪Sa=input.readLine‬‬

‫ﺘﻘﺭﺃ ﺴﻁﺭﹰﺍ ﻤﻥ ﺍﻟﺩﺨل ﺍﻟﻨﻅﺎﻤﻲ ﺇﻟﻰ ﺍﻟﺴﻠﺴﻠﺔ ﺍﻟﺤﺭﻓﻴﺔ ‪.Sa‬‬

‫;)‪a=Float.parseFloat(Sa‬‬ ‫ﺍﻟﺘﻌﻠﻴﻤﺔ‬
‫ﻫﻲ ﻨﻔﺱ ﺘﻌﻠﻴﻤﺔ ﺍﻟﺘﺤﻭﻴل ﺇﻟﻰ ﻨﻤﻁ ﻋﺩﺩﻱ ﺤﻘﻴﻘﻲ ﺍﻟﺘﻲ ﺸﺭﺤﻨﺎﻫﺎ ﺒﺎﻟﺘﻔﺼﻴل ﻓﻲ ﺍﻟﻔﻘﺭﺓ ﺍﻟﺴﺎﺒﻘﺔ‪.‬‬

‫ﺷﻜﻞ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ‬

‫‪1‬‬
‫‪-3‬‬
‫‪-10‬‬
‫‪x1= -2.0 x2= 5.0‬‬

‫‪17‬‬
 ‫‪Java‬‬ ‫‪ -4‬ﺃﻤﺜﻠﺔ ﺒﺭﻤﺠﻴﺔ ﺒﻠﻐﺔ‬

‫ﺴﻨﺘﺒﻊ ﻓﻲ ﺃﻤﺜﻠﺔ ﺒﺭﺍﻤﺠﻨﺎ ﺍﻟﺩﺨل ﺒﻁﺭﻴﻘﺔ ﺒﻴﺎﻨﻴﺔ ﺘﺨﺎﻁﺒﻴﺔ‪ ،‬ﺃﻤﺎ ﺍﻟﺨﺭﺝ ﻓﻬﻭ ﺍﻟﺨﺭﺝ ﺍﻟﻨﻅﺎﻤﻲ ﻋﻠﻰ‬
‫ﺍﻟﺸﺎﺸﺔ ﺍﻟﺴﻭﺩﺍﺀ‪ .‬ﻭﺒﺫﻟﻙ ﻨﻜﺴﺏ ﺴﻬﻭﻟﺔ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﺒﺴﺎﻁﺔ ﺍﻟﻨﺹ ﺍﻟﺒﺭﻤﺠﻲ‪.‬‬
‫ﺠﻤﻴﻊ ﺍﻟﺒﺭﺍﻤﺞ ﺍﻟﻤﻭﺍﻓﻘﺔ ﻟﺨﻭﺍﺭﺯﻤﻴﺎﺕ ﺤل ﺍﻟﻤﺴﺎﺌل ﺍﻟﺘﻲ ﻋﺭﻀﻨﺎﻫﺎ ﻓﻲ‬ ‫‪Java‬‬ ‫ﺴﻨﻌﺭﺽ ﻟﻙ ﺒﻠﻐﺔ‬
‫ﻓﺼل ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺔ‪.‬‬
‫ﺍﻟﻬﻴﻜل ﺍﻷﺴﺎﺴﻲ ﻟﻠﺒﺭﻨﺎﻤﺞ ﻓﻲ ‪ ،Java‬ﺍﻟﺒﻨﻴﺔ ﺍﻷﺴﺎﺴﻴﺔ ﺍﻟﺒﺴﻴﻁﺔ‬

‫ﻧﺘﻴﺠﺔ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ‬

‫…‪My first program in Java‬‬

‫ﻫﺫﺍ ﺃﺒﺴﻁ ﺒﺭﻨﺎﻤﺞ ﻴﻤﻜﻥ ﻜﺘﺎﺒﺘﻪ ﻓﻲ ‪.Java‬‬

‫ﻭﺍﻟﻬﻴﻜل ﺍﻟﻌﺎﻡ ﻴﺠﺏ ﺃﻥ ﻴﻜﻭﻥ ﻤﺘﻭﺍﻓﻘﹰﺎ ﻤﻊ ﻫﺫﺍ ﺍﻟﻤﺜﺎل‪.‬‬
‫ﺍﻟﺴﻁﺭ ‪:1‬‬
‫ﻷﻥ‬ ‫‪Java‬‬ ‫‪ .‬ﺴﻌﺕ‬ ‫‪class‬‬ ‫ﻴﺠﺏ ﺃﻥ ﻴﻜﻭﻥ ﻀﻤﻥ ﺼﻑ‬ ‫‪Java‬‬ ‫ﺃﻱ ﻨﺹ ﺒﺭﻤﺠﻲ ﻗﺎﺒل ﻟﻠﺘﻨﻔﻴﺫ ﻓﻲ‬
‫ﺘﻜﻭﻥ ﻟﻐﺔ ﺒﺭﻤﺠﺔ ﻏﺭﻀﻴﺔ ﺍﻟﺘﻭﺠﻪ ﺒﺸﻜل ﻤﻨﺘﻅﻡ‪ .‬ﻟﺫﻟﻙ ﻻ ﺒﺩ ﻤﻥ ﺘﻐﻠﻴﻑ‪ ،‬ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﻔﻌﻠﻲ ﺒﺎﻟﻜﻠﻤﺔ‬
‫ﺍﻟﻤﻔﺘﺎﺤﻴﺔ ‪ ،class‬ﺜﻡ ﺇﻋﻁﺎﺀ ﺍﺴﻡ ﺘﻌﺭﻴﻑ‪ ،‬ﺘﺨﺘﺎﺭﻩ ﺃﻨﺕ ﻜﻤﺒﺭﻤﺞ‪ ،‬ﻟﻬﺫﺍ ﺍﻟﺼﻑ‪ ،‬ﻭﻫﻨﺎ ﺍﺨﺘﺭﻨﺎ ﺍﻻﺴﻡ‬
‫‪ .WritePg‬ﻴﻠﻲ ﺫﻟﻙ ﻗﻭﺱ ﺒﺩﺍﻴﺔ ﺍﻟﺼﻑ { ‪ ،‬ﻭ ﺒﺎﻟﻁﺒﻊ ﻤﻘﺎﺒل ﻜل ﺒﺩﺍﻴﺔ ﺘﻭﺠﺩ ﻨﻬﺎﻴﺔ‪ ،‬ﻭﻫﻭ ﻫﻨﺎ‬
‫ﻗﻭﺱ ﺍﻟﻨﻬﺎﻴﺔ } ﻓﻲ ﺁﺨﺭ ﺍﻟﻨﺹ ﺍﻟﺒﺭﻤﺠﻲ‪.‬‬
‫ﺍﻟﺴﻁﺭ ‪:3‬‬
‫ﻭﻫﻭ ﺍﻟﺴﻁﺭ ﺍﻟﺘﺎﻟﻲ‪ ،‬ﺒﻌﺩ ﺴﻁﺭ ﺍﻟﺘﺼﺭﻴﺢ ﻋﻥ ﺍﻟﺼﻑ‪.‬‬
‫‪ .‬ﻭﻴﺠﺏ ﺃﻥ ﻴﺄﺨﺫ ﺍﻟﺸﻜل ﺍﻟﻤﻭﺠﻭﺩ ﻤﺘﻀﻤﻨﹰﺎ ﺍﻟﻜﻠﻤﺎﺕ‬ ‫‪main‬‬ ‫ﻴﺘﻀﻤﻥ ﺘﺭﻭﻴﺴﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﺭﺌﻴﺴﻲ‬
‫ﺍﻟﻤﻔﺘﺎﺤﻴﺔ ‪ .public, static, void‬ﻟﻥ ﻴﻠﺯﻤﻙ ﺍﻵﻥ ﺃﻱ ﺸﺭﺡ ﻟﻬﺫﻩ ﺍﻟﻜﻠﻤﺎﺕ‪ ،‬ﻭﻫﻲ ﺫﺍﺕ ﻤﺩﻟﻭﻻﺕ ﻓﻲ‬
‫ﻤﺭﺍﺤل ﻤﺘﻘﺩﻤﺔ ﻓﻲ ﺍﺴﺘﺨﺩﺍﻡ ﺍﻟﻠﻐﺔ‪.‬‬

‫‪18‬‬
‫‪ ،‬ﺃﻋﻁﻴﻨﺎﻩ‬ ‫‪parameters‬‬ ‫ﻭﻴﺘﻀﻤﻨﺎﻥ ﺘﺼﺭﻴﺤﹰﺎ ﻋﻥ ﻤﺘﺤﻭل ﻭﺴﻴﻁ ﺃﻭ ﻤﺤﺩﺩ‬ ‫‪main‬‬ ‫ﺍﻟﻘﻭﺴﺎﻥ )( ﺒﻌﺩ‬
‫‪ ،‬ﻭﻫﻭ ﻤﻥ ﻨﻤﻁ ﺠﺩﻭل ﻤﻥ ﺍﻟﺴﻼﺴل ﺍﻟﺤﺭﻓﻴﺔ ‪ .String‬ﺘﺭﻯ ﺃﻨﻨﺎ ﻟﻡ ﻨﺴﺘﺨﺩﻤﻪ ﻓﻲ‬ ‫‪arg‬‬ ‫ﺍﻻﺴﻡ‬
‫ﺘﻔﺭﻀﻪ ﺃﻴﻀﹰﺎ ﻟﻼﻨﺘﻅﺎﻡ ﻓﻲ ﺠﻤﻴﻊ ﺍﻟﺒﺭﺍﻤﺞ‪ .‬ﺃﻤﺎ ﺩﻻﻟﺘﻪ ‪ ،‬ﺇﻥ ﺸﺌﺕ ﺃﻥ ﺘﺄﺨﺫ‬ ‫‪Java‬‬ ‫ﺍﻟﺒﺭﻨﺎﻤﺞ‪ ،‬ﻭﻟﻜﻥ‬
‫ﻼ‪ :‬ﺍﻷﻤﺭﻓﻲ ‪،DOS‬‬
‫ﻓﻜﺭﺓ ﺃﻭﻟﻴﺔ‪ ،‬ﻓﻬﻲ ﻭﺴﻁﺎﺀ ﻟﻠﺒﺭﻨﺎﻤﺞ ﺇﻥ ﻜﺎﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻗﺩ ﻴﺤﺘﺎﺝ ﺫﻟﻙ‪ ،‬ﻤﺜ ﹸ‬
‫ﻴﻜﻭﻥ‬ ‫‪Java‬‬ ‫‪ ،TYPE myfile‬ﻴﻅﻬﺭ ﻤﻠﻔﹰﺎ ﻋﻠﻰ ﺍﻟﺸﺎﺸﺔ‪ ،‬ﻓﺈﻥ ﻜﺎﻥ ﻫﺫﺍ ﺍﻷﻤﺭ ﻤﻜﺘﻭﺒﹰﺎ ﺒﺒﺭﻨﺎﻤﺞ ﺒﻠﻐﺔ‬
‫ﻫﻭ ﺍﻟﻭﺴﻴﻁ ﺃﻭ ﺍﻟﻤﺤﺩﺩ ﻟﻠﺒﺭﻨﺎﻤﺞ‪ ،‬ﻭﻴﺴﻨﺩ ﺇﻟﻰ ﺍﻟﻤﺘﺤﻭل ‪.arg‬‬ ‫‪myfile‬‬ ‫ﺍﺴﻡ ﺍﻟﻤﻠﻑ‬
‫ﻴﺤﺘﻭﻱ ﺁﺨﺭ ﻫﺫﺍ ﺍﻟﺴﻁﺭ ﻋﻠﻰ ﻗﻭﺱ ﺒﺩﺍﻴﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ { ‪ ،‬ﻭ ﺒﺎﻟﻁﺒﻊ ﻤﻘﺎﺒل ﻜل ﺒﺩﺍﻴﺔ ﺘﻭﺠﺩ ﻨﻬﺎﻴﺔ‪،‬‬
‫ﻭﻗﻭﺱ ﻨﻬﺎﻴﺔ ﺍﻟﺒﺭﻨﺎﻤﺞ } ﺍﻟﻤﻭﺠﻭﺩ ﻓﻲ ﺍﻟﺴﻁﺭ ‪.6‬‬
‫ﺍﻟﺴﻁﺭ ‪:5‬‬
‫ﻭﻴﺘﻀﻤﻥ ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﻭﺤﻴﺩﺓ ﻓﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻭﻫﻲ ﺘﻘﺎﺒل ﺘﻌﻠﻴﻤﺔ ﺍﻟﻜﺘﺎﺒﺔ‪ .‬ﺤﻴﺙ ﻨﺠﺩ ﻤﺎﻴﻅﻬﺭ ﻋﻠﻰ‬
‫ﺍﻟﺸﺎﺸﺔ ﻋﻨﺩ ﺘﻨﻔﻴﺫ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻋﺒﺎﺭﺓ ﺴﻠﺴﻠﺔ ﺤﺭﻓﻴﺔ ﻭﻀﻌﺕ ﺒﻴﻥ ﺇﺸﺎﺭﺘﻲ ﺘﻨﺼﻴﺹ‪.‬‬
‫ﻭﺘﻔﺼﻴﻼﺘﻬﺎ ﻓﻬﻭ ﻜﺎﻟﺘﺎﻟﻲ‪:‬‬ ‫‪System.out.println‬‬ ‫ﺃﻤﺎ ﺍﻟﺘﺩﻗﻴﻕ ﺍﻟﻘﻭﺍﻋﺩﻱ ﻓﻲ ﺍﻟﻌﺒﺎﺭﺓ‬
‫ﻫﻭ ﺍﻟﻭﻅﻴﻔﺔ )ﺍﻹﺠﺭﺍﺀ( ﺍﻟﺫﻱ ﻴﻘﻭﻡ ﺒﺘﻨﻔﻴﺫ ﺍﻟﻜﺘﺎﺒﺔ‪ ،‬ﻭﻴﻨﺘﻤﻲ ﺇﻟﻰ "ﺍﻟﺼﻨﺩﻭﻕ ﺍﻟﻭﻅﻴﻔﻲ" ‪،out‬‬ ‫‪println‬‬

‫ﺍﻟﻤﻨﺘﻤﻲ ﺒﺩﻭﺭﻩ ﺇﻟﻰ "ﺍﻟﺼﻨﺩﻭﻕ ﺍﻟﻭﻅﻴﻔﻲ" ‪.System‬‬

‫‪Object‬‬ ‫ﻫﻭ ﻏﺭﺽ‬ ‫‪out‬‬

‫‪Class‬‬ ‫ﻫﻭ ﺼﻑ‬ ‫‪System‬‬

‫ﻴﻜﻔﻲ ﺃﻥ ﻨﻌﺭﻑ ﺍﻵﻥ ﺃﻥ ‪ Java‬ﺘﺘﻀﻤﻥ ﻭﻅﺎﺌﻑ ﺒﺭﻤﺠﻴﺔ ﺠﺎﻫﺯﺓ ﻤﻨﻅﻤﺔ ﻓﻲ ﺃﻏﺭﺍﺽ ﻭﺼﻔﻭﻑ‬
‫ﻭﺤﺯﻡ ﺒﺭﻤﺠﻴﺔ‪ .‬ﻗﻭﺍﻋﺩﻴ ﹰﺎ ﺃﺴﺘﺨﺩ ‪‬ﻡ ﺍﻟﻨﻘﻁﺔ ‪ .‬ﻟﻁﻠﺏ ﺍﻟﻭﻅﻴﻔﺔ ﺍﻟﻤﻭﺠﻭﺩﺓ ﻓﻴﻬﺎ‬
‫ﺍﻟﺴﻁﺭ ‪:6‬‬
‫ﻗﻭﺱ ﺍﻟﻨﻬﺎﻴﺔ ﻟﻠﺒﺭﻨﺎﻤﺞ ‪.main‬‬
‫ﺍﻟﺴﻁﺭ ‪:8‬‬
‫ﻗﻭﺱ ﺍﻟﻨﻬﺎﻴﺔ ﻟﻠﺼﻑ‪.‬‬
‫ﻤﻼﺤﻅﺔ ﻋﺎﻤﺔ‪:‬‬
‫ﻋﻨﺩ ﺘﺴﻤﻴﺔ ﺍﻟﻭﻅﺎﺌﻑ ﺍﻟﺒﺭﻤﺠﻴﺔ ﺍﻟﺠﺎﻫﺯﺓ‪ ،‬ﺍﻟﻘﻭﺍﻋﺩ ﺍﻟﺘﺎﻟﻴﺔ‪:‬‬ ‫‪Java‬‬ ‫ﺘﺼﻁﻠﺢ‬
‫ﻜل ﻤﺎ ﻴﺒﺩﺃ ﺒﺤﺭﻑ ﻜﺒﻴﺭ ﻭﺘﻠﻴﻪ ﺃﺤﺭﻑ ﺼﻐﻴﺭﺓ‪ ،‬ﻫﻭ ﺍﺴﻡ ﻟﺼﻑ‪ :‬ﻤﺜﺎل‪.String, System :‬‬
‫ﻼ‪.sin, abs :‬‬
‫ﻜل ﻤﺎﻋﺩﺍ ﺫﻟﻙ ﻴﺒﺩﺃ ﺒﺤﺭﻑ ﺼﻐﻴﺭ‪ .‬ﺃﺴﻤﺎﺀ ﺍﻟﺘﻭﺍﺒﻊ ﻤﺜ ﹸ‬
‫ﺍﻟﺜﻭﺍﺒﺕ ﺘﻌﺭﻑ ﺒﺄﺤﺭﻑ ﻜﻠﻬﺎ ﻜﺒﻴﺭﺓ‪ :‬ﻤﺜﺎل‪.PI :‬‬

‫ﺍﻟﻬﻴﻜل ﺍﻷﺴﺎﺴﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻓﻲ ‪ ،Java‬ﺍﻟﺒﻨﻴﺔ ﺍﻷﺴﺎﺴﻴﺔ ﺍﻷﻭﺴﻊ‬

‫‪19‬‬
 ‫ﺭﻏﻡ ﺃﻥ ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﺤﺎﻟﻲ )ﺍﻟﻤﺜﺎل ﺍﻟﻌﺎﻡ‪ :‬ﺤل ﻤﻌﺎﺩﻟﺔ ﻤﻥ ﺍﻟﺩﺭﺠﺔ ﺍﻟﺜﺎﻨﻴﺔ( ﺃﻁﻭل ﺒﻜﺜﻴﺭ ﻤﻥ‬
‫ﺍﻟﺒﺭﻨﺎﻤﺞ ﺍﻟﺴﺎﺒﻕ‪ ،‬ﻓﻬﻭ ﻴﻤﻠﻙ ﺍﻟﺒﻨﻴﺔ ﺍﻷﺴﺎﺴﻴﺔ ﺍﻟﺘﻲ ﺫﻜﺭﻨﺎﻫﺎ ﻓﻲ ﺍﻟﺒﻨﻴﺔ ﺍﻟﺒﺴﻴﻁﺔ‪:‬‬
‫{ ‪class ClassName‬‬

‫{ ) ‪public static void main( String[] arg‬‬

‫‪Instructions‬‬
‫‪……….‬‬
‫}‬
‫}‬
‫ﻭﻤﺎﺯﺍﺩ ﻋﻠﻰ ﺘﻠﻙ ﺍﻟﺒﻨﻴﺔ ﻤﻭﻀﺢ ﺒﺎﻟﺘﻌﻠﻴﻕ ﺍﻟﻤﻭﻀﻭﻉ ﻋﻠﻰ ﺃﺴﻁﺭ ﺍﻟﺒﺭﻨﺎﻤﺞ‪.‬‬
‫ﺍﻟﺴﻁﺭ ‪:1‬‬ ‫‪9‬‬

‫‪ ،‬ﻓﻔﻲ ﻫﺫﺍ ﺍﻟﺒﺭﻨﺎﻤﺞ‬ ‫‪package‬‬ ‫ﻤﻥ ﺤﺯﻤﺔ ﺒﺭﻤﺠﻴﺔ‬ ‫‪class‬‬ ‫ﻟﺼﻑ‬ ‫‪import‬‬ ‫ﻋﺒﺎﺭﺓ ﺍﻻﺴﺘﻴﺭﺍﺩ‬
‫)ﺴﻨﺴﺘﺨﺩﻡ ﻤﻨﻬﺎ ﻤﺎ ﻴﻘﻭﻡ‬ ‫ﺍﻟﺼﻑ ‪JOptionPane‬‬ ‫ﻨﺤﻥ ﺒﺤﺎﺠﺔ ﻟﻭﻅﺎﺌﻑ ﺠﺎﻫﺯﺓ ﻤﻌﺭﻓﺔ ﻓﻲ‬
‫ﺒﺘﻌﻠﻴﻤﺔ ﺍﻹﺩﺨﺎل(‪.‬‬

‫‪20‬‬
 ‫ﺘﻜﻭﻥ ﻋﺒﺎﺭﺍﺕ ﺍﻻﺴﺘﻴﺭﺍﺩ ﺩﻭﻤﹰﺎ ﻓﻲ ﺃﻭل ﺍﻟﻨﺹ ﺍﻟﺒﺭﻤﺠﻲ‪.‬‬
‫ﺍﻟﺸﻜل ﺍﻟﻌﺎﻡ ﻟﻌﺒﺎﺭﺓ ﺍﻻﺴﺘﻴﺭﺍﺩ‪:‬‬
‫;‪import Package.ClassName‬‬
‫ﺍﺴﺘﻴﺭﺍﺩ ﺍﻟﺼﻑ ‪ ClassName‬ﻤﻥ ﺍﻟﺤﺯﻤﺔ ‪.Package‬‬
‫ﺃﻭ‬
‫;*‪import Package.‬‬
‫ﺍﺴﺘﻴﺭﺍﺩ ﺠﻤﻴﻊ ﺍﻟﺼﻔﻭﻑ ﻤﻥ ﺍﻟﺤﺯﻤﺔ ‪.Package‬‬
‫‪ ،‬ﺜﻡ ﻨﻘﻁﺔ‪ ،‬ﺜﻡ ﺍﺴﻡ ﺍﻟﺤﺯﻤﺔ‬ ‫‪javax‬‬ ‫ﺃﻭ‬ ‫‪java‬‬ ‫ﺍﻷﻜﺜﺭ ﺍﺴﺘﺨﺩﺍﻤﹰﺎ ﺘﺒﺩﺃ ﺒـ‬ ‫‪Java‬‬ ‫ﺍﻟﺤﺯﻡ ﺍﻟﺒﺭﻤﺠﻴﺔ ﻓﻲ‬
‫ﺍﻟﻤﺴﺘﺨﺩﻤﺔ‪:‬‬
‫ﻭﺒﺎﻟﺘﺎﻟﻲ‪:‬‬
‫‪Package‬‬
‫‪javax.PackagenName‬‬ ‫ﺃﻭ‬ ‫ﻫﻲ ‪java. PackagenName‬‬

‫ﻤﺜﺎل‪:‬‬
‫;‪import javax.swing.JOptionPane‬‬
‫‪7,8, 9, 10‬‬ ‫ﺍﻷﺴﻁﺭ‬ ‫‪9‬‬

‫ﻭﻓﻴﻬﺎ ﺍﻟﺘﺼﺭﻴﺢ ﻋﻥ ﺍﻟﻤﺘﺤﻭﻻﺕ‪ ،‬ﻭﻏﺎﻟﺒﹰﺎ ﻴﻜﻭﻥ ﺍﻟﺘﺼﺭﻴﺢ ﻋﻥ ﺍﻟﻤﺘﺤﻭﻻﺕ ﻓﻲ ﺃﻭل ﺍﻟﺒﺭﻨﺎﻤﺞ‬

‫ﺒﺎﻟﺘﺼﺭﻴﺢ ﻋﻥ ﺍﻟﻤﺘﺤﻭﻻﺕ ﻓﻲ ﺃﻱ ﻤﻜﺎﻥ ﻓﻲ‬ ‫‪Java‬‬ ‫ﺃﻱ ﻗﺒل ﺍﻟﺘﻌﻠﻴﻤﺎﺕ‪ .‬ﻭﻟﻜﻥ ﺘﺴﻤﺢ‬
‫ﺍﻟﺒﺭﻨﺎﻤﺞ‪ ،‬ﺒﺎﻟﻁﺒﻊ ﻴﺼﺭﺡ ﻋﻥ ﺍﻟﻤﺘﺤﻭل ﻗﺒل ﺍﺴﺘﺨﺩﺍﻤﻪ ﻓﻲ ﺃﻱ ﺘﻌﻠﻴﻤﺔ‪.‬‬
‫ﻨﻨﺼﺢ ﺒﺎﻟﺘﺼﺭﻴﺢ ﻋﻥ ﻜﺎﻤل ﺍﻟﻤﺘﺤﻭﻻﺕ ﻓﻲ ﺃﻭل ﺍﻟﺒﺭﻨﺎﻤﺞ‪.‬‬
‫ﻤﻼﺤﻅﺔ ﻫﺎﻤﺔ‪:‬‬
‫)ﺍﺴﻡ ﻤﺘﺤﻭل ﺃﻭﺍﺴﻡ ﻭﻅﻴﻔﺔ ‪ :‬ﺘﺎﺒﻊ‪/‬ﺇﺠﺭﺍﺀ( ﻏﻴﺭ ﻤﺼﺭﺡ ﻋﻨﻪ ﻓﻲ‬ ‫‪identifier‬‬ ‫ﻜل ﺍﺴﻡ ﺘﻌﺭﻴﻑ‬
‫ﻓﻬﻭ‪:‬‬ ‫ﻤﻥ ﺤﺯﻤﺔ ﻤﻌﻴﻨﺔ‪،‬‬ ‫‪import‬‬ ‫ﺍﻟﻨﺹ ﺍﻟﺒﺭﻤﺠﻲ ﻭﻟﻴﺱ ﻤﺴﺘﻭﺭﺩﹰﺍ ﺒﻌﺒﺎﺭﺓ ﺒﺭﻤﺠﻴﺔ ﺼﺭﻴﺤﺔ‬
‫‪ ،‬ﻭﺍﻟﺘﻲ ﺘﻌﺘﺒﺭ ﺠﻤﻴﻊ ﺍﻟﺼﻔﻭﻑ ﻓﻴﻬﺎ ﻤﺴﺘﻭﺭﺩﺓ‬ ‫‪Java.lang‬‬ ‫ﺇﻤﺎ ﻤﻭﺠﻭﺩ ﻓﻲ ﺍﻟﺤﺯﻤﺔ ﺍﻟﻘﻴﺎﺴﻴﺔ‬
‫ﻀﻤﻨﻴﹰﺎ )ﻤﻨﻬﺎ ‪،(System, Math, String :‬‬
‫ﺃﻭ ﺨﻁﺄ‪.‬‬
‫‪:‬‬ ‫‪Java‬‬ ‫ﻭﻫﻜﺫﺍ ﺘﻜﻭﻥ ﺍﻟﺒﻨﻴﺔ ﺍﻷﺴﺎﺴﻴﺔ ﺍﻷﻭﺴﻊ ﻟﻠﻨﺹ ﺍﻟﺒﺭﻤﺠﻲ ﻓﻲ‬
‫;‪import Package.ClassName‬‬
‫{ ‪class ClassName‬‬
‫{ ) ‪public static void main( String[] arg‬‬
‫‪VariableDeclaration‬‬
‫‪Instructions‬‬
‫‪……….‬‬
‫}‬
‫}‬

‫‪21‬‬
 ‫ﻟﻠﻐﺔ ﺠﺎﻓﺎ‬ keywords ‫ﺍﻟﻜﻠﻤﺎﺕ ﺍﻟﻤﻔﺘﺎﺤﻴﺔ‬
(Java reserved words )

boolean
break
byte
case
catch
char
class
continue
default
do
double
else
extends
false
final
finally
float
for
if
implements
import
instanceof
int
interface
long
native
new
null
package
private
protected
public
return
short
static
super
switch
synchronized
this
throw
throws
transient
true
try
void
volatile
while

22
 ‫ﺘﻤﺎﺭﻴﻥ‬

‫ﺘﺩﺭﻴﺒﺎﺕ ﻤﺘﻔﺭﻗﺔ‪:‬‬
‫ﻭ‬ ‫‪Java‬‬ ‫ﺍﻨﻘل ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺎﺕ‪ ،‬ﺍﻟﺘﻲ ﻨﻔﺫﺘﻬﺎ ﻜﺘﻤﺎﺭﻴﻥ ﻓﻲ ﻓﺼل ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺔ‪ ،‬ﺇﻟﻰ ﺒﺭﺍﻤﺞ ﺒﻠﻐﺔ‬
‫ﺍﺨﺘﺒﺭﻫﺎ ﺒﺸﻜل ﺠﻴﺩ‪.‬‬

‫ﺤﺴﺎﺏ ﺍﻟﻘﺎﺴﻡ ﺍﻟﻤﺸﺘﺭﻙ ﺍﻷﻋﻅﻡ ﺒﻁﺭﻴﻘﺔ ﺒﺎﻗﻲ ﺍﻟﻘﺴﻤﺔ‪:‬‬

‫ﻴﻭﺠﺩ ﺨﻭﺍﺭﺯﻤﻴﺔ ﺃﺨﺭﻯ ﻟﺤﺴﺎﺏ ﺍﻟﻘﺎﺴﻡ ﺍﻟﻤﺸﺘﺭﻙ ﺍﻷﻋﻅﻡ‪ ،‬ﺘﺸﺒﻪ ﺨﻭﺍﺭﺯﻤﻴﺔ ﺇﻗﻠﻴﺩﺱ ﻭﻟﻜﻨﻬﺎ‬
‫)‪if (a>b) ( a = a % b‬‬ ‫ﻻ ﻤﻥ ﺍﻟﻁﺭﺡ ‪:‬‬
‫ﺘﺴﺘﺨﺩﻡ ﺒﺎﻗﻲ ﺍﻟﻘﺴﻤﺔ ﻟﻠﻌﺩﺩ ﺍﻷﻜﺒﺭ ﻋﻠﻰ ﺍﻷﺼﻐﺭ‪ ،‬ﺒﺩ ﹰ‬
‫‪ ،…else‬ﻴﺠﺭﻱ ﺘﻜﺭﺍﺭ ﺫﻟﻙ ﻤﺎﺩﺍﻡ ﻟﻡ ﻴﺼل ﺃﺤﺩ ﺍﻟﻌﺩﺩﻴﻥ ﻟﻠﺼﻔﺭ‪ ،‬ﻋﻨﺩﻫﺎ ﻴﻜﻭﻥ ﺍﻟﻌﺩﺩ ﺍﻵﺨﺭ ﻫﻭ‬
‫ﺍﻟﻘﺎﺴﻡ ﺍﻟﻤﺴﺘﺭﻙ ﺍﻷﻋﻅﻡ‪.‬‬

‫ﺘﻭﺠﻴﻪ‪:‬‬
‫ﻭ ‪.8‬‬ ‫‪12‬‬ ‫‪،‬‬ ‫‪4‬‬ ‫ﻭ‬ ‫‪3‬‬ ‫ﺍﺨﺘﺒﺭ ﺍﻟﻔﻜﺭﺓ ﺍﻟﺘﻲ ﺍﻟﻤﻁﺭﻭﺤﺔ ﻴﺩﻭﻴﹰﺎ ﻓﻲ ﺠﺩﻭل ﻤﻥ ﺃﺠل ﻋﺩﺓ ﺤﺎﻻﺕ‪:‬‬
‫ﺍﻜﺘﺏ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺔ‪ ،‬ﺠﺭﺒﻬﺎ ﻴﺩﻭﻴﺎﹸ‪ ،‬ﺜﻡ ﺍﻨﺘﻘل ﺇﻟﻰ ﺍﻟﻨﺹ ﺍﻟﺒﺭﻤﺠﻲ ﺒﻠﻐﺔ ‪.Java‬‬

‫ﺍﻟﺤل ﺍﻟﻌﺎﻡ ﻟﻤﻌﺎﺩﻟﺔ ﺍﻟﺩﺭﺠﺔ ﺍﻟﺜﺎﻨﻴﺔ ﻤﻊ ﻜﺘﺎﺒﺔ ﺍﻟﺠﺫﻭﺭ ﺍﻟﻌﻘﺩﻴﺔ‬

‫ﻓﻲ ﺍﻟﻤﺜﺎل ﺍﻟﺘﻌﻠﻴﻤﻲ ﺍﻟﻤﻌﺭﻭﺽ ﻟﺤل ﻤﻌﺎﺩﻟﺔ ﻤﻥ ﺍﻟﺩﺭﺠﺔ ﺍﻟﺜﺎﻨﻴﺔ‪ ،‬ﻴﺘﻀﻤﻥ ﺍﺨﺘﺒﺎﺭ‬ ‫‪Java‬‬ ‫ﺇﻥ ﺒﺭﻨﺎﻤﺞ‬
‫! ﻭﻫﺫﺍ ﻗﺩ ﻴﻜﻭﻥ ﻤﺼﺩﺭ‬ ‫)‪if (delta == 0‬‬ ‫ﻴﺴﺎﻭﻱ ﺍﻟﺼﻔﺭ!‬ ‫‪delta‬‬ ‫ﺍﻟﻤﺴﺎﻭﺍﺓ ﻟﻸﻋﺩﺍﺩ ﺍﻟﺤﻘﻴﻘﻴﺔ!‬
‫ﻟﺨﻁﺄ ﻜﻤﺎ ﻨﻭﻫﻨﺎ‪ .‬ﻴﻤﻜﻨﻙ ﺍﺨﺘﺒﺎﺭﻩ ﻋﻠﻰ ﺍﻟﻜﺜﻴﺭ ﺍﻟﻜﺜﻴﺭ ﻤﻥ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻭﻴﻌﻤل ﻤﻌﻬﺎ ﺒﺸﻜل ﺼﺤﻴﺢ‪.‬‬
‫ﻭﻟﻜﻨﻪ ﻟﻴﺱ ﺼﺤﻴﺢ ﺒﺎﻟﻤﻁﻠﻕ! ﻓﻬﻭ ﻻ ﻴﻌﻁﻲ ﺍﻟﻨﺘﻴﺠﺔ ﺍﻟﺼﺤﻴﺤﺔ ﻓﻲ ﺤﺎﻟﺔ ﺃﻋﺩﺍﺩ ﺤﻘﻴﻘﻴﺔ ﻏﻴﺭ‬
‫‪.‬‬ ‫‪1./3‬‬ ‫ﻤﻨﺘﻬﻴﺔ‪ .‬ﻤﺜل ﺤﺎﻟﺔ ﺠﺫﺭ ﻤﻀﺎﻋﻑ‬
‫ﺠﺭ‪‬ﺏ ﺒﻌﺽ ﺍﻟﺘﻐﻴﻴﺭ ﻓﻲ ﺍﻟﺒﺭﻨﺎﻤﺞ ﻟﺘﺠﺎﻭﺯ ﻫﺫﺍ ﺍﻟﺨﻁﺄ‪ ،‬ﻭﻟﻜﻨﻨﺎ ﺴﻨﻁﻠﺏ ﻤﻨﻙ ﺘﺠﺎﻭﺯ ﻫﺫﻩ ﺍﻟﻤﺸﻜﻠﺔ‬
‫ﻋﺒﺭ ﻭﻀﻊ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺔ ﺍﻟﻌﺎﻤﺔ ﻟﺤل ﻤﻌﺎﺩﻟﺔ ﺍﻟﺩﺭﺠﺔ ﺍﻟﺜﺎﻨﻴﺔ ﺒﻤﺎ ﻓﻴﻬﺎ‪ ،‬ﺍﻟﺠﺫﻭﺭ ﺍﻟﻌﻘﺩﻴﺔ ﺍﻟﺘﻲ ﺴﺘﻜﺘﺒﻬﺎ‬
‫ﺒﺎﻟﺸﻜل‪:‬‬
‫ﺍﻟﺠﺯﺀ ﺍﻟﻌﻘﺩﻱ‪.‬‬ ‫‪y‬‬ ‫ﺍﻟﺠﺯﺀ ﺍﻟﺤﻘﻴﻘﻲ‪،‬‬ ‫‪x‬‬ ‫‪ ،‬ﺤﻴﺙ‬ ‫‪x+yi‬‬

‫ﺘﻭﺠﻴﻪ‪:‬‬
‫ﺍﻜﺘﺏ ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺔ ﻋﺒﺭ ﺍﻟﺘﻌﺒﻴﺭ ﻋﻨﻬﺎ ﺒﺘﻤﻴﻴﺯ ﺠﻤﻴﻊ ﺤﺎﻻﺕ ﻗﻴﻡ ﺍﻟﻤﻌﻴﻥ ‪ ،delta‬ﻭﻟﻜﻥ ﺒﺎﺴﺘﺨﺩﺍﻡ‬
‫ﺍﻟﺘﻌﻠﻴﻤﺔ ﺍﻟﺸﺭﻁﻴﺔ ﻤﺯﺩﻭﺠﺔ ﺍﻟﺘﻔﺭﻴﻊ ﺇﺫﺍ ‪ ...‬ﻭﺇﻻ ﺇﺫﺍ ‪...‬ﻭﺇﻻ‪ ،...‬ﻋﻠﻰ ﻨﺤﻭ ﻤﻬﻴﻜل ‪ ،‬ﻻ ﺘﺴﺘﺨﺩﻡ‬
‫ﻫﻨﺎ ﺘﻌﻠﻴﻤﺔ ﺇﺫﺍ ﻓﻘﻁ‪.‬‬
‫ﺍﻨﻘل ﺍﻟﺨﻭﺍﺭﺯﻤﻴﺔ ﺇﻟﻰ ﺒﺭﻨﺎﻤﺞ ﺒﻠﻐﺔ ‪ ،Java‬ﻭﻗﻡ ﺒﺎﺨﺘﺒﺎﺭﻩ ﻋﻠﻰ ﺍﻟﻌﺩﻴﺩ ﻤﻥ ﺍﻟﻤﻌﻁﻴﺎﺕ ﻟﻴﻐﻁﻲ ﺠﻤﻴﻊ‬

‫‪23‬‬
‫ﺍﻟﺤﺎﻻﺕ ﺍﻟﺘﻲ ﻴﻌﺎﻟﺠﻬﺎ ﺍﻟﺤل‪.‬‬

‫‪24‬‬