פונקציות קרן כליף

ביחידה זו נלמד: טווח הכרה של משתנים מהי פונקציה, פרמטרים וערך מוחזר כיצד נראה הזיכרון ספריות של פונקציות מערכים כפרמטר לפונקציה מערכים המוחזרים מפונקציה העמסת פונקציות מערך אנונימי המחלקה Math תהליך הקומפילציה וההרצה בשפת JAVA

טווח הכרה של משתנים public static void main(String[] args) { int x = 8, y=2; if (x < 10) { int z = 5; int y = 3; } if (y < 10) { int z = 7; System.out.println("z=" + z); לא ניתן להגדיר משתנים בעלי שם זהה בבלוקים מקוננים // duplicate local variable ניתן להגדיר משתנים בעלי שם זהה בבלוקים עוקבים משתנה המוגדר בתוך בלוק מוכר אך ורק בבלוקים הפנימיים לו // z cannot be resolved

דוגמא לשכפול קוד: חישוב חלוקת log רצף הפעולות לחישוב לוג זהה, רק כל פעם ביצענו את הפעולות על ערכים שונים  שכפול קוד! מי שקורא את ה- main צריך להבין מה תפקידה של כל לולאה... public static void main(String[] args) { final int BASIS = 10; int num1=100, num2=1000, res; int log1, log2; res = 1; for (log1=0 ; res < num1 ; log1++) res *= BASIS; System.out.printf("log(%d) = %d\n", num1, log1); for (log2=0 ; res < num2 ; log2++) System.out.printf("log(%d) = %d\n", num2, log2); System.out.printf("log(%d/%d) = %d\n", num1, num2, log1-log2); { חישוב log10100 תזכורת: logca ≡ c?=a חישוב 0log10100

הדוגמא ללא שכפול קוד, קריאות טובה ומודלריות עם השימוש בפונקציה הקוד קצר יותר וקריא יותר! ה- main כתוב ב"ראשי פרקים" וניתן להבין בקלות מה הוא מבצע טיפוס המידע שהפונקציה מחזירה שם הפונקציה. יעיד מה היא עושה public static int log10(int num) { final int BASIS = 10; int res = 1, i; for (i=0 ; res < num ; i++) res *= BASIS; return i; { public static void main(String[] args) { int num1=100, num2=1000, res; res = log10(num1) – log10(num2); System.out.printf("log(%d/%d) = %d\n", num1, num2, res); הנתון שהפונקציה צריכה לקבל איך הפונקציה מבצעת את העבודה הערך שהפונקציה מחזירה שימוש בערך שהפונקציה מחזירה קריאה לפונקציה שיודעת לחשב log, פעם עם num1 ופעם עם num2

מהי פונקציה פונקציה היא אוסף הוראות לביצוע שמממשות רעיון משותף ראינו פונקציות בעבר: println, Math.random ועוד גם ה- main שאנחנו כותבים הוא פונקציה עבורנו פונקציות אלו הן "קופסא שחורה" שקיבלנו מספריה מסוימת, ואנו רק יודעים מה הן עושות, אבל לא יודעים איך, כלומר מהו אוסף הפעולות המבוצעות בשיעור זה נלמד לכתוב פונקציות בעצמנו!

פונקציות - מוטיבציה מודולריות: חלוקת התוכנית לקטעי קוד יותר קטנים, כאשר כל קטע עושה משהו נקודתי יתרונות: קוד יותר קריא יותר קל לבדוק את התוכנית חלוקת עבודה שימוש חוזר בקוד חיסכון בבדיקות פחות שגיאות

תזכרו! http://www.thedistractionnetwork.com/images/programming-fail-007.jpg

דוגמא לשימוש בפונקציה public static void main(String[] args) { int res= Math.pow(2, 3); System.out.println(“The result is“ + res); } הערך המוחזר מהפונקציה שם הפונקציה הנתונים המועברים. כל נתון נקרא ארגומנט.

החלקים בשילוב פונקציה שלנו בקוד הצהרה על הפונקציה כאשר כותבים פונקציה ראשית צריך להחליט מה הפונקציה עושה לאחר שהחלטנו על ה"מה", יש להחליט אילו נתונים הפונקציה צריכה לקבל כדי לבצע את העבודה לבסוף נגדיר מה הטיפוס שהפונקציה מחזירה לנו שימוש בפונקציה מימוש הפונקציה

איך כותבים הצהרה של פונקציה דוגמא: פונקציה המחשבת חזקה מה הפונקציה עושה: הפונקציה מחשבת חזקה של שני מספרים מה הפונקציה מקבלת: 2 מספרים, הראשון בסיס והשני מעריך מה הפונקציה מחזירה: את תוצאת חישוב הבסיס במעריך לבחור שם משמעותי לפונקציה int base int exponent תחביר: public static int power(int base, int exponent) ובאופן כללי: baseexponent int power public static <returned value type> <function_name> (<parameters list>)

בחירת שם לפונקציה שם הפונקציה צריך להעיד מה היא עושה למשל: power, log10 מבחינת סגנון כתיבה, ההמלצה היא: שם הפונקציה יתחיל באות קטנה אם יש יותר ממילה אחת בשם הפונקציה כל מילה נוספת תתחיל באות גדולה למשל: calcRectangleArea ב- JAVA זהו סגנון הכתיבה הרשמי, אל תמציאו סגנון חדש!

הצהרת פונקציה - הערך המוחזר (1) הערך המוחזר יכול להיות כל אחד מהטיפוסים שאנחנו מכירים למשל, פונקציה המקבלת אורך צלע ריבוע ומחזירה את שטחו public static int calcSquareArea(int length) למשל, פונקציה המקבלת מספר, ומחזירה את השורש שלו public static double sqrt(int num)

הצהרת פונקציה - הערך המוחזר void החזרה = ניתן לאכסן ערך במשתנה כלשהו שימו לב: הדפסה למסך אינה החזרה של ערך! למשל, פונקציה ריבוע המדפיסה למסך public static void printSquare(int length)

הצהרת פונקציה – הפרמטרים המועברים רשימת הנתונים אשר הפונקציה מקבלת מופרדת ע"י פסיקים דוגמא: פונקציה המקבלת אורך ורוחב של מלבן ומחזירה את שטחו public static int calcRectangleArea(int height, int width) דוגמא: פונקציה המקבלת מספר n ומחזירה n! public static int factorial(int num) אם פונקציה אינה מקבלת נתונים, רשימת הפרמטרים תהייה ריקה למשל, פונקציה הקוראת מהמשתמש את גילו ומחזירה אותו public static int readAge()

הפקודה return מציינת מהו הערך שהפונקציה חישבה עבור ההחזרה מימוש פונקציה דוגמא למימוש פונקציה המקבלת בסיס ומעריך, ומחזירה את החזקה public static int power(int a, int b) { int result=1; for (int i=0 ; i < b ; i++) result *= a; return result; } הפקודה return מציינת מהו הערך שהפונקציה חישבה עבור ההחזרה

תוכנית שלמה עם פונקציה הצהרה + מימוש אחסון הערך המוחזר מהפונקציה שימוש public static int power( , ) { int result=1; for (int i=0 ; i < b ; i++) result *= a; return result; } public static void main(String[] args) { Scanner s = new Scanner(System.in); int base, exponent, result; System.out.print("Please enter base and exponent: "); base = s.nextInt(); exponent = s.nextInt(); = power( , ); System.out.printf("%d^%d=%d\n", base, exponent, result); int a int b הצהרה + מימוש יש להעביר לפונקציה משתנים כמספר הפרמטרים שהיא דורשת, מאותו הסוג ובאותו הסדר! נשים לב כי בקריאה לפונקציה מעבירים רק את שמות המשתנים, ולא את הטיפוסים, בניגוד להצהרת ומימוש הפונקציה! אחסון הערך המוחזר מהפונקציה שימוש result base exponent

אבל זהירות! http://funnypictures4u.files.wordpress.com/2013/06/people_vs_programmers.jpg

דוגמא: תוכנית שלמה עם הפונקציה max public static int max (int x, int y) { if (x > y) return x; else return y; } public static void main(String[] args) { Scanner s = new Scanner(System.in); int num1, num2, maximum; System.out.print("Enter 2 numbers: "); num1 = s.nextInt(); num2 = s.nextInt(); max(num1, num2); System.out.println("The max is “ + maximum); Formal Parameters Actual Parameters בשורה זו מוערך הביטוי מימין וערכו נכנס לתוך המשתנה maximum. לא חייבים לאחסן את הערך המוחזר! maximum =

ואפשר גם כך.. return x > y ? x : y; public static int max (int x, int y) { if (x > y) return x; return y; // witout the ‘else’… } public static void main(String[] args) { Scanner s = new Scanner(System.in); int num1, num2, maximum; System.out.print("Enter 2 numbers: "); num1 = s.nextInt(); num2 = s.nextInt(); maximum = max(num1, num2); System.out.println("The max is “ + maximum); return x > y ? x : y;

אגב, זו לא פונקצית random טובה ;-) https://sslimgs.xkcd.com/comics/random_number.png

מחסנית הקריאות כאשר קוראים לפונקציה, למעשה "קופצים" לאוסף הפקודות שלה, ושומרים את מקום החזרה כאשר נתקלים בפקודה return בתוך גוף הפונקציה, חוזרים לביצוע הפעולות מהמקום בו קראנו לה

תוכנית שלמה עם פונקציה - הרצה public static int power(int a, int b) { int result=1; for (int i=0 ; i < b ; i++) result *= a; return result; } public static void main(String[] args) { Scanner s = new Scanner(System.in); int base, exponent, result; System.out.print("Please enter base and exponent: "); base = s.nextInt(); exponent = s.nextInt(); = power(base, exponent); System.out.printf("%d^%d=%d\n", base, exponent, result); power main ( line 6) מחסנית הקריאות result

סדר ביצוע פעולות קודם תבוצע הפונקציה public static int power(int a, int b) { System.out.println("debuging.. in 'power‘”); int result=1; for (int i=0 ; i < b ; i++) result *= a; return result; } public static void main(String[] args) { System.out.println("2^3=“ + power(2, 3)); קודם תבוצע הפונקציה

ביצוע הפונקציות מתבצע לפי הסדר סדר ביצוע פעולות (2) public static int power(int a, int b) { System.out.printf("debuging.. in 'power': a=%d b=%d\n", a, b); int result=1; for (int i=0 ; i < b ; i++) result *= a; return result; } public static void main(String[] args) { System.out.printf("2^4=%d, 2^5=%d\n", power(2, 4), power(2, 5)); ביצוע הפונקציות מתבצע לפי הסדר

תוכנית שלמה עם פונקציה - הזיכרון int:base 2 int: exponent 3 int: result ??? int:base 2 int: exponent 3 int: result 8 int:base ??? int: exponent int: result public static int power(int a, int b) { int result=1; for (int i=0 ; i < b ; i++) result *= a; return result; } public static void main(String[] args) { Scanner s = new Scanner(System.in); int base, exponent, result; System.out.print("Please enter base and exponent: "); base = s.nextInt(); exponent = s.nextInt(); = power(base, exponent); System.out.printf("%d^%d=%d\n", base, exponent, result); הזיכרון של ה- main המשתנה result שב-main וזה שבפונקציה אינם אותו משתנה, ואין הכרח שהם יהיו עם שם זהה! int: a 2 int: b 3 int: i … int: result 1 int: a 2 int: b 3 int: i … int: result 8 int: a 2 int: b 3 int: i ??? int: result הזיכרון של power power main ( line 6) result מחסנית הקריאות

כיצד נראה הזיכרון - סיכום כיצד נראה הזיכרון - סיכום ראינו את הזיכרון של ה- main תזכורת: ה- main הוא פונקציה לכל פונקציה יש שטח נפרד בזיכרון ה- stack בו מוגדרים משתניה פונקציה יכולה לגשת לשטח הזיכרון שלה בלבד, ולכן אינה יכולה לגשת למשתנים שהוגדרו בפונקציות אחרות הפרמטרים המועברים לפונקציה הם גם משתנים של הפונקציה הפרמטרים המועברים לפונקציה הם העתקים של המשתנים שנשלחו, ולכן העברת פרמטרים כזו נקראת by value כאשר יוצאים מפונקציה, התאים במחסנית שבהם נשמרו ערכיה נמחקים, ולכן קריאה נוספת לפונקציה תייצר אותם מחדש

תכנון TOP-DOWN כאשר ניגשים לכתוב תוכנית, יש לחשוב מהי הבעיה הגדולה שעלינו לפתור ונחלק אותה לחלקים לכל חלק "קשה" נתייחס כאל "קופסא שחורה" (שתמומש בהמשך) כאשר נממש כל חלק "קשה" אנו מתמודדים עם בעיה יותר קטנה שננסה גם אותה לפרק לבעיות יותר קטנות, עד אשר נגדיר בעיות מספיק קטנות

תכנות TOP-DOWN דוגמה: ציור משולש public static void printLine(int length, char ch) { for ( ; ; ) System.out.print(ch); System.out.println(); } public static void printTriangle(int base, char ch) { for( ; ; ) printLine(i, ch); int i=1 i<=length i++ $ $ $ int: length 1 char: ch ‘$’ int: i int: length 2 char: ch ‘$’ int: i 1 int: length 1 char: ch ‘$’ int: i 2 int: length 2 char: ch ‘$’ int: i ??? int: length 3 char: ch ‘$’ int: i ??? int: length 3 char: ch ‘$’ int: i int: length 3 char: ch ‘$’ int: i 4 int: length 3 char: ch ‘$’ int: i 2 int: length 3 char: ch ‘$’ int: i 1 int: length 2 char: ch ‘$’ int: i 3 int: length 2 char: ch ‘$’ int: i int: length 1 char: ch ‘$’ int: i ??? $ $ $ הזיכרון של printLine int i=1 i<=base i++ print Line int: base 3 char: ch ‘$’ int: i 1 int: base 3 char: ch ‘$’ int: i 2 int: base 3 char: ch ‘$’ int: i int: base 3 char: ch ‘$’ int: i 4 int: base 3 char: ch ‘$’ int: i ??? print Triangle (line 2) public static void main(String[] args) { Scanner s = new Scanner(System.in); int base; char ch; System.out.println("Enter base and char: "); base = s.nextInt(); ch = s.next().charAt(0); printTriangle(base, ch); } main ( line 7) הזיכרון של printTriangle מחסנית הקריאות int: base 3 char: ch ‘$’ int: base ??? char: ch הזיכרון של ה- main

דוגמה: חישוב מרחק בין 2 נקודות הנוסחא לחישוב מרחק בין 2 הנקודות (x1,y1) ו- (x2,y2): נרצה לכתוב פונקציה המקבלת 4 קואורדינטות המייצגות 2 נקודות, ומחזירה את המרחק ביניהן: int x1 int y1 int x2 int y2 לכן ההצהרה של הפונקציה תראה כך: public static float distance(int x1, int y1, int x2, int y2) distance float dist

דוגמה: חישוב מרחק בין 2 נקודות (2) הנוסחא לחישוב מרחק בין 2 הנקודות (x1,y1) ו- (x2,y2): ניתן לראות שכדי לחשב מרחק בין שתי נקודות צריך לדעת לחשב חזקה ושורש, לכן נגדיר ונשתמש ב- 2 פונקציות עזר: sqrt המקבלת מספר float ומחזירה את השורש שלו. פונקציה זו כבר קיימת ב- Math power שאותה נכתוב בעצמנו לצורך התרגול (למרות שהיא גם קיימת ב- Math)

דוגמה: חישוב מרחק בין 2 נקודות – תרשים הפונקציה distance x2-x1 x1 y1 x2 y2 power sqrt 2 result + y2-y1 power 2

גם ל- power יש מרחב זיכרון, אך לא נראה אותו פה מפאת חוסר מקום ;+) public static float distance(int x1, int y1, int x2, int y2) { float xDiffPower, yDiffPower, result; power(x2-x1, 2); power(y2-y1, 2); Math.sqrt(xDiffPower+yDiffPower); return result; } int: x1 int: y1 int: x2 4 int: y2 float: dist 5.6 int: x1 ??? int: y1 int: x2 int: y2 float: dist int: x1 int: y1 int: x2 4 int: y2 float: dist ??? xDiffPower = yDiffPower = result = הזיכרון של ה- main public static void main(String[] args) { Scanner s = new Scanner(System.in); int x1, y1, x2, y2; System.out.print("Please enter 2 points (x1, y1, x2, y2): "); x1 = s.nextInt(); y1 = s.nextInt(); x2 = s.nextInt(); y2 = s.nextInt(); distance(x1, y1, x2, y2); System.out.printf("The distance is %f\n", dist); } public static int power(int base, int exponent) { int i, result=1; for (i=0 ; i < exponent ; i++) result *= base; return result; int: x1 int: y1 int: x2 4 int: y2 float: xDiffPower 16 float: yDiffPower float: result ??? int: x1 int: y1 int: x2 4 int: y2 float: xDiffPower 16 float: yDiffPower ??? float: result int: x1 int: y1 int: x2 4 int: y2 float: xDiffPower 16 float: yDiffPower float: result 5.6 int: x1 int: y1 int: x2 4 int: y2 float: xDiffPower ??? float: yDiffPower float: result float dist = הזיכרון של distance power sqrt distance (line 3) distance (line 4) distance (line 4) גם ל- power יש מרחב זיכרון, אך לא נראה אותו פה מפאת חוסר מקום ;+) main ( line 8) מחסנית הקריאות

דוגמה איך לא כותבים פונקציה public static void power() { Scanner s = new Scanner(System.in); int base, exponent, result=1; System.out.print("Please enter base and exponent: "); base = s.nextInt(); exponent = s.nextInt(); for (int i=0 ; i < exponent ; i++) result *= base; System.out.println("The result is “ + result); } public static void main(String[] args) { power();

מדוע לא לכתוב קוד כמו הדוגמה הקודמת? ניתן לעקוף חלקית את הרעיון של העברת ארגומנטים והחזרת ערך מפונקציות ע"י כך שפונקציה תבקש מהמשתמש את הנתונים ותדפיס בסוף את התוצאה למשל, כמו בדוגמא הקודמת, הפונקציה המחשבת חזקה לא קיבלה פרמטרים ולא החזירה את התוצאה לא נעשה זאת! נמנע מלקלוט קלט בתוך פונקציה, אלא אם זה יעוד הפונקציה הסיבה: יתכן ופונקציה אחרת צריכה להשתמש בנתון המתקבל או להעביר נתון, ולא ניתן לצפות מי ישתמש בפונקציה שלנו דוגמא: כמו בפונקציה distance הקוראת ל- power כדי לבדוק פונקציה, נקלוט את הנתונים ב- main ונעבירם לפונקציה. את התוצאה נדפיס ב- main.

מדוע לא לכתוב קוד כמו הדוגמה הקודמת? אם הפונקציה power אינה מקבלת ערכים, אלא קולטת מהמשתמש, לא ניתן להעביר אליה תוצאת חישוב כמו שנדרש בשאלה זו... distance x1 y1 x2 y2 power sqrt result + power

תזכורת למשמעות של העברה by value public static void incNumber(int x) { System.out.println("In function: number before: “ + x); x++; System.out.println("In function: number after: “ +x); { public static void main(String[] args) { int num = 3; System.out.println("In main: number before function: “ + num); incNumber(num); System.out.println("In main: number after function: “ + num); int: x 3 int: x 4 הזיכרון של incNumber int: num ?? int: num 3 הזיכרון של main

מערכים כפרמטר לפונקציה – דוגמא מערכים כפרמטר לפונקציה – דוגמא public static void incArray(int arr[]) { for (int i=0 ; i < arr.length ; i++) arr[i]++; } public static void printArray(int arr[]) { System.out.print(arr[i] + “ “); System.out.println(); int[]: arr הזיכרון של incArray int[]: arr הזיכרון של printArray 5 4 9 4 3 8 public static void main(String[] args) { int arr[] = {4,3,8}; System.out.println("Orig array: "); printArray(arr); incArray(arr); System.out.println("Array after increment: "); } int[]: arr הזיכרון של main

מערכים כפרמטר לפונקציה ראינו כי מערך מתנהג באופן שונה מאשר משתנה מטיפוס בסיסי כאשר מעבירים אותו לפונקציה כאשר מעבירים מערך לפונקציה, לא מועבר עותק של המערך (by value), אלא מועברת רק הפניה למערך לכן כאשר מעבירים מערך לפונקציה ומשנים אותו, השינוי משפיע על המערך המקורי, ולא על עותק – בניגוד לכל משתנה אחר שאנחנו מכירים! נסביר לעומק כאשר נלמד את השיעור על אובייקטים

העברת מטריצה לפונקציה – דוגמא public static void setMatrix(int mat[][]) } for (int i=0 ; i < mat.length ; i++) } for (int j=0 ; j < mat[i].length ; j++) mat[i][j] = (int)(Math.random()*10); { public static void printMatrix(int mat[][]) } System.out.printf("%4d", mat[i][j]); System.out.println(); העברת מטריצה לפונקציה – דוגמא public static void main(String[] args) { int[][] mat1 = new int[3][4], mat2 = new int[4][2]; setMatrix(mat1); setMatrix(mat2); System.out.println("Matrix 1:"); printMatrix(mat1); System.out.println("Matrix 2:"); printMatrix(mat2); {

הזיכרון של createRandomArr החזרת מערך מפונקציה public static int[] createRandomArr(int size) { int[] arr = new int[size]; for (int i=0 ; i < arr.length ; i++) arr[i] = (int)(Math.random()*100); return arr; } public static void main(String[] args) { Scanner s = new Scanner(System.in); System.out.print("How many elements? "); int size = s.nextInt(); int[] numbers = System.out.print("The numbers are: "); for (int i=0 ; i < numbers.length ; i++) System.out.print(numbers[i] + " "); System.out.println(); int: size 4 int[]: arr הזיכרון של createRandomArr 62 29 17 84 int: size 4 int[]: numbes int: size ??? int[]: numbes createRandomArr(size); הזיכרון של main

העברת מערך אנונימי לפונקציה public static void printArr(int[] arr) { for (int i=0 ; i < arr.length ; i++) System.out.print(arr[i] + " "); System.out.println(); } public static void main(String[] args) { int[] arr1 = {19, 32, 88, 49}; printArr(arr1); printArr(new int[] {47, 99, 10, 83, 72}); יצרנו מערך הנגיש אך ורק כפרמטר המועבר לפונקציה. מאחר ואין לו שם לא ניתן לפנות אליו בהמשך ה- main.

הקומפיילר יודע לאיזו גרסא לפנות בהתאם לסוג הפרמטרים הנשלחים public static int min(int x, int y) { return x < y ? x : y; } public static int min(int x, int y, int z) { if (x < y && x < z) return x; return y < z ? y : z; public static double min(double x, double y) { public static void main(String[] args) { System.out.println(min(1, 2)); System.out.println(min(1, 3, 2)); System.out.println(min(1.0, 2.0)); העמסת פונקציות הקומפיילר יודע לאיזו גרסא לפנות בהתאם לסוג הפרמטרים הנשלחים

פונקציות נפוצות שיש במחלקה Math cos, sin: מחשבות סינוס וקוסינוס בהתאמה (לשים לב שמקבלות זוית ברדיאנים, ולא במעלות) ceil: מעגלת מספר כלפי מעלה, מחזירה float floor: מעגלת מספר כלפי מטה, מחזירה float abs: נותנת ערך מוחלט של מספר pow: מחשבת חזקה sqrt: מחשבת שורש

דוגמאות חישוב public static void main(String[] args) { System.out.println("cos(90)=" + Math.cos(90)); System.out.println("sin(90)=" + Math.sin(90)); System.out.println("ceil(4.2)=" + Math.ceil(4.2)); System.out.println("floor(4.2)=" + Math.floor(4.2)); System.out.println("abs(-5.8)=" + Math.abs(-5.8)); System.out.println("abs(5)=" + Math.abs(5)); System.out.println("pow(2,3)=" + Math.pow(2, 3)); System.out.println("pow(8,0.5)=" + Math.pow(8, 0.5)); System.out.println("sqrt(16)=" + Math.sqrt(16)); System.out.println("sqrt(18)=" + Math.sqrt(18)); }

תהליך כתיבה והרצה של תוכנית ב- JAVA נכתב בעורך טקסטואלי כלשהו חומרת המחשב מערכת ההפעלה JVM Java Byte Code (קובץ עם סיומת class) קובץ JAVA מקומפל ל- byte code באמצעות קומפיילר של JAVA ה- JVM יפרש את הפקודות שב- byte code למערכת ההפעלה

דוגמאת עבודה דרך הקונסול

כתיבת והרצת תוכניות בקונסול סביבת העבודה שלנו מהווה מעטפת ויזואלים לכלים הבאים: עורך קומפיילר דיבגר ניתן לכתוב קובץ ב- notepad ולקמפל ולהריץ אותו דרך הקונסול

הרצת פקודת הקומפליציה javac קומפילציה דרך הקונסול הרצת פקודת הקומפליציה javac תוצר הקומפילציה הרצת התוצר פלט התוכנית

ביחידה זו למדנו: טווח הכרה של משתנים מהי פונקציה, פרמטרים וערך מוחזר כיצד נראה הזיכרון ספריות של פונקציות מערכים כפרמטר לפונקציה מערכים המוחזרים מפונקציה העמסת פונקציות מערך אנונימי המחלקה Math תהליך הקומפילציה וההרצה בשפת JAVA

תרגיל 1: מספר הפעמים שספרה מופיעה כתבו פונקציה המקבלת מספר וספרה, ומחזירה את מספר הפעמים שהספרה מופיעה במספר דוגמה: עבור המספר 137432 והספרה 3 יוחזר הערך 2 כתבו פונקציה המקבלת מערך של מספרים וספרה. הפונקציה תחזיר כמה פעמים הספרה מופיעה באיברי המערך דוגמה: עבור המערך [144, 47, 42, 74, 19] והספרה 4 הפונקציה תחזיר 5 מאחר והספרה 4 מופיעה 5 פעמים

תרגיל 2: חישוב קירוב לקוסינוס בתרגיל זה נממש את נוסחאת הקירוב לקוסינוס כתבו פונקציה המקבלת את הזוית X (ברדיאנים) וכן את רמת הקירוב n, הפונקציה תחזיר את ערך (cos(x שימו לב 1: נוסחה זו עובדת עד זויות של 35 רדיאנים שימו לב 2: על מנת שיצא קירוב טוב n צריך להיות בסביבות ה- 50 שימו לב 3: הערכים המתקבלים בחישובים עוברים את גבולות ה- int וה- long, ולכן עבדו עם double גם עבור ערכים שלמים ב- main השוו בין תוצאתכם המתקבלת מהפונקציה שכתבתם לבין התוצאה המתקבלת משימוש ב- Math.cos (שגם היא מקבלת את הזוית ברדיאנים) הקפידו על קוד מודולורי וכתבו פונקציות עזר

תרגיל 3: מערך המכיל ערכים משותפים כתוב פונקציה המקבלת כפרמטר 2 מערכים עם מספרים שלמים. הפונקציה תחזיר מערך חדש שיכיל את הערכים שקיימים בשני המערכים. דוגמה: עבור המערכים [32, 56, 12, 87] ו- [56, 21, 13, 87, 19] יוחזר המערך [56, 87] מאחר ושני ערכים אלו קיימים בשני המערכים. לחילופין, יכול לחזור המערך [87, 56], כלומר, סדר האיברים אינו חשוב.