OOP - Fragen zu Informatik Hausaufgaben

[Trax]

Hallo Leute,
ich haben ein paar Fragen/Probleme mit einer Informatik Hausaufgabe, die auch bedeutend für die nächste Klausur sein wird. Und zwar habe ich von meinem info lehrer 2 aufgaben (Programme) zum thema OOP bekommen:

Zum ersten Programm soll ich schriftlich die wichtigsten sachen im programm erklären. Ich könnte zwar größtenteils durch den sourcecode gehen und die sachen nach und nach versuchen zu erklären, jedoch befürchte ich, dass ich die wichtigsten sachen nicht gut genug erkläre, oder sogar übersehe. Wäre echt super nett, wenn mir hier jemand sagen könnte, worauf ich den focus legen muß. Was muß ich gründlich erklären, was darf ich nicht vergessen?

Hab heute mal ein bischen im Forum gelesen. Da waren so viele nette und hilfsbereite leute, ich hoffe ihr lasst mich nicht hängen. Hab bis donnerstag zeit für meine arbeit. ist sehr wichtig für mich!!

Vielen Dank


Nun aber genug gebettelt, hier der Source:

Delphi-Quellcode:

unit Unit1;  // stellt die Rennstrecke und die Cockpits zur Verfügung

interface
//Types,.. weggelassen

var
  Form1: TForm1;

implementation

uses Auto;              // Einbinden der TAuto-Unit

{$R *.DFM}

var Auto1, Auto2, Auto3: TAuto;      // drei Auto-Objekte deklarieren
    xb: Integer;   // außerhalb des Sichtbereihs licegender Streckenabschnitt

procedure TForm1.FormCreate(Sender: TObject);
begin
 Auto1 := TAuto.Create;   // rotes Auto-Objekt erzeugen (Instanz von TAuto)
 with Auto1 do
 begin
  x := Shape1.Left -100;  y := 10; farbe := clRed
 end;

 Auto2 := TAuto.Create;   // blaues Auto-Objekt erzeugen (Instanz von TAuto)
 with Auto2 do
 begin
  x := Shape1.Left -100;  y := 110; farbe := clBlue
 end;

 Auto3 := TAuto.Create;   // grünes Auto-Objekt erzeugen (Instanz von TAuto)
 with Auto3 do
 begin
  x := Shape1.Left -100;  y := 210; farbe := clGreen
 end;
  Form1.Canvas.Brush.Style := bsClear   // Füllmuster ist transparent
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
 Auto1.Gasgeben(0.5)
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
 Auto1.Bremsen(1)
end;

procedure TForm1.Button4Click(Sender: TObject);
begin
 Auto2.Gasgeben(1.8)
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
 Auto2.Bremsen(1.5)
end;

procedure TForm1.Button6Click(Sender: TObject);
begin
 Auto3.Gasgeben(5)
end;

procedure TForm1.Button5Click(Sender: TObject);
begin
 Auto3.Bremsen(4)
end;

procedure anzeigen(auto:TAuto);    // Anzeigeroutine für ein TAuto-Objekt
 begin
   auto.Zeichnen(Form1.Canvas, Form1.Color);    // alte Position mit Hintergrundfarbe löschen
   auto.x := auto.x + Trunc(auto.va);           // Verschieben der x-Position
   If auto.x >= Form1.ClientWidth then auto.x := -xb;   // Rand erreicht => zurücksetzen
   auto.Zeichnen(Form1.Canvas, auto.farbe)      // an neuer Position zeichnen
 end;

procedure TForm1.Timer1Timer(Sender: TObject);  // periodisches Anzeigen
begin
 anzeigen(auto1);
 anzeigen(auto2);
 anzeigen(auto3)
end;

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
 Auto1.Free;
 Auto2.Free;
 Auto3.Free
end;

procedure TForm1.FormResize(Sender: TObject);
begin
 xb := 3 * Form1.ClientWidth;        // Fensterbreite hat sich geändert
 Timer1Timer(Self)                   // Aufruf von TForm1.Timer1Timer
end;

procedure TForm1.Button7Click(Sender: TObject);  // Beenden
begin
 Form1.Close
end;


end.

Hier ist die Unit Auto

Delphi-Quellcode:

unit Auto;  // stellt die TAuto-Klasse zur Verfügung

interface
uses Graphics;

  type TAuto = class(TObject)     // Klassendeklaration von TAuto
   // Eigenschaften:
   x:Integer;          // x - Position
   y: Integer;         // y - Position
   va: Single;         // aktuelle Geschwindigkeit
   farbe: LongInt;     // Lackierung
   // Methoden:
   procedure Gasgeben(dv:Single);     // erhöht va um dv
   procedure Bremsen(dv:Single);      // verringert va um dv
   procedure Zeichnen(canv:TCanvas; colr: LongInt); // zeichnet Auto auf Canvas in Farbe colr

  end;

 implementation

  // ------------ Methoden implementieren:

 procedure TAuto.Gasgeben(dv:Single);
 begin
  va := va + dv;
  if va > 100 then va := 100         // Geschwindigkeitsbegrenzung
 end;

 procedure TAuto.Bremsen(dv:Single);
 begin
  va := va - dv;
  if va <= 0 then va := 0           // Rückwärtsrollen verhindern
 end;

 procedure TAuto.Zeichnen(canv:TCanvas; colr: LongInt);
  begin
   with canv do begin
    Pen.Color := colr;      // Stiftfarbe zuweisen
    Rectangle(x+10, y+5, x+30, y+20);       // linkes Hinterrad
    Rectangle(x+10,y+70,x+30,y+85);         // rechtes Hinterrad
    Rectangle(x+80,y+10,x+100,y+20);        // linkes Vorderrad
    Rectangle(x+80,y+70,x+100,y+80);        // rechtes Vorderrad
    MoveTo(x+20, y+20); LineTo(x+20,y+30);  // linke Hinterachse
    MoveTo(x+20, y+60); LineTo(x+20,y+70);  // rechte Hinterachse
    MoveTo(x+90, y+20); LineTo(x+90,y+35);  // linke Vorderachse
    MoveTo(x+90, y+55); LineTo(x+90,y+70);  // rechte Vorderachse
    MoveTo(x, y+30); LineTo(x+70,y+30);     // linke Karosserieseite
    LineTo(x+110, y+40); LineTo(x+110,y+50);
    LineTo(x+70, y+60); LineTo(x,y+60);     // rechte Karosserieseite
    LineTo(x,y+30);
    Ellipse(x+45,y+35,x+65,y+55)            // Cockpit
   end
  end;

end.

[sakura]

Folgende Dinge sind wohl besonders wichtig:

• Was ist unterschiedlich in Auto1, Auto2 und Auto3
• Was ist gleich in Auto1, Auto2 und Auto3
• Was bedeuten private, protected, public (u.U. published) in der Klassendeklariation
• Was ist der Unterschied zw. Klassen und Objekten (TAuto und Auto1..3)
• Objektübergabe (TAuto.Zeichnen: canv:TCanvas)
• Was wurde bei TAuto nicht berücksichtigt (schlechter Programmierstil): keine private Sektion zu Schutz von Klassenvariablen.

Das wäre erst einmal ein kleiner Anfang der wohl wichtigsten Dinge.

[phlux]

Das sieht haargenau aus wie das Beispiel aus dem Delphi Kochbuch von Kowalski und Doberenz

Zitat von sakura:

• Was wurde bei TAuto nicht berücksichtigt (schlechter Programmierstil): keine private Sektion zu Schutz von Klassenvariablen.

Das führen die erst 2 Rezepte später ein *doh*

[Trax]

Danke für die schnelle Antwort. Hierzu habe ich aber noch frage:

Zitat von sakura:

• Was bedeuten private, protected, public (u.U. published) in der Klassendeklariation
• Objektübergabe (TAuto.Zeichnen: canv:TCanvas)

1) Kann jemand mal kurz erläutern wo genau der unterschied zwischen protected und private liegt??

2) Was ist genau mit Objektübergabe gemeint?? Der Begriff sagt mir leider nichts.

[RomanK]

Zitat von Chris Seehase:

private / geringste Sichtbarkeit
Auf das, was in diesem Abschnitt deklariert wird kann nur innerhalb der Unit zugegriffen werden, in der die Deklaration steht.
In abgeleiteten Klassen besteht kein Zugriff (wenn sie nicht in der gleichen Unit deklariert werden)

protected / mittlere Sichtbarkeit
Es kann nur innerhalb der Klassendeklaration und davon abgeleiteter Klassen auf diese Einträge zugegriffen werden.

public / Hohe Sichtbarkeit
auf das, was hier deklariert wird kann von überall her zugegriffen werden, von wo aus auf eine Variable des Typs zugegriffen werden kann.

published / Hohe Sichtbarkeit
Wohl nur sinnvoll bei Komponenten einsetzbar.
Im Prinzip wie public, nur dass diese Einträge im Objektinspektor erscheinen und eingestellt werden können.

Damit sich private und protected auswirken können, sollten die Klassendeklarationen in einer separaten Unit stehen, denn innerhalb der Unit in der die Deklaration steht, kann auf diese Felder/Methoden dennoch zugegriffen werden.


[EDIT]published ist Borland spezifisch, die anderen drei wirst Du so auch in VC++ finden[/EDIT]

Stand irgentwo hier im Forum, ich habe den Auszug nur auf der Platte.

[Trax]

Zitat von phlux:

Das sieht haargenau aus wie das Beispiel aus dem Delphi Kochbuch von Kowalski und Doberenz

Kommt in dem Buch auch eine Art "ARCHITEKTen" Programm vor, oder sowas ähnliches. Das ist nämlich das zweite programm zudem ich aufgaben habe und an dem knabbere ich gerade. Vielen Dank schonmal im vorraus - auch an alle anderen für die vielen antworten!

[phlux]

Meinst du Visio?
Rezept R280: OLE-Automation mit Visio realisieren, z.B.

[Trax]

hehe nein nicht wirklich.

nachdem man mir hier bei der ersten frage so nett geholfen hat, poste ich nun die zweite aufgabe die ich lösen muß. Hier hackts bei mir total.


Unit 2 zuerst, weil man zuerst die aufgaben in unit 2 beantworten muß um unit 1 zu beantworten. Also:

Delphi-Quellcode:

unit Unit2;
  //Aufgaben:
  // 1) Ergänze die Methode TViereck.FlaecheBerechnen
  //    Tip:Die Fläche eines beliebigen Vierecks mit den Eckpunkten
  //        (ax,ay);(bx,by);.... berechnet man wie folgt:
  // a0:=(cx-ax)*(by-dy);
  // a1:=(bx-ax)*(by-ay)/2;
  // a2:=(cx-bx)*(by-cy)/2;
  // a3:=(cx-dx)*(cy-dy)/2;
  // a4:=(dx-ax)*(ay-dy)/2;
  // flaeche:=a0-a1-a2-a3-a4;  ERKLÄRE DIE FORMEL!
  //
  // 2) Leite Vom Objekt TViereck ab ein Objekt TGrundstück,
  //    das alle Eigenschaften erbt und zusätzlich die Methode
  //    KostenBerechnen kennt.  (Quadratmeterpreis als Konstante mit
  //    Anfangswert 85 festlegen!)
  // Weitere Aufgaben in Unit1 !

interface
uses graphics,unit1;

  type TViereck = class(TObject)
  public
   ax,ay,bx,by,cx,cy,dx,dy:integer;
   Flaeche:real;
   constructor Erzeugen;
   procedure Zeigen(canv:TCanvas);
   function FlaecheBerechnen :real;
   end;

  {type TGrundstueck .....fehlt...}

implementation
   constructor TViereck.Erzeugen;
   begin   end;

   procedure TViereck.Zeigen (canv:TCanvas);
   begin
    with canv do
      begin
      moveto(ax,ay);
      lineto(by,by);
      lineto(cx,cy);
      lineto(dx,dy);
      lineto(ax,ay);
      end;
   end;

   function TViereck.FlaecheBerechnen:real;
   Var a0,a1,a2,a3,a4:real;
   Begin
   { unfertig}
   End;
   end.

zu 1) hier ich irgendwie meine Probleme. Ich weiß nicht wirklich wie ich das lösen soll. Hier fehlt mir einfach total der Durchblick. ich hab z.b. keine ahnung was a0 ist (bei a1-a4 vermute ich, dass es sich um die vier eckpunkte des dreiecks handelt.

Zu 2) Bei Aufgabe zwei habe ich folgendes (siehe SourceCode)! Ich hoffe das ist soweit in ordnung.

Delphi-Quellcode:

Type
  TGrundstück = class(TViereck)
    private
      PreisProQM: real;
    public
      function KostenBerechnen: real;
      constructor Erzeugen;
  end;

Function TForm1.Kostenberechnen: real;
begin
result := Flaecheberechnen * PreisProQM;
end;

Constructor TGrundstueck.Erzeugen;
begin
inherited create;
PreisProQM := 85;
end;

Hier Unit 1:

Delphi-Quellcode:

unit Unit1;

// Berechnung von Fläche und Preis beliebiger viereckiger Grundstücke
// Ehemals Abituraufgabe(4.Fach)
// UNIT2 wird verwendet !!!
//
// Löse zuerst die in Unit2 gestellten Aufgaben.
//
// Weitere Aufgaben:
// Schreibe mit Hilfe der neuen Methoden aus Unit2
// die hier fehlenden Prozeduren
// a)procedure FlaecheBtnClick(Sender: TObject);
// b)procedure KostenBtnClick(Sender: TObject);

interface

//uses + type weggelassen

var
  Form1: TForm1;

implementation
uses unit2;
{$R *.DFM}

var Viereck1: TViereck;

procedure TForm1.ZeigeBtnClick(Sender: TObject);
begin
 Viereck1.zeigen(Form1.canvas);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  Viereck1:=TViereck.erzeugen;
  with Viereck1 do
  begin
    ax:=20;ay:=180;
    bx:=180;by:=200;
    cx:=200;cy:=40 ;
    dx:=40 ;dy:=20 ;
  end;
end;

procedure TForm1.FlaecheBtnClick(Sender: TObject);
begin
 { unfertig };


end;

procedure TForm1.KostenBtnClick(Sender: TObject);
begin
  { unfertig }


end;
end.

Die kann ich nicht lösen, weil ich die unit 2 nicht ganz verstehe.
Wenn mir hier jemand helfen könnte, wäre ich unendlich dankbar, ich kaue hierbei nämlich ein bischen auf dem Zahnfleisch.

Vielen Dank
Trax

[Mirilin]

anderes Forum, gleiche Frage...
sieh mal hier
(wohl ein Klassenkamerade...)

[Trax]

HEHEHE, jetzt weiß ich, wo mein Klassenkamerad die Lösung her hat, die er mir geschickt hat. Dennoch sind die Antworten im anderen Forum nicht wirklich hilfreich gewesen. Es wäre also nett, wenn ihr trotzdem meine Fragen beantworten würdet.
Ich hab das nämlich noch nicht ganz verstanden.