Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Der Sportchef delegiert (Modularisierung und Delegation)

Ein Sportchef will, dass seine Mannschaft in dieser Saison möglichst viele Spiele gewinnt. Sein Club ist so aufgebaut, wie durch untenstehende Grafik angedeutet. Er selbst trainiert natürlich nicht, sondern delegiert diese vielversprechende Aufgabe seinem Trainer. Dieser wiederum lässt dazu jeden Spieler joggen und 20 Liegestützen ausführen.

Erzeugen Sie in einem Hauptprogramm die dreizehn geforderten Personen und verknüpfen Sie diese, sodass obige Delegationen möglich werden.

Zuletzt lassen Sie den Sportchef trainieren, indem Sie seine trainieren()-Methode aufrufen. Wenn die Programmschleife richtig implementiert ist, so werden nun alle elf Spieler ihre Sportübungen tätigen; dazu reicht pro Spieler eine einfache Ausgabe (z. B. auf der Konsole), dass seine Arbeit erledigt sei.

Der Sportchef delediert das Trainieren dem Trainer.

 

Zusatzaufgabe: Diskutieren Sie das Klassendiagramm, erweitern Sie es wo nötig und implementieren Sie Ihre Lösung.

4 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

Kommentare (4)

Tobias_Petri 3. Februar 2015 22:52   reply report
OO bringt immer einen Vorteil, weil es den Code überschaubarer und leichter handhabbar (wartbar) macht.
Ich habe - aus eigener Neugierde - hier in JavaScript 2 Lösungen geschrieben, die die Unterschiede im OOP zwischen JavaScript und älteren OOP-Sprachen verdeutlichen, denn dieser Vergleich ist IMHO immer wieder eine interessante Frage.
AndyFFW 7. Februar 2013 13:51   reply report
gressly
guggisberg
Das implementieren eines Klassendiagramms ist nicht besonders spannend. Könnte man die Aufgabe nicht so formulieren, dass die Schülerinnen und Schüler von selbst ein Klassendiagramm erstellen und dann implementieren? Wieso braucht es hier Objekte?

Objekte im Sinne einer Objekt orientierten Sprache sind nicht nötig. Ich zeige die Lösung auch in C, um zu zeigen, wie die Datenspeicherung (struct, malloc) in einer nicht Objekt orientierten Sprache aussehen könnte.

Doch im großen und ganzen gehört die Aufgabe eher in einen Kurs über Objektorientierung, gebe ich zu.

OO bringt zwar keinen Vorteil um diese Aufgabe zu lösen. Jedoch hab ich in meiner C++ Lösung Klassen und Objekte verwendet, da man diese Aufgabe als Einstiegsaufgabe in die OO Programmierung sehen kann.
gressly 27. Mai 2011 08:16   reply report
guggisberg
Das implementieren eines Klassendiagramms ist nicht besonders spannend. Könnte man die Aufgabe nicht so formulieren, dass die Schülerinnen und Schüler von selbst ein Klassendiagramm erstellen und dann implementieren? Wieso braucht es hier Objekte?

Objekte im Sinne einer Objekt orientierten Sprache sind nicht nötig. Ich zeige die Lösung auch in C, um zu zeigen, wie die Datenspeicherung (struct, malloc) in einer nicht Objekt orientierten Sprache aussehen könnte.

Doch im großen und ganzen gehört die Aufgabe eher in einen Kurs über Objektorientierung, gebe ich zu.
guggisberg 16. Januar 2011 22:31   reply report
Das implementieren eines Klassendiagramms ist nicht besonders spannend. Könnte man die Aufgabe nicht so formulieren, dass die Schülerinnen und Schüler von selbst ein Klassendiagramm erstellen und dann implementieren? Wieso braucht es hier Objekte?

6 Lösung(en)

public class Spieler {
   String rufname;
   
   void jogging() {
       System.out.println("Ich, " + rufname + " jogge (keuch).");
   }
   
   void liegestuetzen(int anzahl) {
       System.out.println("Ich, " + rufname + " mache " + anzahl + " Liegestuetzen.");
   }
}
//////////////////////////////////////////////////////////////////////
import java.util.ArrayList;

public class Trainer {
  String name;
  ArrayList<Spieler> spieler = new ArrayList<Spieler>();
  
  void trainieren() {
     for(Spieler s : spieler) {
         s.jogging();
         s.liegestuetzen(20);
     }
  }
  
  void spielerHinzufuegen(Spieler s) {
      if(11 > spieler.size()) {
          spieler.add(s);
      } else {
          System.out.println("Mannschaft komplett.");
      }
  }
}
/////////////////////////////////////////////////////////////////////////////
public class Sportchef {
  String name;
  Trainer trainer;
  
  void trainieren() {
      trainer.trainieren();
  }
}
/////////////////////////////////////////////////////////////////////////////
public class Main {

  public static void main(String[] args) {
    new Main(). top();
  }
  
  void top() {
    Sportchef chefe    = new Sportchef();
    Trainer   trainer  = new Trainer();
    chefe.trainer      = trainer;
    alleSpielerHinzufuegen(trainer);
    chefe.trainieren();
  }

  void alleSpielerHinzufuegen(Trainer trainer) {  
    einzelspielerHinzufuegen(trainer, "Horst");
    einzelspielerHinzufuegen(trainer, "Pele");
    einzelspielerHinzufuegen(trainer, "Bolt");
    einzelspielerHinzufuegen(trainer, "Calzeroni");
    einzelspielerHinzufuegen(trainer, "Hakan");
    einzelspielerHinzufuegen(trainer, "Camenzind");
    einzelspielerHinzufuegen(trainer, "Dribbelbauer");
    einzelspielerHinzufuegen(trainer, "Boskamp");
    einzelspielerHinzufuegen(trainer, "Bell");
    einzelspielerHinzufuegen(trainer, "Meier");
    einzelspielerHinzufuegen(trainer, "Kuhn");
  }

  void einzelspielerHinzufuegen(Trainer trainer, String rufname) {
    Spieler s;
    s = new Spieler();
    s.rufname = rufname;
    trainer.spielerHinzufuegen(s);
  }

}
                

Lösung von: Philipp Gressly Freimann (SANTIS Training AG)

/**
 * File : main.c
 * Autor: Philipp Gressly Freimann
 * Ziel : www.programmieraufgaben.ch / Aufgabe "Der Sportchef delegiert"
 * Datum : 27. Mai 2011
 */

#include "spieler.h"
#include "trainer.h"
#include "sportchef.h"

void main() {
  Spieler* spi1  = newSpieler("Pele");
  Spieler* spi2  = newSpieler("Maege");
  Trainer* tra   = newTrainer("Grass");
  trainerSpielerHinzufuegen(tra, spi1);
  trainerSpielerHinzufuegen(tra, spi2);
  Sportchef* spo = newSportchef("Blatti", tra);
  sportchefTrainieren(spo);
}
////////////////////////////////////////////////////////////////////////////////
/**
 * File : sportchef.h
 * Autor: Philipp Gressly Freimann
 * Datum : 27. Mai 2011
 */

#if !defined(__sportchef_h)
#define __sportchef_h

#include "trainer.h"

struct Sportchef {
  Trainer* trainer;
  char* name;
};

typedef struct Sportchef Sportchef;

// METHODS:

Sportchef * newSportchef(char* name, Trainer* t);
void sportchefTrainieren(Sportchef* s);


#endif
////////////////////////////////////////////////////////////////////////////////
/**
 * File : sportchef.c
 * Autor: Philipp Gressly Freimann
 * Datum : 27. Mai 2011
 */

#include <stdio.h>
#include <stdlib.h>

#include "sportchef.h"

Sportchef* newSportchef(char* name, Trainer* t) {
  Sportchef* sp;
  sp          = malloc(sizeof (Sportchef));
  sp->name    = name;
  sp->trainer = t;
  return sp;
}

void sportchefTrainieren(Sportchef* s) {
  trainerTrainieren(s->trainer);
}

// end class sportchef
////////////////////////////////////////////////////////////////////////////////
/**
 * File : trainer.h
 * Autor: Philipp Gressly Freimann
 * Datum : 27. Mai 2011
 */

#if !defined(__trainer_h)
#define __trainer_h

#include "spieler.h"

struct Trainer {
  Spieler* spielerListe[11];
  int anzahlSpieler;
  char* name;
};

typedef struct Trainer Trainer;

// METHODS:

Trainer * newTrainer(char* name);
void trainerSpielerHinzufuegen(Trainer* t, Spieler* s);
void trainerTrainieren(Trainer * t);


#endif
/////////////////////////////////////////////////////////////////////////////////
**
 * File : trainer.c
 * Autor: Philipp Gressly Freimann
 * Datum : 27. Mai 2011
 */

#include <stdio.h>
#include <stdlib.h>

#include "spieler.h"
#include "trainer.h"

Trainer* newTrainer(char* name) {
  Trainer* t;
  t = malloc(sizeof (Trainer));
  t->name = name;
  t->anzahlSpieler = 0;
  return t;
}

void trainerSpielerHinzufuegen(Trainer* t, Spieler* s) {
  int index = t->anzahlSpieler;
  t->spielerListe[index] = s;
  t->anzahlSpieler = index + 1;
}

void trainerTrainieren(Trainer* t) {
  int index = 0;
  while(index < t->anzahlSpieler) {
    Spieler* s = t->spielerListe[index];
    printf("%s trainiert %s:\n", t->name, s->rufname);
    spielerJogging(s);
    spielerLiegeStuetzen(s, 3);
    index = index + 1;
    printf("\n");
  }
}

// end class trainer
/////////////////////////////////////////////////////////////////////////////////
/**
 * File : spieler.h
 * Autor: Philipp Gressly Freimann
 * Datum : 27. Mai 2011
 */

#if !defined(__spieler_h)
#define __spieler_h

struct Spieler {
  char* rufname;
};

typedef struct Spieler Spieler;

// METHODS:

Spieler* newSpieler(char* rufname);
void spielerJogging(Spieler * s);
void spielerLiegeStuetzen(Spieler * s, int anzahl);

#endif
/////////////////////////////////////////////////////////////////////////////////
/**
 * File : spieler.c
 * Autor: Philipp Gressly Freimann
 * Datum : 27. Mai 2011
 */

#include <stdio.h>
#include <stdlib.h>

#include "spieler.h"

Spieler* newSpieler(char* rufname){
  Spieler* s;
  s = malloc(sizeof (Spieler));
  s->rufname = rufname;
  return s;
}

void spielerJogging(Spieler * s) {
  printf("%s ist am Joggen\n", s->rufname);
}

void spielerLiegeStuetzen(Spieler * s, int anzahl) {
  int nr = 1;
  while(nr <= anzahl) {
    printf("%s macht die %d. Liegestütze von %d.\n", s->rufname, nr, anzahl);
    nr = nr + 1;
  }
}

// end class spieler
                

Lösung von: Philipp Gressly Freimann (SANTIS Training AG)

// Autor:				Andy Großhennig
// Solution for task:	Der Sportchef delegiert (Modularisierung und Delegation)

#include <iostream>
#include <string>

using namespace std;

class Player
{
	public:
		string sName;
		void jog()
		{
			cout << "\nIch war joggen\n";
		}
		void pushUps(int amount)
		{
			cout << "Ich habe " << amount << " Liegestuetz gemacht\n";
		}
};

// Function: Add the name to the player
void addPlayerNames(string s_arrPlayerNames[11])
{
	string s_arrNames[11] = {"Rene Adler", "Holger Badstuber", "Jerome Boateng", "Philipp Lahm", "Mats Hummels", "Julian Draxler", "Lukas Podolski", "Sami Khedira", "Toni Kroos", "Mario Gomez", "Miroslav Klose"};

	for(short sh = 0;sh < 11;sh++)
	{
		s_arrPlayerNames[sh] = s_arrNames[sh];
	}
}

class Coach
{
	Player player;

	public:
		Player arrPlayer[11];
		string s_arrPlayerNames[11];
		short shTeamCapacity;
		string sName;
		void train()
		{
			player.jog();
			player.pushUps(20);
		}
		void addPlayer(string sNewName, short shPosition)
		{
			player.sName = sNewName;
			arrPlayer[shPosition] = player;
		}
};

void coach()
{
	Coach coach;

	coach.sName = "Hansi Flick";
	coach.shTeamCapacity = 0;
	addPlayerNames(coach.s_arrPlayerNames);
	for(short sh = 0;sh < 11;sh++)
	{
		coach.addPlayer(coach.s_arrPlayerNames[sh], coach.shTeamCapacity);
		coach.shTeamCapacity++;	
	}
	cout << coach.sName << ": Team komplett. Training faengt an!\n\n";
	for(short sh = 0;sh < 11;sh++)
	{
		cout << endl << coach.arrPlayer[sh].sName << ":";
		coach.train();
	}
}

class SportsChief
{
	public:
		string sName;
		void train()
		{
			coach();
		}
};

void sportsChief()
{
	SportsChief sportsChief;

	sportsChief.sName = "Joachim Loew";
	cout << sportsChief.sName << ": Ich gebe Anweisung zum trainieren!\n\n";
	sportsChief.train();
}

int main()
{
	sportsChief();

	cout << "\n\n";
	system("Pause");
	return 0;
}
                

Lösung von: Andy Großhennig (Bundeswehr)

class Person(object):
    def __init__(self, name):
        self.name = name
    def sagen(self, text):
        print("{} {}:".format(type(self).__name__, self.name), text)

class Sportchef(Person):
    def __init__(self, name):
        super().__init__(name)
        self.trainer = None
    def neuer_trainer(self, trainer):
        if type(trainer) != Trainer:
            self.sagen("Der Trainer ist nicht als Trainer ausgebildet.")
            return
        self.trainer = trainer
    def trainieren(self):
        self.sagen("Ich gebe Anweisung zu trainieren.")
        if self.trainer is not None:
            self.trainer.trainieren()

class Trainer(Person):
    def __init__(self, name):
        super().__init__(name)
        self.spieler = []
    def spieler_hinzufuegen(self, spieler):
        if type(spieler) != Spieler:
            self.sagen("Der Spieler ist nicht als Spieler ausgebildet.")
            return
        self.spieler.append(spieler)
    def trainieren(self):
        if len(self.spieler) < 11:
            self.sagen("Damit die Spieler trainieren koennen muss zuerst " \
                  "das Team vollstaendig sein.")
            return
        self.sagen("Als Trainer ordne ich joggen fuer alle an.")
        for spieler in self.spieler:
            spieler.jogging()
        self.sagen("Als Trainer ordne ich 20 Liegestuetze an.")
        for spieler in self.spieler:
            spieler.liegestuetze(20)

class Spieler(Person):
    def __init__(self, rufname):
        super().__init__(rufname)
    def jogging(self):
        self.sagen("Ich jogge.")
    def liegestuetze(self, n):
        self.sagen("Ich mache {} Liegestuetze.".format(n))


sp = Sportchef("Markus")
tr = Trainer("Tim")
for name in ["Max", "Tom", "Julia", "Maik", "Erik", "Simon",
             "Michael", "Peter", "Paul", "Lukas", "Felix"]:
    tr.spieler_hinzufuegen(Spieler(name))
sp.neuer_trainer(tr)

sp.trainieren()

                

Lösung von: Karl Welzel ()

<script type="text/javascript">
// Lösung 1: Für alle Opjekte werden zunächst Konstruktorfunktionen
// erzeugt, die dann mit 'new' instanziert werden. Dieser Ansatz
// kommt der OOP-Struktur von z.B. Java oder C# nahe.  
// (S. im Gegensatz hierzu Lösung 2 unten.)

var spielernamen = ['Pele','Maege','Grass','Arni','Berni','Boskamp','Bell','Meier','Kuhn'];

var	Spieler = function(name){
	this.rufname = name;
	this.jogging = function(){
		document.write('Spieler '+this.rufname+' ist joggen, ');
	}
	this.liegestuetzen = function(n){
		document.write('Spieler '+this.rufname+' macht '+n+' Liegestützen.<br>');
	}
}

var Trainer = function(name){
	this.name = name;
	this.trainieren = function(){
		for(var i = 0; i < spieler.length; ++i){
			spieler[i].jogging();
			spieler[i].liegestuetzen(20);
		}
	}
	this.spielerHinzufuegen = function(pSpieler){
		spieler.push(pSpieler);
	}
	
	var spieler = [];
}
function Chef(name){
	this.name = name;
	this.trainieren = function(){
		if (typeof trainer != undefined){
			trainer.trainieren();
		}
	}
}
// Opjekte instanzieren:
var chef = new Chef('Störtebecker');
var trainer = new Trainer('Beckenbauer');
var team = []
for (var i = 0; i < spielernamen.length; ++i){
	team[i] = new Spieler(spielernamen[i]);
	trainer.spielerHinzufuegen(team[i]);
}
// "delegieren":
chef.trainieren();



document.write('........<br>');

//**************************************************
// Lösung 2: JavaScript-OOP mit Objektliteralen,
// ohne expliziete Instanzierung:

var sportchef = {
	name : null,
	trainieren :function(){ trainer.trainieren(); }
		// (... Das "trainer"-Objekt kann hier bereits implementiert
		// werden, obwohl es zu diesem Zeitpunkt noch gar nicht existiert!)
}
var trainer = {
	name : 'Beckenbauer',
	spieler : [],
	spielerHinzufuegen : function(pSpieler){ this.spieler = pSpieler; },
	trainieren : function() {
		this.spieler.forEach(function(s){
			s.jogging();
			s.liegestuetzen(20);
		});
	}
}

// Das Array der Namen in ein Array aus Objekten mit den erforderlichen Methoden umwandeln:
var team = spielernamen.map(function(sname){ return{
	rufname : sname, 
	jogging : function() {
		document.write('Spieler '+this.rufname+' ist joggen. ');
	},
	liegestuetzen : function(n){
			document.write('Spieler '+this.rufname+' macht '+n+' Liegestützen.<br>');
	}
}});

// (zu diesem Zeitpunkt bestehen bereits alle Objekte!)
sportchef.name = 'Störtebecker';
trainer.spielerHinzufuegen(team);

// "delegieren":
sportchef.trainieren();


/**** Zusatz:
  Diskusion zum Klassendiagramm und zu Erweiterungen:

  Aus dem Diagramm geht hervor, dass es keine direkte Beziehung zwischen 
  den Objekten Sportchef und Spieler gibt.
  Hier kommt es stark auf die Implementierung an: Sind die Spieler 
  ein Member-Array der Trainer-Klasse oder globale Objekte. Ich habe mich 
  für letztes entschieden, da es einer reellen Lösung mehr entspricht.
  Auf diese Weise lassen sich die Spieler auch über das Sportschef-Objekt 
  referenzieren, -- z.B. wenn der Chef einen Spieler aus seinem Club entlassen
  oder ihm eine Zusatzprämie zahlen will.
  Mit JavaScript lassen sich hierfür zur Laufzeit(!) bequem die Objekte um die 
  notwendigen Methoden bzw. Member erweitern:
****/


// Deklaration:
sportchef.zahlePraemie = function(pSpieler, betrag){
	// nur das betroffene Spieler-Objekt muss um diese Elemente ergänzt werden:
	pSpieler.praemie = betrag;
	pSpieler.freutSichUeberPraemie = function(){
		document.write(this.rufname+' jubelt über '+ this.praemie +' Mäuse!<br>');
	}
}
// Implementierung:
function sportChefZahltPraemieUndSpielerFreutSich(pSpieler, pBetrag){
	pSpieler = team.filter(function(s) { return s.rufname === pSpieler})[0];
	sportchef.zahlePraemie(pSpieler,pBetrag);
	pSpieler.freutSichUeberPraemie();
}
document.write('........<br>');

// Ausführung:
sportChefZahltPraemieUndSpielerFreutSich('Grass',50000)
/***
  Achtung: Alle anderen Spieler-Objekte besitzen diese Member 'praemie' und
  'freutSichUeberPraemie()' nicht! Hier zeigt sich einer der gravierenden 
  Unterschiede im OOP zwischen JavaScript und Sprachen wie C++ oder Java. Bei diesen müsste die Klasse vererbt und erweitert
  werden.
***/

// Programmiert und erläutert: Tobias Petri, 3.2.2015
</script>
                

Lösung von: Tobias Petri (energie graz)

Module Module1
    Public Class Sportchef
        Private _Name As String
        Private _trainer As Trainer

        Sub New(chefName As String)
            _Name = chefName
        End Sub

        Public Property Name As String
            Get
                Return _Name
            End Get
            Set(value As String)
                _Name = value
            End Set
        End Property

        Public Property Trainer As Trainer
            Get
                Return _trainer
            End Get
            Set(value As Trainer)
                _trainer = value
            End Set
        End Property

        Public Sub trainieren()
            _trainer.trainieren()
        End Sub
    End Class

    Public Class Trainer
        Private _Name As String
        Private spieler As New List(Of Spieler)

        Sub New(tName As String)
            _Name = tName
        End Sub

        Public Property Name As String
            Get
                Return _Name
            End Get
            Set(value As String)
                _Name = value
            End Set
        End Property

        Public Sub trainieren()
            For Each el As Spieler In spieler
                el.jogging()
                el.liegestuetzen(20)
            Next
        End Sub

        Public Sub spielerHinzufuegen(spielerName As String)
            If Not spieler.Count >= 11 Then
                spieler.Add(New Spieler(spielerName))
            Else
                Console.WriteLine("In der Mannschaft sind bereits 11 Spieler!")
            End If
        End Sub
    End Class

    Public Class Spieler
        Private _Rufname As String

        Sub New(rufname As String)
            _Rufname = rufname
        End Sub

        Public Property Rufname As String
            Get
                Return _Rufname
            End Get
            Set(value As String)
                _Rufname = value
            End Set
        End Property

        Public Sub jogging()
            Console.WriteLine(Rufname & " joggt!")
        End Sub

        Public Sub liegestuetzen(nummer As Integer)
            Console.WriteLine(Rufname & " macht " & nummer & " Liegestützen!")
        End Sub
    End Class

    Sub Main()
        Dim chef As New Sportchef("Hans")
        Dim trainer As New Trainer("Sepp")
        chef.Trainer = trainer
        alleSpielerEintragen(trainer)
        Console.WriteLine("Chef: " & chef.Name)
        Console.WriteLine("Trainer: " & trainer.Name)
        Console.WriteLine()

        chef.trainieren()

        Console.ReadLine()
    End Sub

    Public Sub alleSpielerEintragen(trainer As Trainer)
        trainer.spielerHinzufuegen("Karl")
        trainer.spielerHinzufuegen("Simon")
        trainer.spielerHinzufuegen("Fabio")
        trainer.spielerHinzufuegen("Elias")
        trainer.spielerHinzufuegen("Edward")
        trainer.spielerHinzufuegen("Daniel")
        trainer.spielerHinzufuegen("Luca")
        trainer.spielerHinzufuegen("Manuel")
        trainer.spielerHinzufuegen("Fabio")
        trainer.spielerHinzufuegen("David")
        trainer.spielerHinzufuegen("Fabian")
    End Sub
End Module
                

Lösung von: Elias Zech (Optics Balzers)

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit:
Schwierigkeit: k.A.
Webcode: 3oxh-5vny
Autor: Philipp Gressly Freimann (SANTIS Training AG)

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen