OOP Problem: kein Zugriff auf Prozeduren

[maximus Caesar]

Hallo!
Ich habe ein OOP Problem!

Mein Code sieht so aus:

Delphi-Quellcode:

unit objekte;                        

interface

type
 TObjekt1 = class
  FTyp:String;
  FUsed:Boolean;
  FItems:Array [1..100] of String;
  FName:String;
  FAktion:String;
  FBild:String;
  FX:Integer;
  FY:Integer;
  procedure WriteTyp(Variable:String);
  procedure WriteUsed(Variable:Boolean);
  procedure WriteItem(Item:String; Position:Integer);
  procedure WriteName(Name:String);
  procedure WriteAktion(Aktion:String);
  procedure WriteBild(Bild:String);
  procedure WriteX(x:integer);
  procedure WriteY(y:Integer);
  function GetTyp:String;
  function GetUsed:Boolean;
  function GetItem(position:integer):String;
  function GetName:String;
  function GetAktion:String;
  function GetBild:String;
  function GetX:Integer;
  function GetY:Integer;
  property Typ : String Read FTyp Write FTyp;
 end;


implementation


// Prozeduren und Funktionen der Klasse "Objekt1"

 procedure TObjekt1.WriteTyp(Variable:String);
 begin
  FTyp:=Variable;
 end;

 procedure TObjekt1.WriteUsed(Variable:Boolean);
 begin
  FUsed:=Variable;
 end;

 procedure TObjekt1.WriteItem(Item:String; Position:Integer);
 begin
  FItems[Position]:=Item;
 end;

 procedure TObjekt1.WriteName(Name:String);
 begin
  FName:=Name;
 end;

 procedure TObjekt1.WriteAktion(Aktion:String);
 begin
  FAktion:=Aktion;
 end;

 procedure TOBjekt1.WriteBild(Bild:String);
 begin
  FBild:=Bild;
 end;

 procedure TObjekt1.WriteX(x:Integer);
 begin
  FX:=x;
 end;

 procedure TObjekt1.WriteY(y:Integer);
 begin
  FY:=y;
 end;

 function TObjekt1.GetTyp:String;
 begin
  result:=FTyp;
 end;

 function TObjekt1.GetUsed:Boolean;
 begin
  result:=FUsed;
 end;

 function TOBjekt1.GetItem(position:Integer):String;
 begin
  result:= FItems[position];
 end;

 function TObjekt1.GetName:String;
 begin
  result:=FName;
 end;

 function TObjekt1.GetAktion:String;
 begin
  result:=FAktion;
 end;

 function TObjekt1.GetBild:String;
 begin
  result:=FBild;
 end;

 function TObjekt1.GetX:Integer;
 begin
  result:=FX;
 end;
 
 function TObjekt1.GetY:Integer;
 begin
  result:=FY;
 end;






end.

Ich kann nicht z.B von einem Button aus nicht auf die Prozeduren zugreifen.
Wie kann ich dafür sorgen, dass dies möglich wird?

PS: auf den Property "Typ" kann ich auch nicht zugreifen!

[Dax]

Das ist kein Wunder, alles in der Klasse ist private.
So müsste es gehen:

Delphi-Quellcode:

type
TObjekt1 = class
  FTyp:String;
  FUsed:Boolean;
  FItems:Array [1..100] of String;
  FName:String;
  FAktion:String;
  FBild:String;
  FX:Integer;
  FY:Integer;
 public
  procedure WriteTyp(Variable:String);
  procedure WriteUsed(Variable:Boolean);
  procedure WriteItem(Item:String; Position:Integer);
  procedure WriteName(Name:String);
  procedure WriteAktion(Aktion:String);
  procedure WriteBild(Bild:String);
  procedure WriteX(x:integer);
  procedure WriteY(y:Integer);
  function GetTyp:String;
  function GetUsed:Boolean;
  function GetItem(position:integer):String;
  function GetName:String;
  function GetAktion:String;
  function GetBild:String;
  function GetX:Integer;
  function GetY:Integer;
  property Typ : String Read FTyp Write FTyp;
end;

[maximus Caesar]

Funktioniert leider immer noch nicht!

Wenn ich jetzt ein neues Programm anfange,

Delphi-Quellcode:

uses objekte;

reinschreibe und dann versuche auf das objekt zuzugreifen bekomme ich zwar Zugriff, aber nicht auf die Prozeduren und Funktionen!

[Dax]

Versuchs doch mal mit einer Standardmäßigen Typ-Deklaration:

Delphi-Quellcode:

type
TObjekt1 = class
 private
  FTyp:String;
  FUsed:Boolean;
  FItems:Array [1..100] of String;
  FName:String;
  FAktion:String;
  FBild:String;
  FX:Integer;
  FY:Integer;
 published
  procedure WriteTyp(Variable:String);
  procedure WriteUsed(Variable:Boolean);
  procedure WriteItem(Item:String; Position:Integer);
  procedure WriteName(Name:String);
  procedure WriteAktion(Aktion:String);
  procedure WriteBild(Bild:String);
  procedure WriteX(x:integer);
  procedure WriteY(y:Integer);
  function GetTyp:String;
  function GetUsed:Boolean;
  function GetItem(position:integer):String;
  function GetName:String;
  function GetAktion:String;
  function GetBild:String;
  function GetX:Integer;
  function GetY:Integer;
  property Typ : String Read FTyp Write FTyp;
end;

Die Unterscheidet sich zwar kaum von der anderen, aber wenn es so nicht funktioniert, weiss ich auch nicht mehr weiter.

[jim_raynor]

IRgendwie hab ich das gefühl, dass du das mit der OOP noch nicht ganz verstanden hast. Was du da angelegt hast, ist eine Klasse. Ein Klasse ist quasi ein Bauplan für ein Objekt. Du musst jetzt erstmal selber ein Objekt erzeugen.

Dazu musst du eine Variable vom Typ TObjekt1 anlegen:

Delphi-Quellcode:

var
  Obj1: TObjekt1

Jetzt hast du aber nur einen Zeiger auf ein Objekt. Das Objekt selber existiert noch nicht. Du musst es als mit Obj1:=TObjekt1.Create noch selber erzeugen. Dann kannst du z.B. per Obj1.WriteTyp auf die Prozeduren zu greifen.

Am Ende musst du noch Obj1.Free aufrufen um den Speicherplatz wieder freizugeben.

[maximus Caesar]

Danke!
Kannst du mir vielleicht das auch noch anhand von meinem Code zeigen?
Das währe sehr nett!

PS: Hast recht! Fange grad erst an mit OOP!

[Luckie]

Dann könnte evnetuell mein Tutorial http://tutorials.luckie-online.de hilfreich sein.

[maximus Caesar]

Habs raus!
Danke für die Hilfe! :thumb:
Bsp:

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
var Obj1: TObjekt1;
begin
Obj1:=TObjekt1.Create;
Obj1.WriteTyp('TEST');
showmessage(Obj1.GetTyp);
end;

PS: Das Tutorial hab ich schon. Jetzt versteh ichs auch besser!

[Christian Seehase]

Moin Caesar,

dazu gehört dann auch noch die Freigabe des Objektes:

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
var Obj1: TObjekt1;
begin
  Obj1:=TObjekt1.Create; // Objekt erzeugen
  try
    // Mit dem Objekt arbeiten
    Obj1.WriteTyp('TEST');
    showmessage(Obj1.GetTyp);
  finally
    // Und wieder freigeben, wenn es nicht mehr benötigt wird
    FreeAndNil(Obj1);
  end;
end;

try/finally soll sicherstellen, dass das Objekt wieder freigegeben wird, selbst wenn im Try-Abschnitt ein Fehler (Exception) auftritt.