Programmieren lernen

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 G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

/**
 * 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 G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

// 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)

// NET 6.x | C# 10.x | VS-2022

namespace Delegieren {
    internal class Program {
        public static void Main() {
            var sc = new Sportchef("Sportchef");
            var tr = new Trainer("Trainer");
            for (int i = 0; i < 11; i++)
                tr.SpielerHinzufuegen(new Spieler($"Spieler{i + 1}"));
            sc.Trainieren();
        }
    }

    internal abstract class Person {
        protected string? Name { get; set; }
    }

    internal sealed class Spieler : Person {
        public Spieler(string name) => Name = name;
        public void Jogging(int km) => Console.WriteLine($"{Name} joggt {km} km!");
        public void Liegestuetze(int anzahl) => Console.WriteLine($"{Name} macht {anzahl} Liegestütze!");
    }

    internal abstract class Fuehrungsperson : Person {
        static protected List<Spieler> lstSpieler = new List<Spieler>();
        public virtual void Trainieren() {
            foreach (var s in lstSpieler) {
                s.Jogging(10);
                s.Liegestuetze(20);
            }
        }
    }

    internal sealed class Trainer : Fuehrungsperson {
        public Trainer(string name) => Name = name;
        public void SpielerHinzufuegen(Spieler spieler) => lstSpieler.Add(spieler);
    }

    internal sealed class Sportchef : Fuehrungsperson {
        public Sportchef(string name) => Name = name;
    }
}
                

Lösung von: Jens Kelm (@JKooP)

// C++ 17
#include <iostream>
#include <vector>
#include <string>

class Person {
    std::string name_;
public:
    void set_name(std::string);
    std::string get_name();
};

void Person::set_name(std::string name) {
    name_ = name; 
}

std::string Person::get_name() {
    return name_; 
}

/*-------------------------------------------------------------------------*/

struct Spieler : public Person {
    Spieler(std::string name) { 
        set_name(name);
    }

    void Jogging(int);

    void Liegestuetze(int);
};
void Spieler::Jogging(int km) {
    std::cout << get_name() << " joggt " << km << " km!\n";
}

void Spieler::Liegestuetze(int anzahl) {
    std::cout << get_name() << " macht " << anzahl << " Liegestuetze!\n";
}

std::vector<Spieler> v_spieler{};

/*---------------------------------------------------------------------------*/

struct Fuehrungsperson : public Person {
    void Trainieren();
};

void Fuehrungsperson::Trainieren() {
    for (auto& s : v_spieler) {
        s.Jogging(10);
        s.Liegestuetze(20);
    }
}

/*---------------------------------------------------------------------------*/

struct Trainer : public Fuehrungsperson {
    Trainer(std::string name) {
        set_name(name); 
    }
    void SpielerHinzufuegen(Spieler);
};

void Trainer::SpielerHinzufuegen(Spieler spieler) {
    v_spieler.push_back(spieler); 
}

/*---------------------------------------------------------------------------*/

struct Sportchef : public Fuehrungsperson {
    Sportchef(std::string name) {
        set_name(name); 
    }
};

/*---------------------------------------------------------------------------*/

int main() {
    auto sc{ Sportchef("Sportchef") };
    auto tr{ Trainer("Trainer") };

    for (auto i{ 0 }; i < 11; ++i)
        tr.SpielerHinzufuegen(Spieler("Spieler" + std::to_string(i + 1)));

    sc.Trainieren();
}
                

Lösung von: Jens Kelm (@JKooP)

/***************************\
|* ES6-ISCH                *|
\***************************/

class Person {
  constructor (name) { this.name = name; }
}

class President extends Person {
  delegate() {
    console.log('La prezidanto delegas:')
    for (let t of team) trainer.train(t);
  }
}

class Trainer extends Person {
  train(player) {
    console.log(`La trejnisto trejnigas ${player.name}:n:`);
    player.jog();
    player.pressUp();
  }
  addPlayer(name) {
    if (team.length >= 11) console.warn('Teamo kompleta!');
    else team.push(new Player(name));
  }
}

class Player extends Person {
  jog() { console.log(`${this.name} ?ogas.`); }
  pressUp(times = 20) {
    console.log(`${this.name} ku?apogas ${times} fojojn.`)
  }
}

/* MAIN */
let team = [],
    trainer = new Trainer('Vanesa'),
    president = new President('Zara'),
    playerNames =
      'Ana Babsi Caca ?ika Dani Efa Faba Gabi ?ina Hane ?ale Ida'.split(' ');

// eine übersicht der geschaffenen objekte
console.log('Prezidanto:', president);
console.log('Trejnisto: ', trainer);

// team füllen
for (let i = 1; i < 12; i++)
  trainer.addPlayer(playerNames.shift());
console.log('Teamo:', team);
console.log('Haveblaj futbalistoj: ', playerNames);

// was macht dieser knopf hier?
president.delegate();

                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)