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

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);

Copy constructor - יצירת אובייקט חדש על בסיס אובייקט קיים מאותו טיפוס

public Complex(Complex other){

im = other.im; real = other.real;

{

אשר מבצע (default constructorמספקת לנו בנאי ברירת מחדל ) Javaם לא הגדרנו בנאי כלשהו, א

:)ובמקרה שלנו נקבל( השמה של ערכי ברירת המחדל לכל השדות

public Complex(){

im = 0;

real = 0;

}

. אם נרצה default constructor -כבר לא תספק לנו ה Javaבמידה והגדרנו בנאי כלשהו במחלקה,

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

public class Complex{ public double real;

public double im; public Complex(double realPart, double imPart){

real = realPart; im = imPart; }

}

:נקבל שגיאת קומפילציהרה הבאה אם ננסה ליצור אובייקט בצוc1 = new Complex();

(methodsשיטות )

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

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

…

public String toString() {

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

return ans;

}

}


5

ניתן להשתמש בשיטה באופן הבא: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 + 00.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 כפל:

(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;

}


6

}

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

עליו היא שדות של האובייקט אשר ה משתמשת בערכי 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

על אף אובייקט. לכן, כל ניסיון יםמצביע , אינם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את השיטה נשנהלכן , nullמחזיר nullספה או כפל ב , החלטנו שהוהמחלקה

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


public double real;

public double im;

public Complex(){

real = 0;

im = 0;


7

}

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);

}

}

דוגמת שימוש: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);


8

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

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

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

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

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

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

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

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

()toString. : יא השיטהה אלו שיטותחלק מ

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

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

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

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

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

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

public class Complex {

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) {

Complex c1 = new Complex(5, 7);

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

}

}


9

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

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

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

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

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

, אז השחקן השני מאבד כמות נקודות אקראית 0. אם המספר שהוגרל הוא 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;

}

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

public int addPoints(int points){

score = score+points;

return score;

}

}

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

public 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;

}


10

}

מנהלת את המשחק. 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=round+1) {

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);

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;

}

}

}


11

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.



------------- 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


12

Javadoc :

הסבר באתר:

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

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

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

Documents