# GrundlagenBeispiel zu OOP



## Kremsn (8. Nov 2009)

Hi,

ich sollte eine Funktion union schreiben, die 2 Rechtecke r1 und r2 in eins vereinigt. Dazu soll ich eine Klassen und eine Instanzmethode schreiben

Die Dreiecke sollten mit dieser Klasse und dem Kontruktor realisiert werden:


```
class Rectangle {
             int x, y;                         // linke untere Ecke
             int width;                        // Ausdehnung in x-Richtung
             int height;                       // Ausdehnung in y-Richtung
             Rectangle(int x0, int y0, int wi, int hi) {...}
     }
```

Ich hab dann zwei Klassen geschrieben:einmal diese Hauptklasse


```
public class Rectangle {

	static int x = 0;
	static int y = 1;
	static int wi = 2;
	static int hi = 3;
	
	//union als Klassenmethode
	public static int[] union(int[] R1, int [] R2 ){
		
		
		
		int[] Rneu = new int[4];
		
		if (R1[x] <= R2[x])
			Rneu[x] = R1[x];
		else Rneu[x] = R2[x];
		
		if(R1[y] <= R2[y])
			Rneu[y] = R1[y];
		else Rneu[y] = R2[y];
		
		if(R1[x] >= R2[x])
			Rneu[2] = R1[x]+ R1[wi]-Rneu[x];
		else Rneu[wi] = R2[x] + R2[wi] -Rneu[x];
		
		if (R1[y] >= R2[y])
			Rneu[hi] = R1[y] + R1[hi] - Rneu[y];
		else Rneu[hi]= R2[y]+R2[hi] - Rneu[y];
		return Rneu;
		
		
		
	}
	//union als Instanzmethode
public int[] union1(int[] R1, int [] R2 ){
		
		
		
		int[] Rneu = new int[4];
		
		if (R1[x] <= R2[x])
			Rneu[x] = R1[x];
		else Rneu[x] = R2[x];
		
		if(R1[y] <= R2[y])
			Rneu[y] = R1[y];
		else Rneu[y] = R2[y];
		
		if(R1[x] >= R2[x])
			Rneu[2] = R1[x]+ R1[wi]-Rneu[x];
		else Rneu[wi] = R2[x] + R2[wi] -Rneu[x];
		
		if (R1[y] >= R2[y])
			Rneu[hi] = R1[y] + R1[hi] - Rneu[y];
		else Rneu[hi]= R2[y]+R2[hi] - Rneu[y];
		return Rneu;
}
	
	
			public static void main(String[] args){
				
				//int[] r1 = {1,2,3,4};
				//int[] r2 = {2,3,4,5};
				
				//System.out.println(java.util.Arrays.toString(union(r1,r2)));
				
				Rectangle2 obj1 = new Rectangle2(1, 2, 3, 4);
				Rectangle2 obj2 = new Rectangle2(2,3,4,5);
				
				System.out.println(java.util.Arrays.toString(union1()));
				
				}
}
```

und dann diese mit dem Kontruktor.


```
class Rectangle2 {
             int x, y;                         // linke untere Ecke
             int width;                        // Ausdehnung in x-Richtung
             int height;                       // Ausdehnung in y-Richtung
			
			
             Rectangle2(int x0, int y0, int wi, int hi) {
            	 
            	 x = x0;
            	 y = y0;
            	 width = wi;
            	 height = hi;
            	 
            	
            
			
			}
     }
```


1. Wie bring ich jetzt die union1-Funktion mit den Objekten zum laufen?
2. Ist das jetzt so richtig, spirch OOP?
3. Gehört die Instanzmehtode in die erste oder in die zweite Klasse?


----------



## Marco13 (8. Nov 2009)

Bevor ich's nachzuvollziehen versuche: Dreiecke und Rechtecke haben nicht viel gemeinsam (außer drei Ecken, aber Rechtecke haben noch eine mehr). Es geht um letztere?


----------



## Painii (8. Nov 2009)

Marco13 hat gesagt.:


> Bevor ich's nachzuvollziehen versuche: Dreiecke und Rechtecke haben nicht viel gemeinsam (außer drei Ecken, aber Rechtecke haben noch eine mehr). Es geht um letztere?



Wenn du 2 Dreiecke mit den längsten Seiten zueinander legst erhälst du ein Rechteck (ich denke das ist hier gemeint)


----------



## Marco13 (8. Nov 2009)

Nur wenn es SEHR spezielle Dreiecke sind ... 

Bisher ist das einzig hilfreiche, was ich sagen kann, dass ich davon ausgehe, dass das mit EINER Klasse gemacht werden sollte, oder höchstens zwei, aber die sollten dann unterschiedlich(er) heißen und aufgebaut sein...


----------



## Kremsn (9. Nov 2009)

oh tschuldigung meinte rechtecke


----------



## Michael... (9. Nov 2009)

Wenn das ganze objektorientiert sein soll, dann sollte man auch mit den Objekten arbeiten und nicht mit irgendwelchen Feldern als quasi-Objekt.
Hier mal ein Bsp. der Algorithmus für die Vereinigung muss dann noch in Zeile 36ff implementiert werden. Ggf. müsste man noch analog zu den get-Methoden noch set-Methoden implementieren, um Attribute bestehender Rectangle Objekte nachträglich zu manipulieren.

```
public class Rectangle {
	private int x, y, w, h;

	public Rectangle(int x, int y, int w, int h) {
		this.x = x;
		this.y = y;
		this.w = w;
		this.h = h;
	}
	
	public int getX() {
		return x;
	}
	
	public int getY() {
		return y;
	}
	
	public int getWidth() {
		return w;
	}
	
	public int getHeight() {
		return h;
	}

	// union als Instanz-Methode - verwendet intern die statische Methode, da man
	// den Algorithmus ja nicht unbedingt doppelt implementieren muss
	public Rectangle union(Rectangle rect) {
		return Rectangle.union(this, rect);
	}

	// union als statische Methode
	public static Rectangle union(Rectangle rect1, Rectangle rect2) {
		Rectangle unionRect = null;

		// hier muss die Implementierung der union Methode erfolgen

		return unionRect;
	}

	public String toString() {
		return "Rechteck mit der Position " + x + ", " + y + "und den Maßen "
				+ w + " x " + h;
	}

	public static void main(String[] args) {
		Rectangle rect1 = new Rectangle(1, 2, 3, 4);
		Rectangle rect2 = new Rectangle(2, 3, 4, 5);

		// Möglichkeit 1
		System.out.println(rect1.union(rect2));
		// Möglichkeit 2
		System.out.println(Rectangle.union(rect1, rect2));
	}
}
```



> 1. Wie bring ich jetzt die union1-Funktion mit den Objekten zum laufen?
> 2. Ist das jetzt so richtig, spirch OOP?
> 3. Gehört die Instanzmehtode in die erste oder in die zweite Klasse?


1. siehe Bsp
2. nein, siehe Bsp
3. ich würde nur eine Klasse verwenden, siehe Bsp. man könnte die statische Methode aber auch in eine eigene Klasse auslagern


----------



## Kremsn (11. Nov 2009)

@michael 

nochmal danke für deine mühe, hat mir echt geholfen. Jetzt ist mir auch klar geworden was mit objektorientiert gemeint ist.


----------

