[delphi] zomaar een vraagje

[Verwijderd]

Ik ben nu delphi aan het leren en ik kon al Java (WHOOT)
Nu ga ik lekker in delphi (een boek helpt me), maar ik zat nog met een vraagje.

Je hebt in Java een methode om je classen aan te makken

Mijnclass Nieuwe= new Mijnclass();

Alleen hoe doe ik dit in delphi maar dan in de implementation?

Ik weet dat ik nog al wat van jullie vraag maar je bent een held als je me kan helpen.

[Delphi32]

Nou vooruit, dit is wel heel erg RTFM , maar omdat je in Java misschien andere terminologie gewend bent kan dat wel eens lastig zoeken zijn.

code:

var
  MyClass: TMyClass; //declareert een variable van type TMyClass
begin
  MyClass := TMyClass.Create; //laat MyClass verwijzen naar een nieuwe instantie van TMyClass;
end;

[LordLarry]

En vergeet dan ook de MyClass.Free; niet. Anders heb je een memory leak. Iets waar Java geen last van heeft met zn garbage collection

[Delphi32]

Op woensdag 17 juli 2002 16:48 schreef LordLarry het volgende:
En vergeet dan ook de MyClass.Free; niet. Anders heb je een memory leak. Iets waar Java geen last van heeft met zn garbage collection

* Delphi32 kent geen Java maar vindt de aanvulling desalniettemin zeer terecht

[Verwijderd]

hoe maak je dat dan dynamish.
want nu kan ik alleen een class createn als hij in de var staat geprototypt.

[Creepy]

Hoe maak je wat dynamisch???

[Verwijderd]

kijk in java hoef je niet te prototypen(Var is prototyping toch??)


Je kan door een loopje net zoveel classes createn als je zelf wil(of als nodig is).
Ik zie ff niet in, hoe dit wel kan in delphi.
Al zal ik wel weer compleet blind zijn.

[Verwijderd]

ik ben niet zo'n ster in de object-pascal syntax, dus maar ff semi-pseude code...

zou dit niet gewoon moeten werken:

code:

begin
  MyClass[20]: TMyClass;

  for i = 0 to 19
  begin
    MyClass[i] := TMyClass.Create;
  end

end

Tadaaaa, een hele reeks van gecreëerde classen

EDIT: is natuurlijk nog niet helemaal dynamisch, maar dan moet je een linked-list gebruiken ofzo...
En ja, in pascal/c++ moet je met veeeel meer dingen rekening houden als java, vooral op geheugen gebied.

[Verwijderd]

kijk dat is nou wat ik zoek, door mijn java-opleiding ken ik niet zoiets als prototypen(bestaat natuurlijk wel in java maar is nie nodig)
maar een array is natuurlijk mooi.
Ik denk dat ik hier wel mee verder kan.

Tnx alot luitjes, ik ben weer blij;)

[jopiek]

gewoon ook geen appels met peren vergelijken, gewoon proggen wat je moet proggen en java-onzin vergeten

maar iig probeer "Delphi 6 Developers Guide" of "Mastering Delphi 6" eens!

ik heb trouwens eerst delphi, toen c++ en toen java geleerd, maar andersom zou uiteraard ook prima moeten gaan, iig gefeliciteerd dat je delphi wilt leren!!! (meeste javamensen halen daar hun neus voor op...)

[Creepy]

Tzal wel aan mij liggen, maar in java maak je toch instanties van klassen. In Delphi leg je van te voren vast welke variabelen er zijn, die dus ook instanties van objecten kunnen zijn.

* Creepy ziet het verschil niet echt.
Je weet toch wel van te voren hoeveel instanties je van een bepaald object nodig hebt? En zo niet, dan gebruik je bijv een array, lists (TList/TObjectlist.. zalig ding!)

Dat je in Object Pascal je definities van var's in een var stukje moet doen, en je dit met Java (en C(++)) overal in je code kan doen, maakt opzich geen verschil lijkt me.

[edit]
Hmm.. dit kan ook in Delphi:

code:

var dummy: TMyObject;
begin
     dummy:=TMyObject.create;
   
     // doe iets met dummy

     dummy:=TMyObject.create;

     // doe weer iets met dummy
end;

Je bent dan wel je referentie naar de eerst aangemaakt instantie kwijt. Maar dat is in Java ook lijkt me. Met het verschil dat java deze vanzelf opruimt, en Delphi niet (en hoppa.. een mem leakje)

[Delphi32]

Op woensdag 17 juli 2002 22:32 schreef unteraarsch het volgende:
[...]
EDIT: is natuurlijk nog niet helemaal dynamisch, maar dan moet je een linked-list gebruiken ofzo...
En ja, in pascal/c++ moet je met veeeel meer dingen rekening houden als java, vooral op geheugen gebied.

Ik maak het nog dynamischer voor je

code:

var
  MyObjectList: TObjectList;
  i: integer;
begin
  MyObjectList := TObjectList.Create;
  try
    MyObjectList.Add(TMyFirstClass.Create);
    MyObjectList.Add(TMySecondClass.Create);
    MyObjectList.Add(TAnotherClass.Create);
    for i := 0 to MyObjectList.Count - 1 do begin
    ShowMessage(TObject(MyObjectList[i]).ClassName);
    end;
  finally
    MyObjectList.Free;
  end;
end;

Zo, nu heb je een list (MyObjectList), een managed list is dat zelfs want hij ownt de objecten. En er zitten drie verschillende classes in. Ik heb het for-loopje erin gezet om te laten zien dat als de classes van een common ancestor afkomen, je ze kan casten en zo de methods/properties van de ancestor kan benaderen. (de cast naar TObject is in dit geval overbodig maar ter illustratie)
En aan het eind (finally) zorg ik ervoor dat het object dat ik heb gemaakt (MyObjectList) weer wordt vrijgegeven. Omdat de TObjectList een managed list is, zorgt de MyObjectList.Free ervoor dat alle geïnserte objecten ook worden vrijgegeven.