םימצע החנומ תונכתל אובמ 8 רפסמ לוגרת object...

8תרגול מס' ,א"עסמסטר א' תש -מבוא למדעי המחשב

1

מבוא לתכנות מונחה עצמים: 8תרגול מספר

Object Oriented Programming

היום:

( מחלקותclasses( ואובייקטים )-instances,מופעיםobjects.) ( שדות המחלקהfields) ( שיטותmethods.של מחלקה )

ה מבצעות עד עכשיו השתמשנו רק במשתנים מטיפוסים פרימיטיביים ופונקציות שבעזרת המשתנים האל

חישובים או פעולות מסוימות. לעתים, משתנים המוגדרים בעזרת טיפוסים פרימיטיביים בלבד אינם

מספיקים לכתיבה נוחה של הקוד. למשל, אם נממש מערכת המנהלת רשומות סטודנטים, נשאף כי כל נתוני

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

. טיפוסים אלה יעזרו לנו לנהל ביתר קלות כמות גדולה של קוד. למשל, במקום Studentחדש הנקרא

לשלוח לפונקציה מסוימת רשימה ארוכה של פרמטרים המתארים סטודנט יחיד, נוכל עתה לשלוח פרמטר

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

לפי ת"ז או לפי ציון ממוצע, וכו'.

(, ולמשתנים הנוצרים מטיפוסים אלו קוראים classesלטיפוסים חדשים אלו קוראים "מחלקות" )

(. באנלוגיה לטיפוסים:instances( או מופעים )objectsאובייקטים )

int i;

Student s;

. לרוב נשתמש במונח "אובייקט" Studentלאובייקט מסוג המצביעהוא משתנה sל למעשה, בדוגמה הנ"

כאשר בעצם נתכוון להגיד "מצביע לאובייקט". אם זאת ישנם מקרים בהם נרצה להפריד בין שני המושגים

האלו, כפי שניראה בהמשך.

(. השמה fieldsדות" )מחלקה מגדירה את אוסף המשתנים הפנימיים אשר כל מופע שלה יכיל, הנקראים "ש

( של המופע. בנוסף, המחלקה גם מגדירה state" )המצבשל ערכים לשדות אלו עבור מופע מסוים נקראת "

(, methods" )שיטותאוסף של פונקציות אשר המופעים שלה יכולים להפעיל. פונקציות אלו נקראות "

יקרי בין פונקציה לשיטה הוא ( של המחלקה. ההבדל העbehavior" )ההתנהגותואוסף השיטות נקרא "

שלו. למשל, ההדפסה כתוצאה מהפעלת במצבששיטה מתבצעת בהקשר של אובייקט מסוים, והיא תלויה

( אשר יפעיל Studentיהיה תלוי באובייקט )מסוג Studentהמוגדרת במחלקה ()printNameהשיטה

שיטה זו.

יש מצב מסוים Stringל אובייקט מסוג . לכStringדוגמה למחלקה בה נתקלתם כבר היא המחלקה

יכולים String)המגדיר את סדרת התווים במחרוזת ספציפית(. בנוסף, ישנן שיטות שאובייקטים מסוג

התנהגות(. לדוגמה: –לבצע )כלומר

String str = "abcd";

System.out.println(str.charAt(2));

משתנה טיפוס

אובייקט מחלקה

charAt(int index) היא שיטה של

. Stringהמחלקה


2

הגדרת מחלקה = הגדרת טיפוס חדש

, a + biאת האופן בו יוצרים מחלקה חדשה בעזרת הדוגמה הבאה. מספר מרוכב הוא מספר מהצורה נדגים הם מספרים a,b. -1הוא השורש הריבועי של i-נקרא החלק המדומה ו bנקרא החלק הממשי, aכאשר

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

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

הכוללת שני שדות Complexנגדיר מחלקה חדשה בשם .javaפרימיטיבי עבור מספרים מרוכבים בשפת

.bהמייצג את החלק המדומה im-, וaהמייצג את החלק הממשי realממשיים: public class Complex

{

public double real;

public double im;

}

. כל אובייקט שניצור Complexמופעים( מטיפוס instances-המחלקה מגדירה כיצד יראו אובייקטים )

ניתן לחשוב על המחלקה .real, imשנקראים doubleממחלקה זו יאגד בתוכו שני משתנים מסוג

הם נשתמש.כ"תבנית" ממנה ניצוק את האובייקטים ב

על מנת ליצור מופע חדש משתמשים במילה השמורה new :"ובשיטה מיוחדת הנקראת "בנאי , Complex complexNum;

complexNum = new Complex();

", ששמו הוא Complex"מצביע לאובייקט מסוג מכריזה עלהשורה הראשונה בקוד לעיל

complexNum בשורה השנייה, הפקודה .new Complex() גורמת ליצירת אובייקט חדש מסוג

Complex וההשמה )=( גורמת למצביע ,complexNum .להצביע על אובייקט זה

גישה לשדות של אובייקט

אופרטור השייכות. –( .לאחר שהאובייקט נוצר ניתן לפנות לשדות שלו על ידי אופרטור הנקודה )

Complex complexNum;

complexNum = new Complex();

complexNum.real = 17.2;

complexNum.im = 1.3333;

System.out.println("The number: "+ complexNum.real + "+" +

complexNum.im + "i");


3

c2

נתבונן כעת בדוגמה המגדירה מספר אובייקטים ובתמונת הזיכרון במהלך ההרצה.

Complex c1, c2, c3; //#1

c1 = new Complex();

c1.real = 1;

c1.im = 1.5;

c2= new Complex();

c2.real = 1;

c2.im = 1.5; //#2

c2.real = 2;

c2.im = 2.5; //#3

c2 = c1; //#4

c1.im = 2.2;

c3 = new Complex();

c3.real=0.12;

c3.im = c2.im; //#5

בנאים

בנאים הם שיטות מיוחדות הנקראות בכל פעם שנוצר אובייקט חדש, ומטרתם לאפשר אתחול של שדות

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

:Complex. ניצור בנאי במחלקה המחלקה, וכותרת הבנאי לא מכילה ערך החזרה

public class Complex{

public double real;

public double im;

public Complex(){ // empty constructor

real = 0;

im = 0;

}

public Complex(double realPart, double imPart){// constructor

real = realPart;

im = imPart;

}

c1

c3

1

1.5

1

1.5

1.5

1

1

2.2

0.12

2.2

#1 #2 #4 #5

1

1.5

2

2.5

#3


4

}

תחל אותם בזמן יצירה:כעת ניתן ליצור אובייקטים חדשים ולאComplex c1,c2,c3;

c1 = new Complex(10,5.7);

c2 = new Complex();

c3 = new Complex(2.5,2.5);

(methodsשיטות )

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

:toStringהשיטה את Complexהייצוג של המספר המרוכב. נוסיף למחלקה public class Complex{

…

public String toString() {

String ans = real+" + "+ im + "i";

return ans;

}

}

ניתן להשתמש בשיטה באופן הבא:Complex c1 = new Complex(5,2);

System.out.println(c1.toString());

i 2.0 + 5.0מודפס:

שדות – real, im)כמו גם כל שיטה שנכתוב במחלקה( ניגשת למשתנים ()toStringם לב כי השיטה נשי

של האובייקט. כך (scope)ללא אופרטור הנקודה, מכיוון שהגישה מבוצעת בתוך ההקשר –המחלקה

למשל אם נבצע את הקוד הבא:

Complex c1 = new Complex(10.4, 20);

Complex c2 = new Complex(15, 1);



c2והשניה את המצב של c1נקבל הדפסות שונות עבור שני האובייקטים. הראשונה מתארת את המצב של

הפלט )כלומר כל קריאה מתבצעת בקונטקסט של אובייקט אחר ואין שיתוף שדות בין אובייקטים שונים(.

יהיה:

10.4 + 20.0 i

15.0 + 1.0 i

ניתן לבצע פעולות על מספרים מרוכבים, כגון חיבור שני מספרים מרוכבים, כפל שני מספרים מרוכבים,

מציאת ערך מוחלט של מספר מרוכב ועוד. פעולות אלו מוגדרות באופן הבא:

ערך מוחלט:

|a + bi| = a*a + b*b : a+bi, c+diים עבור זוג המספר

חיבור:

(a+bi) +(c+di) = (a+b) +(c+d)i כפל:


5

(a+bi) * (c + di) = (ac – bd) + (ad + bc)i

שיטה המוצאת ערך מוחלט. לפי הגדרת הערך המוחלט השיטה תחזיר מספר Complexנוסיף למחלקה

ממשי.


… public double abs(){

return Math.sqrt(real*real + im * im);

}

}

המעדכנת את updateאת השיטה Complexנוסיף למחלקה שיטות יכולות גם לשנות את מצב האובייקט.

הערך האמיתי והמדומה של האובייקט, הניתנים כארגומנטים לשיטה.


… public void update(double otherReal, double otherIm){

real = otherReal;

im = otherIm;

}

}

לאשימו לב כי ההבדל התחבירי בין כתיבת שיטה לבין כתיבת פונקציה הוא בכך שבעת הגדרת שיטה

עליו היא שדות של האובייקט אשר ה משתמשת בערכי update. השיטה staticמשתמשים במילה השמורה

ופן הבא:. כעת ניתן לבצע חיבור מספרים ממשיים באמופעלת

Complex c1 = new Complex(1, 0.5);

c1.update(11.1, 9.5);

System.out.println(c1.toString()); // 11.1 + 9.5 i

הניתן כארגומנט, Complexהמקבלת אובייקט מטיפוס addאת השיטה Complexנוסיף למחלקה

מאחר .הסכום בין הארגומנט לאובייקט עצמושערכו הוא Complexומחזירה אובייקט חדש מסוג

בתור Complexמגדירה טיפוס חדש, ניתן להעביר אובייקטים מהטיפוס חדש Complexוהמחלקה

ארגומנטים לשיטות.


… public Complex add(Complex other){

Complex result = null;

result = new Complex(real + other.real, im + other.im);

return result;

}

}

כעת ניתן לבצע חיבור מספרים ממשיים באופן הבא:

Complex c1 = new Complex(1, 0.5);

Complex c2 = new Complex(10.1, 9);

Complex c3 = c1.add(c2);

System.out.println(c3.toString()); // 11.1 + 9.5 i


6

על אף אובייקט. לכן, כל ניסיון יםמצביע , אינםnullשערכו מצביע וגםשלא אותחל מצביע לאובייקט

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

NullPointerException:

Complex c1;

c1.im = 5.5; // compilation error – uninitialized variable

Complex c1 = null, c2 = new Complex(1, 2);

c2.add(c1); // runtime error - java.lang.NullPointerException

חישבו: מדוע לא ניתן לזהות שגיאות כדוגמת השגיאה השנייה כבר בזמן קומפילציה?

שכתבנו. נוסיף גם שיטות עבור addת השיטה למנוע גישות כאלה ולכן נתקן א באחראיות המתכנת

הפעולות כפל וערך מוחלט. המחלקה שתתקבל היא:


public double real;

public double im;

public Complex(){

real = 0;

im = 0;

}

public Complex(double realPart, double imPart){

real = realPart;

im = imPart;

}

public String toString(){

String ans = real+" + "+ im + " i";

return ans;

}

public Complex add(Complex other){


if (other != null) {

result = new Complex(real +

other.real, im + other.im);

}

return result;

}

public Complex mult(Complex other){


if (other != null) {

double multReal = real * other.real – im*other.im;

double multIm = real*other.im + im*other.real;

result = new Complex(multReal, multIm);

}

return result;

}

public double abs(){

return Math.sqrt(real*real + im * im);

}

}


7

דוגמת שימוש:public class Calc{

public static void main(String[] args){

Complex c1 ,c2;

c1 = new Complex(1, 2);

c2 = new Complex(3, 4);

Complex c3 = c1.mult(c2);

System.out.println("c1 * c2 = " + c3.toString());

System.out.println("Absolute value: " + c3.abs());

}

}

פלט:

c1 * c2 = -5.0 + 10.0 i

Absolute value: 11.180339887498949

נשים לב שכעת לא תיווצר שגיאת זמן ריצה אם נכתוב

Complex c1 = null, c2 = new Complex(1, 2);

c2.add(c1);

אך עדיין תיווצר שגיאת זמן ריצה אם נכתוב c1.add(c2);

מהן. עכך שתטפל בשגיאות אלו ויש להימנ addלא ניתן לשנות את השיטה

, נבין כיצד נוכל לכתוב שיטות שאינן משנות )פונקציות סטטיות( שיטות סטאטיותבהמשך, כשנכיר מהן

האובייקט בצורה נכונה יותר.את המצב של

:שיטות מיוחדות

קיימות מספר שיטות שמתווספות לכל מחלקה בצורה כל דבר שאינו פרימיטיבי הוא אובייקט. Java -ב

השיטות האלו נוספות בצורה , גם אם לא הגדרנו אותן בצורה מפורשת. )ולכן גם לכל אובייקט( אוטומטית

טיבי.אוטומטית לכל משתנה שאיננו פרימי

הן: אלו שיטותחלק מ

.toString(), equals()

משמשת להשוואת אובייקטים. - equalsהשיטה

שמשווה בין התווים שמכילות שתי מחרוזות. equalsכבר קיימת שיטת Stringכזכור, למחלקה

אם נרשום:


Complex c2 = c1;


8


boolean b1 = ( c1 == c2 );

boolean b2 = ( c1 == c3 );

מצביע בודק האם לשני המשתנים אותו ערך, כלומר כי האופרטור == b2 false-אבל ב b1 true-נקבל ב

אותו מקום בזיכרון, אך אינו בודק אם שני האובייקטים זהים לוגית.ל

אם יש להם אותו ערך אמיתי ואותו ערך מדומה. זהות לוגית לדוגמה, שני מספרים מרוכבים זהים לוגית

אינה בהכרח זהות בין ערכי כל השדות אלא נקבעת על ידי המתכנת באופן מיוחד לבעיה הנתונה.

:equalsעל מנת לבדוק שוויון לוגי נממש את השיטה

public class Complex {

…

public boolean equals(Object other) {

boolean result = false;

if (other instanceof Complex) {

Complex c = (Complex) other;

result = (real == c.real) && (im == c.im);

}

return result;

}

}

ואז נשתמש בה כך:


Complex c2 = c1;


boolean b1 = ( c1.equals(c2) );

boolean b2 = ( c1.equals(c3) );

.trueאת הערך b2 -וגם ב b1 -ונקבל גם ב

הבודקת השוואת מצביעים )בדיוק כמו equalsתהיה למחלקה שיטה equalsאם לא תממשו את השיטה

==(.האופרטור

דוגמא נוספת:

רור לנו איזו אינפורמציה צריכה להופיע על המסך.כאשר רוצים להדפיס מספר שלם או מחרוזת ב

? תשובה: כללי ההמרה של Complexאך מה נעשה אם למשל נרצה להדפיס טיפוס נתונים המייצג

()toString.אובייקט למחרוזת ייקבעו ע"י מי שכותב את המחלקה של האובייקט, ע"י שימוש בשיטה

המכיל את שם המחלקה וכתובת האובייקט Stringר היא להחזי ()toStringברירת המחדל של השיטה

. , ובמחלקות שנכתוב נגדיר שיטה זו כך שתחזיר ייצוג משמעותי יותרבזיכרון

לצרכינו: ר, כך שתתאים יות()toStringאת נממש מחדש

public class Complex {


9

public double real;

public double im;

public Complex(double realVal, double imVal) {

real = realVal;

im = imVal;

}

…

public String toString() {

return "(" + real + " + " + im + "i)";

}

public static void main(String[] args) {


System.out.println(c1) ; // (5.0 + 7.0i)

}

}

. כאשר מפעילים את השיטה ()toStringנשים לב כי ההדפסה נעשתה ללא קריאה מפורשת לשיטה

println( מתבצעת המרה ,casting של )c1 ל- String בעזרת השיטהtoString() .שמימשנו

דוגמה לסיכום התרגול:

בים. בכל סיבוב הדוגמה הבאה מתארת תוכנית המנהלת משחק בין שני שחקנים. המשחק מתנהל בסיבו

, אז השחקן הראשון מאבד כמות נקודות 1הוא . אם המספר שהוגרל3ל 1המחשב מגריל מספר בין

, אז השחקן השני מאבד כמות נקודות אקראית 2. אם המספר שהוגרל הוא 100עד 1אקראית בתחום

)כל 100עד 1. אחרת כל אחד משני השחקנים מרוויח כמות נקודות אקראית בתחום 100עד 1בתחום

סיבובים. 10אחד יכול להרוויח כמות שונה(. המנצח הוא השחקן שצבר יותר נקודות בתום

פאות. nכאל זריקת קוביה בעלת nעד 1-ניתן להתייחס להגרלה של מספר שלם בתחום מ

להיות האובייקטים המרכיבים את התוכנית הם שחקן, קוביה ומשחק. נשים לב כי שדות של מחלקה יכולים

אף הם אובייקטים )ממחלקות אחרות או מאותה המחלקה(, ולא רק משתנים פרימיטיביים. מחלקת המשחק

תכיל שני מופעים של המחלקה שחקן ושני מופעים של המחלקה קוביה.

מחלקת השחקן מכילה שני שדות: שם וכמות נקודות. כמו כן היא מכילה שיטות להדפסת נתונים על המסך,

ות ושיטה להורדת נקודות. הוספת נקוד

public class Player{

public String name;

public int score;

public Player(String playerName){ // constructor name = playerName;

score = 0;

}

public String toString(){

return "Player: " + name + ", score: "+score;

}


10

/* adds points to player score and returns its new value */

public int addPoints(int points){

score = score+points;

return score;

}

}

מכילה שדה עבור כמות הפאות, ושיטה עבור זריקת הקוביה. המחלקת הקוביי

class Die{

public int faces;

public Die(int numOfFaces) {

faces = numOfFaces;

}

// returns a number between 1 and faces

public int roll(){

return (int)(Math.random()*faces)+1;

}

}

מנהלת את המשחק. Gameהמחלקה

public class Game{

Player firstPlayer, secondPlayer; //players

Die roundTypeDie, pointsDie;

public Game(Player p1, Player p2){

firstPlayer = p1;

secondPlayer = p2;

roundTypeDie = new Die(3);

pointsDie = new Die(100);

}

/* play the game */

public Player randomPlay(){

int roundType;

for(int round=0; round<10; round++) {

System.out.println("\n------------- "+(round+1)+" -------------");

roundType = roundTypeDie.roll();

if (roundType == 1){

takePoints(firstPlayer);

}

else if(roundType == 2){

takePoints(secondPlayer);

}

else{

addPoints(firstPlayer);

addPoints(secondPlayer);

}

System.out.print("TOTAL: "

+firstPlayer.toString()+",\t"+secondPlayer.toString());

} // next round

return getWinner();

}

public void takePoints(Player p){

int dieResult = pointsDie.roll();

p.addPoints(-dieResult);


11

System.out.println(p.name + " lost " + dieResult + " points.");

}

public void addPoints(Player p){

int dieResult = pointsDie.roll();

p.addPoints(dieResult);

System.out.println(p.name + " won " + dieResult + " points.");

}

/* returns Player object that is the winner in this game */

public Player getWinner(){

if(firstPlayer.score>secondPlayer.score){

return firstPlayer;

}

else{

return secondPlayer;

}

}

}

public class Main {

public static void main(String[] args) {

Player p1, p2, winner;

p1 = new Player("Bob");

p2= new Player("Alice");

Game game= new Game(p1, p2);

winner = game.randomPlay(); // play the game

System.out.println("\nThe winner is "+ winner.toString());

}

}

דוגמת ריצה:

------------- 1 -------------

Bob won 5 points.

Alice won 26 points.

TOTAL: Player: Bob, score: 5, Player: Alice, score: 26

------------- 2 -------------

Bob lost 11 points.

TOTAL: Player: Bob, score: -6, Player: Alice, score: 26

------------- 3 -------------

Bob won 65 points.



------------- 4 -------------

Bob lost 51 points.


------------- 5 -------------

Bob won 4 points.



------------- 6 -------------

Bob won 38 points.




12

------------- 7 -------------

Bob won 90 points.



------------- 8 -------------

Bob won 79 points.



------------- 9 -------------

Alice lost 80 points.


------------- 10 -------------

Bob lost 54 points.


The winner is Player: Alice, score: 183

Javadoc :

הסבר באתר:

http://www.cs.bgu.ac.il/~intro111/Practical_Sessions/Javadoc

אקליפס:בעזרת כפלט זאת כיצד להוציא

ide.html-eclipse-in-javadoc-ide/generating-blog.org/eclipse-http://www.eclipse

http://www.cs.bgu.ac.il/~intro111/Practical_Sessions/Javadoc

http://www.eclipse-blog.org/eclipse-ide/generating-javadoc-in-eclipse-ide.html

םימצע החנומ תונכתל אובמ 8 רפסמ לוגרת object...

Documents