# Vererbung- Erweiterung von Klassen



## Maurice16 (1. April 2011)

Hallo Leute,
also ich habe hier ein Problem.
Ich weiß absolut nicht was ich bei dieser Aufgabenstellung machen soll.
Vllt. könntet ihr mir da mal ein bisschen helfen (ich kann nicht so gut mit Java umgehen).
Wäre gut wenn ihr mir ein Beispiel geben könntet wie ich damit anfangen könnte, so dass ich es dann alleine weiter versuchen kann mit eurer hilfe.

*Aufgabenstellung:*

1.) In diesem Versuch soll die Klasse Random aus dem Paket java.util beerbt werden.

Die Klasse Random besitzt eine Methode, um eine zufälliges Zeichen in den Grenzen von
' ' (32) bis '~' (126) zu generieren.

Schreibe eine Klasse (MyRandom), die die Klasse Random beerbt.

Ihre Klasse soll 4 Konstuktoren und zwei Methoden sowie Attribute für die obere und untere Grenze enthalten.

*Konstruktor 1:* Dieser Konstuktor ist parameterlos und initialisiert die Attribute der Klasse
                        in den oben genannten Grenzen.

*Konstruktor 2:* Dieser Konstuktor besitzt 2 Parameter dür die obere und unter Grenze. Die
                     beiden Parameter initialisieren die Attribute der Klasse mit beliebigen Werten.

Die Klasse Random besitzt einen Konstruktor, dem ein long-Wert übergeben wird, um den Zufallsgenerator mit einem festgelegten Startwert zu initialisieren.

*Konstruktor 3:* Dieser Konstruktor besitzt einen Parameter, um den Zufallsgenerator mit
                        einem Startwert zu initialisieren, außerdem initialisiert er die Attribute der
                        Klasse in den oben genannten Grenzen.

*Konstruktor 4:* Dieser Konstruktor besitzt einen Parameter, der den Startwert des
                        Zufallsgenerators initialisiert sowie 2 Parameter für die Initialisierung der
                        Attribute der Klasse mit beliebigen Werten.

Die beiden *Methoden,* die Ihre lasse besitzt, sollen wie folgt porgrammiert werden.

*Methode 1:* Diese Methode ist parameterlos und soll ein zufällig generiertes Zeichen in
                  den Grenzen von ' '(32) bis '~' (126) generieren.

*Methode 2:* Diese Methode besitzt 2 Parameter für die obere und untere Grenze,
                   innerhalb derer ein zufälliges Zeichen generiert werden soll.

2.) Schreibe eine Applikation, die 2 Zeichenketten auf dem Bildschirm ausgibt.

Die *1. Zeichenkette* soll eine zufällige Länge von 15 bis 20 Zeichen haben und aus zufälligen Zeichen zwischen ' ' (32) bis '~' (126) bestehen.

Die* 2. Zeichenkette* soll eine zufällige Länge von 8 bis 12 Zeichen haben und aus zufälligen Zeichen von 'A' (65) bis 'Z' (90) besten.

P.S: Eine komplette Lösung möchte ich gar nicht von euch haben, nur paar Tipps und Unterstützung.

Danke euch im Vorraus.


----------



## wakoz (1. April 2011)

Hi

Was möchtest du nun wissen, du hast im Thread titel und auch im Beitrag alles was du brauchst 

beerbt klingt zwar komisch, ist aber so 

also deine Entwicklungsumgebung An werfen und klasse erzeugen lassen, ich bevorzuge Eclipse 


```
class deinklassenname extends Random{...}
```
damit hast du du die klasse und den rumpf, gegebenenfalls noch paar imports nötig compiler wird dann aber schon meckern und bei Eclipse wird er helfen die imports zu machen 

der Konstruktor ist nichts anderes als das womit mein Objekt von einer Klasse erzeugt und hat den selben Namen wie die klasse, also

```
class deinklassenname extends Random{
public deinklassenname();//<--Konstruktor
}
```
 für den leeren Konstruktor
oder 

```
class deinklassenname extends Random{
private typ klassenvar1; //<-- so sind die variablen in der ganzen klasse zu sehen
private typ klassenvar2;
public deinklassenname(typ variable1, typ variable2) {  //<--Konstruktor mit Variablen / Parameter
klassenvar1 = vaeriable1
klassenvar2 = vaeriable2
}
}
```
 für einen mit Variablen, wobei du typ durch String int etc ersetzen musst. Je nachdem was du benötigst. Für die Variablen nimmt man auch Namen die selbst erklärend sind!

Ist zwar alles nur grob um rissen aber für den Anfang sollte es reichen 

Ich persönlich kann dir die javainsel ans Herz legen. Zum schreiben von deinem Programm wirst du dort viel finden.

Falls du was nicht verstehst frag einfach


----------



## Maurice16 (1. April 2011)

Also ich fang ja erstmal an mit 

```
import java.util.*;

public static void main (String args[]) {
```
Und dann werden doch erstmal die 2 Startwerte für die Konstruktor deklariert, oder?
Danach kann ich doch mit this.1Wert=1Wert die werte dort reinholen oder? 
Müssen die konstruktoren immer public sein?


----------



## staromir (1. April 2011)

Hallo,
Eigentlich solltest du noch den klassenNamen zwischen dem import und main() haben wie es wakoz geschrieben hat.
Konstruktoren sind ja Funktionen, folglich werden sie nicht in der main() deklariert sondern ausserhalb.
Und Konstruktoren müssen nicht zwingend Public sein , sie können auch private protected oder so sein, wie eine Methode halt auch.


----------



## Maurice16 (3. April 2011)

Irgentwie bekomme ich das einfach nicht hin...
Ich weiß gar nicht was ich da machen muss...
Und für morgen brauche ich das =/
Könnte mir einer vllt. das Programm mal schreiben?
Nur wenn es nicht so viel Zeit benötigt...
Ist zwar ne sehr unpassende Art es zu lernen, 
jedoch schaffe ich das bis morgen nicht mehr und das gibt dann ziemlich stress..

Bitte...

MfG Maurice


----------



## Maurice16 (3. April 2011)

Wie müssten die 4 Konstruktoren aussehn?


----------



## Muepe32 (3. April 2011)

Die 4 Konstruktoren müssen so gewählt werden, dass sie dem entsprechen, was in der Aufgabenstellung gefordert wird. Wakoz hat dir ja bereits beschrieben, wie man einen Konstruktor in einer Klasse erzeugt. In Pseudocode müssen deine Konstruktoren ja das folgende tun:

```
konstruktor1()
{
   ObereGrenze = 126; // in der Aufgabenstellung steht nicht direkt ob exklusiv oder inklusiv
   UntereGrenze = 32;
}

konstruktor2(obereGrenze, untereGrenze)
{
   ObereGrenze = obereGrenze;
   UntereGrenze = untereGrenze;
}

konstruktor3(seed) : Random(seed)
{
   ObereGrenze = 126;
   UntereGrenze = 32;
}

konstruktor4(seed, obereGrenze, untereGrenze) : Random(seed)
{
   ObereGrenze = obereGrenze;
   UntereGrenze = untereGrenze;
}
```


----------



## Maurice16 (3. April 2011)

Wofür ist denn dieses "seed"?
Weil das hatten wir noch gar nicht...
Kann man das evtl. noch anderes schreiben die letzten 2 Konstruktoren?


----------



## Muepe32 (3. April 2011)

Du musst es sowieso noch anders schreiben - wie ich sagte, das ist Pseudocode, der dir die Textform der Aufgabe etwas näher an Code orientiert darstellt. Du musst nun diesen Pseudocode noch in richtigen Javacode umwandeln.

"seed" ist der Name des Parameters. In der Programmierung werden Startwerte häufig als "seed" bezeichnet daher habe ich dies als Namen für den Parameter genommen.


----------



## Maurice16 (3. April 2011)

Jetzt verstehe ich gar nichts mehr..^^
Wofür ist der Parameter im 3. und 4. Konstuktor?


----------



## Muepe32 (3. April 2011)

Maurice16 hat gesagt.:


> *Konstruktor 3:* Dieser Konstruktor besitzt einen Parameter, um den Zufallsgenerator mit
> einem Startwert zu initialisieren, außerdem initialisiert er die Attribute der
> Klasse in den oben genannten Grenzen.
> 
> ...


 
Konstruktor 3 fasst einen Parameter, der als Startwert für die Klasse Random dienen soll:
=>

```
konstruktor3(startwert) : Random(startwert)
{
}
```

Den Konstruktor einer Basisklasse kannst du via super aufrufen.

Konstruktor 4 fasst insgesamt 3 Parameter. Einer dient als Startwert, die anderen zwei zur Initialisierung der Grenzen.

Versuch doch jetzt mal damit zu beginnen, dass du eine Klasse anlegst, die von Random erbt. Das hat dir ja Wokaz auch schon beschrieben. Danach schauen wir dann weiter.


----------



## Maurice16 (3. April 2011)

Also ich bin jetzt so weit...


```
import java.util.*

public class MyRandom extends Random {

//Deklaration
privat long UntereGrenze;
privat long ObereGrenze;

// 1. Konstruktor
public MyRandom ()
{
ObereGrenze=126;
UntereGrenze=32;
}

// 2. Konstuktor
public MyRandom (ObereGrenze, UntereGranze)
{
this.ObereGrenze = ObereGrenze
this.UntereGrenze = UntereGrenze
}

// 3.Konstuktor HIER weiß ich nicht wie ichs schreibnen muss
public MyRandom(5) : Random (5)
{
ObereGrenze = 126;
UntereGrenze = 32;
}

// 4. Konstuktor Hier auch nicht
public MyRandom (5, UntereGranze, ObereGrenze) : Random(5)
{
this.ObereGrenze = ObereGrenze
this.UntereGrenze = UntereGrenze
}
}
```


----------



## Muepe32 (3. April 2011)

Zum einen brauchen die Parameter deines Konstruktors noch Type:

```
public MyRandom (long obereGrenze, long untereGrenze)
...
```

Und für den dritten und vierten Konstruktor hast du wieder ganz normal einfach die erwähnten Argumente. Als Beispiel Konstruktor 4:

```
public MyRandom (long startWert, long untereGrenze, long obereGrenze)
{
   super(startWert);
   this.ObereGrenze = obereGrenze;
   this.UntereGrenze = untereGrenze;
}
```


----------



## Maurice16 (3. April 2011)

Also so?

```
import java.util.*
 
public class MyRandom extends Random {
 
//Deklaration
privat long UntereGrenze;
privat long ObereGrenze;
privat long StartWert;
 
// 1. Konstruktor
public MyRandom ()
{
ObereGrenze=126;
UntereGrenze=32;
}
 
// 2. Konstuktor
public MyRandom (long ObereGrenze, long UntereGranze)
{
this.ObereGrenze = ObereGrenze;
this.UntereGrenze = UntereGrenze;
}
 
// 3.Konstuktor 
public MyRandom (long StartWert)
{
super(StartWert);
ObereGrenze = 126;
UntereGrenze = 32;
}
 
// 4. Konstuktor 
public MyRandom (long StartWert, long UntereGranze, long ObereGrenze)
{
super(StartWert);
this.ObereGrenze = ObereGrenze;
this.UntereGrenze = UntereGrenze;
}
}
```

Frage:
Wofür dient das "super"?
Wie mache ich nun weiter?


----------



## Muepe32 (3. April 2011)

Muepe32 hat gesagt.:


> Den Konstruktor einer Basisklasse kannst du via super aufrufen.


 

Du musst übrigens nicht einen Member StartWert anlegen, denn den Parameter StartWert brauchst du ja nur um den Konstruktor von Random aufzurufen, der einen Startwert erwartet.

Nun musst du die zwei erwähnten Methoden implementieren. Das ist ziemlich einfach, du kannst dazu die von Random geerbten Funktionen verwenden (Random.nextInt).


----------



## Maurice16 (3. April 2011)

Also mit dem StartWert meinst du in der Deklaration? oder wo?

Mit den Methoden komme ich nicht weiter...
Ich weiß nicht wie ich das mache...

EDIT: man muss doch den 1. Konstruktor mit der 1 Methode aufrufen oder? (wenn ja weiß ich trozdem nicht wie es geht) "leider"


----------



## Muepe32 (3. April 2011)

Genau, du brauchst kein Attribut StartWert in deiner Klasse.

Was ist denn das Problem mit dem Deklarieren der Methoden?

```
package de.tutorials;

import java.util.Random;

public class MyRandom extends Random {
	private int ObereGrenze, UntereGrenze;
	
	public MyRandom(int obereGrenze, int untereGrenze) {
		ObereGrenze = obereGrenze;
		UntereGrenze = untereGrenze;
	}
	
	public MyRandom() {
		this(126, 32);
	}
	
	public MyRandom(int seed) {
		this(seed, 126, 32);
	}
	
	public MyRandom(int seed, int obereGrenze, int untereGrenze) {
		super(seed);
		ObereGrenze = obereGrenze;
		UntereGrenze = untereGrenze;
	}
	
	public int getRandom() {
		return getRandom(32, 126);
	}
	
	public int getRandom(int untereGrenze, int obereGrenze) {
		// was kommt hier?
	}
}
```


----------



## Maurice16 (3. April 2011)

```
return getRandom();
```
So?


----------



## Muepe32 (3. April 2011)

Das wäre nicht so gut, denn getRandom() ruft ja wieder getRandom(32, 126) auf, usw. Du kannst da die Funktion zur Generierung von Zufallszahlen aus der Klasse Random verwenden von der deine Klasse ja erbt.


----------



## Maurice16 (3. April 2011)

mhh... und was muss dann da rein?


----------



## Muepe32 (3. April 2011)

Welche Funktion der Klasse Random sieht denn mal nicht schlecht aus um eine Zufallszahl in einem Intervall zu generieren? Schau dich mal in der von mir geposteten Referenz durch, sind ja nicht so viele Möglichkeiten.


----------



## Maurice16 (3. April 2011)

Random.nextInt?


----------



## Muepe32 (3. April 2011)

Genau. Da kannst du dann auch einen Maximalwert angeben. Damit hast du dann auch die Lösung des Problems.


----------



## Maurice16 (4. April 2011)

Wie siehts denn damit aus?
Kann man das auch so schreiben?

```
class Tochterklasse2 extends java.util.Random{
	private int grenzeOben;		
	private int grenzeUnten;				//Attribute der Klasse
	
	//Methode1: zufälliges zeichen zw. 32-126, parameterlos
	char zufallszeichen(){ // Zugriffsbezeichner, Typ des Rückgabewertes, Name der Methode (Parameter)	
		char zeichen = (char) (nextInt(95) + 32); // Zahl zwischen 32 und 126, Int Wert wird in cahr Wert umgewandelt
//nextInt liefert eine Zufallszahl als int und ist eine Methode von der Klasse random
		return zeichen;
	}
	//Methode:zufällige zeichen mit parameterliste:
	char zufallszeichenMitGrenzen(int gOben, int gUnten){
		char zeichenMG = (char) (nextInt(gOben-gUnten+1) + gUnten);
		return zeichenMG;
	}
	//Standardkonstruktor, der Grenzen ohne Parameter speichert:
	Tochterklasse2(){
		this.grenzeOben = 126; //Dem Attribut wird ein Wert zugewiesen, grenzeOben = private int grenzeOben
		this.grenzeUnten = 32;
	}
	//Konstruktor initialisiert 2 grenzen mit zu übergebenen Werten:
	Tochterklasse2(int grenzeO, int grenzeU){
		this.grenzeOben = grenzeO;
		this.grenzeUnten = grenzeU;
	}
	//Konstruktor der Klasse Random bekommt über super() den Wert sw zugewiesen:
	Tochterklasse2(long sw){   //Zahlenwert 64-bit)
		super(sw);
		this.grenzeOben = 126;
		this.grenzeUnten = 32;
	}
	//Konstruktor initialisiert die 3 Werten:
	Tochterklasse2(long sw, int oG, int uG){		
		super(sw);
		this.grenzeOben = oG;
		this.grenzeUnten = uG;

	}
}

//Durch extends wird die Klasse java.util.random beerbt. Dadurch sind die Methoden der Elternklasse verfügbar.
//In der Tochterklasse können jetzt Methoden neu kodiert(verändern) werden. Der Konstruktor der Elternklasse wird mit super() aufgerufen.
// this verweist auf Objekte und ist erforderlich da es sonst Namenskonflikte geben würde
// Konstruktoren: 	Tragen den Namen des zu erzeugenden Objekts und initialisiert(setzt/erzeugt) Attribute;
//					Ihm können Parameter übergeben werden; ohne Parameterliste Standartkonstruktor. genannt;
//					 Hat keinen Rückgabewert; werden mit new operator aufgerufen;
```

App.:

```
import java.util.Random;

class Versuch6_1 {
	
	public static void main(String args[]){

//Erste Zeichenkette (15-20 Zeichen)
	Tochterklasse2 a = new Tochterklasse2();	
	int laenge;
	String ausgabe = "";
			
	laenge =(a.nextInt(6) + 15);
	
	for(int i = 0; i<laenge; i++){
		ausgabe += a.zufallszeichen() +" ";
	}
	System.out.println(ausgabe);
	

//Zweite Zeichenkette (8-12 Zeichen)
	ausgabe="";
	laenge=0;
	laenge = (a.nextInt(5) + 8);
	
	for(int i = 0; i<laenge ; i++){
		ausgabe += a.zufallszeichenMitGrenzen(90,65)+ " ";
	}
	System.out.println(ausgabe);
}
}
```


----------

