Sprechen Sie über Klassen und Objekte in Delphi
1. Kann mehrere Konzepte ohne Bildung nicht verstehen.
Wenn wir von Klassen und Objekten sprechen, können wir nicht umhin, die folgenden Konzepte zu erwähnen: Klassen, Objekte und Instanzen. Ich persönlich finde es in Ordnung
Verstehen Sie es so: „Objekt“ bezieht sich auf einen allgemeinen Begriff, und jede Entität in der Natur kann als Objekt betrachtet werden, während sich „Klasse“ darauf bezieht
Eine Reihe von Kategorien, die in bestimmte Merkmale dieser Objekte unterteilt sind; eine Instanz bezieht sich speziell auf ein Objekt, das zu einer bestimmten Kategorie gehört.
Okay, mehr muss ich zu diesen großen Prinzipien nicht sagen. Warum nicht einen „gegenteiligen“ Ansatz wählen und Delphi verwenden?
Code, um einige von diesen Ausländern vorgebrachte Konzepte zu erklären, die für uns Chinesen schwer zu verstehen sind:
var
ABtn:TButton;
Definieren Sie ABtn als ein Objekt, das zur TButton-Klasse gehört, aber ABtn kann nicht als Instanz bezeichnet werden, da dies nicht der Fall ist
wird erstellt, also sagen wir, dass ein Objekt definiert ist. Wenn eine Instanz definiert ist, mehr oder weniger
Manche sind nicht präzise genug. :) :)
beginnen
ABtn:=TButton.Create(Self);//Eine Instanz von TButton erstellen
ABtn.Caption:='object';
ABtn.Free;
Ende;
2. Das Objekt ist ein reiner Zeiger
Aus physikalischer Sicht ist das Objekt ein Adressraum, und das Symbol dieses Adressraums ist das, was wir definieren.
Klasse „Variable“. Wir können uns ein Objekt also als Zeiger auf eine Klasse vorstellen. Wie wir alle wissen, ist der Zugriff auf einen Zeiger einfach
Der Zeiger muss initialisiert werden. Da es sich bei dem Objekt um einen Zeiger handelt, muss es initialisiert werden. Wie initialisiere ich es?
Lassen Sie uns über die Initialisierung von Zeigern sprechen. Es gibt zwei Möglichkeiten, einen Zeiger zu initialisieren:
(1) Direktvertrieb
var
Pint:^Integer;
beginnen
neu(Pint);
Pint^:=12;
Entsorgen(Pint);
Ende;
(2) Variablen, die auf andere zugewiesene Räume verweisen
var
Pint:^Integer;
i:Ganzzahl;
beginnen
i:=12;
Pint:=@i;
Ende;
Interessanterweise gibt es zwei Möglichkeiten, „Zeiger“ wie Objekte zu initialisieren:
(1) Direktvertrieb
var
AForm:TForm;
beginnen
AForm:=TForm.Create(Self);
AForm.ShowModal;
AForm.Free;
Ende;
(2) Zeigen Sie auf andere Instanzen des zugewiesenen Speicherplatzes
var
AForm:TForm;
beginnen
AForm:=Selbst;
AForm.Caption:='Wissen Sie? Warum passiert das?';
Ende;
file://Dieses AForm und die Formularinstanz, auf die es verweist, teilen sich dieselbe Adresseinheit, und alle Vorgänge auf dem AForm werden antworten
file:// zu seiner entsprechenden Form-Instanz.
Apropos: Wir können leicht erklären, warum die Objektparameter der Prozedur (Funktion) in einem Format wie diesem übergeben werden:
(1)PROcedure SetEdit(var Edit:TEdit);
beginnen
Edit.Text:='11';
Ende;
Und
(2) Prozedur SetEdit(Edit:TEdit);
beginnen
Edit.Text:='11';
Ende;
Der Effekt ist der gleiche. (1) besteht darin, eine TEdit-Entität als Parameterreferenz zu übergeben, (2) darin
Übergeben Sie einen TEdit-Objekt-„Zeiger“ als Parameter.
3. Klasse kann als spezieller Datentyp verstanden werden
Wir wissen, dass Datentypen zur Typkonvertierung gezwungen werden können, da eine Klasse als Datentyp verstanden werden kann
Dann sollte es auch in der Lage sein, eine Klassentypkonvertierung durchzuführen. Der folgende Code ist beispielsweise ein Klickereignis einer Schaltfläche (Button1):
(eins)
procedure TForm1.Button1Click(Sender: TObject);
var
ACaption:String;
beginnen
ACaption:=TButton(Sender).Caption;//Sender konvertiert von TObject in TButton
ShowMessage(Format('Sie haben auf ''%s'' geklickt!',[ACaption]));
Ende;
In diesem Code ist Sender ein Objekt vom Typ TObject und wir wandeln es in den Typ TButton um. wie du
Wenn Sie nicht klar sehen können, können Sie auf unsere übliche Datentypkonvertierung zurückgreifen:
(zwei)
procedure TForm1.Button1Click(Sender: TObject);
var
S_Str:String;
P_Str:PChar;
beginnen
S_Str:='Ich liebe China!';
P_Str:=PChar(S_Str);
S_Str:='';
S_Str:=String(P_Str);
ShowMessage(S_Str);
Ende;
Bei der objektorientierten Programmierung liegt der Schwerpunkt jedoch auf der Sicherheit. Beispielsweise weist die erzwungene Typkonvertierung in (1) viele Probleme auf.
Sicherheit. Der folgende Code schreibt weiterhin das Button1.OnClick-Ereignis:
(drei)
procedure TForm1.Button1Click(Sender: TObject);
beginnen
TCanvas(Sender).Brush.Color:=clRed;
Ende;
Wenn Sie es ausführen, tritt ein Fehler auf. Verstößt dies nicht gegen den Zweck der objektorientierten Programmierung? Nein, natürlich
Wenn es sich um eine Klasse handelt, sollte es eine klassenspezifische Zwangsmethode geben. Die zu ändernde Methode (3) lautet wie folgt:
(Vier)
procedure TForm1.Button1Click(Sender: TObject);
beginnen
(Absender als TCanvas).Brush.Color:=clRed;
end;//Verwenden Sie as zum Konvertieren, da es den Fehler abfangen kann und den normalen Betrieb des Programms nicht beeinträchtigt.
Apropos, lassen Sie mich übrigens VB erwähnen. Wenn Sie VB gelernt haben, wird Ihnen die Steuerungsanordnung darin möglicherweise mehr Spaß machen, insbesondere in
Beim Schreiben eines Programms wie eines Taschenrechners. Aber was gibt uns Delphi? Die Antwort ist, dass Delphi auch schnell und übersichtlich geöffnet werden kann.
Geben Sie ein solches Programm heraus. Wenn Sie dies tun: Fügen Sie ein Bearbeiten und zehn Schaltflächen in das Formular ein und teilen Sie Button.Caption in auf
Setzen Sie es nicht auf „0“, „1“, „2“, … „9“ und schreiben Sie dann das OnClick-Ereignis einer Schaltfläche wie folgt:
(fünf)
procedure TForm1.Button1Click(Sender: TObject);
beginnen
Edit1.Text:=Edit1.Text+(Sender as TButton).Caption;
Ende;
Ordnen Sie die OnClick-Ereignisse anderer Buttons Button1Click zu und führen Sie das Programm aus. Klatschen Sie in die Hände!
Der Prototyp des Programms ist jetzt verfügbar. Wir verwenden die Klassentypkonvertierung von Delphi, um eine Kontrollarray-Funktion ähnlich der in VB zu entwickeln.
Das Programm ist auch großartig! :)
4. Abstrakte Klasse und ihre Instanzen
In Delphi gibt es eine Klasse, die abstrakte Klasse genannt wird, und Sie können nicht einfach direkt eine Instanz davon erstellen. Wie zum Beispiel: TStrings
Art. Der folgende Code:
(eins)
var
StrLst:TStrings;
beginnen
StrLst:=TStrings.Create;
StrLst.Add('Ich liebe Japan!');
StrLst.Free;
Ende;
Das ist nicht richtig. Wie konstruiert man also Instanzen abstrakter Klassen wie TStrings? Die Antwort ist, es nicht zu pumpen
Unterklasse der Elefanten. Wir wissen, dass TStrings eine nicht abstrakte Unterklasse von TStringList hat. Wir können Folgendes tun:
(zwei)
var
StrLst:TStrings;
beginnen
StrLst:=TStringList.Create;//Unterklasse StrLst mit Hilfe ihres Unterklassenkonstruktors
StrLst.Add('Ich liebe China!');
StrLst.Free;
Ende;
(drei)
var
StrLst:TStringList;
beginnen
StrLst:=TStringList.Create;
file://Gib auf, verwende keine abstrakten Klassen mehr, sondern verwende einfach ihren „Sohn“, um dein Geschäft zu erledigen
StrLst.Add('Ich liebe China!');
StrLst.Free;
Ende;
5. Klassen sind ein hochgradig kapselnder Mechanismus für Daten und Operationen.
(1) Datenkapselung
Einheit Einheit2;
Schnittstelle
Typ
TEmployee=Klasse
Privat
FName:String;
öffentlich
Konstruktor erstellen;
Funktion GetName:String;
procedure SetName(AName:String);
Ende;
Durchführung
{ Mitarbeiter }
Konstruktor TEmployee.Create;
beginnen
FName:='BlazingFire';
Ende;
Funktion TEmployee.GetName: String;
beginnen
Ergebnis:=FName;
Ende;
procedure TEmployee.SetName(AName: String);
beginnen
FName:=AName;
Ende;
Ende.
Wie im obigen Code gezeigt, verwenden wir eine Prozedur SetName und eine Funktion GetName, um die private Variable FName vollständig festzulegen.
Verkapselung. Das ist alles, was wir mit FName tun müssen:
verwendet
Einheit2;
procedure TForm1.Button1Click(Sender: TObject);
var
AEmployee:TEmployee;
beginnen
AEmployee:=TEmployee.Create;
AEmployee.SetName('Rose');//SetName verwenden, um FName festzulegen
MessageBox(Handle,PChar(AEmployee.GetName),'Empoyee',0);
file://Verwenden Sie GetName, um auf FName zuzugreifen
AEmployee.Free;
Ende;
(2) Betriebskapselung
Einheit Einheit2;
Schnittstelle
Typ
TDivision=Klasse
öffentlich
file://Polymorphismus macht Ihr Programm „flexibler“
Funktion GetDiv(Num1,Num2:Double):Double;overload;
Funktion GetDiv(Num1,Num2:integer):integer;overload;
Ende;
Durchführung
{Abteilung}
Funktion TDivision.GetDiv(Num1, Num2: Double): Double;
beginnen
versuchen
Ergebnis:=Anzahl1/Anzahl2;
außer
Ergebnis:=0;//Stellt einen Aufzählungsverarbeitungsmechanismus bereit, um die Situation zu bewältigen, in der der Divisor 0 ist
Ende;
Ende;
Funktion TDivision.GetDiv(Num1, Num2: integer): integer;
beginnen
versuchen
Ergebnis:=Num1 div Num2;
außer
Ergebnis:=0;//Stellt einen Aufzählungsverarbeitungsmechanismus bereit, um die Situation zu bewältigen, in der der Divisor 0 ist
Ende;
Ende;
Ende.
Im obigen Code verwenden wir den Polymorphismusmechanismus der Klasse, um die Division in Ganzzahldivision bzw. Nicht-Ganzzahldivision zu verarbeiten, und verwenden den Ausnahmebehandlungsbildschirm
Um den Fall zu beseitigen, dass die Zahl 0 ist und die Sicherheit des Vorgangs beim Anruf gewährleistet ist, können wir Folgendes tun:
verwendet
Einheit2;
{$R *.dfm}
procedure TForm1.Button1Click(Sender: TObject);
var
Abteilung:TDivision;
IValue:integer;
FWert:Double;
beginnen
Division:=TDivision.Create;
IValue:=Division.GetDiv(1,2);
FValue:=Division.GetDiv(1.0,2);
IValue:=Division.GetDiv(1,0);
FValue:=Division.GetDiv(1.0,0);
Division.Free;
Ende;
6. Klassen sind ein Mechanismus zur Wiederverwendung von Code
Wenn wir beispielsweise in 5 dieser Klasse eine GetAdd-Funktion hinzufügen möchten, um Additionsoperationen durchzuführen, können wir die Klassenvererbung verwenden. wie
Schreiben Sie einfach:
(eins)
Einheit Einheit2;
Schnittstelle
Typ
TDivision=Klasse
öffentlich
Funktion GetDiv(Num1,Num2:Double):Double;overload;
Funktion GetDiv(Num1,Num2:integer):integer;overload;
Ende;
Typ
TOperation=Klasse(TDivision)
öffentlich
Funktion GetAdd(Num1,Num2:Double):Double;
Ende;
Durchführung
{Abteilung}
Funktion TDivision.GetDiv(Num1, Num2: Double): Double;
beginnen
versuchen
Ergebnis:=Anzahl1/Anzahl2;
außer
Ergebnis:=0;
Ende;
Ende;
Funktion TDivision.GetDiv(Num1, Num2: integer): integer;
beginnen
versuchen
Ergebnis:=Num1 div Num2;
außer
Ergebnis:=0;
Ende;
Ende;
{TOPperation}
function TOperation.GetAdd(Num1, Num2: Double): Double;
beginnen
Ergebnis:=Anzahl1+Anzahl2;
Ende;
Ende.
Hier erben wir eine Unterklasse TOPeration von TDivision. TOperation kann TDivsion haben
Die öffentliche Methode GetDiv verfügt über ihre eigene einzigartige Methode GetAdd. Dies ist der Kurs „Nimm deinen Kuchen und iss ihn auch“, den wir anbieten.
„Get“-Methode.