|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Änderungen gegenüber Java / C#
- Alle Methoden erhalten 'self' als ersten Parameter
- Der Konstruktor heißt _ _init(self)_ _
- Der Konstruktor heißt _ _init(self)_ _
- Es gibt keinen De-Konstruktor, aber etwas Ähnliches.
-
Attribute sollten im Konstruktor angelegt werden.
- Es gibt kein "private".
- Konvention:
Zugriff auf _meinePrivateVariable ist per Konvention "verboten".
Stichwort Unterstrich: _
- Setter und Getter sind möglich
def __init__(self):
self._x = 100
def getX(self)
return _x
def setX(self, wert)
self._x=wert
# toString()
def __str__(self):
return str(self._x)
# compare-Methode, lessThan, definiert die Reihenfolge zw. Objekten
def __lt__(self, other):
return self.getX() < other.getX() # aufsteigend sortiert
- Vererbung auch mehrfach: class KlasseB(KlasseA, IDrucken)
- Überschreiben und Überladen erlaubt.
- statische Methoden sind erlaubt, ist aber umständlich
- Operatoren können überladen werden!
- Unäre Operatoren überladen
+
-
abs
~
- Binäre Operatoren überladen
+=
-=
*=
/=
//=
**=
%=
>>= (shift right)
<<=(shift left)
&= (Modulo)
|=
= (XOR)
|
|
|
|
|
|
# coding=utf8
import math
class Punkt:
def __init__(self, x, y):
# Klassen-Attribute definieren
self._x=x
self._y=y
def getX(self):
return self._x
def getY(self):
return self._y
def setX(self,x):
self._x=x
def setY(self,y):
self._y=y
def __str__(self): # toString
return str(self.x)+", "+str(self.y)
class Linie:
def __init__(self, x1, y1, x2, y2):
# Klassen-Attribute definieren
self.p1=Punkt(x1,y1)
self.p2=Punkt(x2,y2)
def getLaenge(self):
dx = self.p2.getX()-self.p1.getX()
dy = self.p2.getY()-self.p1.getY()
return math.sqrt(dx*dx+dy*dy)
def __str__(self): # toString
return str(self.x1)+"/"+str(self.y1)+" , "+str(self.x2)+", "+str(self.y2)
# main
p1 = Punkt(12,13)
p1.setX(42)
p1.setY(24)
print(p1.getX())
print(p1.getY())
print(p1) # toString
l1 = Linie(1,2,3,4)
print(l1.getLaenge())
|
|
|
|
|
|
|
|
|
|
|
|
# coding=utf8
class A:
def __init__(self):
self._x = 1337
print("Konstruktor von A")
def m(self):
print("Methode m von A. Es ist self._x =", self._x)
def getX(self):
return self._x
def setX(self,x):
self._x=x
class B(A):
def __init__(self):
A.__init__(self) # nun hat B auch das Attribut X!
self._y = 10000
print("Konstruktor von B")
def n(self):
print("Methode n von B. Es ist self.Y =", self._y)
def getY(self):
return self._y
def setY(self,y):
self._y=y
b = B()
b.n()
b.m()
|
|
|
|
|
|
|
|
|
|
|
|
#! /usr/bin/env python3
# coding=utf8
# mit interface
class IDrucken(object):
def __init__(self):
pass
def drucken(self):
raise Exception("NotImplemented")
class Flugzeug(IDrucken):
def __init__(self, name, laenge):
self.name = name
self.laenge = laenge
print("Konstruktor von Flugzeug")
def drucken(self):
print("Flugzeug ",self.name,"Länge: ", self.laenge)
class Frachtflugzeug(Flugzeug):
def __init__(self, name, laenge, fracht):
Flugzeug.__init__(self,name, laenge)
self.fracht = fracht
print("Konstruktor von Frachtflugzeug")
def drucken(self):
print("Frachtflugzeug",self.name,"Länge: ", self.laenge,"Fracht: ",self.fracht)
class Vogel(IDrucken):
def __init__(self, name, gewicht):
self.name = name
self.gewicht= gewicht
print("Konstruktor von Vogel")
def drucken(self):
print("Vogel",self.name,"Gewicht: ", self.gewicht)
class Singvogel(Vogel):
def __init__(self, name, gewicht, melodie):
Vogel.__init__(self, name, gewicht)
self.melodie = melodie
print("Konstruktor von Singvogel")
def drucken(self):
print("Singvogel",self.name,"Gewicht: ", self.gewicht,"Melodie:",self.melodie)
f1 = Flugzeug('Airbus 300 M',100.2)
f2 = Frachtflugzeug('Airbus 300 X',100.2,34505)
v1 = Vogel('Eule',134)
v2 = Singvogel('Drossel',89, 'gut')
liste = []
liste.append(f1)
liste.append(f2)
liste.append(v1)
liste.append(v2)
for item in liste:
item.drucken()
|
|
|
Python Functions
tkinter
|
|
|
|
|