mit 1. Form auf 2. Form zugreifen

[Affemitwaffe93]

Hallo Leute,

Also ich habe mir das ganze so vorgestellt:

Ich hab schon über Datei/Neu ..usw. ein 2. Formular erstellt und jetzt will ich mit Button1 auf der Form1 auf z.B. Button1 auf der Form2 zugreifen (im Sinne von z.B. Caption usw ändern)

Ich hab ehrlich gesagt keine Ahnung wie das gehen soll weil wenn ich den Quelltext einfach so eingebe, funktioniert (logischerweise, wie ich mir jetzt denke) nichts ^^.

[mkinzler]

Hast du die Unit in diese Uses übernommen?

[Affemitwaffe93]

ja hab ich ^^ aber eigentlich geht es mir eher drum was ich den reinschreiben muss, dass das ganze funktioniert ^^

[DeddyH]

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
begin
  Form2.Button1.Caption := 'Wuppdi';
end;

So schon versucht?

[Affemitwaffe93]

hmhmhmhmh höhrt sich gut an ^^ viielen daaank

[Affemitwaffe93]

jetzt mal noch eine Frage^^

werden variablen die ich in Form1 deklariere auch in Form2 übernommen ?

und wenn nicht, wie kann ich das machen ?

[mkinzler]

Nein, du kannst aber auf Variablen, die im Interface deklariert wurden und auf nicht private Member der Form zugreifen

[Affemitwaffe93]

ok den satz hab ich glaub verstanden ^^ aber wie mach ich das ?

[taaktaak]

Kommt darauf an...
Widerspricht aber der Kapselung von Informationen.
Wenn die Infos aber im Form2 notwendig sind, dann sollten diese Infos im Form1 als Properties bereitgestellt werden.

[Affemitwaffe93]

achso ^^ sry aber des check ich jetzt gar nicht mehr... kann mir mal einer nen quellcode dazu schreiben, wo man des sieht *liebguck*^^

[mkinzler]

Für was, eine Variable im Interface, öffentlicher Formmember oder property?

[taaktaak]

Delphi-Quellcode:

private
  FIrgendwas : Integer;
public
  property Irgendwas : Integer read FIrgendwas write FIrgendwas;
end;

implementation

//..

FIrgendwas:=99;

//..

Nun kannst du im Form2 auf Form1.Irgendwas zugreifen!

[Chemiker]

Hallo Affemitwaffe93,

oder so:

z.B.:

Form2 – Aufrufen:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  sTestString: String;
begin
  sTestString:= 'Aufruf ';
  TForm2.GetData1 (sTestString);
  ShowMessage('Das ist ein TestString: '+sTestString);
end;

In Form2 deklarieren:

Delphi-Quellcode:

public
    { Public-Deklarationen }
      class function GetData1 (var sString: String): Boolean;



implementation

class function TForm2.GetData1 (var sString: String): Boolean;
begin
  with TForm2.Create(nil) do
    try
      Result := ShowModal=mrok;  // ModalResult auf mrOk im OI einstellen
      if Result then
      begin
        sString:= sString+ 'Das ist ein Test';
      end; 
      finally
       free;                 
   end;
end;

Edit: end; nachgereicht

Bis bald Chemiker

[taaktaak]

Delphi-Quellcode:

if Result then 
      begin 
        sString:= sString+ 'Das ist ein Test'; 
      finally 
       free;                  
   end;

Hmm, sind begin und end da richtig gesetzt?
Schaut irgendwie komisch aus?

[Chemiker]

Hallo taaktaak,

Zitat:

Zitat von taaktaak

Schaut irgendwie komisch aus?

habe den Quellcode verbessert, ich hoffe er ist jetzt richtig.

Bis bald Chemiker

[taaktaak]

Hallo Chemiker,
bin kein Erbsenzähler, aber bevor es einen Einsteiger verwirrt...
:hi:

[Affemitwaffe93]

irgendwie sieht das von Taaktaak einfacher aus ^^

Delphi-Quellcode:

property Irgendwas : Integer read FIrgendwas write FIrgendwas;

das brauch ich alles oder ???

und dann hald nur die variable auf meinen Namen ändern ^^

[taaktaak]

JEIN, "write ..." wird nur benötigt, wenn du den Wert von ausserhalb auch ändern möchtest. Aber in jedem Fall - das ist insgesamt nur eine Möglichkeit von mehreren, so etwas zu realisieren.

[Affemitwaffe93]

ahhh ok ... ja will ich ^^

also nochmal vielen dank^^

[taaktaak]

Vielleicht noch mal etwas weiter erklärt. Mein Beispiel ist eigentlich noch nicht sehr sinnvoll. Gleiches wäre erreicht, wenn du die Variable einfach nur als public deklarierst:

Delphi-Quellcode:

private 
  public 
    Irgendwas : Integer; 
end; 

implementation 

//.. 

Irgendwas:=99; 

//..

So richtig sinnvoll sind Properties m.E. erst, wenn der Zugriff über Getter/Setter-Methoden erfolgt. Beispiel:

Delphi-Quellcode:

  private 
  FIrgendwas : Integer; 
  procedure SetIrgendwas(NeuerWert:Integer)
  function  GetIrgendwas:Integer;
public 
  property Irgendwas : Integer read GetIrgendwas write SetIrgendwas; 
end; 

implementation 

//.. 

procedure T~~.SetIrgendwas(NeuerWert:Integer);
begin
  if NeuerWert>0 then FIrgendwas:=NeuerWert;
  ShowMessage('FIrgendwas wurde verändert')
end;

function T~~.GetIrgendwas:Integer;
begin
  Result:=FIrgendwas;
  ShowMessage('FIrgendwas wurde gelesen')
end;

//..

Damit erhälts du interessante Möglichkeiten; du kannst z.B. den neuen Wert prüfen und eine Änderung nur unter bestimmten Bedingungen zulassen. Ausserdem sind lesende und schreibende Zugriffe auf die interne Variable jetzt quasi zu einem Event geworden auf das du unit-intern reagieren kannst (das ShowMessage() ist hier nur ein Platzhalter). Denkbar ist z.B., daß nach einer Änderung des Wertes von aussen, die Unit eine Anzeige aktualisiert - das wär ohne den Setter schon schwieriger zu realisieren.

[Affemitwaffe93]

hmmhmhmh des blick ich jetzt nimmer

und wenn ich des hier eingebe
[quote="taaktaak"]

Delphi-Quellcode:

private
  FIrgendwas : Integer;
public
  property Irgendwas : Integer read FIrgendwas write FIrgendwas;
end;

implementation

//..

FIrgendwas:=99;

//..

dann kommt einer Fehlermeldung.

Die Variablen einfach so

Delphi-Quellcode:

  public
     Zahl1: Integer;

deklarieren kann ich nicht oder ?

[himitsu]

gehen tut das schon,

aber irgendwie sind viele der Meinung man solle sich die möglichkeit offen lassen das Read/Write später doch mal über Setter- und/oder Getter-Prozeduren laufen zu lassen ... drum der "sinnlos" aussehende Weg über das Property.

bei property Irgendwas : Integer read ... write ...; ist nach innen (zu Klasse alles offen ... da kann nun umgenannt oder erweitert werden, ohne das man nach ausen (da wo Irgendwas verwendet wird) sich etwas ändert.

nja, aber du bist der Programmierer, also mach was du für besser hälst :angel:

[DeddyH]

Die Zeile

Zitat:

Delphi-Quellcode:

FIrgendwas:=99;

darfst Du ja auch nicht einfach wild in den Implementation-Teil schreiben, die gehört schon in eine Methode bzw. den Constructor.

[Affemitwaffe93]

muss ich dann

Delphi-Quellcode:

public 
     Zahl1: Integer;

in beide Formen schreiben ?

weil ich hab das jetzt so gemacht und dann habe ich keinen wert in der 2. Form

wenn ich allerdings nichts in die public reinschreib kommt eine Fehlermeldung.

und warum muss ich eigentlich diese Variablen nicht in

Delphi-Quellcode:

var

deklarieren ?

@DeddyH: ja das hab ich gewusst

[DeddyH]

Wenn Du die "Variable" in den public-Teil einer Klasse schreibst, verwendet jede Instanz dieser Klasse ihre eigene "Variable"(Property), als var deklariert ist das eine globale Variable, die von allen gleich benutzt wird.

[Affemitwaffe93]

??? :gruebel: :wiejetzt:

heisst des jetzt ich muss die variablen in den Var Teil reinschreiben ?

ohh man bin ich so blöd ?

[mkinzler]

Nein, sie ist ja ein Member der (Formular-)Klasse

[himitsu]

wenn du das in beide Formen(Klassen) reinschreibst, dann sind es auch 2 verschiedene Variablen, also auch 2 unterschidliche Inhalte.

= nur in eine Klasse/Form reinmachen

[DeddyH]

Delphi-Quellcode:

type 
  TMyClass = class
  private
    FMyVar: integer;  //privates Feld
  public
    constructor Create;override;
    property MyVar: integer read FMyVar write FMyVar; //Property zum Zugriff auf FMyVar
  end;  

var EineVar: integer = 0; //globale Variable

implementation

constructor TMyClass.Create;
begin
  inherited Create;
  FMyVar := 99;  //Setzen des Initialwertes für FMyVar
  inc(EineVar);  //Erhöhen der globalen Variablen
end;

Wenn Du nun 2 Instanzen von TMyClass erzeugst und der ersten den Wert 10 für MyVar zuweist, ist MyVar der zweiten immer noch 99, MyVar hängt also an der Instanz. EineVar dürfte dann aber den Wert 2 haben, da beide Instanzen hier auf dieselbe Variable zugreifen.

[mkinzler]

Es würde imho nicht schaden, sich mal mit den Grundlagen der OOP zu befassen

[Affemitwaffe93]

ok funktioniert super, danke