Mir fehlt glaube ich das Verständnis......

[Daniel Thoma]

Hallo webba,

Bei der prozeduralen Programmierung hat man idR. eine Trennung von Daten und Algorithmen. Man definiert zuerst seine Datentypen und anschließen die Prozeduren, die diese manipulieren.
Die Idee der OOP ist es nun, die Algorithmen direkt an die Datenstrukturen zu packen und die Software dadurch praktisch anhand der Struktur der Daten zu strukturieren. Der Programmablauf ist dann nicht mehr zentralisiert sondern über die Objekte verteilt.

Beispiel: eine Bank.

Prozedural würde man sowas schreiben (Pseudocode):

  
type Bank is record  
  name: String;  
  accounts: List of Account;  
end Bank;  
  
type Account is record  
  number: Integer;  
  balance: Integer;  
end Account;  
  
procedure transfer (fromBank: Bank, fromNumber: Integer,  
   toBank: Bank, toNumber: Integer, amount: Integer)  
is  
  fromAccount: Account := findAccount(fromBank, fromNumber);  
  toAccount: Account := findAccount(toBank, toNumber);  
begin  
  fromAccount := fromAccount - ammount;  
  toAccount := toAccount - account;  
end transfer;  

Dem OOP-Ansatz nach würde man eher so etwas schreiben:

  
class Bank is  
  name: String;  
  accounts: List of Account;  
  
  method transferTo(toBank: bank, fromNumber: Integer, toNumber: Integer,  
    amount: Integer)  
  is  
    fromAccount: Account := findAccount(fromNumber);  
  begin  
    fromAccount.decrease(amount);  
    toBank.transferFrom(this, fromNumber, toNumber);  
  end transferto;  
  
  method transferTo(fromBank: bank, fromNumber: Integer, toNumber: Integer,  
    amount: Integer)  
  is  
    toAccount: Account := findAccount(toNumber);  
  begin  
    toAccount.increase(amount);  
  end transferto;  
end Bank;  
  
class Account is  
  number: Integer;  
  balance: Integer;  
end Account;  

Hier sieht man auch je eine zentrale Stärke und Schwäche der Idee:
OOP ermöglicht es, Verhalten zusammen mit den Daten zu beschreiben und man kann das Problem so schön in kleine, lokale Aufgaben zerlegen.
Das Problem ist dabei, dass man die globalen Zusammenhänge nicht mehr so leicht sieht (da sie nicht mehr direkt dastehen sondern sich erst aus dem Zusammenspiel mehrerer Objekte ergeben) und es auch schwierig sein kann, globale Bedingungen umzusetzen.
Wenn man aufpasst, sieht man in dem Beispiel, dass man natürlich tranferFrom direkt aufrufen könnte und damit Geld überweisen, das nirgendwo abgebucht wird. Man müsste also möglicherweise die Schnittstelle ausbauen, damit Bank-Objekte feststellen können, ob ein Aufruf zulässig ist.

Um diese Idee gut umsetzen zu können, entstanden etliche Sprachkonzepte (z.B. Vererbung, Schnittstellen, ...), durch die sich OOP-Sprachen dann auszeichnen. Die grundlegende Idee kann man freilich auch in prozeduralen Sprachen umsetzen (Stichwort Abstrakte Datentypen).

Grüße

Daniel