# Ausgabe + Schleifeninvariante



## cgame (7. Jan 2013)

Hallo Leute habe einpaar Fragen und hoffe ihr könnt mir helfen.

Erstmal die Codes


```
public class A {
public int x;
public static int y = 0;
public A() {
this.x = 5;
y ++;
}
public A( int i) {
this ();
y ++;
}
public int f( double d) {
return 1;
}
public int f( int i) {
return 2;
}
}
```


```
public class B extends A {
public int z = 8;
public B( int x) {
z = 3;
}
public int f( double d) {
return 3;
}
public int f( float f) {
return 4;
}
}
```


```
public class M {
public static void main ( String [] args ) {
A a = new A (6);
System.out.println(a.x); // OUT : [5]
int retA = a.f (1.2 f);
System.out.println( retA ); // OUT : [1]
B b = new B (7);
System.out.println(b.y + " " + b.z); // OUT : [3] [3]
int retB = b.f (12);
System.out.println( retB ); // OUT : [2]
A ab = b;
int retAB = ab.f (1.2 f);
System.out.println( retAB ); // OUT : [3]
}
}
```

Meine Fragen sind folgenede:
1)Also zunächst zu den OUTs die ersten beiden OUTs(Ausgaben) kann ich nachvollziehen aber die restlichen nicht also diese hier


```
B b = new B (7);
System.out.println(b.y + " " + b.z); // OUT : [3] [3]
int retB = b.f (12);
System.out.println( retB ); // OUT : [2]
A ab = b;
int retAB = ab.f (1.2 f);
System.out.println( retAB ); // OUT : [3]
```

2) Was heißt eigentlich B b = new B(7); . Ich weiß was B b = new B(); macht aber nicht was B(7); macht

3)Was passiert eigentlich hier A ab = b;. Dies sehe ich zum ersten mal. Wird den jetzt ein A erstellt namens ab oder was ist das.

4)Was ist eigentlich eine Schleifeninvariante bzw. wie kommt man an diese ran.

Ich bedanke mich schonmal im Vorraus.

MfG
cgame


----------



## nillehammer (7. Jan 2013)

> 2) Was heißt eigentlich B b = new B(7); . Ich weiß was B b = new B(); macht aber nicht was B(7); macht


Du rufst den Konstruktor von B auf, der einen int als Parameter erwartet (in dem hier geposteten Beispielcode die Zeile 6). Der übergebene int wird vom Konstruktor aber garnicht beachtet, sondern einfach stumpf z=3 gesetzt. Das dürfte auch Deine erste Frage beantworten.


> 3)Was passiert eigentlich hier A ab = b;. Dies sehe ich zum ersten mal. Wird den jetzt ein A erstellt namens ab oder was ist das.


B extendet A. D.h. überall, wo Du eine Referenz auf eine Instanz von B hast (hier in der Variablen namens b), kannst Du diese einer anderen Variable vom Typ A zuweisen. Genau das geschieht hier.


> 4)Was ist eigentlich eine Schleifeninvariante bzw. wie kommt man an diese ran.


Ich sehe in dem geposteten Code überhaupt keine Schleifen. Aber allgemein ist eine Invariante eine Bedingung, die erfüllt sein muss. Eine Schleifeninvariante wäre also die Bedingung, unter der eine Schleife (weiter-)läuft.


----------



## Timothy Truckle (7. Jan 2013)

cgame hat gesagt.:


> 1)Also zunächst zu den OUTs die ersten beiden OUTs(Ausgaben) kann ich nachvollziehen aber die restlichen nicht also diese hier
> 
> 
> ```
> ...


Das ergibt sich hoffentlich wenn Du 2 verstanden hast.



cgame hat gesagt.:


> 2) Was heißt eigentlich B b = new B(7); . Ich weiß was B b = new B(); macht aber nicht was B(7); macht


Das ruft den parametrisierten Konstruktor von 
	
	
	
	





```
B
```
 auf. Macht also prinzipiell das gleiche wie 
	
	
	
	





```
B()
```
.



cgame hat gesagt.:


> 3)Was passiert eigentlich hier A ab = b;. Dies sehe ich zum ersten mal. Wird den jetzt ein A erstellt namens ab oder was ist das.


der Referenz vom Typ 
	
	
	
	





```
A
```
 namens 
	
	
	
	





```
ab
```
 wird das Objekt aus der Referenz 
	
	
	
	





```
b
```
 vom Typ 
	
	
	
	





```
B
```
 zugewiesen. Das geht, weil 
	
	
	
	





```
B
```


```
A
```
 erweitert (
	
	
	
	





```
B extends A
```
)



cgame hat gesagt.:


> 4)Was ist eigentlich eine Schleifeninvariante


Eine Variable, in der (üblicher Weise) die laufende Nummer des aktuellen Schleifendurchlaufs steht Schau Dir nochmal an, wass Du über 
	
	
	
	





```
for
```
 gelernt hast.

bye
TT


----------



## SlaterB (7. Jan 2013)

> A a = new A (6);
verstehst du, aber
> B b = new B (7);
dann nicht mehr?

dass im Konstruktor von A bzw. B ein int-Parameter definiert ist hilft oder nicht?


1)
kannst du noch bisschen mehr schreiben außer 'nicht nachvollziehen'?
welche Variable(n) wird ausgegeben, welchen Startwert hat diese, wo wird sie womöglich geändert,
kannst du das ungefähr verfolgen, hast du vielleicht eine andere Vorstellung des aktuellen Wertes?

3) das siehst du richtig,
wie eine Variable deklariert wird und/ oder später/ gleichzeitig Werte zugewiesen werden, das beruht auf einer handfesten Syntax, 
Klassenname (unbedingt immer groß) + Variablenname (klein) direkt hintereinander steht für Variablendeklaration usw.,
das solltest du festigen, deine Probleme damit überdenken und formulieren, sofern noch offen

Syntax und Code musst beherrscht werden, kein 'oder was ist das' 

4) kann man nachschlagen in Suchmaschinen, wobei du hier wenig Schleifen hast,
die Bedeutung von 
Schleifeninvariante ? Wikipedia
ist hier vielleicht allgemein auf jeden Zeitpunkt des Programms gemünzt, was gilt immer, welche Variable hat vielleicht immer denselben Wert?

auf die Schnelle würde ich nicht entsprechendes vermuten (edit: in diesem Programm, vielleicht auch nur allgemein gefragt), 
gibt es mehr Informationen als nur pauschal 'Schleifeninvariante, los jetzt' hingeschmettert?


----------



## cgame (7. Jan 2013)

SlaterB hat gesagt.:


> > A a = new A (6);
> verstehst du, aber
> > B b = new B (7);
> dann nicht mehr?



Ich dachte ich verstands ^^. Aber ich hoffe jetzt schon. Also mit z.B.(6) wird der Konstruktur aufgerufen der als Argument einen Parameter hat. Und was ist eigentlich mit (); wird den ein Konstruktor aufgerufen, der keine Argumente besitzt  ? Was passiert den wenn ein Konstruktur aufgerufen werden soll der eigentlich garnicht existiert oder angenommen ich haette eine klasse wo es einen Konstruktor gibt, der als Argument einen String besitzt ich aber veruche die Klasse mit ... new A(5); aufzurufen. Ich hoffe du verstehst meine Frage ^^  Ich dachte eigentlich mit z.B. B b = new B(); 
wird einfach eine neune B Klasses erstellt mit allem was die KLasse B besitzt sprich methoden usw. .  





> 1)
> kannst du noch bisschen mehr schreiben außer 'nicht nachvollziehen'?
> welche Variable(n) wird ausgegeben, welchen Startwert hat diese, wo wird sie womöglich geändert,
> kannst du das ungefähr verfolgen, hast du vielleicht eine andere Vorstellung des aktuellen Wertes?




Also ich versuchs mal ^^. Ich versuch mal die erste Ausgabe zu erklaeren.


```
A a = new A (6);
System.out.println(a.x);
```

Also es wird eine neue Klasse namens a erstellt das einen Parameterwert (6) in diesem Falle einen Integer übergibt.

Schauen wir uns mal die Klasse A an:

```
public class A {
public int x;
public static int y = 0;
public A() {
this.x = 5;
y ++;
}
public A( int i) {
this ();
y ++;
}
public int f( double d) {
return 1;
}
public int f( int i) {
return 2;
}
}
```

Zunächst wird folgender Konstruktor aufgerufen da dieser einen Integer als Argument hat

```
public A( int i) {
this ();
y ++;
}
```
Dieser setzt y von 0 auf 1 und beinhaltet diese Methode this ();
Durch diese Methode wird der Konstruktor ohne Argument aufgerufen also dieser hier:


```
public A() {
this.x = 5;
y ++;
```

Dieser wiederum setzt x auf 5 und erhoeht wieder y um 1 mehr
Also x = 5 und y = 2.

Und durch 
	
	
	
	





```
System.out.println(a.x);
```
 wird 5 ausgegeben.

Hoffe ich habs richtig erklaert ^^ und hoffe nicht das ich durch zufall auf das richtige ergebniss gekommen bin ^^






```
Syntax und Code musst beherrscht werden, kein 'oder was ist das' ;)
```
Anfängerfehler hahah xd Danke ^^



> 4) kann man nachschlagen in Suchmaschinen, wobei du hier wenig Schleifen hast,
> die Bedeutung von
> Schleifeninvariante ? Wikipedia
> ist hier vielleicht allgemein auf jeden Zeitpunkt des Programms gemünzt, was gilt immer, welche Variable hat vielleicht immer denselben Wert?
> ...



Also die Schleifeninvariante bezieht sich den\das Hoare-Kalkül. Bei der Verifikation(Hoare-Kalkül) wird ja die Schleifeninvariante benötigt. Darauf bezog sich meine Frage zur Schleifeninvariante. 






An Alle die geantwortet haben vielen Dank!! Einiges leuchtet mir ein ^^:idea:

Bin wieder In 2hours zurück ^^

MfG

cgame


----------



## Timothy Truckle (7. Jan 2013)

cgame hat gesagt.:


> Und was ist eigentlich mit (); wird den ein Konstruktor aufgerufen, der keine Argumente besitzt  ?


Ja.



cgame hat gesagt.:


> Was passiert den wenn ein Konstruktur aufgerufen werden soll der eigentlich garnicht existiert oder angenommen ich haette eine klasse wo es einen Konstruktor gibt, der als Argument einen String besitzt ich aber veruche die Klasse mit ... new A(5); aufzurufen.


Dann meckert der Compiler.


cgame hat gesagt.:


> Ich hoffe du verstehst meine Frage ^^  Ich dachte eigentlich mit z.B. B b = new B();
> wird einfach eine neune B Klasses erstellt mit allem was die KLasse B besitzt sprich methoden usw. .


 Nein, es würde ein neues Objekt der Klasse 
	
	
	
	





```
B
```
 erstellt, aber es gibt keinen parameterlosen Konstruktor in 
	
	
	
	





```
B
```
.




cgame hat gesagt.:


> Also ich versuchs mal ^^. Ich versuch mal die erste Ausgabe zu erklaeren.[Erklärung]


Ist korrekt so.

bye
TT


----------



## SlaterB (7. Jan 2013)

> Und was ist eigentlich mit (); wird den ein Konstruktor aufgerufen, der keine Argumente besitzt ? Was passiert den wenn ein Konstruktur aufgerufen werden soll der eigentlich garnicht existiert oder angenommen ich haette eine klasse wo es einen Konstruktor gibt, der als Argument einen String besitzt ich aber veruche die Klasse mit ... new A(5); aufzurufen. Ich hoffe du verstehst meine Frage ^^


das kannst und solltest du alles ausprobieren,

jedes Standard-Kapitel zu Konstruktoren wird auch was zu fehlenden Konstruktor sagen, 
einfach die Seite lesen die jeder lesen soll, statt in Foren eine teure eigene Schrift-Version zu verlangen 
Galileo Computing :: Java ist auch eine Insel - 5 Eigene Klassen schreiben

wichtig ist hier vielleicht noch zu bedenken, dass bei Erstellung von B auch mindestens ein Konstruktor von A durchlaufen wird, denn B erbt von A,
das wird sicherlich eher erst in Vererbungs-Kapiteln in Lehrbüchern thematisiert, 
dann aber wieder ein wichtiges Grundlagenthema, auf welches nicht verzichtet werden kann




> Zunächst wird folgender Konstruktor aufgerufen da dieser einen Integer als Argument hat
> 
> Dieser setzt y von 0 auf 1 und beinhaltet diese Methode this ();
> 
> ...


genau aufpassen, erst kommt mit this() der parameterlose Konstruktor dran, der erhöht y auf 1, dann der erste Konstruktor wieder, erhöht auf 2,
letztlich hier natürlich egal (edit: bei bestimmten Rechnungen kann die Reihenfolge aber sehr wichtig sein, 'mal 2 plus 3' oder so)

soweit ganz gut erklärt, ob du bei den B-Ausgaben usw. durchsiehst ist damit freilich nicht geklärt, das war ja eher deine Frage


----------



## cgame (7. Jan 2013)

Super Vielendank !! bisdahin ist mir fast alles klar geworden. Nur habe ich noch zwei  Fragen und zwar  bei  der Ausgabe in diesem Codeteil : 


```
A ab = b;
int retAB = ab.f (1.2 f);
System.out.println( retAB ); // OUT : [3]
```

Muesste nicht als OUT 4 kommen ? 

Hier 
	
	
	
	





```
ab.f (1.2 f)
```
 wird doch folgende Methode aufgerufen 
	
	
	
	





```
public int f( float f) {
return 4;
}
```
 oder irre ich mich ?



> wichtig ist hier vielleicht noch zu bedenken, dass bei Erstellung von B auch mindestens ein Konstruktor von A durchlaufen wird, denn B erbt von A,
> das wird sicherlich eher erst in Vererbungs-Kapiteln in Lehrbüchern thematisiert,
> dann aber wieder ein wichtiges Grundlagenthema, auf welches nicht verzichtet werden kann



Es werden doch aber keine Konstruktoren Vererbt bzw. dies ist doch eigentlich nicht möglich soweit ich weis.

Dankte Leute ihr seit TOLL !!! ^^


----------



## SlaterB (7. Jan 2013)

> oder irre ich mich ?

ganz pauschal kann man dahin raten,
aber wenn es nun schon einen Hinweis gibt dann ruhig extra lange nachdenken, warum das so sein könnte

die Variable ist vom Typ A, es werden nur dessen Methoden gesehen, dann passt am ehesten die Methode mit Parameter double,
nachdem diese ausgewählt wird kommt die Vererbung dennoch zum Tragen, es ist die double-Methode von B

Methoden-Signaturen werden statisch, zur Compilier-Zeit gebunden (ausgewählt), 
zur Laufzeit aber anhand des tatsächlichen Objektes dynamisch aus der Vererbung gebunden
http://www.java-forum.org/java-basics-anfaenger-themen/24797-statische-dynamische-bindung.html
usw.

> Es werden doch aber keine Konstruktoren Vererbt bzw. dies ist doch eigentlich nicht möglich soweit ich weis.

sage ich ja auch nicht, nur dass Konstruktoren von A durchlaufen werden, nicht ignorieren/ vergessen


----------



## cgame (7. Jan 2013)

Dankesehr !


----------

