מבוא למדעי המחשב

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

תוכן עניינים טיפוסי נתונים מורכבים

המחלקה String תזכורת לשימוש שעשינו במחלקה String str = new String( Hello ); s.o.p(str.tostring()); s.o.p(str.charat(4)); s.o.p(str.equals( Good bye ); המחלקה String מעשירה את שפת Java היא מוסיפה לשפה טיפוס נתונים חדש רצף של תווים בהכרח לא טיפוס נתונים פרימיטיבי

String str = new String( Hello ); s.o.p(str.tostring()); s.o.p(str.charat(4)); s.o.p(str.equals( Good bye ); המבנה של המחלקה String המחלקה מאפשרת String <array of char> ליצור (באמצעות הפעולה (new מחרוזות חדשות ו- לאתחל אותן במהלך היצירה לפעול על המחרוזות שנוצרו המחלקה מגדירה לשם כך שלושה חלקים: שדות המחלקה String() String(<string>) String(<array of char>) tostring() charat(<index>) equals(<string>) חשוב: מבני נתונים (שדות) המקום שצריך להקצות כדי שיהיה אפשר לאכסן את רצף התווים של המחרוזת החדשה פרוצדורות אתחול (בנאים) פרוצדורות (מעין פונקציות) שמאתחלות את מבנה הנתונים במחרוזת הנחוצה שיטות שיטות (פונקציות לא סטטיות) לפעולה על המחרוזת שנוצרו (למען האמת יכול להיות לה גם חלק נוסף (סטטי) שאינו קשור לענייננו) בנאים שיטות המחלקה (על חלקיה) אינה אלא תבנית של טיפוס הנתונים המוגדר

String str = new String( Hello ); s.o.p(str.tostring()); s.o.p(str.charat(4)); s.o.p(str.equals( Good bye ); יצירה של מחרוזת חדשה String <array of char> יצירה של מחרוזת חדשה נעשית באמצעות הפעולה new String( ) היצירה מתבצעת בשלבים: מוקצה מקום למבנה הנתונים שדות המחלקה בהתאם למה שרשום במחלקה השדות מאופסים בנאים String() String(<string>) String(<array of char>) בהתאם לטיפוס שלהם מופעל בנאי המאתחל את מבנה הנתונים במחרוזת הרצויה tostring() charat(<index>) equals(<string>) בהתאם לערך שמועבר בזמן היצירה מוחזרת הפניה אותה אפשר לשמור במשתנה לשימוש עתידי להפעיל שיטות על המחרוזת שנוצרה ערך שם טיפוס שיטות String str Hello

String str = new String( Hello ); s.o.p(str.tostring()); s.o.p(str.charat(4)); s.o.p(str.equals( Good bye ); פעולה על מחרוזת קיימת (שכבר נוצרה) רושמים,str.method( ) כאשר String str הוא המשתנה בו שמורה ההפניה למחרוזת (שהתקבלה בתהליך היצירה) המחלקה <array of char> String היא שם של אחת השיטות שמוגדרות במחלקה method ו- הם הערכים שיש להעביר לשיטה בהתאם לפרמטרים שלה שדות String() String(<string>) String(<array of char>) לדוגמה str.tostring() מחזירה את רצף התווים ששמור במבנה הנתונים של המחרוזת (בדוגמה שלנו ( Hello str.charat(4) מחזיר את התו הרביעי של רצף התווים ששמור במבנה הנתונים (בדוגמה שלנו התו o ) בנאים tostring() charat(<index>) equals(<string>) bye ) str.equals( Good משווה את רצף התווים ששמור במבנה הנתונים של המחרוזת לרצף התווים מהפרמטר ומחזיר true אם ורק אם הם זהים (בדוגמה שלנו (false ערך שם טיפוס שיטות String str Hello

תוכן עניינים טיפוסי נתונים מורכבים מערך דינאמי

הטיפוס Object Object לפני שנתחיל בתיאור המערך הדינאמי, נסתכל על הטיפוס מחלקה ב- Java לענייננו, לעת עתה (עוד נחזור אל Object בהמשך) ניתן להגדיר משתנים מסוג Object במשתנה מסוג Object ניתן לתלות כל אובייקט של Java כדי לפעול על האובייקט שתלינו יש "להגיד" לקומפיילר מה תלינו באמצעות המרה Object x = new String( 123 Dag Makoach ); s.o.p(((string) x).substring(4,7)); // Dag

שדות בנאים שיטות Object[] data; int size; int incrementsize; DynamicIntArray DynamicIntArray(int initialcapacity) DynamicIntArray() int size() boolean isempty() void add(object element) void add(int index, Object element) Object get(int index) Object set(int index, Object element) Object remove(int index) String tostring() boolean equals(object x) מערך דינאמי לפעמים יש צורך במערך שהגודל שלו משתנה עם הזמן (מערך דינאמי) המערך הרגיל של Java לא מאפשר זאת נגדיר בעצמנו מחלקה בשם DynamicArray שתשמש תבנית לטיפוס חדש של מערך דינאמי ההתנהגות של המערך תוגדר כלהלן: נבדיל בין ה- capacity של המערך (מספר התאים במערך) לבין ה- size הלוגי של המערך (מספר התאים התפוסים במערך) המערך יתחיל עם capacity ראשוני (גדול מאפס), ובכל פעם שהתאים כולם של המערך יתמלאו נוסיף למערך תאים כמספר התאים של ה- capacity הראשוני. אם מספר התאים הפנויים יהיה כפליים מה- capacity הראשוני, נצמצם אותם במספר התאים של ה- capacity הראשוני. נגדיר את הפעולות (שיטות) הבאות על המערך: קבלת הגודל הלוגי (size) של המערך האם המערך ריק (isempty) הוספה (add) של ערך חדש בסוף המערך או במקום מסוים במערך (בתחום (size-1)].. ([0 קבלה (get) של ערך ממקום מסוים במערך (בתחום (size-1)].. 0]) החלפה (set) של ערך מסוים במערך (בתחום (size-1)].. 0]) מחיקה (remove) של ערך מסוים במערך (בתחום (size-1)].. 0]) תיאור התוכן של המערך באמצעות מחרוזת (tostring) השוואה (equals) של המערך עם מערך אחר נעיר ש- Java מגיע עם מחלקה בשם ArrayList שעושה מה שאנחנו עושים (ויותר) ערך שם טיפוס DynamicIntArray da data size incrementsize

מערך דינאמי public class DynamicIntArray { מסגרת ההגדרה השימוש יכול להיעשות בכל מחלקה public class MyClass { public static void main(string[] args) { בדף הבא // public static DynamicIntArray primesdarray(int n) { DynamicArray primes = new DynamicArray(); בדף הבא //

דוגמה לשימוש אפשרי public static DynamicArray primesdarray(int n) { DynamicArray primes = new DynamicArray(); for (int number = 2; number <= n; number = number + 1) { boolean isprime = true; for (int i = 0; i < primes.size() && (int) primes.get(i) * (int) primes.get(i) <= number && isprime; i = i + 1) if (number % (int) primes.get(i) == 0) isprime = false; if (isprime) primes.add(number); return primes; public static void main(string[] args) { Scanner myscanner = new Scanner(System.in); int n = myscanner.nextint(); DynamicArray primes = primesdarray(n); System.out.println(primes.toString());

private static final int DEFAULT_CAPACITY = 16; שדות ובנאים private Object[] data; private int size; private int incrementsize; // constructs an empty dynamic array with the specified initial capacity public DynamicArray(int initialcapacity) { if (initialcapacity <= 0) throw new IllegalArgumentException("non-positive initial capacity"); data = new Object[initialCapacity]; incrementsize = initialcapacity; size = 0; // constructs an empty dynamic array with an initial capacity of DEFAULT_CAPACITY public DynamicArray() { this(default_capacity);

השיטות size ו- isempty private Object[] data; private int size; private int incrementsize; // returns the number of elements in this dynamic array public int size() { return size; // returns true if the dynamic array contains no elements public boolean isempty() { return size == 0;

private Object[] data; private int size; private int incrementsize; השיטה add // inserts the specified element at the specified position public void add(int index, Object element) { בדף הבא // rangecheck(index); for (int i = size; i > index; i = i - 1) data[i] = data[i - 1]; data[index] = element; size = size + 1; ensurecapacity(); // increases the capacity of the dynamic array, if necessary, // to ensure that it can hold more elements private void ensurecapacity() { if (size == data.length) { Object[] newdata = new Object[data.length + incrementsize]; for (int i = 0; i < size; i = i + 1) newdata[i] = data[i]; data = newdata; // Adds the specified element to the end public void add(object element) { data[size] = element; size = size + 1; ensurecapacity();

השיטה get private Object[] data; private int size; private int incrementsize; // returns the element at the specified position public Object get(int index) { rangecheck(index); return data[index]; // check if a given index is in rang private void rangecheck(int index) { if (index < 0 index >= size) throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);

השיטה set private Object[] data; private int size; private int incrementsize; // replaces the element at the specified position with the specified element public Object set(int index, Object element) { rangecheck(index); Object prev = data[index]; data[index] = element; return prev;

private Object[] data; private int size; private int incrementsize; השיטה remove // removes the element at the specified position public Object remove(int index) { rangecheck(index); Object x = data[index]; for (int i = index + 1; i < size; i = i + 1) data[i - 1] = data[i]; ensurecompaction(); return x; // decrease the capacity of the array, if necessary, // to ensure that there is no too much free space private void ensurecompaction() { if (size == data.length - 2 * DEFAULT_CAPACITY) { Object[] newdata = new Object[data.length - incrementsize]; for (int i = 0; i < size; i = i + 1) newdata[i] = data[i]; data = newdata;

השיטה tostring private Object[] data; private int size; private int incrementsize; // returns a string representing the dynamic array public String tostring() { String output = "{"; for (int i = 0; i < size; i = i + 1) { Object x = data[i]; if (x == null) output = output + "(null)"; else output = output + "(" + x.tostring() + ")"; output = output + ""; return output;

השיטה equals private Object[] data; private int size; private int incrementsize; // compares the dynamic array for equality public boolean equals(object x) { if (!(x instanceof DynamicArray)) return false; DynamicArray other = (DynamicArray) x; boolean isequals = this.size == other.size; for (int i = 0; i < size && isequals; i = i + 1) if (this.data[i]!= other.data[i]) isequals = false; return isequals;