הקודם – הרחבה על הורשה · הבא – כללי base ו־this
כעת נלמד (שוב) לכתוב ולהבין שרשור בנאים (Constructor Chaining)
הגדרה: כאשר עצם במחלקה (class) נוצר, הזמן ריצה (runtime) קורא לבנאי שלה. בנאים הם פעולות מיוחדות שיש להן את אותו שם כמו למחלקה, והן בדרך כלל מאתחלות את שדות הנתונים של האובייקט החדש.
1. בנאי בסיסי
בדוגמה הבאה, מחלקה בשם Taxi מוגדרת באמצעות בנאי פשוט. המחלקה נוצרת לאחר מכן באמצעות האופרטור new. הזמן ריצה מפעיל את הבנאי של Taxi מיד לאחר הקצאת זיכרון לאובייקט החדש.
public class Taxi
{
private string taxiTag;
// בנאי עם פרמטר
public Taxi(string tag) => taxiTag = tag;
public override string ToString() => $"Taxi: {taxiTag}";
}
class TestTaxi
{
static void Main()
{
Taxi t = new Taxi("Tag1345");
Console.WriteLine(t); // פלט: Taxi: Tag1345
}
}
2. בנאי ללא פרמטרים (Parameterless Constructor)
חשוב: בנאי שלא מקבל פרמטרים נקרא “בנאי ללא פרמטרים”. הזמן ריצה מפעיל אותו כאשר אובייקט נוצר באמצעות new ללא ארגומנטים.
בנאי ברירת מחדל
אם לא מגדירים בנאי במחלקה, המהדר של C# יוצר אוטומטית בנאי ציבורי ללא פרמטרים:
public class Car
{
private string model;
private int year;
// המהדר יוצר אוטומטית:
// public Car() { }
}
// שימוש
Car myCar = new Car(); // עובד בגלל הבנאי האוטומטי
3. ריבוי בנאים (Constructor Overloading)
מחלקות יכולות להגדיר מספר בנאים עם חתימות שונות:
public class Employee
{
private int salary;
private string name;
// בנאי ללא פרמטרים
public Employee()
{
salary = 0;
name = "Unknown";
}
// בנאי עם פרמטר אחד
public Employee(int annualSalary)
{
salary = annualSalary;
name = "Unknown";
}
// בנאי עם שני פרמטרים
public Employee(string name, int annualSalary)
{
this.name = name;
this.salary = annualSalary;
}
// בנאי שמחשב משכורת שנתית
public Employee(string name, int weeklySalary, int numberOfWeeks)
{
this.name = name;
this.salary = weeklySalary * numberOfWeeks;
}
}
שימוש בבנאים השונים:
Employee e1 = new Employee(); // ברירת מחדל
Employee e2 = new Employee(30000); // משכורת בלבד
Employee e3 = new Employee("John", 50000); // שם ומשכורת
Employee e4 = new Employee("Jane", 1000, 52); // חישוב שנתי
4. שרשור בנאים עם base
בנאי יכול להשתמש במילת המפתח base כדי לקרוא לבנאי של מחלקת הבסיס:
public class Manager : Employee
{
private string department;
public Manager(string name, int annualSalary, string department)
: base(name, annualSalary) // קריאה לבנאי של Employee
{
this.department = department;
// הוראות נוספות כאן
}
}
5. סדר הפעולה בשרשור בנאים (Constructor chaining)
הקריאה new SportsCar(...) בוחרת את הבנאי של SportsCar. הקריאות עם : base(...) ממשיכות ל-Car ואז ל-Vehicle. גופי הבנאים מתבצעים מהבסיס אל היורש, כפי שרואים בסדר ההדפסות.
דוגמה להרצה: שלוש מחלקות בשרשרת
using System;
class Vehicle
{
public Vehicle(string manufacturer, int year)
{
Console.WriteLine($"1. Vehicle constructor: {manufacturer}, {year}");
}
}
class Car : Vehicle
{
public Car(string manufacturer, string model, int year, int doors)
: base(manufacturer, year)
{
Console.WriteLine($"2. Car constructor: {model}, {doors} doors");
}
}
class SportsCar : Car
{
public SportsCar(string manufacturer, string model, int year, int topSpeed)
: base(manufacturer, model, year, 2)
{
Console.WriteLine($"3. SportsCar constructor: Top speed {topSpeed} km/h");
}
}
class Program
{
static void Main()
{
new SportsCar("Ferrari", "F40", 1987, 324);
}
}
הפלט:
1. Vehicle constructor: Ferrari, 1987
2. Car constructor: F40, 2 doors
3. SportsCar constructor: Top speed 324 km/h
6. קריאה משתמעת (מובלעת) לבנאי הבסיס
אם הבנאי אינו מציין : base(...) או : this(...), הקומפיילר מוסיף קריאה ל-base(). כדי שהקריאה תתקמפל, צריך בנאי נגיש ללא פרמטרים במחלקת הבסיס.
// שתי ההגדרות הבאות זהות:
public Manager(int initialData)
{
// קריאה אוטומטית ל-base()
}
public Manager(int initialData)
: base() // קריאה מפורשת
{
}
7. העדר בנאי ברירת מחדל
אזהרה: אם אין במחלקת הבסיס בנאי נגיש ללא פרמטרים, שרשרת הבנאים של המחלקה היורשת צריכה להגיע לקריאה מפורשת עם : base(...).
הקומפיילר יוצר בנאי ברירת מחדל במחלקה שאין בה בנאי מופע מפורש. אם המחלקה מגדירה רק בנאי מופע עם פרמטרים, המחלקה היורשת צריכה להעביר לו ארגומנטים ב-: base(...).
להמחשה: להלן דוגמא מינימלית שלא תתקמפל!!:
public class A
{
protected int i;
public A(int i) // מבטל את בנאי ברירת המחדל
{
this.i = i;
}
}
public class B : A
{
public B() // יוצג באדום: לא נמצא בנאי ברירת מחדל, ואין פניה לבנאי שכן קיים
{
Console.WriteLine("will not compile");
}
public B(int i) // יוצג באדום: לא נמצא בנאי ברירת מחדל, ואין פניה לבנאי שכן קיים
{
Console.WriteLine("will not compile");
}
}
8. שרשור בנאים עם this
בנאי יכול לקרוא לבנאי אחר באותה מחלקה באמצעות : this(...). בכל הכרזת בנאי אפשר לציין קריאה אחת בלבד, : this(...) או : base(...).
public class Rectangle
{
private int width;
private int height;
// בנאי ראשי
public Rectangle(int width, int height)
{
this.width = width;
this.height = height;
Console.WriteLine($"Rec created: {width}x{height}");
}
// בנאי לריבוע - קורא לבנאי הראשי
public Rectangle(int size)
: this(size, size)
{
Console.WriteLine("Square created");
}
// בנאי ברירת מחדל
public Rectangle()
: this(1, 1)
{
Console.WriteLine("Default rectangle created");
}
// Getters and Setters - Java Style
public int GetWidth() { return width; }
public void SetWidth(int width) { this.width = width; }
public int GetHeight() { return height; }
public void SetHeight(int height) { this.height = height; }
}
דוגמה לשימוש:
Rectangle r1 = new Rectangle(5, 10); // Rectangle created: 5x10
Rectangle r2 = new Rectangle(7); // Rectangle created: 7x7, Square created
Rectangle r3 = new Rectangle(); // Rectangle created: 1x1, Default rectangle created
9. מתאמי גישה (access modifiers) לבנאים
בנאים יכולים להיות מוגדרים עם מתאמי גישה שונים: לא ראיתי שאלות בהקשר זה בבגרוית.
public class DatabaseConnection
{
// בנאי ציבורי - נגיש מכל מקום
public DatabaseConnection(string connectionString)
{
// אתחול חיבור
}
// בנאי מוגן - נגיש רק למחלקות יורשות
protected DatabaseConnection()
{
// בנאי למחלקות נגזרות
}
// בנאי פנימי - נגיש רק באותו Assembly
internal DatabaseConnection(int timeout)
{
// בנאי לשימוש פנימי
}
// בנאי פרטי - לשימוש פנימי במחלקה בלבד
private DatabaseConnection(bool isTest)
{
// בנאי לבדיקות
}
}
מתאמי גישה נפוצים:
public- נגיש מכל מקוםprivate- נגיש רק בתוך המחלקהprotected- נגיש למחלקה ולמחלקות יורשותinternal- נגיש באותו Assembly
10. דוגמה מקיפה - מערכת בנקאית
public abstract class Account
{
private static int nextAccountNumber = 1000;
private int accountNumber;
private string owner;
protected double balance; // protected כדי שמחלקות נגזרות יוכלו לגשת
private DateTime createdDate;
// בנאי סטטי - אתחול מונה חשבונות
static Account()
{
Console.WriteLine("Banking system initialized");
// ניתן לטעון את המספר האחרון מבסיס נתונים
}
// בנאי מוגן למחלקות נגזרות
protected Account(string owner, double initialBalance)
{
if (string.IsNullOrEmpty(owner))
owner = "Unknown Owner";
if (initialBalance < 0)
{
Console.WriteLine("Initial balance cannot be negative");
initialBalance=0;
}
accountNumber = nextAccountNumber++;
this.owner = owner;
this.balance = initialBalance;
this.createdDate = DateTime.Now;
Console.WriteLine($"Account #{accountNumber} created for {owner}");
}
// Getters
public int GetAccountNumber() => accountNumber;
public string GetOwner() { return owner; }
public double GetBalance() { return balance; }
public DateTime GetCreatedDate() { return createdDate; }
// Protected setter for balance - למחלקות נגזרות
protected void SetBalance(double balance) { this.balance = balance; }
}
public class SavingsAccount : Account
{
private double interestRate;
// שרשור לבנאי הבסיס
public SavingsAccount(string owner, double initialBalance, double interestRate)
: base(owner, initialBalance)
{
if (interestRate < 0 || interestRate > 0.1)
interestRate = 0;
this.interestRate = interestRate;
Console.WriteLine($"Savings account with {interestRate:P} interest");
}
// בנאי נוחות עם ריבית ברירת מחדל
public SavingsAccount(string owner, double initialBalance)
: this(owner, initialBalance, 0.02) // 2% ברירת מחדל
{
}
// Getters and Setters
public double GetInterestRate() { return interestRate; }
public void SetInterestRate(double rate)
{
if (rate >= 0 && rate <= 0.1)
this.interestRate = rate;
}
}
public class CheckingAccount : Account
{
private double overdraftLimit;
public CheckingAccount(string owner, double initialBalance, double overdraftLimit)
: base(owner, initialBalance)
{
if (overdraftLimit < 0)
overdraftLimit *= -1;
this.overdraftLimit = overdraftLimit;
Console.WriteLine($"Checking account with ${overdraftLimit} overdraft");
}
// בנאי ללא אוברדרפט
public CheckingAccount(string owner, double initialBalance)
: this(owner, initialBalance, 0)
{
}
// Getters and Setters
public double GetOverdraftLimit() { return overdraftLimit; }
public void SetOverdraftLimit(double limit)
{
if (limit >= 0)
this.overdraftLimit = limit;
}
}
// שימוש
public class BankingApp
{
public static void Main()
{
var savings = new SavingsAccount("Alice", 1000);
var checking = new CheckingAccount("Bob", 500, 200);
var vipSavings = new SavingsAccount("Charlie", 10000, 0.05);
// שימוש ב-Getters
Console.WriteLine($"Alice's balance: ${savings.GetBalance()}");
Console.WriteLine($"Bob's overdraft: ${checking.GetOverdraftLimit()}");
Console.WriteLine($"Charlie's interest rate: {vipSavings.GetInterestRate():P}");
}
}
פלט:
Banking system initialized
Account #1000 created for Alice
Savings account with 2.00% interest
Account #1001 created for Bob
Checking account with $200 overdraft
Account #1002 created for Charlie
Savings account with 5.00% interest
Alice's balance: $1000
Bob's overdraft: $200
Charlie's interest rate: 5.00%
סיכום
נקודות מפתח לזכור:
- בנאים נקראים אוטומטית בעת יצירת אובייקט עם
new - אם לא מגדירים בנאי, המהדר יוצר בנאי ללא פרמטרים
- ניתן להגדיר מספר בנאים עם חתימות שונות (Overloading)
- השתמשו ב-
baseלקריאה לבנאי מחלקת הבסיס - השתמשו ב-
thisלקריאה לבנאי אחר באותה מחלקה
טיפ: תמיד אתחלו את כל השדות (החדשים) בבנאי כדי למנוע מצבים לא מוגדרים. היעזרו בבנאים של מחלקות הבסיס לאיתחול שדות המוגדרים בהן.